# Linux Sandboxes (/docs/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 [#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-linux-sandbox]

Create a sandbox.

<Tabs syncKey="linux-create">
<TabItem label="Default">

Create a container sandbox. A sandbox created without a snapshot uses the Daytona default snapshot. To pick a size, set one of the default container snapshots.

| **Snapshot**            | **vCPU** | **Memory** | **Storage** | **Sandbox Class** |
| ----------------------- | -------- | ---------- | ----------- | ----------------- |
| **`daytona-small`**     | 1        | 1GiB       | 3GiB        | Container         |
| **`daytona-medium`**    | 2        | 4GiB       | 8GiB        | Container         |
| **`daytona-large`**     | 4        | 8GiB       | 10GiB       | Container         |
| **`daytona-vm-small`**  | 1        | 1GiB       | 3GiB        | Linux VM          |
| **`daytona-vm-medium`** | 2        | 4GiB       | 8GiB        | Linux VM          |
| **`daytona-vm-large`**  | 4        | 8GiB       | 10GiB       | Linux VM          |

1. Go to [Daytona Sandboxes ↗](https://app.daytona.io/dashboard/sandboxes)
2. Click <Button>Create Sandbox</Button>
3. Click <Button>Create</Button>

<Tabs syncKey="language">
<TabItem label="Python" icon="seti:python">

```python
from daytona import Daytona

daytona = Daytona()
sandbox = daytona.create()
```

</TabItem>
<TabItem label="TypeScript" icon="seti:typescript">

```typescript
import { Daytona } from '@daytona/sdk'

const daytona = new Daytona()
const sandbox = await daytona.create()
```

</TabItem>
<TabItem label="Ruby" icon="seti:ruby">

```ruby
require 'daytona'

daytona = Daytona::Daytona.new
sandbox = daytona.create
```

</TabItem>
<TabItem label="Go" icon="seti:go">

```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)
}
```

</TabItem>
<TabItem label="Java" icon="seti:java">

```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();
        }
    }
}
```

</TabItem>
<TabItem label="CLI" icon="seti:shell">

```bash
daytona create
```

</TabItem>
<TabItem label="API" icon="seti:json">

```bash
curl 'https://app.daytona.io/api/sandbox' \
  --request POST \
  --header 'Content-Type: application/json' \
  --header 'Authorization: Bearer YOUR_API_KEY' \
  --data '{}'
```

</TabItem>
</Tabs>

</TabItem>
<TabItem label="Custom">

Create a Linux sandbox from your own snapshot. Create the snapshot from any publicly accessible image, then create sandboxes from it.

1. Go to [Daytona Snapshots ↗](https://app.daytona.io/dashboard/snapshots)
2. Click <Button>Create Snapshot</Button>
3. Enter the <Button>Snapshot Name</Button>, for example **`my-snapshot`**
4. Enter the <Button>Image</Button>, for example **`python:3.12`**
5. Click <Button>Create</Button>
6. Go to [Daytona Sandboxes ↗](https://app.daytona.io/dashboard/sandboxes)
7. Click <Button>Create Sandbox</Button>
8. Select the <Button>Snapshot</Button> **`my-snapshot`**
9. Click <Button>Create</Button>

<Tabs syncKey="language">
<TabItem label="Python" icon="seti:python">

```python
from daytona import CreateSandboxFromSnapshotParams, CreateSnapshotParams, Daytona

daytona = Daytona()

# Create a snapshot from an image
daytona.snapshot.create(
    CreateSnapshotParams(
        name="my-snapshot",
        image="python:3.12",
    ),
)

# Create a sandbox from the snapshot
sandbox = daytona.create(CreateSandboxFromSnapshotParams(snapshot="my-snapshot"))
```

</TabItem>
<TabItem label="TypeScript" icon="seti:typescript">

```typescript
import { Daytona } from '@daytona/sdk'

const daytona = new Daytona()

// Create a snapshot from an image
await daytona.snapshot.create({
  name: 'my-snapshot',
  image: 'python:3.12',
})

// Create a sandbox from the snapshot
const sandbox = await daytona.create({ snapshot: 'my-snapshot' })
```

</TabItem>
<TabItem label="Ruby" icon="seti:ruby">

```ruby
require 'daytona'

daytona = Daytona::Daytona.new

# Create a snapshot from an image
daytona.snapshot.create(
  Daytona::CreateSnapshotParams.new(
    name: 'my-snapshot',
    image: 'python:3.12'
  )
)

# Create a sandbox from the snapshot
sandbox = daytona.create(Daytona::CreateSandboxFromSnapshotParams.new(snapshot: 'my-snapshot'))
```

</TabItem>
<TabItem label="Go" icon="seti:go">

```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 snapshot from an image
	_, logCh, _ := client.Snapshot.Create(ctx, &types.CreateSnapshotParams{
		Name:  "my-snapshot",
		Image: "python:3.12",
	})
	for range logCh {
	}

	// Create a sandbox from the snapshot
	_, _ = client.Create(ctx, types.SnapshotParams{Snapshot: "my-snapshot"})
}
```

</TabItem>
<TabItem label="Java" icon="seti:java">

```java
import io.daytona.sdk.Daytona;
import io.daytona.sdk.Sandbox;
import io.daytona.sdk.model.CreateSandboxFromSnapshotParams;
import io.daytona.sdk.model.Snapshot;

public class App {
    public static void main(String[] args) {
        try (Daytona daytona = new Daytona()) {
            // Create a snapshot from an image
            Snapshot snapshot = daytona.snapshot().create("my-snapshot", "python:3.12");

            // Create a sandbox from the snapshot
            CreateSandboxFromSnapshotParams params = new CreateSandboxFromSnapshotParams();
            params.setSnapshot("my-snapshot");
            Sandbox sandbox = daytona.create(params);
        }
    }
}
```

</TabItem>
<TabItem label="CLI" icon="seti:shell">

```bash
daytona snapshot create my-snapshot --image python:3.12
daytona create --snapshot my-snapshot
```

</TabItem>
<TabItem label="API" icon="seti:json">

```bash
# Create a snapshot from an image
curl 'https://app.daytona.io/api/snapshots' \
  --request POST \
  --header 'Content-Type: application/json' \
  --header 'Authorization: Bearer YOUR_API_KEY' \
  --data '{
    "name": "my-snapshot",
    "imageName": "python:3.12"
  }'

# Create a 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-snapshot"}'
```

</TabItem>
</Tabs>

</TabItem>
</Tabs>

## Create a Linux VM sandbox [#create-a-linux-vm-sandbox]

Create a Linux VM sandbox.

<Callout type="note" title="Limitations">
VM sandboxes can currently only be created from existing VM snapshots. Dynamic builds through the declarative builder are supported for container sandboxes only.
</Callout>

<Tabs syncKey="linux-vm-create">
<TabItem label="Default">

Create a Linux VM sandbox from a default snapshot.

| **Snapshot**            | **vCPU** | **Memory** | **Storage** |
| ----------------------- | -------- | ---------- | ----------- |
| **`daytona-vm-small`**  | 1        | 1GiB       | 3GiB        |
| **`daytona-vm-medium`** | 2        | 4GiB       | 8GiB        |
| **`daytona-vm-large`**  | 4        | 8GiB       | 10GiB       |

1. Go to [Daytona Sandboxes ↗](https://app.daytona.io/dashboard/sandboxes)
2. Click <Button>Create Sandbox</Button>
3. Select a VM <Button>Snapshot</Button>: **`daytona-vm-small`**, **`daytona-vm-medium`**, or **`daytona-vm-large`**
4. Click <Button>Create</Button>

<Tabs syncKey="language">
<TabItem label="Python" icon="seti:python">

```python
from daytona import Daytona, CreateSandboxFromSnapshotParams

daytona = Daytona()
sandbox = daytona.create(CreateSandboxFromSnapshotParams(snapshot="daytona-vm-small"))
```

</TabItem>
<TabItem label="TypeScript" icon="seti:typescript">

```typescript
import { Daytona } from '@daytona/sdk'

const daytona = new Daytona()
const sandbox = await daytona.create({ snapshot: 'daytona-vm-small' })
```

</TabItem>
<TabItem label="Ruby" icon="seti:ruby">

```ruby
require 'daytona'

daytona = Daytona::Daytona.new
sandbox = daytona.create(
  Daytona::CreateSandboxFromSnapshotParams.new(snapshot: 'daytona-vm-small')
)
```

</TabItem>
<TabItem label="Go" icon="seti:go">

```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",
	})
}
```

</TabItem>
<TabItem label="Java" icon="seti:java">

```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);
        }
    }
}
```

</TabItem>
<TabItem label="CLI" icon="seti:shell">

```bash
daytona create --snapshot daytona-vm-small
```

</TabItem>
<TabItem label="API" icon="seti:json">

```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"
}'
```

</TabItem>
</Tabs>

</TabItem>
<TabItem label="Custom">

Create a Linux VM sandbox.

1. Go to [Daytona Snapshots ↗](https://app.daytona.io/dashboard/snapshots)
2. Click <Button>Create Snapshot</Button>
3. Enter the <Button>Snapshot Name</Button>, for example **`my-vm-snapshot`**
4. Enter the <Button>Image</Button>, for example **`ubuntu:22.04`**
5. Select <Button>Sandbox Class</Button>: **`LINUX_VM`**
6. Click <Button>Create</Button>
7. Go to [Daytona Sandboxes ↗](https://app.daytona.io/dashboard/sandboxes)
8. Click <Button>Create Sandbox</Button>
9. Select the VM <Button>Snapshot</Button>, for example **`my-vm-snapshot`**
10. Click <Button>Create</Button>

<Tabs syncKey="language">
<TabItem label="Python" icon="seti:python">

```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"))
```

</TabItem>
<TabItem label="TypeScript" icon="seti:typescript">

```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' })
```

</TabItem>
<TabItem label="Ruby" icon="seti:ruby">

```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'))
```

</TabItem>
<TabItem label="Go" icon="seti:go">

```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",
	})
}
```

</TabItem>
<TabItem label="Java" icon="seti:java">

```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);
        }
    }
}
```

</TabItem>
<TabItem label="CLI" icon="seti:shell">

```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
```

</TabItem>
<TabItem label="API" icon="seti:json">

```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"
}'
```

</TabItem>
</Tabs>

</TabItem>
</Tabs>

## Nested virtualization [#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.

<Callout type="note">
KVM sandboxes must be enabled for your organization. Contact [support@daytona.io](mailto:support@daytona.io).
</Callout>

<Tabs syncKey="language">
<TabItem label="Python" icon="seti:python">

```python
from daytona import Daytona, CreateSandboxFromSnapshotParams

daytona = Daytona()
sandbox = daytona.create(
    CreateSandboxFromSnapshotParams(
        snapshot="daytona-vm-small",
        kvm=True,
    )
)
```

</TabItem>
<TabItem label="TypeScript" icon="seti:typescript">

```typescript
import { Daytona } from '@daytona/sdk'

const daytona = new Daytona()
const sandbox = await daytona.create({
  snapshot: 'daytona-vm-small',
  kvm: true,
})
```

</TabItem>
<TabItem label="Ruby" icon="seti:ruby">

```ruby
require 'daytona'

daytona = Daytona::Daytona.new
sandbox = daytona.create(
  Daytona::CreateSandboxFromSnapshotParams.new(
    snapshot: 'daytona-vm-small',
    kvm: true
  )
)
```

</TabItem>
<TabItem label="Go" icon="seti:go">

```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)
}
```

</TabItem>
<TabItem label="Java" icon="seti:java">

```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);
        }
    }
}
```

</TabItem>
<TabItem label="CLI" icon="seti:shell">

```bash
daytona create --snapshot daytona-vm-small --kvm
```

</TabItem>
<TabItem label="API" icon="seti:json">

```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
}'
```

</TabItem>
</Tabs>

## Filesystem snapshot [#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.

<Tabs syncKey="sandbox-class">
<TabItem label="Container" icon="seti:docker">

<Tabs syncKey="language">
<TabItem label="Python" icon="seti:python">

```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
```

</TabItem>
<TabItem label="TypeScript" icon="seti:typescript">

```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
```

</TabItem>
<TabItem label="Ruby" icon="seti:ruby">

```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
```

</TabItem>
<TabItem label="Go" icon="seti:go">

```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
}
```

</TabItem>
<TabItem label="Java" icon="seti:java">

```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
        }
    }
}
```

</TabItem>
<TabItem label="API" icon="seti:json">

```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'
```

</TabItem>
</Tabs>

</TabItem>
<TabItem label="Linux VM" icon="linux">

<Tabs syncKey="language">
<TabItem label="Python" icon="seti:python">

```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
```

</TabItem>
<TabItem label="TypeScript" icon="seti:typescript">

```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
```

</TabItem>
<TabItem label="Ruby" icon="seti:ruby">

```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
```

</TabItem>
<TabItem label="Go" icon="seti:go">

```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
}
```

</TabItem>
<TabItem label="Java" icon="seti:java">

```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
        }
    }
}
```

</TabItem>
<TabItem label="API" icon="seti:json">

```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'
```

</TabItem>
</Tabs>

</TabItem>
</Tabs>

## Memory snapshot [#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. Container sandboxes do not support memory snapshots.

<Tabs syncKey="language">
<TabItem label="API" icon="seti:json">

```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
}'
```

</TabItem>
</Tabs>

## Filesystem persistence [#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](/docs/sandboxes#archive-sandboxes), and [filesystem snapshots](#filesystem-snapshot) created from a sandbox. An [ephemeral sandbox](/docs/sandboxes#ephemeral-sandboxes) is deleted on stop, so its filesystem is not kept. The sandbox classes differ in where the preserved filesystem is stored.

| **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.                                 |

<Tabs syncKey="sandbox-class">
<TabItem label="Container" icon="seti:docker">

<Tabs syncKey="language">
<TabItem label="Python" icon="seti:python">

```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
```

</TabItem>
<TabItem label="TypeScript" icon="seti:typescript">

```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
```

</TabItem>
<TabItem label="Ruby" icon="seti:ruby">

```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
```

</TabItem>
<TabItem label="Go" icon="seti:go">

```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
}
```

</TabItem>
<TabItem label="Java" icon="seti:java">

```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
        }
    }
}
```

</TabItem>
<TabItem label="CLI" icon="seti:shell">

```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
```

</TabItem>
<TabItem label="API" icon="seti:json">

```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'
```

</TabItem>
</Tabs>

</TabItem>
<TabItem label="Linux VM" icon="linux">

<Tabs syncKey="language">
<TabItem label="Python" icon="seti:python">

```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
```

</TabItem>
<TabItem label="TypeScript" icon="seti:typescript">

```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
```

</TabItem>
<TabItem label="Ruby" icon="seti:ruby">

```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
```

</TabItem>
<TabItem label="Go" icon="seti:go">

```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
}
```

</TabItem>
<TabItem label="Java" icon="seti:java">

```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
        }
    }
}
```

</TabItem>
<TabItem label="CLI" icon="seti:shell">

```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
```

</TabItem>
<TabItem label="API" icon="seti:json">

```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'
```

</TabItem>
</Tabs>

</TabItem>
</Tabs>

## Memory persistence [#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. |

<Tabs syncKey="language">
<TabItem label="Python" icon="seti:python">

```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
```

</TabItem>
<TabItem label="TypeScript" icon="seti:typescript">

```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
```

</TabItem>
<TabItem label="Ruby" icon="seti:ruby">

```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
```

</TabItem>
<TabItem label="Go" icon="seti:go">

```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"]) // <nil>: the process is still running
}
```

</TabItem>
<TabItem label="Java" icon="seti:java">

```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
        }
    }
}
```

</TabItem>
<TabItem label="CLI" icon="seti:shell">

```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]
```

</TabItem>
<TabItem label="API" icon="seti:json">

```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'
```

</TabItem>
</Tabs>

## Lifecycle [#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.

<SandboxDiagram variant="linux" />

| **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                    |

<Collapsible title="Sandbox states">

| **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. |

</Collapsible>

<Collapsible title="State transitions">

| **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.                               |

</Collapsible>

### Wait for state [#wait-for-state]

Wait until a sandbox reaches the started or stopped state.

<Tabs syncKey="language">
<TabItem label="Python" icon="seti:python">

```python
sandbox.wait_for_sandbox_start(timeout=60)
sandbox.wait_for_sandbox_stop(timeout=60)
```

</TabItem>
<TabItem label="TypeScript" icon="seti:typescript">

```typescript
await sandbox.waitUntilStarted(60)
await sandbox.waitUntilStopped(60)
```

</TabItem>
<TabItem label="Ruby" icon="seti:ruby">

```ruby
sandbox.wait_for_sandbox_start(60)
sandbox.wait_for_sandbox_stop(60)
```

</TabItem>
<TabItem label="Go" icon="seti:go">

```go
err := sandbox.WaitForStart(ctx, 60*time.Second)
err = sandbox.WaitForStop(ctx, 60*time.Second)
```

</TabItem>
<TabItem label="Java" icon="seti:java">

```java
sandbox.waitUntilStarted(60);
sandbox.waitUntilStopped(60);
```

</TabItem>
</Tabs>

### Stop / start [#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.

<Tabs syncKey="sandbox-class">
<TabItem label="Container" icon="seti:docker">

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/start icon <Button>⏹</Button> / <Button>▶</Button> next to the sandbox you want to stop/start

<Tabs syncKey="language">
<TabItem label="Python" icon="seti:python">

```python
sandbox.stop()
```

```python
sandbox.start()
```

</TabItem>
<TabItem label="TypeScript" icon="seti:typescript">

```typescript
await sandbox.stop()
```

```typescript
await sandbox.start()
```

</TabItem>
<TabItem label="Ruby" icon="seti:ruby">

```ruby
sandbox.stop
```

```ruby
sandbox.start
```

</TabItem>
<TabItem label="Go" icon="seti:go">

```go
sandbox.Stop(ctx)
```

```go
sandbox.Start(ctx)
```

</TabItem>
<TabItem label="Java" icon="seti:java">

```java
sandbox.stop();
```

```java
sandbox.start();
```

</TabItem>
<TabItem label="CLI" icon="seti:shell">

```bash
daytona stop [SANDBOX_ID] | [SANDBOX_NAME] [flags]
```

```bash
daytona start [SANDBOX_ID] | [SANDBOX_NAME] [flags]
```

</TabItem>
<TabItem label="API" icon="seti:json">

```bash
curl 'https://app.daytona.io/api/sandbox/{sandboxIdOrName}/stop' \
  --request POST \
  --header 'Authorization: Bearer YOUR_API_KEY'
```

```bash
curl 'https://app.daytona.io/api/sandbox/{sandboxIdOrName}/start' \
  --request POST \
  --header 'Authorization: Bearer YOUR_API_KEY'
```

</TabItem>
</Tabs>

</TabItem>
<TabItem label="Linux VM" icon="linux">

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/start icon <Button>⏹</Button> / <Button>▶</Button> next to the sandbox you want to start/stop

<Tabs syncKey="language">
<TabItem label="Python" icon="seti:python">

```python
sandbox.stop()
```

```python
sandbox.start()
```

</TabItem>
<TabItem label="TypeScript" icon="seti:typescript">

```typescript
await sandbox.stop()
```

```typescript
await sandbox.start()
```

</TabItem>
<TabItem label="Ruby" icon="seti:ruby">

```ruby
sandbox.stop
```

```ruby
sandbox.start
```

</TabItem>
<TabItem label="Go" icon="seti:go">

```go
sandbox.Stop(ctx)
```

```go
sandbox.Start(ctx)
```

</TabItem>
<TabItem label="Java" icon="seti:java">

```java
sandbox.stop();
```

```java
sandbox.start();
```

</TabItem>
<TabItem label="CLI" icon="seti:shell">

```bash
daytona stop [SANDBOX_ID] | [SANDBOX_NAME] [flags]
daytona start [SANDBOX_ID] | [SANDBOX_NAME] [flags]
```

</TabItem>
<TabItem label="API" icon="seti:json">

```bash
curl 'https://app.daytona.io/api/sandbox/{sandboxIdOrName}/stop' \
  --request POST \
  --header 'Authorization: Bearer YOUR_API_KEY'
```

```bash
curl 'https://app.daytona.io/api/sandbox/{sandboxIdOrName}/start' \
  --request POST \
  --header 'Authorization: Bearer YOUR_API_KEY'
```

</TabItem>
</Tabs>

</TabItem>
</Tabs>

<Callout type="note" title="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.
</Callout>

<a id="pause-sandboxes"></a>

### Pause / resume [#pause--resume]

Pause and resume a sandbox.

<Tabs syncKey="sandbox-class">
<TabItem label="Container" icon="seti:docker">

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.

</TabItem>
<TabItem label="Linux VM" icon="linux">

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

<Tabs syncKey="language">
<TabItem label="Python" icon="seti:python">

```python
sandbox.pause()
```

</TabItem>
<TabItem label="TypeScript" icon="seti:typescript">

```typescript
await sandbox.pause()
```

</TabItem>
<TabItem label="Ruby" icon="seti:ruby">

```ruby
sandbox.pause
```

</TabItem>
<TabItem label="Go" icon="seti:go">

```go
sandbox.Pause(ctx)
```

</TabItem>
<TabItem label="Java" icon="seti:java">

```java
sandbox.pause();
```

</TabItem>
<TabItem label="CLI" icon="seti:shell">

```bash
daytona pause [SANDBOX_ID] | [SANDBOX_NAME]
```

</TabItem>
<TabItem label="API" icon="seti:json">

```bash
curl 'https://app.daytona.io/api/sandbox/{sandboxIdOrName}/pause' \
  --request POST \
  --header 'Authorization: Bearer YOUR_API_KEY'
```

</TabItem>
</Tabs>

</TabItem>
</Tabs>

### Fork [#fork]

Fork a sandbox.

<Tabs syncKey="sandbox-class">
<TabItem label="Container" icon="seti:docker">

Forking is not supported for container sandboxes. Use [create snapshot from sandbox](/docs/snapshots#create-snapshot-from-sandbox) to capture filesystem state, then create a new sandbox from that snapshot.

</TabItem>
<TabItem label="Linux VM" icon="linux">

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 <Button>Fork</Button>

<Tabs syncKey="language">
<TabItem label="Python" icon="seti:python">

```python
# Fork sandbox through the Sandbox instance
forked = sandbox.fork(name="my-forked-sandbox")
```

</TabItem>
<TabItem label="TypeScript" icon="seti:typescript">

```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" });
```

</TabItem>
<TabItem label="Ruby" icon="seti:ruby">

```ruby
# Fork sandbox through the Sandbox instance
forkedSandbox = sandbox.fork(name: "my-forked-sandbox")
```

</TabItem>
<TabItem label="Go" icon="seti:go">

```go
// Fork sandbox through the Sandbox instance
name := "my-forked-sandbox"
forkedSandbox, err := sandbox.Fork(ctx, &name)
if err != nil {
    return err
}
```

</TabItem>
<TabItem label="Java" icon="seti:java">

```java
// Fork sandbox through the Sandbox instance
Sandbox forkedSandbox = sandbox.fork("my-forked-sandbox", 60);
```

</TabItem>
<TabItem label="API" icon="seti:json">

```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'
```

</TabItem>
</Tabs>

</TabItem>
</Tabs>

### Delete [#delete]

Delete a sandbox.

<Callout type="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.
</Callout>

1. Go to [Daytona Sandboxes ↗](https://app.daytona.io/dashboard/sandboxes)
2. Click <Button>Delete</Button> next to the sandbox you want to delete

<Tabs syncKey="language">
<TabItem label="Python" icon="seti:python">

```python
sandbox.delete()

# Block until the sandbox is deleted
sandbox.delete(timeout=60, wait=True)
```

</TabItem>
<TabItem label="TypeScript" icon="seti:typescript">

```typescript
await sandbox.delete()

// Block until the sandbox is deleted
await sandbox.delete(60, true)
```

</TabItem>
<TabItem label="Ruby" icon="seti:ruby">

```ruby
sandbox.delete

# Block until the sandbox is deleted
sandbox.delete(60, wait: true)
```

</TabItem>
<TabItem label="Go" icon="seti:go">

```go
err = sandbox.Delete(ctx)

// Block until the sandbox is deleted
err = sandbox.DeleteAndWait(ctx, 60*time.Second)
```

</TabItem>
<TabItem label="Java" icon="seti:java">

```java
sandbox.delete();

// Block until the sandbox is deleted
sandbox.delete(60, true);
```

</TabItem>
<TabItem label="CLI" icon="seti:shell">

```bash
daytona delete [SANDBOX_ID] | [SANDBOX_NAME]
```

</TabItem>
<TabItem label="API" icon="seti:json">

```bash
curl 'https://app.daytona.io/api/sandbox/{sandboxIdOrName}' \
  --request DELETE \
  --header 'Authorization: Bearer YOUR_API_KEY'
```

</TabItem>
</Tabs>

### Timeouts [#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 [#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](/docs/sandboxes#vm-sandboxes) and is mutually exclusive with the [auto-stop interval](/docs/sandboxes#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](/docs/preview) do not reset the timer.

<Tabs syncKey="sandbox-class">
<TabItem label="Container" icon="seti:docker">

Auto-pause is not supported for container sandboxes. Use [auto-stop](/docs/sandboxes#auto-stop-interval) to stop a container sandbox after a period of inactivity.

</TabItem>
<TabItem label="Linux VM" icon="linux">

1. Go to [Daytona Sandboxes ↗](https://app.daytona.io/dashboard/sandboxes)
2. Click <Button>Create Sandbox</Button>
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 <Button>Create</Button>

<Tabs syncKey="language">
<TabItem label="Python" icon="seti:python">

```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)
```

</TabItem>
<TabItem label="TypeScript" icon="seti:typescript">

```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)
```

</TabItem>
<TabItem label="Ruby" icon="seti:ruby">

```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
```

</TabItem>
<TabItem label="Go" icon="seti:go">

```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)
```

</TabItem>
<TabItem label="Java" icon="seti:java">

```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);
        }
    }
}
```

</TabItem>
<TabItem label="API" icon="seti:json">

```bash
curl 'https://app.daytona.io/api/sandbox/{sandboxIdOrName}/autopause/{interval}' \
  --request POST \
  --header 'Authorization: Bearer YOUR_API_KEY'
```

</TabItem>
</Tabs>

</TabItem>
<TabItem label="GPU" icon="seti:cu">

Auto-pause is not supported for GPU sandboxes. GPU sandboxes are ephemeral and cannot have auto-pause enabled.

</TabItem>
</Tabs>

<div id="auto-archive-interval"></div>

#### Wall-clock TTL [#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](/docs/sandboxes#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.

<Tabs syncKey="language">
<TabItem label="Python" icon="seti:python">

```python
sandbox = daytona.create(CreateSandboxFromSnapshotParams(
    snapshot="daytona-vm-small",
    ttl_minutes=120,
))

# Reset the deadline to 60 minutes from now
sandbox.set_ttl(60)
```

</TabItem>
<TabItem label="TypeScript" icon="seti:typescript">

```typescript
const sandbox = await daytona.create({
  snapshot: 'daytona-vm-small',
  ttlMinutes: 120,
})

// Reset the deadline to 60 minutes from now
await sandbox.setTtl(60)
```

</TabItem>
<TabItem label="Ruby" icon="seti:ruby">

```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
```

</TabItem>
<TabItem label="Go" icon="seti:go">

```go
ttlMinutes := 120
sandbox, err := client.Create(ctx, types.SnapshotParams{
	Snapshot: "daytona-vm-small",
	SandboxBaseParams: types.SandboxBaseParams{
		TtlMinutes: &ttlMinutes,
	},
})
```

</TabItem>
<TabItem label="Java" icon="seti:java">

```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);
```

</TabItem>
<TabItem label="CLI" icon="seti:shell">

```bash
daytona create --snapshot daytona-vm-small --ttl 120
```

</TabItem>
<TabItem label="API" icon="seti:json">

```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'
```

</TabItem>
</Tabs>