# Linux Sandboxes Daytona provides **Linux sandboxes** as the default sandbox for AI agents. A Linux sandbox is an isolated runtime environment you manage programmatically to run code. Each sandbox has a dedicated filesystem, network stack, and allocated vCPU, RAM, and disk. Agents and developers can install packages, run servers, compile code, and manage processes. Linux sandboxes run as **containers** or as **Linux virtual machines (VMs)**. The snapshot sets the sandbox class, and both classes use the same SDKs, CLI, and API. Linux sandboxes start from a snapshot or a Docker image, keep their filesystem across stop and start, and are deleted when a timeout elapses or on request. | **Term** | **Description** | | -------------------------- | -------------------------------------------------------------------------------------------------------------------------------------- | | **Sandbox** | An isolated Linux environment created on demand to run code. | | **Container** | A sandbox that runs as a Linux container and shares the kernel of the host. The default sandbox class. | | **Linux VM** | A sandbox that runs as a virtual machine with its own Linux kernel. The hardware enforces the boundary between sandboxes. | | **Sandbox class** | The runtime of a Linux sandbox: container or Linux VM. The snapshot sets the class. | | **Image** | A packaged filesystem that defines the software a sandbox starts with. Container sandboxes can start from a Docker image. | | **Snapshot** | A pre-configured template that new sandboxes start from. | | **Toolbox** | The Daytona daemon inside the sandbox that serves file, Git, and process requests. | ## Use cases Linux sandboxes are used wherever code must run in a real environment, but you cannot trust the code or you cannot afford for it to affect anything else. - **Code execution for AI agents**: an agent writes code, runs it in a sandbox, reads the output, and decides what to do next. The sandbox gives the agent a real shell and filesystem while keeping its actions away from your infrastructure. - **Coding agents**: an agent clones a repository, installs dependencies, edits files, runs the test suite, and pushes a branch, all inside one sandbox. - **Reinforcement learning (RL) and evaluation**: each episode or test case gets a clean, identical machine created from a shared snapshot, so results do not depend on leftover state and each environment stays cheap. - **Untrusted user code**: online coding platforms, grading systems, code interpreters, and plugin hosts run code submitted by users or generated by a model without exposing other users or the service. - **Computer-use agents**: an agent operates a graphical desktop, a browser, or desktop applications through screenshots and input events. - **Development environments**: a developer gets a preconfigured machine from an image, connects over SSH or from an editor, and previews web applications through a URL. - **Long-lived and branching agent sessions**: a Linux VM sandbox pauses when the agent goes idle and resumes with its processes and memory intact, and is forked to try several approaches from the same point. ## Create a Linux sandbox Create a sandbox. 1. Go to [Daytona Sandboxes ↗](https://app.daytona.io/dashboard/sandboxes) 2. Click 3. Click ```python from daytona import Daytona daytona = Daytona() sandbox = daytona.create() ``` ```typescript import { Daytona } from '@daytona/sdk' const daytona = new Daytona() const sandbox = await daytona.create() ``` ```ruby require 'daytona' daytona = Daytona::Daytona.new sandbox = daytona.create ``` ```go package main import ( "context" "github.com/daytona/clients/sdk-go/pkg/daytona" ) func main() { client, _ := daytona.NewClient() ctx := context.Background() _, _ = client.Create(ctx, nil) } ``` ```java import io.daytona.sdk.Daytona; import io.daytona.sdk.Sandbox; public class App { public static void main(String[] args) { try (Daytona daytona = new Daytona()) { Sandbox sandbox = daytona.create(); } } } ``` ```bash daytona create ``` ```bash curl 'https://app.daytona.io/api/sandbox' \ --request POST \ --header 'Content-Type: application/json' \ --header 'Authorization: Bearer YOUR_API_KEY' \ --data '{}' ``` ## Create a Linux VM sandbox Create a Linux VM sandbox. :::note[Limitations] VM sandboxes can currently only be created from existing VM snapshots. Dynamic builds through the declarative builder are supported for container sandboxes only. ::: Create a Linux VM sandbox. 1. Go to [Daytona Snapshots ↗](https://app.daytona.io/dashboard/snapshots) 2. Click 3. Enter the , for example **`my-vm-snapshot`** 4. Enter the , for example **`ubuntu:22.04`** 5. Select : **`LINUX_VM`** 6. Click 7. Go to [Daytona Sandboxes ↗](https://app.daytona.io/dashboard/sandboxes) 8. Click 9. Select the VM , for example **`my-vm-snapshot`** 10. Click ```python from daytona import ( Daytona, CreateSnapshotParams, CreateSandboxFromSnapshotParams, SandboxClass, ) daytona = Daytona() # Create a Linux VM snapshot daytona.snapshot.create( CreateSnapshotParams( name="my-vm-snapshot", image="ubuntu:22.04", sandbox_class=SandboxClass.LINUX_VM, ) ) # Create a Linux VM sandbox from the snapshot sandbox = daytona.create(CreateSandboxFromSnapshotParams(snapshot="my-vm-snapshot")) ``` ```typescript import { Daytona, SandboxClass } from '@daytona/sdk' const daytona = new Daytona() // Create a Linux VM snapshot await daytona.snapshot.create({ name: 'my-vm-snapshot', image: 'ubuntu:22.04', sandboxClass: SandboxClass.LINUX_VM, }) // Create a Linux VM sandbox from the snapshot const sandbox = await daytona.create({ snapshot: 'my-vm-snapshot' }) ``` ```ruby require 'daytona' daytona = Daytona::Daytona.new # Create a Linux VM snapshot daytona.snapshot.create( Daytona::CreateSnapshotParams.new( name: 'my-vm-snapshot', image: 'ubuntu:22.04', sandbox_class: DaytonaApiClient::SandboxClass::LINUX_VM ) ) # Create a Linux VM sandbox from the snapshot sandbox = daytona.create(Daytona::CreateSandboxFromSnapshotParams.new(snapshot: 'my-vm-snapshot')) ``` ```go package main import ( "context" "github.com/daytona/clients/sdk-go/pkg/daytona" "github.com/daytona/clients/sdk-go/pkg/types" ) func main() { client, _ := daytona.NewClient() ctx := context.Background() // Create a Linux VM snapshot sandboxClass := types.SandboxClassLinuxVM _, logCh, _ := client.Snapshot.Create(ctx, &types.CreateSnapshotParams{ Name: "my-vm-snapshot", Image: "ubuntu:22.04", SandboxClass: &sandboxClass, }) for range logCh { } // Create a Linux VM sandbox from the snapshot _, _ = client.Create(ctx, types.SnapshotParams{ Snapshot: "my-vm-snapshot", }) } ``` ```java import io.daytona.sdk.Daytona; import io.daytona.sdk.Sandbox; import io.daytona.api.client.model.SandboxClass; import io.daytona.sdk.model.CreateSandboxFromSnapshotParams; public class App { public static void main(String[] args) { try (Daytona daytona = new Daytona()) { // Create a Linux VM snapshot daytona.snapshot().create("my-vm-snapshot", "ubuntu:22.04", SandboxClass.LINUX_VM); // Create a Linux VM sandbox from the snapshot CreateSandboxFromSnapshotParams params = new CreateSandboxFromSnapshotParams(); params.setSnapshot("my-vm-snapshot"); Sandbox sandbox = daytona.create(params); } } } ``` ```bash # Create a Linux VM snapshot daytona snapshot create my-vm-snapshot --image ubuntu:22.04 --sandbox-class linux-vm # Create a Linux VM sandbox from the snapshot daytona create --snapshot my-vm-snapshot ``` ```bash # Create a Linux VM snapshot curl 'https://app.daytona.io/api/snapshots' \ --request POST \ --header 'Content-Type: application/json' \ --header 'Authorization: Bearer YOUR_API_KEY' \ --data '{ "name": "my-vm-snapshot", "imageName": "ubuntu:22.04", "sandboxClass": "linux-vm" }' # Create a Linux VM sandbox from the snapshot curl 'https://app.daytona.io/api/sandbox' \ --request POST \ --header 'Content-Type: application/json' \ --header 'Authorization: Bearer YOUR_API_KEY' \ --data '{ "snapshot": "my-vm-snapshot" }' ``` Create a Linux VM sandbox from a default snapshot. 1. Go to [Daytona Sandboxes ↗](https://app.daytona.io/dashboard/sandboxes) 2. Click 3. Select a VM : **`daytona-vm-small`**, **`daytona-vm-medium`**, or **`daytona-vm-large`** 4. Click ```python from daytona import Daytona, CreateSandboxFromSnapshotParams daytona = Daytona() sandbox = daytona.create(CreateSandboxFromSnapshotParams(snapshot="daytona-vm-small")) ``` ```typescript import { Daytona } from '@daytona/sdk' const daytona = new Daytona() const sandbox = await daytona.create({ snapshot: 'daytona-vm-small' }) ``` ```ruby require 'daytona' daytona = Daytona::Daytona.new sandbox = daytona.create( Daytona::CreateSandboxFromSnapshotParams.new(snapshot: 'daytona-vm-small') ) ``` ```go package main import ( "context" "github.com/daytona/clients/sdk-go/pkg/daytona" "github.com/daytona/clients/sdk-go/pkg/types" ) func main() { client, _ := daytona.NewClient() ctx := context.Background() _, _ = client.Create(ctx, types.SnapshotParams{ Snapshot: "daytona-vm-small", }) } ``` ```java import io.daytona.sdk.Daytona; import io.daytona.sdk.Sandbox; import io.daytona.sdk.model.CreateSandboxFromSnapshotParams; public class App { public static void main(String[] args) { try (Daytona daytona = new Daytona()) { CreateSandboxFromSnapshotParams params = new CreateSandboxFromSnapshotParams(); params.setSnapshot("daytona-vm-small"); Sandbox sandbox = daytona.create(params); } } } ``` ```bash daytona create --snapshot daytona-vm-small ``` ```bash curl 'https://app.daytona.io/api/sandbox' \ --request POST \ --header 'Content-Type: application/json' \ --header 'Authorization: Bearer YOUR_API_KEY' \ --data '{ "snapshot": "daytona-vm-small" }' ``` ## Nested virtualization Daytona provides nested virtualization for Linux VM sandboxes. Nested virtualization exposes KVM (`/dev/kvm`) inside the guest, so the sandbox can run its own virtual machines with hardware acceleration. :::note KVM sandboxes must be enabled for your organization. Contact [support@daytona.io](mailto:support@daytona.io). ::: ```python from daytona import Daytona, CreateSandboxFromSnapshotParams daytona = Daytona() sandbox = daytona.create( CreateSandboxFromSnapshotParams( snapshot="daytona-vm-small", kvm=True, ) ) ``` ```typescript import { Daytona } from '@daytona/sdk' const daytona = new Daytona() const sandbox = await daytona.create({ snapshot: 'daytona-vm-small', kvm: true, }) ``` ```ruby require 'daytona' daytona = Daytona::Daytona.new sandbox = daytona.create( Daytona::CreateSandboxFromSnapshotParams.new( snapshot: 'daytona-vm-small', kvm: true ) ) ``` ```go package main import ( "context" "github.com/daytona/clients/sdk-go/pkg/daytona" "github.com/daytona/clients/sdk-go/pkg/types" ) func main() { client, _ := daytona.NewClient() ctx := context.Background() params := types.SnapshotParams{ SandboxBaseParams: types.SandboxBaseParams{ Kvm: true, }, Snapshot: "daytona-vm-small", } _, _ = client.Create(ctx, params) } ``` ```java import io.daytona.sdk.Daytona; import io.daytona.sdk.Sandbox; import io.daytona.sdk.model.CreateSandboxFromSnapshotParams; public class App { public static void main(String[] args) { try (Daytona daytona = new Daytona()) { CreateSandboxFromSnapshotParams params = new CreateSandboxFromSnapshotParams(); params.setSnapshot("daytona-vm-small"); params.setKvm(true); Sandbox sandbox = daytona.create(params); } } } ``` ```bash daytona create --snapshot daytona-vm-small --kvm ``` ```bash curl 'https://app.daytona.io/api/sandbox' \ --request POST \ --header 'Content-Type: application/json' \ --header 'Authorization: Bearer YOUR_API_KEY' \ --data '{ "snapshot": "daytona-vm-small", "kvm": true }' ``` ## Filesystem persistence Filesystem persistence keeps the contents of a sandbox's disk: files, installed packages, cloned repositories, and build artifacts. A sandbox with a preserved filesystem starts with its environment intact, with nothing to reinstall or rebuild. Linux sandboxes preserve their filesystem across [stop and start](#stop--start), [archive](https://www.daytona.io/docs/en/sandboxes.md#archive-sandboxes), and [filesystem snapshots](#filesystem-snapshot) created from a sandbox. An [ephemeral sandbox](https://www.daytona.io/docs/en/sandboxes.md#ephemeral-sandboxes) is deleted on stop, so its filesystem is not kept. The sandbox classes differ in where the preserved filesystem is stored while the sandbox is stopped: | **Sandbox class** | **Filesystem persistence** | | ----------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | **Container** | Filesystem is preserved through stop and start: it stays on the runner and counts against disk quota while stopped. Archive moves it to object storage and frees the quota, and starting an archived sandbox restores it. Use filesystem snapshots to capture the filesystem. | | **Linux VM** | Filesystem is preserved through stop and start: stopping offloads it to nearby storage and releases disk quota, starting restores it. Archive is not needed. Use filesystem snapshots to capture the filesystem. | ```python from daytona import Daytona daytona = Daytona() sandbox = daytona.create() # Write a file to the filesystem sandbox.fs.upload_file(b"done", "setup.log") # Stop clears memory and keeps the filesystem sandbox.stop() # Start boots the sandbox from its filesystem sandbox.start() content = sandbox.fs.download_file("setup.log") print(content.decode()) # done ``` ```typescript import { Daytona } from '@daytona/sdk' const daytona = new Daytona() const sandbox = await daytona.create() // Write a file to the filesystem await sandbox.fs.uploadFile(Buffer.from('done'), 'setup.log') // Stop clears memory and keeps the filesystem await sandbox.stop() // Start boots the sandbox from its filesystem await sandbox.start() const content = await sandbox.fs.downloadFile('setup.log') console.log(content.toString()) // done ``` ```ruby require 'daytona' daytona = Daytona::Daytona.new sandbox = daytona.create # Write a file to the filesystem sandbox.fs.upload_file('done', 'setup.log') # Stop clears memory and keeps the filesystem sandbox.stop # Start boots the sandbox from its filesystem sandbox.start content = sandbox.fs.download_file('setup.log') puts content # done ``` ```go package main import ( "context" "fmt" "github.com/daytona/clients/sdk-go/pkg/daytona" "github.com/daytona/clients/sdk-go/pkg/types" ) func main() { client, _ := daytona.NewClient() ctx := context.Background() sandbox, err := client.Create(ctx, types.SnapshotParams{}) if err != nil { panic(err) } // Write a file to the filesystem if err := sandbox.FileSystem.UploadFile(ctx, []byte("done"), "setup.log"); err != nil { panic(err) } // Stop clears memory and keeps the filesystem if err := sandbox.Stop(ctx); err != nil { panic(err) } // Start boots the sandbox from its filesystem if err := sandbox.Start(ctx); err != nil { panic(err) } content, err := sandbox.FileSystem.DownloadFile(ctx, "setup.log", nil) if err != nil { panic(err) } fmt.Println(string(content)) // done } ``` ```java import io.daytona.sdk.Daytona; import io.daytona.sdk.Sandbox; public class App { public static void main(String[] args) { try (Daytona daytona = new Daytona()) { Sandbox sandbox = daytona.create(); // Write a file to the filesystem sandbox.fs.uploadFile("done".getBytes(), "setup.log"); // Stop clears memory and keeps the filesystem sandbox.stop(); // Start boots the sandbox from its filesystem sandbox.start(); byte[] content = sandbox.fs.downloadFile("setup.log"); System.out.println(new String(content)); // done } } } ``` ```bash daytona create # Write a file to the filesystem daytona exec [SANDBOX_ID] -- sh -c 'echo done > setup.log' # Stop clears memory and keeps the filesystem daytona stop [SANDBOX_ID] # Start boots the sandbox from its filesystem daytona start [SANDBOX_ID] daytona exec [SANDBOX_ID] -- cat setup.log ``` ```bash curl 'https://app.daytona.io/api/sandbox' \ --request POST \ --header 'Content-Type: application/json' \ --header 'Authorization: Bearer YOUR_API_KEY' \ --data '{}' # Write a file to the filesystem curl 'https://proxy.app.daytona.io/toolbox/{sandboxId}/files/upload-v2?path=setup.log' \ --request POST \ --header 'Authorization: Bearer YOUR_API_KEY' \ --form 'file=@setup.log' # Stop clears memory and keeps the filesystem curl 'https://app.daytona.io/api/sandbox/{sandboxId}/stop' \ --request POST \ --header 'Authorization: Bearer YOUR_API_KEY' # Start boots the sandbox from its filesystem curl 'https://app.daytona.io/api/sandbox/{sandboxId}/start' \ --request POST \ --header 'Authorization: Bearer YOUR_API_KEY' curl 'https://proxy.app.daytona.io/toolbox/{sandboxId}/files/download?path=setup.log' \ --header 'Authorization: Bearer YOUR_API_KEY' ``` ```python from daytona import Daytona, CreateSandboxFromSnapshotParams daytona = Daytona() sandbox = daytona.create(CreateSandboxFromSnapshotParams(snapshot="daytona-vm-small")) # Write a file to the filesystem sandbox.fs.upload_file(b"done", "setup.log") # Stop clears memory and moves the filesystem to nearby storage sandbox.stop() # Start restores the filesystem and boots the sandbox sandbox.start() content = sandbox.fs.download_file("setup.log") print(content.decode()) # done ``` ```typescript import { Daytona } from '@daytona/sdk' const daytona = new Daytona() const sandbox = await daytona.create({ snapshot: 'daytona-vm-small' }) // Write a file to the filesystem await sandbox.fs.uploadFile(Buffer.from('done'), 'setup.log') // Stop clears memory and moves the filesystem to nearby storage await sandbox.stop() // Start restores the filesystem and boots the sandbox await sandbox.start() const content = await sandbox.fs.downloadFile('setup.log') console.log(content.toString()) // done ``` ```ruby require 'daytona' daytona = Daytona::Daytona.new sandbox = daytona.create(Daytona::CreateSandboxFromSnapshotParams.new(snapshot: 'daytona-vm-small')) # Write a file to the filesystem sandbox.fs.upload_file('done', 'setup.log') # Stop clears memory and moves the filesystem to nearby storage sandbox.stop # Start restores the filesystem and boots the sandbox sandbox.start content = sandbox.fs.download_file('setup.log') puts content # done ``` ```go package main import ( "context" "fmt" "github.com/daytona/clients/sdk-go/pkg/daytona" "github.com/daytona/clients/sdk-go/pkg/types" ) func main() { client, _ := daytona.NewClient() ctx := context.Background() sandbox, err := client.Create(ctx, types.SnapshotParams{Snapshot: "daytona-vm-small"}) if err != nil { panic(err) } // Write a file to the filesystem if err := sandbox.FileSystem.UploadFile(ctx, []byte("done"), "setup.log"); err != nil { panic(err) } // Stop clears memory and moves the filesystem to nearby storage if err := sandbox.Stop(ctx); err != nil { panic(err) } // Start restores the filesystem and boots the sandbox if err := sandbox.Start(ctx); err != nil { panic(err) } content, err := sandbox.FileSystem.DownloadFile(ctx, "setup.log", nil) if err != nil { panic(err) } fmt.Println(string(content)) // done } ``` ```java import io.daytona.sdk.Daytona; import io.daytona.sdk.Sandbox; import io.daytona.sdk.model.CreateSandboxFromSnapshotParams; public class App { public static void main(String[] args) { try (Daytona daytona = new Daytona()) { CreateSandboxFromSnapshotParams params = new CreateSandboxFromSnapshotParams(); params.setSnapshot("daytona-vm-small"); Sandbox sandbox = daytona.create(params); // Write a file to the filesystem sandbox.fs.uploadFile("done".getBytes(), "setup.log"); // Stop clears memory and moves the filesystem to nearby storage sandbox.stop(); // Start restores the filesystem and boots the sandbox sandbox.start(); byte[] content = sandbox.fs.downloadFile("setup.log"); System.out.println(new String(content)); // done } } } ``` ```bash daytona create --snapshot daytona-vm-small # Write a file to the filesystem daytona exec [SANDBOX_ID] -- sh -c 'echo done > setup.log' # Stop clears memory and moves the filesystem to nearby storage daytona stop [SANDBOX_ID] # Start restores the filesystem and boots the sandbox daytona start [SANDBOX_ID] daytona exec [SANDBOX_ID] -- cat setup.log ``` ```bash curl 'https://app.daytona.io/api/sandbox' \ --request POST \ --header 'Content-Type: application/json' \ --header 'Authorization: Bearer YOUR_API_KEY' \ --data '{"snapshot": "daytona-vm-small"}' # Write a file to the filesystem curl 'https://proxy.app.daytona.io/toolbox/{sandboxId}/files/upload-v2?path=setup.log' \ --request POST \ --header 'Authorization: Bearer YOUR_API_KEY' \ --form 'file=@setup.log' # Stop clears memory and moves the filesystem to nearby storage curl 'https://app.daytona.io/api/sandbox/{sandboxId}/stop' \ --request POST \ --header 'Authorization: Bearer YOUR_API_KEY' # Start restores the filesystem and boots the sandbox curl 'https://app.daytona.io/api/sandbox/{sandboxId}/start' \ --request POST \ --header 'Authorization: Bearer YOUR_API_KEY' curl 'https://proxy.app.daytona.io/toolbox/{sandboxId}/files/download?path=setup.log' \ --header 'Authorization: Bearer YOUR_API_KEY' ``` ## Memory persistence Memory persistence keeps the runtime state of a sandbox: running processes, open connections, and everything loaded in RAM. A sandbox with preserved memory continues from the point it was frozen, with processes still running, instead of starting from a clean boot. Linux VM sandboxes preserve their memory across [pause and resume](#pause--resume), [memory snapshots](#memory-snapshot) created from a sandbox, and [forks](#fork). Memory state is cleared on every stop. The sandbox classes differ in whether memory can be preserved without keeping the sandbox running: | **Sandbox class** | **Memory persistence** | | ----------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | **Container** | Memory persists only while the sandbox is running. Set the auto-stop interval to zero to run indefinitely, or relaunch processes after each start. Pause is not supported. | | **Linux VM** | Memory is preserved through pause and resume: pausing freezes the VM with memory intact, resuming continues all processes from the point they were frozen. Use memory snapshots or forks to capture memory. | The following example creates a Linux VM sandbox. Pause requires a non-ephemeral Linux VM sandbox in the **Started** state. ```python from daytona import Daytona, CreateSandboxFromSnapshotParams, SessionExecuteRequest daytona = Daytona() sandbox = daytona.create(CreateSandboxFromSnapshotParams(snapshot="daytona-vm-small")) # Start a process that runs in the background sandbox.process.create_session("keepalive") response = sandbox.process.execute_session_command( "keepalive", SessionExecuteRequest(command="sleep 3600", run_async=True), ) # Pause keeps the filesystem and memory sandbox.pause() # Start resumes every process from the point where the sandbox paused sandbox.start() command = sandbox.process.get_session_command("keepalive", response.cmd_id) print(command.exit_code) # None: the process is still running ``` ```typescript import { Daytona } from '@daytona/sdk' const daytona = new Daytona() const sandbox = await daytona.create({ snapshot: 'daytona-vm-small' }) // Start a process that runs in the background await sandbox.process.createSession('keepalive') const response = await sandbox.process.executeSessionCommand('keepalive', { command: 'sleep 3600', runAsync: true, }) // Pause keeps the filesystem and memory await sandbox.pause() // Start resumes every process from the point where the sandbox paused await sandbox.start() const command = await sandbox.process.getSessionCommand('keepalive', response.cmdId) console.log(command.exitCode) // undefined: the process is still running ``` ```ruby require 'daytona' daytona = Daytona::Daytona.new sandbox = daytona.create(Daytona::CreateSandboxFromSnapshotParams.new(snapshot: 'daytona-vm-small')) # Start a process that runs in the background sandbox.process.create_session('keepalive') response = sandbox.process.execute_session_command( session_id: 'keepalive', req: Daytona::SessionExecuteRequest.new(command: 'sleep 3600', run_async: true) ) # Pause keeps the filesystem and memory sandbox.pause # Start resumes every process from the point where the sandbox paused sandbox.start command = sandbox.process.get_session_command(session_id: 'keepalive', command_id: response.cmd_id) puts command.exit_code.inspect # nil: the process is still running ``` ```go package main import ( "context" "fmt" "github.com/daytona/clients/sdk-go/pkg/daytona" "github.com/daytona/clients/sdk-go/pkg/types" ) func main() { client, _ := daytona.NewClient() ctx := context.Background() sandbox, err := client.Create(ctx, types.SnapshotParams{Snapshot: "daytona-vm-small"}) if err != nil { panic(err) } // Start a process that runs in the background if err := sandbox.Process.CreateSession(ctx, "keepalive"); err != nil { panic(err) } response, err := sandbox.Process.ExecuteSessionCommand(ctx, "keepalive", "sleep 3600", true, false) if err != nil { panic(err) } // Pause keeps the filesystem and memory if err := sandbox.Pause(ctx); err != nil { panic(err) } // Start resumes every process from the point where the sandbox paused if err := sandbox.Start(ctx); err != nil { panic(err) } command, err := sandbox.Process.GetSessionCommand(ctx, "keepalive", response["cmdId"].(string)) if err != nil { panic(err) } fmt.Println(command["exitCode"]) // : the process is still running } ``` ```java import io.daytona.sdk.Daytona; import io.daytona.sdk.Sandbox; import io.daytona.sdk.model.Command; import io.daytona.sdk.model.CreateSandboxFromSnapshotParams; import io.daytona.sdk.model.SessionExecuteRequest; import io.daytona.sdk.model.SessionExecuteResponse; public class App { public static void main(String[] args) { try (Daytona daytona = new Daytona()) { CreateSandboxFromSnapshotParams params = new CreateSandboxFromSnapshotParams(); params.setSnapshot("daytona-vm-small"); Sandbox sandbox = daytona.create(params); // Start a process that runs in the background sandbox.process.createSession("keepalive"); SessionExecuteResponse response = sandbox.process.executeSessionCommand( "keepalive", new SessionExecuteRequest("sleep 3600", true) ); // Pause keeps the filesystem and memory sandbox.pause(); // Start resumes every process from the point where the sandbox paused sandbox.start(); Command command = sandbox.process.getSessionCommand("keepalive", response.getCmdId()); System.out.println(command.getExitCode()); // null: the process is still running } } } ``` ```bash daytona create --snapshot daytona-vm-small # Pause keeps the filesystem and memory daytona pause [SANDBOX_ID] # Start resumes every process from the point where the sandbox paused daytona start [SANDBOX_ID] ``` ```bash curl 'https://app.daytona.io/api/sandbox' \ --request POST \ --header 'Content-Type: application/json' \ --header 'Authorization: Bearer YOUR_API_KEY' \ --data '{"snapshot": "daytona-vm-small"}' # Start a process that runs in the background curl 'https://proxy.app.daytona.io/toolbox/{sandboxId}/process/session' \ --request POST \ --header 'Content-Type: application/json' \ --header 'Authorization: Bearer YOUR_API_KEY' \ --data '{"sessionId": "keepalive"}' curl 'https://proxy.app.daytona.io/toolbox/{sandboxId}/process/session/keepalive/exec' \ --request POST \ --header 'Content-Type: application/json' \ --header 'Authorization: Bearer YOUR_API_KEY' \ --data '{"command": "sleep 3600", "runAsync": true}' # Pause keeps the filesystem and memory curl 'https://app.daytona.io/api/sandbox/{sandboxId}/pause' \ --request POST \ --header 'Authorization: Bearer YOUR_API_KEY' # Start resumes every process from the point where the sandbox paused curl 'https://app.daytona.io/api/sandbox/{sandboxId}/start' \ --request POST \ --header 'Authorization: Bearer YOUR_API_KEY' # The command has no exitCode while the process is still running curl 'https://proxy.app.daytona.io/toolbox/{sandboxId}/process/session/keepalive/command/{commandId}' \ --header 'Authorization: Bearer YOUR_API_KEY' ``` ## Memory snapshot A memory snapshot, also called a hot snapshot, saves the filesystem and memory of a started Linux VM sandbox. A sandbox created from a memory snapshot starts with its processes already running. Enable the include memory option when you create the snapshot. Container sandboxes do not support memory snapshots. A memory snapshot requires a Linux VM sandbox in the **Started** state. The SDKs do not expose the include memory option, so use the API. ```bash curl 'https://app.daytona.io/api/sandbox/{sandboxIdOrName}/snapshot' \ --request POST \ --header 'Content-Type: application/json' \ --header 'Authorization: Bearer YOUR_API_KEY' \ --data '{ "name": "my-vm-snapshot", "includeMemory": true }' ``` ## Filesystem snapshot A filesystem snapshot, also called a cold snapshot, saves the filesystem of a stopped Linux sandbox. Both sandbox classes support filesystem snapshots. A snapshot without the include memory option is a filesystem snapshot. A filesystem snapshot requires a sandbox in the **Stopped** state. An ephemeral sandbox is deleted on stop, so it cannot take a filesystem snapshot. ```python from daytona import Daytona, CreateSandboxFromSnapshotParams daytona = Daytona() sandbox = daytona.create() # Write a file to the filesystem sandbox.fs.upload_file(b"done", "setup.log") # A filesystem snapshot requires a stopped sandbox sandbox.stop() sandbox.create_snapshot("my-snapshot") # A sandbox created from the snapshot starts with the same filesystem new_sandbox = daytona.create(CreateSandboxFromSnapshotParams(snapshot="my-snapshot")) content = new_sandbox.fs.download_file("setup.log") print(content.decode()) # done ``` ```typescript import { Daytona } from '@daytona/sdk' const daytona = new Daytona() const sandbox = await daytona.create() // Write a file to the filesystem await sandbox.fs.uploadFile(Buffer.from('done'), 'setup.log') // A filesystem snapshot requires a stopped sandbox await sandbox.stop() await sandbox.createSnapshot('my-snapshot') // A sandbox created from the snapshot starts with the same filesystem const newSandbox = await daytona.create({ snapshot: 'my-snapshot' }) const content = await newSandbox.fs.downloadFile('setup.log') console.log(content.toString()) // done ``` ```ruby require 'daytona' daytona = Daytona::Daytona.new sandbox = daytona.create # Write a file to the filesystem sandbox.fs.upload_file('done', 'setup.log') # A filesystem snapshot requires a stopped sandbox sandbox.stop sandbox.create_snapshot(name: 'my-snapshot') # A sandbox created from the snapshot starts with the same filesystem new_sandbox = daytona.create(Daytona::CreateSandboxFromSnapshotParams.new(snapshot: 'my-snapshot')) content = new_sandbox.fs.download_file('setup.log') puts content # done ``` ```go package main import ( "context" "fmt" "github.com/daytona/clients/sdk-go/pkg/daytona" "github.com/daytona/clients/sdk-go/pkg/types" ) func main() { client, _ := daytona.NewClient() ctx := context.Background() sandbox, err := client.Create(ctx, types.SnapshotParams{}) if err != nil { panic(err) } // Write a file to the filesystem if err := sandbox.FileSystem.UploadFile(ctx, []byte("done"), "setup.log"); err != nil { panic(err) } // A filesystem snapshot requires a stopped sandbox if err := sandbox.Stop(ctx); err != nil { panic(err) } if err := sandbox.CreateSnapshot(ctx, "my-snapshot"); err != nil { panic(err) } // A sandbox created from the snapshot starts with the same filesystem newSandbox, err := client.Create(ctx, types.SnapshotParams{Snapshot: "my-snapshot"}) if err != nil { panic(err) } content, err := newSandbox.FileSystem.DownloadFile(ctx, "setup.log", nil) if err != nil { panic(err) } fmt.Println(string(content)) // done } ``` ```java import io.daytona.sdk.Daytona; import io.daytona.sdk.Sandbox; import io.daytona.sdk.model.CreateSandboxFromSnapshotParams; public class App { public static void main(String[] args) { try (Daytona daytona = new Daytona()) { Sandbox sandbox = daytona.create(); // Write a file to the filesystem sandbox.fs.uploadFile("done".getBytes(), "setup.log"); // A filesystem snapshot requires a stopped sandbox sandbox.stop(); sandbox.createSnapshot("my-snapshot"); // A sandbox created from the snapshot starts with the same filesystem CreateSandboxFromSnapshotParams fromSnapshot = new CreateSandboxFromSnapshotParams(); fromSnapshot.setSnapshot("my-snapshot"); Sandbox newSandbox = daytona.create(fromSnapshot); byte[] content = newSandbox.fs.downloadFile("setup.log"); System.out.println(new String(content)); // done } } } ``` ```bash curl 'https://app.daytona.io/api/sandbox' \ --request POST \ --header 'Content-Type: application/json' \ --header 'Authorization: Bearer YOUR_API_KEY' \ --data '{}' # Write a file to the filesystem curl 'https://proxy.app.daytona.io/toolbox/{sandboxId}/files/upload-v2?path=setup.log' \ --request POST \ --header 'Authorization: Bearer YOUR_API_KEY' \ --form 'file=@setup.log' # A filesystem snapshot requires a stopped sandbox curl 'https://app.daytona.io/api/sandbox/{sandboxId}/stop' \ --request POST \ --header 'Authorization: Bearer YOUR_API_KEY' curl 'https://app.daytona.io/api/sandbox/{sandboxId}/snapshot' \ --request POST \ --header 'Content-Type: application/json' \ --header 'Authorization: Bearer YOUR_API_KEY' \ --data '{ "name": "my-snapshot", "includeMemory": false }' # A sandbox created from the snapshot starts with the same filesystem curl 'https://app.daytona.io/api/sandbox' \ --request POST \ --header 'Content-Type: application/json' \ --header 'Authorization: Bearer YOUR_API_KEY' \ --data '{"snapshot": "my-snapshot"}' curl 'https://proxy.app.daytona.io/toolbox/{newSandboxId}/files/download?path=setup.log' \ --header 'Authorization: Bearer YOUR_API_KEY' ``` ```python from daytona import Daytona, CreateSandboxFromSnapshotParams daytona = Daytona() sandbox = daytona.create(CreateSandboxFromSnapshotParams(snapshot="daytona-vm-small")) # Write a file to the filesystem sandbox.fs.upload_file(b"done", "setup.log") # A filesystem snapshot requires a stopped sandbox sandbox.stop() sandbox.create_snapshot("my-vm-snapshot") # A sandbox created from the snapshot starts with the same filesystem new_sandbox = daytona.create(CreateSandboxFromSnapshotParams(snapshot="my-vm-snapshot")) content = new_sandbox.fs.download_file("setup.log") print(content.decode()) # done ``` ```typescript import { Daytona } from '@daytona/sdk' const daytona = new Daytona() const sandbox = await daytona.create({ snapshot: 'daytona-vm-small' }) // Write a file to the filesystem await sandbox.fs.uploadFile(Buffer.from('done'), 'setup.log') // A filesystem snapshot requires a stopped sandbox await sandbox.stop() await sandbox.createSnapshot('my-vm-snapshot') // A sandbox created from the snapshot starts with the same filesystem const newSandbox = await daytona.create({ snapshot: 'my-vm-snapshot' }) const content = await newSandbox.fs.downloadFile('setup.log') console.log(content.toString()) // done ``` ```ruby require 'daytona' daytona = Daytona::Daytona.new sandbox = daytona.create(Daytona::CreateSandboxFromSnapshotParams.new(snapshot: 'daytona-vm-small')) # Write a file to the filesystem sandbox.fs.upload_file('done', 'setup.log') # A filesystem snapshot requires a stopped sandbox sandbox.stop sandbox.create_snapshot(name: 'my-vm-snapshot') # A sandbox created from the snapshot starts with the same filesystem new_sandbox = daytona.create(Daytona::CreateSandboxFromSnapshotParams.new(snapshot: 'my-vm-snapshot')) content = new_sandbox.fs.download_file('setup.log') puts content # done ``` ```go package main import ( "context" "fmt" "github.com/daytona/clients/sdk-go/pkg/daytona" "github.com/daytona/clients/sdk-go/pkg/types" ) func main() { client, _ := daytona.NewClient() ctx := context.Background() sandbox, err := client.Create(ctx, types.SnapshotParams{Snapshot: "daytona-vm-small"}) if err != nil { panic(err) } // Write a file to the filesystem if err := sandbox.FileSystem.UploadFile(ctx, []byte("done"), "setup.log"); err != nil { panic(err) } // A filesystem snapshot requires a stopped sandbox if err := sandbox.Stop(ctx); err != nil { panic(err) } if err := sandbox.CreateSnapshot(ctx, "my-vm-snapshot"); err != nil { panic(err) } // A sandbox created from the snapshot starts with the same filesystem newSandbox, err := client.Create(ctx, types.SnapshotParams{Snapshot: "my-vm-snapshot"}) if err != nil { panic(err) } content, err := newSandbox.FileSystem.DownloadFile(ctx, "setup.log", nil) if err != nil { panic(err) } fmt.Println(string(content)) // done } ``` ```java import io.daytona.sdk.Daytona; import io.daytona.sdk.Sandbox; import io.daytona.sdk.model.CreateSandboxFromSnapshotParams; public class App { public static void main(String[] args) { try (Daytona daytona = new Daytona()) { CreateSandboxFromSnapshotParams params = new CreateSandboxFromSnapshotParams(); params.setSnapshot("daytona-vm-small"); Sandbox sandbox = daytona.create(params); // Write a file to the filesystem sandbox.fs.uploadFile("done".getBytes(), "setup.log"); // A filesystem snapshot requires a stopped sandbox sandbox.stop(); sandbox.createSnapshot("my-vm-snapshot"); // A sandbox created from the snapshot starts with the same filesystem CreateSandboxFromSnapshotParams fromSnapshot = new CreateSandboxFromSnapshotParams(); fromSnapshot.setSnapshot("my-vm-snapshot"); Sandbox newSandbox = daytona.create(fromSnapshot); byte[] content = newSandbox.fs.downloadFile("setup.log"); System.out.println(new String(content)); // done } } } ``` ```bash curl 'https://app.daytona.io/api/sandbox' \ --request POST \ --header 'Content-Type: application/json' \ --header 'Authorization: Bearer YOUR_API_KEY' \ --data '{"snapshot": "daytona-vm-small"}' # Write a file to the filesystem curl 'https://proxy.app.daytona.io/toolbox/{sandboxId}/files/upload-v2?path=setup.log' \ --request POST \ --header 'Authorization: Bearer YOUR_API_KEY' \ --form 'file=@setup.log' # A filesystem snapshot requires a stopped sandbox curl 'https://app.daytona.io/api/sandbox/{sandboxId}/stop' \ --request POST \ --header 'Authorization: Bearer YOUR_API_KEY' curl 'https://app.daytona.io/api/sandbox/{sandboxId}/snapshot' \ --request POST \ --header 'Content-Type: application/json' \ --header 'Authorization: Bearer YOUR_API_KEY' \ --data '{ "name": "my-vm-snapshot", "includeMemory": false }' # A sandbox created from the snapshot starts with the same filesystem curl 'https://app.daytona.io/api/sandbox' \ --request POST \ --header 'Content-Type: application/json' \ --header 'Authorization: Bearer YOUR_API_KEY' \ --data '{"snapshot": "my-vm-snapshot"}' curl 'https://proxy.app.daytona.io/toolbox/{newSandboxId}/files/download?path=setup.log' \ --header 'Authorization: Bearer YOUR_API_KEY' ``` ## Lifecycle Every Linux sandbox moves through a lifecycle. A Linux sandbox can have several different states. Each state reflects the status of your sandbox. A Linux sandbox transitions between states in response to user actions, or automatically when one of its [timeouts](#timeouts) elapses. | **Feature** | **Container** | **Container (ephemeral)** | **Linux VM** | **Linux VM (ephemeral)** | | ------------------------------------------------- | ------------- | ------------------------- | ------------ | ------------------------ | | **Stop and start** | ✓ | ✗ | ✓ | ✗ | | **Pause and resume** | ✗ | ✗ | ✓ | ✗ | | **Fork** | ✗ | ✗ | ✓ | ✓ | | **Archive** | ✓ | ✗ | ✗ | ✗ | | **Delete** | ✓ | ✓ | ✓ | ✓ | | **Filesystem persistence** | ✓ | ✗ | ✓ | ✗ | | **Memory persistence** | ✗ | ✗ | ✓ | ✗ | | **Memory snapshot** | ✗ | ✗ | ✓ | ✓ | | **Filesystem snapshot** | ✓ | ✗ | ✓ | ✗ | | **Nested virtualization** | ✗ | ✗ | ✓ | ✓ | | **Desktop** | ✓ VNC | ✓ VNC | ✓ VNC | ✓ VNC | | **State** | **Description** | | ---------------------- | --------------------------------------------------------------------------------------------------- | | **Pending Build** | The build is queued. | | **Building Snapshot** | The sandbox is building a snapshot from an image. Container sandboxes only. | | **Pulling Snapshot** | The sandbox is pulling a snapshot. | | **Creating** | The sandbox is being created. | | **Starting** | The sandbox is starting. | | **Started** | The sandbox is running and accepts requests. | | **Stopping** | The sandbox is stopping and does not accept new requests. | | **Stopped** | The sandbox is stopped. The filesystem is kept and memory is cleared. | | **Pausing** | The Linux VM sandbox is pausing. | | **Paused** | The Linux VM sandbox is paused with its filesystem and memory preserved. | | **Resuming** | The Linux VM sandbox is resuming from the paused state. | | **Archiving** | The container sandbox filesystem is moving to object storage. | | **Archived** | The container sandbox filesystem is in object storage. | | **Restoring** | The sandbox is being restored. | | **Resizing** | The sandbox resources are being changed. | | **Snapshotting** | The sandbox is creating a memory snapshot or a filesystem snapshot. | | **Forking** | The Linux VM sandbox is being forked. | | **Deleting** | The sandbox is being deleted. | | **Deleted** | The sandbox is deleted. | | **Error** | The sandbox hit an error. A recoverable error can be recovered. | | **Initial state** | **Target state** | **Trigger** | | ----------------- | ---------------- | ------------------------------------------------------------------------------------ | | **Started** | **Stopping** | A stop is requested, or the auto-stop interval elapses. | | **Stopping** | **Stopped** | The shutdown completes. The filesystem is kept and memory is cleared. | | **Stopped** | **Starting** | A start is requested. | | **Started** | **Pausing** | A pause is requested on a Linux VM sandbox, or the auto-pause interval elapses. | | **Pausing** | **Paused** | The filesystem and memory are preserved. | | **Paused** | **Resuming** | A start is requested on a paused Linux VM sandbox. | | **Paused** | **Stopping** | A stop is requested on a paused Linux VM sandbox. | | **Resuming** | **Started** | The sandbox resumes from memory and is running. | | **Stopped** | **Archiving** | An archive is requested on a container sandbox, or the auto-archive interval elapses. | | **Archived** | **Restoring** | A start is requested on an archived container sandbox. | | **Started** | **Snapshotting** | A memory snapshot is requested on a Linux VM sandbox. | | **Stopped** | **Snapshotting** | A filesystem snapshot is requested. | | **Started** | **Forking** | A fork is requested on a Linux VM sandbox. | | **Started** | **Deleting** | A delete is requested, or an ephemeral sandbox is stopped. | | **Stopped** | **Deleting** | A delete is requested, or the auto-delete interval elapses. | | **Deleting** | **Deleted** | The sandbox is removed and its resources are released. | ### Wait for state Wait until a sandbox reaches the started or stopped state. Each method takes a timeout in seconds. ```python sandbox.wait_for_sandbox_start(timeout=60) sandbox.wait_for_sandbox_stop(timeout=60) ``` ```typescript await sandbox.waitUntilStarted(60) await sandbox.waitUntilStopped(60) ``` ```ruby sandbox.wait_for_sandbox_start(60) sandbox.wait_for_sandbox_stop(60) ``` ```go err := sandbox.WaitForStart(ctx, 60*time.Second) err = sandbox.WaitForStop(ctx, 60*time.Second) ``` ```java sandbox.waitUntilStarted(60); sandbox.waitUntilStopped(60); ``` ### Stop / start Stop a sandbox. The sandbox moves to the **stopped** state when shutdown completes. While a stop is in progress, the sandbox is in the **stopping** state and does not accept new requests. Stopping terminates the running container. The filesystem is preserved, but memory state is not. Container sandboxes do not support pause; stop is the way to shut down a container sandbox when it is not in use. 1. Go to [Daytona Sandboxes ↗](https://app.daytona.io/dashboard/sandboxes) 2. Click the stop icon (**⏹**) next to the sandbox you want to stop ```python sandbox.stop() ``` ```typescript await sandbox.stop() ``` ```ruby sandbox.stop ``` ```go sandbox.Stop(ctx) ``` ```java sandbox.stop(); ``` ```bash daytona stop [SANDBOX_ID] | [SANDBOX_NAME] [flags] ``` ```bash curl 'https://app.daytona.io/api/sandbox/{sandboxIdOrName}/stop' \ --request POST \ --header 'Authorization: Bearer YOUR_API_KEY' ``` Stopping shuts down the virtual machine while preserving the filesystem. Memory state is cleared. To preserve running process state without consuming CPU, use [pause / resume](#pause--resume). 1. Go to [Daytona Sandboxes ↗](https://app.daytona.io/dashboard/sandboxes) 2. Click the stop icon (**⏹**) next to the sandbox you want to stop ```python sandbox.stop() ``` ```typescript await sandbox.stop() ``` ```ruby sandbox.stop ``` ```go sandbox.Stop(ctx) ``` ```java sandbox.stop(); ``` ```bash daytona stop [SANDBOX_ID] | [SANDBOX_NAME] [flags] ``` ```bash curl 'https://app.daytona.io/api/sandbox/{sandboxIdOrName}/stop' \ --request POST \ --header 'Authorization: Bearer YOUR_API_KEY' ``` :::note[Force stop] If you need a faster shutdown, use force stop (`force=true` / `--force`) to terminate the sandbox immediately. Force stop is ungraceful and should be used when quick termination is more important than process cleanup. Avoid force stop for normal shutdowns where the process should flush buffers, write final state, or run cleanup. ::: Start a sandbox. 1. Go to [Daytona Sandboxes ↗](https://app.daytona.io/dashboard/sandboxes) 2. Click the start icon next to the sandbox you want to start ```python sandbox.start() ``` ```typescript await sandbox.start() ``` ```ruby sandbox.start ``` ```go sandbox.Start(ctx) ``` ```java sandbox.start(); ``` ```bash daytona start [SANDBOX_ID] | [SANDBOX_NAME] [flags] ``` ```bash curl 'https://app.daytona.io/api/sandbox/{sandboxIdOrName}/start' \ --request POST \ --header 'Authorization: Bearer YOUR_API_KEY' ``` ### Pause / resume Pause and resume a sandbox. Pause is not supported for container sandboxes. The filesystem can be preserved on stop, but memory state is not. Use [stop](#stop--start) to shut down a container sandbox when it is not in use. The filesystem and memory state are preserved, and CPU is no longer consumed. 1. Ensure the Linux VM sandbox is **started** 2. **Pause** the Linux VM sandbox 3. Wait for the Linux VM sandbox to reach the **paused** state 4. **Resume** (start) the Linux VM sandbox again when you need to resume it ```python sandbox.pause() ``` ```typescript await sandbox.pause() ``` ```ruby sandbox.pause ``` ```go sandbox.Pause(ctx) ``` ```java sandbox.pause(); ``` ```bash daytona pause [SANDBOX_ID] | [SANDBOX_NAME] ``` ```bash curl 'https://app.daytona.io/api/sandbox/{sandboxIdOrName}/pause' \ --request POST \ --header 'Authorization: Bearer YOUR_API_KEY' ``` ### Fork Fork a sandbox. Forking is not supported for container sandboxes. Use [create snapshot from sandbox](https://www.daytona.io/docs/en/snapshots.md#create-snapshot-from-sandbox) to capture filesystem state, then create a new sandbox from that snapshot. Forking creates a duplicate of a Linux VM sandbox's filesystem and memory state in a new sandbox. The forked sandbox is fully independent: it can be started, stopped, and deleted without affecting the original. Daytona tracks the parent-child relationship in a fork tree, so you can trace a fork's lineage back to the sandbox it was created from. You can fork a fork to build branches. The parent sandbox cannot be deleted while it has active fork children. A fork of a [KVM sandbox](#nested-virtualization) inherits the `kvm` setting. Forking a KVM sandbox returns a `403` error if KVM sandboxes are not enabled for your organization. 1. Go to [Daytona Sandboxes ↗](https://app.daytona.io/dashboard/sandboxes) 2. Click the three-dot menu (**⋮**) next to the started Linux VM sandbox you want to fork 3. Select ```python # Fork sandbox through the Sandbox instance forked = sandbox.fork(name="my-forked-sandbox") ``` ```typescript // Fork sandbox through the Sandbox instance const forkedSandbox = await sandbox.fork({ name: "my-forked-sandbox" }); // Or use the Daytona helper method const helperForkedSandbox = await daytona.fork(sandbox, { name: "my-forked-sandbox" }); ``` ```ruby # Fork sandbox through the Sandbox instance forkedSandbox = sandbox.fork(name: "my-forked-sandbox") ``` ```go // Fork sandbox through the Sandbox instance name := "my-forked-sandbox" forkedSandbox, err := sandbox.Fork(ctx, &name) if err != nil { return err } ``` ```java // Fork sandbox through the Sandbox instance Sandbox forkedSandbox = sandbox.fork("my-forked-sandbox", 60); ``` ```bash curl 'https://app.daytona.io/api/sandbox/{sandboxIdOrName}/fork' \ --request POST \ --header 'X-Daytona-Organization-ID: YOUR_ORGANIZATION_ID' \ --header 'Content-Type: application/json' \ --header 'Authorization: Bearer YOUR_API_KEY' \ --data '{ "name": "my-forked-sandbox" }' ``` Query fork relationships: ```bash # List direct fork children of a sandbox curl 'https://app.daytona.io/api/sandbox/{sandboxIdOrName}/forks' \ --header 'Authorization: Bearer YOUR_API_KEY' # Get the parent sandbox of a fork curl 'https://app.daytona.io/api/sandbox/{sandboxIdOrName}/parent' \ --header 'Authorization: Bearer YOUR_API_KEY' # Get the full ancestor chain (parent, grandparent, and so on) curl 'https://app.daytona.io/api/sandbox/{sandboxIdOrName}/ancestors' \ --header 'Authorization: Bearer YOUR_API_KEY' ``` ### Delete Delete a sandbox. :::note By default delete is fire-and-forget: it returns as soon as the API accepts the deletion request, without waiting for the sandbox to be destroyed. Pass the `wait` flag to block until the sandbox reaches the destroyed state. ::: 1. Go to [Daytona Sandboxes ↗](https://app.daytona.io/dashboard/sandboxes) 2. Click next to the sandbox you want to delete ```python sandbox.delete() # Block until the sandbox is deleted sandbox.delete(timeout=60, wait=True) ``` ```typescript await sandbox.delete() // Block until the sandbox is deleted await sandbox.delete(60, true) ``` ```ruby sandbox.delete # Block until the sandbox is deleted sandbox.delete(60, wait: true) ``` ```go err = sandbox.Delete(ctx) // Block until the sandbox is deleted err = sandbox.DeleteAndWait(ctx, 60*time.Second) ``` ```java sandbox.delete(); // Block until the sandbox is deleted sandbox.delete(60, true); ``` ```bash daytona delete [SANDBOX_ID] | [SANDBOX_NAME] ``` ```bash curl 'https://app.daytona.io/api/sandbox/{sandboxIdOrName}' \ --request DELETE \ --header 'Authorization: Bearer YOUR_API_KEY' ``` ### Timeouts Daytona stops, pauses, archives, or deletes a sandbox when a timeout elapses. Each timeout is set in minutes. Zero disables auto-stop, auto-pause, and wall-clock TTL. Zero does not disable auto-archive or auto-delete: auto-archive set to zero uses the maximum interval of 30 days, and auto-delete set to zero deletes the sandbox as soon as it stops. To disable auto-delete, set it to -1. | **Interval** | **Container** | **Linux VM** | **Action** | | -------------------------------------------------------------- | ---------------------------- | ----------------------------------- | -------------------------------------------------- | | **Auto-stop** | ✓ (default 15 minutes) | ✓ | Stops the sandbox after inactivity. | | **Auto-pause** | ✗ | ✓ (default 60 minutes) | Pauses the sandbox after inactivity. | | **Auto-archive** | ✓ | ✗ | Archives a stopped sandbox. | | **Auto-delete** | ✓ | ✓ | Deletes a stopped sandbox. | | **Wall-clock TTL** | ✓ | ✓ | Deletes the sandbox at a fixed deadline, in any state. | #### Auto-pause The auto-pause interval sets the amount of time after which an idle VM sandbox is automatically [paused](#pause--resume). Auto-pause applies only to [VM sandboxes](https://www.daytona.io/docs/en/sandboxes.md#vm-sandboxes) and is mutually exclusive with the [auto-stop interval](https://www.daytona.io/docs/en/sandboxes.md#auto-stop-interval): at most one of the two intervals may be non-zero. Ephemeral sandboxes cannot have auto-pause enabled. The interval is set in minutes: - **`0`**: disables the auto-pause functionality - if neither auto-pause nor auto-stop is set, non-ephemeral sandbox classes that support pausing default to an auto-pause interval of 60 minutes with auto-stop disabled The sandbox pauses after no new events occur for the specified interval. Events include sandbox state changes and interactions with the sandbox through the SDK. Interactions through [sandbox previews](https://www.daytona.io/docs/en/preview.md) do not reset the timer. Auto-pause is not supported for container sandboxes. Use [auto-stop](https://www.daytona.io/docs/en/sandboxes.md#auto-stop-interval) to stop a container sandbox after a period of inactivity. 1. Go to [Daytona Sandboxes ↗](https://app.daytona.io/dashboard/sandboxes) 2. Click 3. Select a Linux VM snapshot 4. Set **`auto-pause`** interval to the desired value in minutes - **`0`**: disables the auto-pause functionality - if neither auto-pause nor auto-stop is set, the default interval of 60 minutes is used with auto-stop disabled 5. Click ```python from daytona import CreateSandboxFromSnapshotParams sandbox = daytona.create(CreateSandboxFromSnapshotParams( snapshot="daytona-vm-small", # Auto-pause after 1 hour of inactivity auto_pause_interval=60, )) # Update the auto-pause interval on an existing sandbox sandbox.set_auto_pause_interval(60) # Disable auto-pause sandbox.set_auto_pause_interval(0) ``` ```typescript const sandbox = await daytona.create({ snapshot: 'daytona-vm-small', // Auto-pause after 1 hour of inactivity autoPauseInterval: 60, }) // Update the auto-pause interval on an existing sandbox await sandbox.setAutoPauseInterval(60) // Disable auto-pause await sandbox.setAutoPauseInterval(0) ``` ```ruby sandbox = daytona.create( Daytona::CreateSandboxFromSnapshotParams.new( snapshot: 'daytona-vm-small', # Auto-pause after 1 hour of inactivity auto_pause_interval: 60 ) ) # Update the auto-pause interval on an existing sandbox sandbox.auto_pause_interval = 60 # Disable auto-pause sandbox.auto_pause_interval = 0 ``` ```go // Auto-pause after 1 hour of inactivity autoPauseInterval := 60 params := types.SnapshotParams{ Snapshot: "daytona-vm-small", SandboxBaseParams: types.SandboxBaseParams{ AutoPauseInterval: &autoPauseInterval, }, } sandbox, err := client.Create(ctx, params) ``` ```java import io.daytona.sdk.Daytona; import io.daytona.sdk.Sandbox; import io.daytona.sdk.model.CreateSandboxFromSnapshotParams; public class App { public static void main(String[] args) { try (Daytona daytona = new Daytona()) { CreateSandboxFromSnapshotParams params = new CreateSandboxFromSnapshotParams(); params.setSnapshot("daytona-vm-small"); // Auto-pause after 1 hour of inactivity params.setAutoPauseInterval(60); Sandbox sandbox = daytona.create(params); // Update the auto-pause interval on an existing sandbox sandbox.setAutoPauseInterval(60); // Disable auto-pause sandbox.setAutoPauseInterval(0); } } } ``` ```bash curl 'https://app.daytona.io/api/sandbox/{sandboxIdOrName}/autopause/{interval}' \ --request POST \ --header 'Authorization: Bearer YOUR_API_KEY' ``` Auto-pause is not supported for GPU sandboxes. GPU sandboxes are ephemeral and cannot have auto-pause enabled.
#### Wall-clock TTL The wall-clock TTL (time-to-live) sets a hard upper bound on how long a sandbox may exist. Unlike the [auto-delete interval](https://www.daytona.io/docs/en/sandboxes.md#auto-delete-interval), which counts time only while the sandbox is stopped, TTL runs as wall-clock time from creation (or from the moment you last set it) and destroys the sandbox in any state: started, stopped, paused, or archived. Set `ttl_minutes` when creating a sandbox, or update it later. The value is in minutes: - **`0`**: disables the TTL - if not set, the sandbox has no TTL deadline Calling `set_ttl` after creation resets the deadline from the current moment. Use wall-clock TTL for agent sessions, CI jobs, and any sandbox that must not outlive a fixed deadline. ```python sandbox = daytona.create(CreateSandboxFromSnapshotParams( snapshot="daytona-vm-small", ttl_minutes=120, )) # Reset the deadline to 60 minutes from now sandbox.set_ttl(60) ``` ```typescript const sandbox = await daytona.create({ snapshot: 'daytona-vm-small', ttlMinutes: 120, }) // Reset the deadline to 60 minutes from now await sandbox.setTtl(60) ``` ```ruby sandbox = daytona.create( Daytona::CreateSandboxFromSnapshotParams.new( snapshot: 'daytona-vm-small', ttl_minutes: 120 ) ) # Reset the deadline to 60 minutes from now sandbox.ttl_minutes = 60 ``` ```go ttlMinutes := 120 sandbox, err := client.Create(ctx, types.SnapshotParams{ Snapshot: "daytona-vm-small", SandboxBaseParams: types.SandboxBaseParams{ TtlMinutes: &ttlMinutes, }, }) ``` ```java CreateSandboxFromSnapshotParams params = new CreateSandboxFromSnapshotParams(); params.setSnapshot("daytona-vm-small"); params.setTtlMinutes(120); Sandbox sandbox = daytona.create(params); // Reset the deadline to 60 minutes from now sandbox.setTtl(60); ``` ```bash daytona create --snapshot daytona-vm-small --ttl 120 ``` ```bash curl 'https://app.daytona.io/api/sandbox' \ --request POST \ --header 'Content-Type: application/json' \ --header 'Authorization: Bearer YOUR_API_KEY' \ --data '{ "snapshot": "daytona-vm-small", "ttlMinutes": 120 }' # Reset the deadline to 60 minutes from now curl 'https://app.daytona.io/api/sandbox/{sandboxIdOrName}/ttl/60' \ --request POST \ --header 'Authorization: Bearer YOUR_API_KEY' ```