Sandboxes

このコンテンツはまだ日本語訳がありません。

Sandboxes are isolated runtime environments managed by Daytona. This guide covers the lifecycle of Sandboxes and how to create, manage, and remove them using the Daytona SDK.

Daytona Sandboxes use 1 vCPU, 1GB RAM, and 3GiB disk by default. Organizations get a maximum sandbox resource limit of 4 vCPUs, 8GB RAM, and 10GB disk. For more power, contact support@daytona.io.

Sandbox lifecycle

Throughout its lifecycle, a Daytona Sandbox can have several different states. The diagram below shows the states and possible transitions between them.

Multiple runtime support

Daytona Sandboxes support Python, TypeScript, and JavaScript programming language runtimes for direct code execution inside the sandbox.

The language parameter controls which programming language runtime is used for the sandbox:

python
typescript
javascript

If omitted, the Daytona SDK will default to python. To override this, explicitly set the language value when creating the sandbox.

Create Sandboxes

Daytona provides options to programmatically create sandboxes with default or custom configurations. You can specify programming language runtime, snapshots, resources, environment variables, and volumes for each sandbox. Running sandboxes utilize CPU, memory, and disk storage. Every resource is charged per second of usage.

from daytona import Daytona, CreateSandboxFromSnapshotParams

daytona = Daytona()

# Create a sandbox
sandbox = daytona.create()

# Create a sandbox with python
params = CreateSandboxFromSnapshotParams(language="python")
sandbox = daytona.create(params)

# Create a sandbox with a custom name
params = CreateSandboxFromSnapshotParams(name="my_awesome_sandbox")
sandbox = daytona.create(params)

# Create a sandbox with custom labels
params = CreateSandboxFromSnapshotParams(labels={"LABEL": "label"})
sandbox = daytona.create(params)

import { Daytona } from '@daytonaio/sdk';

const daytona = new Daytona();

// Create a sandbox
const sandbox = await daytona.create();

// Create a sandbox with typescript
const sandbox = await daytona.create({ language: 'typescript' });

// Create a sandbox with a custom name
const sandbox = await daytona.create({ name: 'my_awesome_sandbox' });

// Create a sandbox with custom labels
const sandbox = await daytona.create({ labels: { LABEL: 'label' } });

require 'daytona'

daytona = Daytona::Daytona.new

# Create a sandbox
sandbox = daytona.create

# Create a sandbox with python
params = Daytona::CreateSandboxFromSnapshotParams.new(language: Daytona::CodeLanguage::PYTHON)
sandbox = daytona.create(params)

# Create a sandbox with custom labels
params = Daytona::CreateSandboxFromSnapshotParams.new(labels: { 'LABEL' => 'label' })
sandbox = daytona.create(params)

// Create a sandbox
params := types.SnapshotParams{
    SandboxBaseParams: types.SandboxBaseParams{
        Language: types.CodeLanguagePython,
    },
}
sandbox, err := client.Create(ctx, params)

daytona create [flags]

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

For more information, see the Python SDK, TypeScript SDK, Ruby SDK, Go SDK, API, and CLI references:

create (Python SDK)

create (TypeScript SDK)

create (Ruby SDK)

Create (Go SDK)

create (CLI)

create (API)

Resources

Daytona Sandbox uses 1 vCPU, 1GB RAM, and 3GiB disk by default.

Daytona keeps a pool of warm sandboxes using default snapshots. When available, sandboxes launch within milliseconds instead of cold-booting.

To set custom sandbox resources (CPU, memory, and disk space), use the Resources class:

from daytona import Daytona, Resources, CreateSandboxFromImageParams, Image

daytona = Daytona()

# Create a sandbox with custom resources
resources = Resources(
    cpu=2,    # 2 CPU cores
    memory=4, # 4GB RAM
    disk=8,   # 8GB disk space
)

params = CreateSandboxFromImageParams(
    image=Image.debian_slim("3.12"),
    resources=resources
)

sandbox = daytona.create(params)

import { Daytona, Image } from "@daytonaio/sdk";

async function main() {
  const daytona = new Daytona();

  // Create a sandbox with custom resources
  const sandbox = await daytona.create({
    image: Image.debianSlim("3.12"),
    resources: {
      cpu: 2,     // 2 CPU cores
      memory: 4,  // 4GB RAM
      disk: 8,    // 8GB disk space
    },
  });
}

main();

require 'daytona'

daytona = Daytona::Daytona.new

# Create a sandbox with custom resources
sandbox = daytona.create(
  Daytona::CreateSandboxFromImageParams.new(
    image: Daytona::Image.debian_slim('3.12'),
    resources: Daytona::Resources.new(
      cpu: 2,     # 2 CPU cores
      memory: 4,  # 4GB RAM
      disk: 8     # 8GB disk space
    )
  )
)

// Create a sandbox with custom resources
sandbox, err := client.Create(ctx, types.ImageParams{
    Image: "python:3.11",
    Resources: &types.Resources{
        CPU:    2,   // 2 CPU cores
        Memory: 4,   // 4GiB RAM
        Disk:   8,   // 8GiB disk space
    },
})

# --memory is in MB; --disk is in GB
daytona create --cpu 2 --memory 4096 --disk 8

curl 'https://app.daytona.io/api/sandbox' \
  --request POST \
  --header 'Content-Type: application/json' \
  --header 'Authorization: Bearer YOUR_SECRET_TOKEN' \
  --data '{
  "cpu": 2,
  "memory": 4,
  "disk": 8
}'

All resource parameters are optional. If not specified, Daytona will use default values appropriate for the selected language and use case.

For more information, see the Python SDK, TypeScript SDK, Ruby SDK, Go SDK, CLI, and API references:

Resources (Python SDK)

Resources (TypeScript SDK)

Resources (Ruby SDK)

Resources (API)

Resources (CLI)

Ephemeral Sandboxes

Ephemeral Sandboxes are automatically deleted once they are stopped. They are useful for short-lived tasks or for testing purposes.

To create an ephemeral Sandbox, set the ephemeral parameter to True when creating a sandbox:

from daytona import Daytona, CreateSandboxFromSnapshotParams

daytona = Daytona()

# Create an ephemeral sandbox
params = CreateSandboxFromSnapshotParams(
  ephemeral=True,
  auto_stop_interval=5 # The ephemeral sandbox will be deleted after 5 minutes of inactivity
)
sandbox = daytona.create(params)

import { Daytona } from '@daytonaio/sdk';

const daytona = new Daytona();

// Create an ephemeral sandbox
const sandbox = await daytona.create({
  ephemeral: true,
  autoStopInterval: 5 // The ephemeral sandbox will be deleted after 5 minutes of inactivity
});

require 'daytona'

daytona = Daytona::Daytona.new

# Create an ephemeral Sandbox
params = Daytona::CreateSandboxFromSnapshotParams.new(
  ephemeral: true,
  auto_stop_interval: 5 # The ephemeral sandbox will be deleted after 5 minutes of inactivity
)
sandbox = daytona.create(params)

// Create an ephemeral sandbox
autoStopInterval := 5
params := types.SnapshotParams{
    SandboxBaseParams: types.SandboxBaseParams{
        Language:         types.CodeLanguagePython,
        Ephemeral:        true,
        AutoStopInterval: &autoStopInterval,
    },
}
sandbox, err := client.Create(ctx, params)

Network settings (Firewall)

Daytona Sandboxes provide configurable network firewall controls to enhance security and manage connectivity. By default, network access follows standard security policies, but you can customize network settings when creating a sandbox.

Start Sandboxes

Daytona provides options to start sandboxes in Daytona Dashboard ↗ or programmatically using the Python SDK, TypeScript SDK, Ruby SDK, CLI, and API references.

Navigate to Daytona Sandboxes ↗
Click the start icon (▶) next to the sandbox you want to start.

Starting sandbox with ID: <sandbox-id>

sandbox = daytona.create(CreateSandboxFromSnapshotParams(language="python"))
# Start Sandbox
sandbox.start()

const sandbox = await daytona.create({ language: 'typescript' });
// Start Sandbox
await sandbox.start();

sandbox = daytona.create(Daytona::CreateSandboxFromSnapshotParams.new(language: Daytona::CodeLanguage::PYTHON))
# Start Sandbox
sandbox.start

// Start sandbox
err = sandbox.Start(ctx)

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

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

For more information, see the Python SDK, TypeScript SDK, Ruby SDK, Go SDK, CLI, and API references:

start (Python SDK)

start (TypeScript SDK)

start (Ruby SDK)

Start (Go SDK)

start (CLI)

start (API)

List Sandboxes

Daytona provides options to view information about sandboxes (ID, root directory, and status) and manage their lifecycle.

# List all sandboxes
result = daytona.list()

# Iterate through results
for sandbox in result.items:
    print(f"Sandbox: {sandbox.id} (state: {sandbox.state})")

# List sandboxes with labels filter
result = daytona.list(labels={"env": "dev"})

// List all sandboxes
const result = await daytona.list();

// Iterate through results
for (const sandbox of result.items) {
    console.log(`Sandbox: ${sandbox.id} (state: ${sandbox.state})`);
}

// List sandboxes with labels filter
const filtered = await daytona.list({ 'env': 'dev' });

# List all sandboxes
result = daytona.list

# Iterate through results
result.items.each do |sandbox|
  puts "Sandbox: #{sandbox.id} (state: #{sandbox.state})"
end

# List sandboxes with labels filter
result = daytona.list({ 'env' => 'dev' })

// List all sandboxes
result, err := client.List(ctx, nil, nil, nil)

// Iterate through results
for _, sandbox := range result.Items {
    fmt.Printf("Sandbox: %s (state: %s)\n", sandbox.Name, sandbox.State)
}

daytona list [flags]

curl 'https://app.daytona.io/api/sandbox' \
  --header 'Authorization: Bearer YOUR_SECRET_TOKEN'

For more information, see the Python SDK, TypeScript SDK, Ruby SDK, Go SDK, CLI, and API references:

list (Python SDK)

list (TypeScript SDK)

list (Ruby SDK)

List (Go SDK)

list (CLI)

list (API)

Stop Sandboxes

Daytona provides methods to stop sandboxes in Daytona Dashboard ↗ or programmatically using the Python SDK, TypeScript SDK, and Ruby SDK.

Navigate to Daytona Sandboxes ↗
Click the stop icon (⏹) next to the sandbox you want to stop.

Stopping sandbox with ID: <sandbox-id>

Stopped sandboxes maintain filesystem persistence while their memory state is cleared. They incur only disk usage costs and can be started again when needed.

The stopped state should be used when a sandbox is expected to be started again soon. Otherwise, it is recommended to stop and then archive the sandbox to eliminate disk usage costs.

sandbox = daytona.create(CreateSandboxFromSnapshotParams(language="python"))

# Stop sandbox
sandbox.stop()

print(sandbox.id) # 7cd11133-96c1-4cc8-9baa-c757b8f8c916

# The sandbox ID can later be used to find the sandbox and start it
sandbox = daytona.find_one("7cd11133-96c1-4cc8-9baa-c757b8f8c916")

# Start sandbox
sandbox.start()

const sandbox = await daytona.create({ language: 'typescript' });

// Stop sandbox
await sandbox.stop();

console.log(sandbox.id) // 7cd11133-96c1-4cc8-9baa-c757b8f8c916

// The sandbox ID can later be used to find the sandbox and start it
const found = await daytona.findOne({ idOrName: '7cd11133-96c1-4cc8-9baa-c757b8f8c916' });

// Start sandbox
await found.start();

sandbox = daytona.create(Daytona::CreateSandboxFromSnapshotParams.new(language: Daytona::CodeLanguage::PYTHON))

# Stop sandbox
sandbox.stop

puts sandbox.id # 7cd11133-96c1-4cc8-9baa-c757b8f8c916

# The sandbox ID can later be used to find the sandbox and start it
sandbox = daytona.find_one(id: '7cd11133-96c1-4cc8-9baa-c757b8f8c916')

# Start sandbox
sandbox.start

// Stop sandbox
err = sandbox.Stop(ctx)

fmt.Println(sandbox.ID) // 7cd11133-96c1-4cc8-9baa-c757b8f8c916

// The sandbox ID can later be used to find the sandbox and start it
sandbox, err = client.Get(ctx, sandbox.ID)

// Start sandbox
err = sandbox.Start(ctx)

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

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

For more information, see the Python SDK, TypeScript SDK, Ruby SDK, Go SDK, CLI, and API references:

stop (Python SDK)

stop (TypeScript SDK)

stop (Ruby SDK)

Stop (Go SDK)

find_one (Python SDK)

findOne (TypeScript SDK)

find_one (Ruby SDK)

FindOne (Go SDK)

stop (CLI)

stop (API)

Archive Sandboxes

Daytona provides methods to archive sandboxes in Daytona Dashboard ↗ or programmatically using the Python SDK, TypeScript SDK, and Ruby SDK.

When sandboxes are archived, the entire filesystem state is moved to a cost-effective object storage, making it possible to keep sandboxes available for an extended period. Starting an archived sandbox takes more time than starting a stopped sandbox, depending on its size.

A sandbox must be stopped before it can be archived and can be started again in the same way as a stopped sandbox.

# Archive Sandbox
sandbox.archive()

// Archive Sandbox
await sandbox.archive();

# Archive Sandbox
sandbox.archive

// Archive sandbox
err = sandbox.Archive(ctx)

daytona archive [SANDBOX_ID] | [SANDBOX_NAME] [flags]

curl 'https://app.daytona.io/api/sandbox/{sandboxIdOrName}/archive' \
  --request POST \
  --header 'Authorization: Bearer YOUR_SECRET_TOKEN'

For more information, see the Python SDK, TypeScript SDK, Ruby SDK, Go SDK, CLI, and API references:

archive (Python SDK)

archive (TypeScript SDK)

archive (Ruby SDK)

Archive (Go SDK)

archive (CLI)

archive (API)

Recover Sandboxes

Daytona provides methods to recover sandboxes in Daytona Dashboard ↗ or programmatically using the Python SDK, TypeScript SDK, and Ruby SDK.

# Recover sandbox
sandbox.recover()

// Recover sandbox
await sandbox.recover();

# Recover sandbox
sandbox.recover

curl 'https://app.daytona.io/api/sandbox/{sandboxIdOrName}/recover' \
  --request POST \
  --header 'Authorization: Bearer YOUR_SECRET_TOKEN'

For more information, see the Python SDK, TypeScript SDK, Ruby SDK, and API references:

recover (Python SDK)

recover (TypeScript SDK)

recover (Ruby SDK)

recover (API)

Recover from error state

When a sandbox enters an error state, it can sometimes be recovered using the recover method, depending on the underlying error reason. The recoverable flag indicates whether the error state can be resolved through an automated recovery procedure.

# Check if the Sandbox is recoverable
if sandbox.recoverable:
    sandbox.recover()
    print("Sandbox recovered successfully")

// Check if the Sandbox is recoverable
if (sandbox.recoverable) {
    await sandbox.recover();
    console.log('Sandbox recovered successfully');
}

# Check if the Sandbox is in an error state before recovering
if sandbox.state == 'error'
  sandbox.recover
  puts 'Sandbox recovered successfully'
end

curl 'https://app.daytona.io/api/sandbox/{sandboxIdOrName}/recover' \
  --request POST \
  --header 'Authorization: Bearer YOUR_SECRET_TOKEN'

For more information, see the Python SDK, TypeScript SDK, Ruby SDK, and API references:

recover (Python SDK)

recover (TypeScript SDK)

recover (Ruby SDK)

recover (API)

Resize Sandboxes

Daytona provides methods to resize sandbox resources (CPU, memory, and disk) after creation.

Resizing a started sandbox allows you to increase CPU and memory without interruption. To increase disk capacity or decrease CPU and memory, the sandbox must be stopped first.

from daytona import Daytona, Resources

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

# Resize a started sandbox (CPU and memory can be increased)
sandbox.resize(Resources(cpu=2, memory=4))

# Resize a stopped sandbox (CPU, memory, and disk can be changed)
sandbox.stop()
sandbox.resize(Resources(cpu=4, memory=8, disk=20))
sandbox.start()

import { Daytona } from '@daytonaio/sdk';

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

// Resize a started sandbox (CPU and memory can be increased)
await sandbox.resize({ cpu: 2, memory: 4 });

// Resize a stopped sandbox (CPU, memory, and disk can be changed)
await sandbox.stop();
await sandbox.resize({ cpu: 4, memory: 8, disk: 20 });
await sandbox.start();

require 'daytona'

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

# Resize a started sandbox (CPU and memory can be increased)
sandbox.resize(Daytona::Resources.new(cpu: 2, memory: 4))

# Resize a stopped sandbox (CPU, memory, and disk can be changed)
sandbox.stop
sandbox.resize(Daytona::Resources.new(cpu: 4, memory: 8, disk: 20))
sandbox.start

// Resize a started sandbox (CPU and memory can be increased)
err := sandbox.Resize(ctx, &types.Resources{CPU: 2, Memory: 4})

// Resize a stopped sandbox (CPU, memory, and disk can be changed)
err = sandbox.Stop(ctx)
err = sandbox.Resize(ctx, &types.Resources{CPU: 4, Memory: 8, Disk: 20})
err = sandbox.Start(ctx)

curl 'https://app.daytona.io/api/sandbox/{sandboxIdOrName}/resize' \
  --request POST \
  --header 'Content-Type: application/json' \
  --header 'Authorization: Bearer YOUR_SECRET_TOKEN' \
  --data '{
  "cpu": 2,
  "memory": 4,
  "disk": 20
}'

For more information, see the Python SDK, TypeScript SDK, Go SDK, and Ruby SDK references:

resize (Python SDK)

resize (TypeScript SDK)

Resize (Go SDK)

resize (Ruby SDK)

Delete Sandboxes

Daytona provides methods to delete sandboxes in Daytona Dashboard ↗ or programmatically using the Python SDK, TypeScript SDK, and Ruby SDK.

Navigate to Daytona Sandboxes ↗
Click the Delete button next to the sandbox you want to delete.

Deleting sandbox with ID: <sandbox-id>

# Delete sandbox
sandbox.delete()

// Delete sandbox
await sandbox.delete();

# Delete sandbox
sandbox.delete

// Delete sandbox
err = sandbox.Delete(ctx)

daytona delete [SANDBOX_ID] | [SANDBOX_NAME] [flags]

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

For more information, see the Python SDK, TypeScript SDK, Ruby SDK, Go SDK, CLI, and API references:

delete (Python SDK)

delete (TypeScript SDK)

delete (Ruby SDK)

Delete (Go SDK)

delete (CLI)

delete (API)

Automated lifecycle management

Daytona Sandboxes can be automatically stopped, archived, and deleted based on user-defined intervals.

Auto-stop interval

The auto-stop interval parameter sets the amount of time after which a running sandbox will be automatically stopped.

The auto-stop interval will trigger even if there are internal processes running in the sandbox. The system differentiates between “internal processes” and “active user interaction”. Merely having a script or background task running is not sufficient to keep the sandbox alive.

The parameter can either be set to:

a time interval in minutes
0: disables the auto-stop functionality, allowing the sandbox to run indefinitely

If the parameter is not set, the default interval of 15 minutes will be used.

sandbox = daytona.create(CreateSandboxFromSnapshotParams(
    snapshot="my-snapshot-name",
    # Disables the auto-stop feature - default is 15 minutes
    auto_stop_interval=0,
))

const sandbox = await daytona.create({
    snapshot: "my-snapshot-name",
      // Disables the auto-stop feature - default is 15 minutes
    autoStopInterval: 0,
});

sandbox = daytona.create(
  Daytona::CreateSandboxFromSnapshotParams.new(
    snapshot: 'my-snapshot-name',
    # Disables the auto-stop feature - default is 15 minutes
    auto_stop_interval: 0
  )
)

// Create a sandbox with auto-stop disabled
autoStopInterval := 0
params := types.SnapshotParams{
    Snapshot: "my-snapshot-name",
    SandboxBaseParams: types.SandboxBaseParams{
        AutoStopInterval: &autoStopInterval,
    },
}
sandbox, err := client.Create(ctx, params)

curl 'https://app.daytona.io/api/sandbox/{sandboxIdOrName}/autostop/{interval}' \
  --request POST \
  --header 'Authorization: Bearer YOUR_SECRET_TOKEN'

For more information, see the Python SDK, TypeScript SDK, Ruby SDK, Go SDK, and API references:

set_autostop_interval (Python SDK)

setAutostopInterval (TypeScript SDK)

auto_stop_interval (Ruby SDK)

set_auto_stop_interval (API)

What resets the timer

The inactivity timer resets only for specific external interactions:

Accessing sandbox previews (network requests through preview URLs)
Active SSH connections
Daytona Toolbox SDK API calls

What does not reset the timer

The following do not reset the timer:

SDK calls that are not toolbox actions
Background scripts (e.g., npm run dev run as a fire-and-forget command)
Long-running tasks without external interaction
Processes that don’t involve active monitoring

If you run a long-running task like LLM inference that takes more than 15 minutes without any external interaction, the sandbox may auto-stop mid-process because the process itself doesn’t count as “activity”.

Auto-archive interval

Daytona provides methods to set the auto-archive interval using the Python SDK, TypeScript SDK, and Ruby SDK.

The auto-archive interval parameter sets the amount of time after which a continuously stopped sandbox will be automatically archived.

The parameter can either be set to:

a time interval in minutes
0: the maximum interval of 30 days will be used

If the parameter is not set, the default interval of 7 days will be used.

sandbox = daytona.create(CreateSandboxFromSnapshotParams(
    snapshot="my-snapshot-name",
    # Auto-archive after a sandbox has been stopped for 1 hour
    auto_archive_interval=60,
))

const sandbox = await daytona.create({
    snapshot: "my-snapshot-name",
    // Auto-archive after a sandbox has been stopped for 1 hour
    autoArchiveInterval: 60,
});

sandbox = daytona.create(
  Daytona::CreateSandboxFromSnapshotParams.new(
    snapshot: 'my-snapshot-name',
    # Auto-archive after a sandbox has been stopped for 1 hour
    auto_archive_interval: 60
  )
)

// Create a sandbox with auto-archive after 1 hour
autoArchiveInterval := 60
params := types.SnapshotParams{
    Snapshot: "my-snapshot-name",
    SandboxBaseParams: types.SandboxBaseParams{
        AutoArchiveInterval: &autoArchiveInterval,
    },
}
sandbox, err := client.Create(ctx, params)

curl 'https://app.daytona.io/api/sandbox/{sandboxIdOrName}/autoarchive/{interval}' \
  --request POST \
  --header 'Authorization: Bearer YOUR_SECRET_TOKEN'

For more information, see the Python SDK, TypeScript SDK, Ruby SDK, Go SDK, and API references:

set_auto_archive_interval (Python SDK)

setAutoArchiveInterval (TypeScript SDK)

auto_archive_interval (Ruby SDK)

SetAutoArchiveInterval (Go SDK)

set_auto_archive_interval (API)

Auto-delete interval

Daytona provides methods to set the auto-delete interval using the Python SDK, TypeScript SDK, and Ruby SDK.

The auto-delete interval parameter sets the amount of time after which a continuously stopped sandbox will be automatically deleted. By default, sandboxes will never be automatically deleted.

The parameter can either be set to:

a time interval in minutes
-1: disables the auto-delete functionality
0: the sandbox will be deleted immediately after stopping

If the parameter is not set, the sandbox will not be deleted automatically.

sandbox = daytona.create(CreateSandboxFromSnapshotParams(
    snapshot="my-snapshot-name",
    # Auto-delete after a sandbox has been stopped for 1 hour
    auto_delete_interval=60,
))

# Delete the sandbox immediately after it has been stopped
sandbox.set_auto_delete_interval(0)

# Disable auto-deletion
sandbox.set_auto_delete_interval(-1)

const sandbox = await daytona.create({
    snapshot: "my-snapshot-name",
    // Auto-delete after a sandbox has been stopped for 1 hour
    autoDeleteInterval: 60,
});

// Delete the sandbox immediately after it has been stopped
await sandbox.setAutoDeleteInterval(0)

// Disable auto-deletion
await sandbox.setAutoDeleteInterval(-1)

sandbox = daytona.create(
  Daytona::CreateSandboxFromSnapshotParams.new(
    snapshot: 'my-snapshot-name',
    # Auto-delete after a sandbox has been stopped for 1 hour
    auto_delete_interval: 60
  )
)

# Delete the sandbox immediately after it has been stopped
sandbox.auto_delete_interval = 0

# Disable auto-deletion
sandbox.auto_delete_interval = -1

// Create a sandbox with auto-delete after 1 hour
autoDeleteInterval := 60
params := types.SnapshotParams{
    Snapshot: "my-snapshot-name",
    SandboxBaseParams: types.SandboxBaseParams{
        AutoDeleteInterval: &autoDeleteInterval,
    },
}
sandbox, err := client.Create(ctx, params)

// Delete the sandbox immediately after it has been stopped
zeroInterval := 0
err = sandbox.SetAutoDeleteInterval(ctx, &zeroInterval)

// Disable auto-deletion
disableInterval := -1
err = sandbox.SetAutoDeleteInterval(ctx, &disableInterval)

curl 'https://app.daytona.io/api/sandbox/{sandboxIdOrName}/autodelete/{interval}' \
  --request POST \
  --header 'Authorization: Bearer YOUR_SECRET_TOKEN'

For more information, see the Python SDK, TypeScript SDK, Ruby SDK, Go SDK, and API references:

set_auto_delete_interval (Python SDK)

setAutoDeleteInterval (TypeScript SDK)

auto_delete_interval (Ruby SDK)

SetAutoDeleteInterval (Go SDK)

set_auto_delete_interval (API)

Running indefinitely

Daytona provides methods to run sandboxes indefinitely using the Python SDK, TypeScript SDK, and Ruby SDK.

By default, Daytona Sandboxes auto-stop after 15 minutes of inactivity. To keep a sandbox running without interruption, set the auto-stop interval to 0 when creating a new sandbox:

sandbox = daytona.create(CreateSandboxFromSnapshotParams(
    snapshot="my_awesome_snapshot",
    # Disables the auto-stop feature - default is 15 minutes
    auto_stop_interval=0,
))

const sandbox = await daytona.create({
    snapshot: "my_awesome_snapshot",
    // Disables the auto-stop feature - default is 15 minutes
    autoStopInterval: 0,
});

sandbox = daytona.create(
  Daytona::CreateSandboxFromSnapshotParams.new(
    snapshot: 'my_awesome_snapshot',
    # Disables the auto-stop feature - default is 15 minutes
    auto_stop_interval: 0
  )
)

// Disables the auto-stop feature - default is 15 minutes
autoStopInterval := 0
params := types.SnapshotParams{
    Snapshot: "my_awesome_snapshot",
    SandboxBaseParams: types.SandboxBaseParams{
        AutoStopInterval: &autoStopInterval,
    },
}
sandbox, err := client.Create(ctx, params)