Skip to content

Sandbox Management

Sandboxes are isolated development environments managed by Daytona. This guide covers how to create, manage, and remove Sandboxes using the SDK. By default, Sandboxes auto-stop after 15 minutes of inactivity and use 1 vCPU, 1GB RAM, and 3GiB disk.

Sandbox Lifecycle

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

sandbox.delete()
sandbox.delete()
STARTED
STARTED
sandbox.delete()
sandbox.delete()
STOPPED
STOPPED
DELETED
DELETED
d
d
sandbox.delete()
sandbox.delete()
ARCHIVED
ARCHIVED
Daytona.create()sandbox.stop()auto-stop (15 min)sandbox.start()sandbox.archive()auto-archive (7 days)sandbox.start()

By default, sandboxes auto-stop after 15 minutes of inactivity and auto-archive after 7 days of being stopped. To keep the Sandbox running indefinitely without interruption, set the auto-stop value to 0 during creation.

Creating Sandboxes

The Daytona SDK provides an option to create Sandboxes with default or custom configurations. You can specify the language, Snapshot, resources, environment variables, and volumes for the Sandbox. Running Sandboxes utilize CPU, memory, and disk storage. Every resource is charged per second of usage.

Basic Sandbox Creation

The Daytona SDK provides methods to create Sandboxes with default configurations, specific languages, or custom labels using Python and TypeScript.

from daytona import Daytona, CreateSandboxFromSnapshotParams
daytona = Daytona()
# Create a basic Sandbox
sandbox = daytona.create()
# Create a Sandbox with specific language
params = CreateSandboxFromSnapshotParams(language="python")
sandbox = daytona.create(params)
# Create a Sandbox with custom labels
params = CreateSandboxFromSnapshotParams(labels={"SOME_LABEL": "my-label"})
sandbox = daytona.create(params)

When Sandboxes are not actively used, it is recommended that they be stopped. This can be done manually using the stop command or automatically by setting the auto-stop interval.

Sandbox Resources

Daytona Sandboxes come with 1 vCPU, 1GB RAM, and 3GiB disk by default.

Need more power? Use the Resources class to define exactly what you need: CPU, memory, and disk space are all customizable.

Check your available resources and limits in the dashboard.

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)

Sandbox Information

The Daytona SDK provides methods to get information about a Sandbox, such as ID, root directory, and status using Python and TypeScript.

# Get Sandbox ID
sandbox_id = sandbox.id
# Get the root directory of the Sandbox user
root_dir = sandbox.get_user_root_dir()
# Get the Sandbox id, auto-stop interval and state
print(sandbox.id)
print(sandbox.auto_stop_interval)
print(sandbox.state)

To get the preview URL for a specific port, check out Preview & Authentication.

Stop and Start Sandbox

The Daytona SDK provides methods to stop and start Sandboxes using Python and TypeScript.

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

sandbox = daytona.create(CreateSandboxParams(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()

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

Archive Sandbox

The Daytona SDK provides methods to archive Sandboxes using Python and TypeScript.

When Sandboxes are archived, the entire filesystem state is moved to very 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()

Delete Sandbox

The Daytona SDK provides methods to delete Sandboxes using Python and TypeScript.

# Delete Sandbox
sandbox.delete()

Auto-stop and Auto-archive

Daytona Sandboxes can be automatically stopped and archived 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 parameter can either be set to:

  • a time interval in minutes
  • 0, which 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",
auto_stop_interval=0, # Disables the auto-stop feature - default is 15 minutes
))

Auto-archive Interval

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, which means the maximum interval of 30 days will be used

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

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

Run Indefinitely

By default, 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-snapshot-name",
auto_stop_interval=0, # Disables the auto-stop feature - default is 15 minutes
))