Daytona | Daytona

Daytona

class Daytona()

Main class for interacting with the Daytona API.

This class provides methods to create, manage, and interact with Daytona Sandboxes. It can be initialized either with explicit configuration or using environment variables.

Attributes:

Example:

Using environment variables:

daytona = Daytona()  # Uses DAYTONA_API_KEY, DAYTONA_API_URL

sandbox = daytona.create()

Using explicit configuration:

config = DaytonaConfig(
    api_key="your-api-key",
    api_url="https://your-api.com",
    target="us"
)

daytona = Daytona(config)

sandbox = daytona.create()

Using OpenTelemetry tracing:

config = DaytonaConfig(
    api_key="your-api-key",
    experimental={"otelEnabled": True}  # Enable OpenTelemetry tracing through experimental config
)

async with Daytona(config) as daytona:
    sandbox = daytona.create()
    # All SDK operations will be traced
# OpenTelemetry traces are flushed on close

Daytona.init

def __init__(config: DaytonaConfig | None = None)

Initializes Daytona instance with optional configuration.

If no config is provided, reads from environment variables:

Arguments:

Raises:

Example:

from daytona import Daytona, DaytonaConfig

# Using environment variables

daytona1 = Daytona()

# Using explicit configuration

config = DaytonaConfig(
    api_key="your-api-key",
    api_url="https://your-api.com",
    target="us"
)

daytona2 = Daytona(config)

Daytona.create

@overload
def create(params: CreateSandboxFromSnapshotParams | None = None,
           *,
           timeout: float = 60) -> Sandbox

Creates Sandboxes from specified or default snapshot. You can specify various parameters, including language, image, environment variables, and volumes.

Arguments:

Returns:

Raises:

Example:

Create a default Python Sandbox:

sandbox = daytona.create()

Create a custom Sandbox:

params = CreateSandboxFromSnapshotParams(
    language="python",
    snapshot="my-snapshot-id",
    env_vars={"DEBUG": "true"},
    auto_stop_interval=0,
    auto_archive_interval=60,
    auto_delete_interval=120
)

sandbox = daytona.create(params, timeout=40)

Daytona.create

@overload
def create(
        params: CreateSandboxFromImageParams | None = None,
        *,
        timeout: float = 60,
        on_snapshot_create_logs: Callable[[str], None] | None = None
) -> Sandbox

Creates Sandboxes from specified image available on some registry or declarative Daytona Image. You can specify various parameters, including resources, language, image, environment variables, and volumes. Daytona creates snapshot from provided image and uses it to create Sandbox.

Arguments:

Returns:

Raises:

Example:

Create a default Python Sandbox from image:

sandbox = daytona.create(CreateSandboxFromImageParams(image="debian:12.9"))

Create a custom Sandbox from declarative Image definition:

declarative_image = (
    Image.base("alpine:3.18")
    .pipInstall(["numpy", "pandas"])
    .env({"MY_ENV_VAR": "My Environment Variable"})
)

params = CreateSandboxFromImageParams(
    language="python",
    image=declarative_image,
    env_vars={"DEBUG": "true"},
    resources=Resources(cpu=2, memory=4),
    auto_stop_interval=0,
    auto_archive_interval=60,
    auto_delete_interval=120
)

sandbox = daytona.create(
    params,
    timeout=40,
    on_snapshot_create_logs=lambda chunk: print(chunk, end=""),
)

Daytona.delete

@with_instrumentation()
def delete(sandbox: Sandbox, timeout: float = 60, wait: bool = False) -> None

Deletes a Sandbox.

By default returns as soon as the deletion request is accepted (fire-and-forget). Pass wait=True to block until the Sandbox reaches the ‘destroyed’ state.

Arguments:

Raises:

Example:

sandbox = daytona.create()

# ... use sandbox ...

daytona.delete(sandbox)  # Clean up when done

Daytona.get

@intercept_errors(message_prefix="Failed to get sandbox: ")
@with_instrumentation()
def get(sandbox_id_or_name: str,
        request_timeout: float | None = None) -> Sandbox

Gets a Sandbox by its ID or name.

Arguments:

Returns:

Raises:

Example:

sandbox = daytona.get("my-sandbox-id-or-name")

print(sandbox.state)

Daytona.list

@intercept_errors(message_prefix="Failed to list sandboxes: ")
@with_instrumentation()
def list(query: ListSandboxesQuery | None = None,
         request_timeout: float | None = None) -> Iterator[Sandbox]

Iterates over Sandboxes matching the given query.

Arguments:

Yields:

Example:

from daytona import ListSandboxesQuery

for sandbox in daytona.list(ListSandboxesQuery(labels={"env": "dev"})):
    print(sandbox.id)

Daytona.start

@with_instrumentation()
def start(sandbox: Sandbox, timeout: float = 60) -> None

Starts a Sandbox and waits for it to be ready.

Arguments:

Raises:

Daytona.stop

@with_instrumentation()
def stop(sandbox: Sandbox, timeout: float = 60) -> None

Stops a Sandbox and waits for it to be stopped.

Arguments:

Raises:

CodeLanguage

class CodeLanguage(str, Enum)

Programming languages supported by Daytona

Enum Members:

DaytonaConfig

class DaytonaConfig(BaseModel)

Configuration options for initializing the Daytona client.

Attributes:

.. deprecated:: Polling-only mode will be removed in a future release; event streaming is the default and falls back to polling automatically when WebSockets are unavailable.

Example:

config = DaytonaConfig(api_key="your-api-key")

config = DaytonaConfig(jwt_token="your-jwt-token", organization_id="your-organization-id")

CreateSandboxBaseParams

class CreateSandboxBaseParams(BaseModel)

Base parameters for creating a new Sandbox.

Attributes:

CreateSandboxFromImageParams

class CreateSandboxFromImageParams(CreateSandboxBaseParams)

Parameters for creating a new Sandbox from an image.

Attributes:

CreateSandboxFromSnapshotParams

class CreateSandboxFromSnapshotParams(CreateSandboxBaseParams)

Parameters for creating a new Sandbox from a snapshot.

Attributes: