> **Building with AI coding agents?** Install the authstack plugin with one command. This equips your agent with accurate Scalekit implementation patterns. > > **Recommended** (the `-y` flags skip prompts, so the command runs without an interactive terminal): > ```bash > npx -y @scalekit-inc/cli setup -y > ``` > > Global: > ```bash > npm install -g @scalekit-inc/cli > scalekit setup -y > ``` > > Supports Claude Code, Cursor, GitHub Copilot, Codex + skills for other Agent Skills-compatible agents in `~/.agents/skills`. > Skills: integrate-agentkit, implement-saaskit, add-mcp-oauth, implement-sso, implement-scim. > [Full setup guide](https://docs.scalekit.com/dev-kit/build-with-ai/) --- # Connect AI agents to Daytona The Daytona connector lets your AI agent act in each user's Daytona account. Each user connects their own Daytona access token once, and Scalekit sends it with every call, so your agent never handles credentials. It comes with 100 tools. **Authentication:** Bearer Token **Categories:** Developer Tools, AI **Tools:** 100: 42 read, 49 write, 9 destructive **Users sign in with:** Access token **Built by:** Scalekit connector **Try it:** [Playground in the Scalekit dashboard](https://app.scalekit.com/ws/signup?sk_intent=playground&provider=DAYTONA) ## Setup 1. ### Install the SDK **Node.js** ```bash npm install @scalekit-sdk/node dotenv ``` **Python** ```bash pip install scalekit-sdk-python python-dotenv ``` 2. ### Set your credentials Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. ```sh title=".env" SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Create the Daytona connection In **AgentKit > Connections**, create a Daytona connection. The name you give it is the `connection_name` your code passes. See [Configure connections](/agentkit/connections/). 4. ### Authorize a user and make your first call **Node.js** (`quickstart.mts`) ```typescript import { ScalekitClient } from '@scalekit-sdk/node' import 'dotenv/config' import { createInterface } from 'node:readline/promises' const scalekit = new ScalekitClient( process.env.SCALEKIT_ENVIRONMENT_URL, process.env.SCALEKIT_CLIENT_ID, process.env.SCALEKIT_CLIENT_SECRET, ) const actions = scalekit.actions const connector = 'daytona' const identifier = 'user_123' // Generate an authorization link for the user const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) console.log('Authorize Daytona:', link) const rl = createInterface({ input: process.stdin, output: process.stdout }) await rl.question('Press Enter after authorizing...') rl.close() // Make your first call const result = await actions.executeTool({ connector, identifier, toolName: 'daytona_get_current_api_key', toolInput: {}, }) console.log(result) ``` ```bash npx tsx quickstart.mts ``` **Python** (`quickstart.py`) ```python import os from scalekit import ScalekitClient from dotenv import load_dotenv load_dotenv() scalekit_client = ScalekitClient( env_url=os.getenv("SCALEKIT_ENVIRONMENT_URL"), client_id=os.getenv("SCALEKIT_CLIENT_ID"), client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), ) actions = scalekit_client.actions connection_name = "daytona" identifier = "user_123" # Generate an authorization link for the user link_response = actions.get_authorization_link( connection_name=connection_name, identifier=identifier, ) print("Authorize Daytona:", link_response.link) input("Press Enter after authorizing...") # Make your first call result = actions.execute_tool( tool_input={}, tool_name="daytona_get_current_api_key", connection_name=connection_name, identifier=identifier, ) print(result) ``` ```bash python quickstart.py ``` Each user opens the link once and enters their Daytona credentials there. See [Authorize a user](/agentkit/tools/authorize/) for the full flow and statuses. ## Tools Pass the exact name to `execute_tool`, with an input like each tool's example. To ask for a tool that's missing, use the [request form](https://scalekitsupport.portal.usepylon.com/forms/request-a-connector-tool). **Node.js** ```typescript const result = await actions.executeTool({ toolName: 'daytona_check_port_in_use', toolInput: { port: 3000, sandbox_id: '', }, connector: 'daytona', identifier: 'user_123', }) ``` **Python** ```python result = actions.execute_tool( tool_name="daytona_check_port_in_use", tool_input={ "port": 3000, "sandbox_id": "", }, connection_name="daytona", identifier="user_123", ) ``` `result.data` is the app's response as JSON, and `result.execution_id` (`executionId` in Node.js) is the ID of the call. ### `daytona_check_port_in_use` Check Port in Use · Read-only Check whether a specific port is in use inside a started Daytona sandbox. Returns isInUse as true or false. Use daytona_check_port_in_use to confirm a server has started. Use daytona_list_ports to see all open ports. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `port` (`integer`, required): Port number to check, between 3000 and 9999. Example: 3000 - `sandbox_id` (`string`, required): ID of a started sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). The sandbox must be in the started state and in the US region. Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b Example input: `{"port":3000,"sandbox_id":""}` ### `daytona_download_file` Download File · Read-only Read the contents of a file inside a started Daytona sandbox. Returns the file contents; text files come back as a string. Use daytona_download_file to read source files, logs or outputs. Use daytona_get_file_info for metadata only. Binary files are not decoded. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `path` (`string`, required): Path of the file to read. Example: /home/daytona/workspace/main.py - `sandbox_id` (`string`, required): ID of a started sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). The sandbox must be in the started state and in the US region. Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b Example input: `{"path":"","sandbox_id":""}` ### `daytona_find_in_files` Find in Files · Read-only Search the contents of files under a directory inside a started Daytona sandbox for a text pattern (like grep). Returns matches with file, line number and the matching line content. Use daytona_find_in_files to locate code or text. Use daytona_search_files to match file names, and daytona_replace_in_files to change matches. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `path` (`string`, required): Directory to search in. Example: /home/daytona/workspace - `pattern` (`string`, required): Text pattern to search for. Example: TODO - `sandbox_id` (`string`, required): ID of a started sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). The sandbox must be in the started state and in the US region. Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b Example input: `{"path":"","pattern":"","sandbox_id":""}` ### `daytona_get_current_api_key` Get Current API Key · Read-only Get details of the Daytona API key used for this connection. Returns the key's name, masked value, permissions, createdAt and expiresAt. Use daytona_get_current_api_key to check which permissions the connected key has when a call returns 403. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: none. Example input: `{}` ### `daytona_get_file_info` Get File Info · Read-only Get metadata for one file or folder inside a started Daytona sandbox. Returns name, path, isDir, size, mode, permissions, owner, group and modifiedAt. Use daytona_get_file_info to check that a path exists or read its size and permissions. Use daytona_download_file for the contents. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `path` (`string`, required): Path of the file or folder. Example: /home/daytona/workspace/main.py - `sandbox_id` (`string`, required): ID of a started sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). The sandbox must be in the started state and in the US region. Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b Example input: `{"path":"","sandbox_id":""}` ### `daytona_get_organization` Get Organization · Read-only Get the details and per-sandbox limits of a Daytona organization. Returns the organization's id, name, suspension status, defaultRegionId and limits such as maxCpuPerSandbox, maxMemoryPerSandbox and maxDiskPerSandbox. Use daytona_get_organization to read limits before sizing sandboxes. Use daytona_get_organization_usage for current quota usage. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `organization_id` (`string`, required): ID of the Daytona organization. Every sandbox object carries it in its `organizationId` field (see daytona_get_sandbox). Example: 2c9a7a4e-1f0b-4d1e-8c3a-6f5e4d3c2b1a Example input: `{"organization_id":""}` ### `daytona_get_organization_usage` Get Organization Usage · Read-only Get the current CPU, memory, disk and GPU usage of a Daytona organization against its quotas, per region and sandbox class. Returns regionUsage entries with total quotas and current usage for CPU, memory, disk and GPU. Use daytona_get_organization_usage to check headroom before creating sandboxes. Use daytona_get_organization for per-sandbox limits. The API key needs the read:billing or write:sandboxes permission. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `organization_id` (`string`, required): ID of the Daytona organization. Every sandbox object carries it in its `organizationId` field (see daytona_get_sandbox). Example: 2c9a7a4e-1f0b-4d1e-8c3a-6f5e4d3c2b1a Example input: `{"organization_id":""}` ### `daytona_get_port_preview_url` Get Port Preview URL · Read-only Get the HTTP preview URL for a port inside a Daytona sandbox, so a web app or API running there can be reached from a browser. Returns the preview url, the sandboxId and an access token (send it as the x-daytona-preview-token header when the sandbox is private). Use daytona_get_port_preview_url for a standard preview link. Use daytona_get_signed_preview_url for a self-contained link that expires. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `port` (`integer`, required): Port number inside the sandbox where your app or server is listening, between 3000 and 9999. Example: 3000 - `sandbox_id_or_name` (`string`, required): ID or name of the sandbox. Use daytona_list_sandboxes to find it. Example: my-sandbox Example input: `{"port":3000,"sandbox_id_or_name":""}` ### `daytona_get_registry` Get Registry · Read-only Get one Docker registry configured in Daytona by its ID. Returns the registry's id, name, url, username, project, registryType and timestamps. Use daytona_get_registry for one registry. Use daytona_list_registries to browse. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `registry_id` (`string`, required): ID of the Docker registry, from the `id` field returned by daytona_list_registries. Example: 123e4567-e89b-12d3-a456-426614174000 Example input: `{"registry_id":""}` ### `daytona_get_sandbox` Get Sandbox · Read-only Get the full details of one Daytona sandbox by ID or name. Returns the sandbox object: id, name, organizationId, state, desiredState, snapshot, cpu, memory, disk, env, labels, public flag, target region, toolboxProxyUrl, errorReason and lifecycle intervals. Use daytona_get_sandbox to check state (for example after create or start) or read settings. Use daytona_list_sandboxes to search across sandboxes. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `sandbox_id_or_name` (`string`, required): ID or name of the sandbox. Use daytona_list_sandboxes to find it. Example: my-sandbox - `verbose` (`boolean`, optional): Include verbose output in the response. Defaults to false. Example input: `{"sandbox_id_or_name":""}` ### `daytona_get_sandbox_build_logs_url` Get Sandbox Build Logs URL · Read-only Get the URL for the build logs of a Daytona sandbox that was built from a Dockerfile or image. Returns an object with the logs url. Use daytona_get_sandbox_build_logs_url to debug a sandbox in build_failed or pending_build state. Use daytona_get_snapshot_build_logs_url for snapshot builds. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `sandbox_id_or_name` (`string`, required): ID or name of the sandbox. Use daytona_list_sandboxes to find it. Example: my-sandbox Example input: `{"sandbox_id_or_name":""}` ### `daytona_get_sandbox_logs` Get Sandbox Logs · Read-only Get OpenTelemetry logs emitted by a Daytona sandbox within a time range, with optional severity and text filters. Returns log entries (timestamp, body, severityText, serviceName, attributes, traceId) with total and page counts. Use daytona_get_sandbox_logs to inspect application logs. Use daytona_get_sandbox_traces for traces and daytona_get_sandbox_metrics for metrics. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `from` (`string`, required): Start of the time range, ISO 8601. Example: 2024-01-01T00:00:00Z - `sandbox_id` (`string`, required): ID of the sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b - `to` (`string`, required): End of the time range, ISO 8601. Example: 2024-01-01T01:00:00Z - `limit` (`integer`, optional): Number of log entries per page. Defaults to 100. Example: 50 - `page` (`integer`, optional): Page number, starting at 1. Defaults to 1. - `search` (`string`, optional): Only return logs whose body contains this text. Example: timeout - `severities` (`array`, optional): Only return logs with these severity levels: DEBUG, INFO, WARN or ERROR. Example: ["ERROR", "WARN"] Example input: `{"from":"","sandbox_id":"","to":""}` ### `daytona_get_sandbox_metrics` Get Sandbox Metrics · Read-only Get OpenTelemetry metric series recorded for a Daytona sandbox within a time range. Returns metric series, each with metricName and its timestamped dataPoints. Use daytona_get_sandbox_metrics for historical resource and app metrics. Use daytona_get_sandbox_resource_usage for the current CPU, memory and disk snapshot. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `from` (`string`, required): Start of the time range, ISO 8601. Example: 2024-01-01T00:00:00Z - `sandbox_id` (`string`, required): ID of the sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b - `to` (`string`, required): End of the time range, ISO 8601. Example: 2024-01-01T01:00:00Z - `metric_names` (`array`, optional): Only return these metric names. Example: ["system.cpu.utilization"] Example input: `{"from":"","sandbox_id":"","to":""}` ### `daytona_get_sandbox_resource_usage` Get Sandbox Resource Usage · Read-only Get the current CPU, memory and disk usage of a started Daytona sandbox. Returns cpuCount, cpuUsedPct, memTotal, memUsed, memCache, diskTotal, diskUsed, diskFree (bytes) and a timestamp. Use daytona_get_sandbox_resource_usage for a live snapshot before resizing. Use daytona_get_sandbox_metrics for history. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `sandbox_id` (`string`, required): ID of a started sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). The sandbox must be in the started state and in the US region. Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b Example input: `{"sandbox_id":""}` ### `daytona_get_sandbox_traces` Get Sandbox Traces · Read-only Get OpenTelemetry trace summaries recorded for a Daytona sandbox within a time range. Returns traces with traceId, rootSpanName, startTime, endTime, durationMs, spanCount and statusCode, plus total, page and totalPages. Use daytona_get_sandbox_traces to find slow or failing requests. Use daytona_get_sandbox_logs for log lines. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `from` (`string`, required): Start of the time range, ISO 8601. Example: 2024-01-01T00:00:00Z - `sandbox_id` (`string`, required): ID of the sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b - `to` (`string`, required): End of the time range, ISO 8601. Example: 2024-01-01T01:00:00Z - `limit` (`integer`, optional): Number of traces per page. Defaults to 100. Example: 50 - `page` (`integer`, optional): Page number, starting at 1. Defaults to 1. Example input: `{"from":"","sandbox_id":"","to":""}` ### `daytona_get_secret` Get Secret · Read-only Get the metadata of one Daytona secret by ID (the value is never returned). Returns the secret's id, name, description, placeholder, allowed hosts and timestamps. Use daytona_get_secret to check a secret's allowed hosts. Use daytona_list_secrets to browse. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `secret_id` (`string`, required): ID of the secret, from the `id` field returned by daytona_list_secrets. Example: 123e4567-e89b-12d3-a456-426614174000 Example input: `{"secret_id":""}` ### `daytona_get_session` Get Session · Read-only Get one shell session inside a started Daytona sandbox, with the commands run in it. Returns the sessionId and its commands (id, command, exitCode). Use daytona_get_session to see a session's command history. Use daytona_get_session_command for one command. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `sandbox_id` (`string`, required): ID of a started sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). The sandbox must be in the started state and in the US region. Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b - `session_id` (`string`, required): ID of the shell session, as chosen in daytona_create_session. Example: build-session Example input: `{"sandbox_id":"","session_id":""}` ### `daytona_get_session_command` Get Session Command · Read-only Get the status of one command run in a shell session inside a started Daytona sandbox. Returns the command id, command text and exitCode (empty while it is still running). Use daytona_get_session_command to check whether an async command has finished. Use daytona_get_session_command_logs for its output. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `command_id` (`string`, required): ID of the command, from the cmdId field returned by daytona_session_execute_command. Example: 0b2f7c9e-1a3d-4e5f-8a9b-7c6d5e4f3a2b - `sandbox_id` (`string`, required): ID of a started sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). The sandbox must be in the started state and in the US region. Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b - `session_id` (`string`, required): ID of the shell session, as chosen in daytona_create_session. Example: build-session Example input: `{"command_id":"","sandbox_id":"","session_id":""}` ### `daytona_get_session_command_logs` Get Session Command Logs · Read-only Get the output logs of a command run in a shell session inside a started Daytona sandbox. Returns the command's output so far (stdout and stderr). Use daytona_get_session_command_logs to read output of async commands. Use daytona_get_session_command for the exit code. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `command_id` (`string`, required): ID of the command, from the cmdId field returned by daytona_session_execute_command. Example: 0b2f7c9e-1a3d-4e5f-8a9b-7c6d5e4f3a2b - `sandbox_id` (`string`, required): ID of a started sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). The sandbox must be in the started state and in the US region. Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b - `session_id` (`string`, required): ID of the shell session, as chosen in daytona_create_session. Example: build-session Example input: `{"command_id":"","sandbox_id":"","session_id":""}` ### `daytona_get_signed_preview_url` Get Signed Preview URL · Read-only Get a signed, expiring preview URL for a port inside a Daytona sandbox; the token is embedded in the URL so no header is needed. Returns the signed url, port, sandboxId and token. Use daytona_get_signed_preview_url to share a link temporarily. Use daytona_get_port_preview_url for a standard link, and daytona_expire_signed_preview_url to revoke one early. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `port` (`integer`, required): Port number inside the sandbox where your app or server is listening, between 3000 and 9999. Example: 3000 - `sandbox_id_or_name` (`string`, required): ID or name of the sandbox. Use daytona_list_sandboxes to find it. Example: my-sandbox - `expires_in_seconds` (`integer`, optional): How long the URL stays valid, in seconds. Defaults to 60. Example: 3600 Example input: `{"port":3000,"sandbox_id_or_name":""}` ### `daytona_get_snapshot` Get Snapshot · Read-only Get one Daytona snapshot by its ID or name. Returns the snapshot's id, name, imageName, state, errorReason, size, entrypoint, cpu, gpu, memory, disk and timestamps. Use daytona_get_snapshot to check whether a snapshot is active before creating sandboxes from it. Use daytona_list_snapshots to browse. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `snapshot_id_or_name` (`string`, required): ID or name of the snapshot. Example: python-data-science Example input: `{"snapshot_id_or_name":""}` ### `daytona_get_snapshot_build_logs_url` Get Snapshot Build Logs URL · Read-only Get the URL for the build logs of a Daytona snapshot. Returns an object with the logs url. Use daytona_get_snapshot_build_logs_url to debug a snapshot stuck in building or in build_failed. Use daytona_get_sandbox_build_logs_url for sandbox builds. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `snapshot_id` (`string`, required): ID of the snapshot, from the `id` field returned by daytona_list_snapshots. Example: 7b1e2d3c-4a5b-6c7d-8e9f-0a1b2c3d4e5f Example input: `{"snapshot_id":""}` ### `daytona_get_toolbox_proxy_url` Get Toolbox Proxy URL · Read-only Get the toolbox proxy base URL that serves process, file and Git operations for a Daytona sandbox. Returns an object with the url, for example https://proxy.app.daytona.io/toolbox. Use daytona_get_toolbox_proxy_url to check which region proxy a sandbox uses; the toolbox tools in this connector call https://proxy.app.daytona.io/toolbox. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `sandbox_id` (`string`, required): ID of the sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b Example input: `{"sandbox_id":""}` ### `daytona_get_user_home_dir` Get User Home Directory · Read-only Get the home directory of the sandbox user in a started Daytona sandbox. Returns the dir path. Use daytona_get_user_home_dir to locate the user's home folder. Use daytona_get_work_dir for the default command directory. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `sandbox_id` (`string`, required): ID of a started sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). The sandbox must be in the started state and in the US region. Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b Example input: `{"sandbox_id":""}` ### `daytona_get_volume` Get Volume · Read-only Get one Daytona volume by its ID. Returns the volume's id, name, state, timestamps and errorReason. Use daytona_get_volume to check a volume is ready. Use daytona_get_volume_by_name when you only know the name. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `volume_id` (`string`, required): ID of the volume, from the `id` field returned by daytona_list_volumes. Example: 9d8c7b6a-5e4f-4a3b-2c1d-0e9f8a7b6c5d Example input: `{"volume_id":""}` ### `daytona_get_volume_by_name` Get Volume by Name · Read-only Get one Daytona volume by its name. Returns the volume's id, name, state, timestamps and errorReason. Use daytona_get_volume_by_name to resolve a name to an ID. Use daytona_get_volume when you already have the ID. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `name` (`string`, required): Name of the volume. Example: shared-datasets Example input: `{"name":""}` ### `daytona_get_work_dir` Get Working Directory · Read-only Get the default working directory of a started Daytona sandbox. Returns the dir path used for running commands. Use daytona_get_work_dir to build absolute paths for file and Git tools. Use daytona_get_user_home_dir for the home folder. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `sandbox_id` (`string`, required): ID of a started sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). The sandbox must be in the started state and in the US region. Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b Example input: `{"sandbox_id":""}` ### `daytona_git_history` Git History · Read-only Get the commit history of a Git repository inside a started Daytona sandbox. Returns commits with hash, author, email, message and timestamp. Use daytona_git_history to review past commits. Use daytona_git_status for uncommitted changes. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `path` (`string`, required): Path of the Git repository inside the sandbox, absolute or relative to the working directory. Example: workspace/my-repo - `sandbox_id` (`string`, required): ID of a started sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). The sandbox must be in the started state and in the US region. Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b Example input: `{"path":"","sandbox_id":""}` ### `daytona_git_list_branches` Git List Branches · Read-only List the branches of a Git repository inside a started Daytona sandbox. Returns a branches array and the current branch name. Use daytona_git_list_branches before switching with daytona_git_checkout. Use daytona_git_status for the working-tree state. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `path` (`string`, required): Path of the Git repository inside the sandbox, absolute or relative to the working directory. Example: workspace/my-repo - `sandbox_id` (`string`, required): ID of a started sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). The sandbox must be in the started state and in the US region. Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b Example input: `{"path":"","sandbox_id":""}` ### `daytona_git_list_remotes` Git List Remotes · Read-only List the remotes configured in a Git repository inside a started Daytona sandbox. Returns a remotes array with each remote's name and url. Use daytona_git_list_remotes to check where pushes go. Use daytona_git_add_remote to add one. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `path` (`string`, required): Path of the Git repository inside the sandbox, absolute or relative to the working directory. Example: workspace/my-repo - `sandbox_id` (`string`, required): ID of a started sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). The sandbox must be in the started state and in the US region. Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b Example input: `{"path":"","sandbox_id":""}` ### `daytona_git_status` Git Status · Read-only Get the Git status of a repository inside a started Daytona sandbox. Returns currentBranch, upstream, ahead, behind, detached, branchPublished and fileStatus entries with each file's staging and worktree status. Use daytona_git_status before committing to see what changed. Use daytona_git_history for past commits. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `path` (`string`, required): Path of the Git repository inside the sandbox, absolute or relative to the working directory. Example: workspace/my-repo - `sandbox_id` (`string`, required): ID of a started sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). The sandbox must be in the started state and in the US region. Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b Example input: `{"path":"","sandbox_id":""}` ### `daytona_list_available_sandbox_classes` List Available Sandbox Classes · Read-only List the sandbox classes (container, linux-vm, windows) and GPU types the Daytona organization can use in each region. Returns entries with regionId, sandboxClass, gpuAvailable and allowedGpuTypes. Use daytona_list_available_sandbox_classes before creating GPU or VM sandboxes. Use daytona_list_regions for region details. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `organization_id` (`string`, required): ID of the Daytona organization. Every sandbox object carries it in its `organizationId` field (see daytona_get_sandbox). Example: 2c9a7a4e-1f0b-4d1e-8c3a-6f5e4d3c2b1a Example input: `{"organization_id":""}` ### `daytona_list_files` List Files · Read-only List files and folders at a path inside a started Daytona sandbox, optionally recursing several levels. Returns entries with name, path, isDir, size, mode, permissions, owner, group and modifiedAt. Use daytona_list_files to explore a directory. Use daytona_search_files to match file names by pattern and daytona_find_in_files to search file contents. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `sandbox_id` (`string`, required): ID of a started sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). The sandbox must be in the started state and in the US region. Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b - `depth` (`integer`, optional): How many levels deep to list: 1 lists the directory's entries, 2 also includes their children, and so on. Defaults to 1. - `path` (`string`, optional): Directory to list. Defaults to the sandbox working directory. Example: /home/daytona/workspace Example input: `{"sandbox_id":""}` ### `daytona_list_ports` List Ports · Read-only List the ports that processes are listening on inside a started Daytona sandbox. Returns a ports array of port numbers. Use daytona_list_ports to find a running app's port before calling daytona_get_port_preview_url. Use daytona_check_port_in_use for one port. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `sandbox_id` (`string`, required): ID of a started sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). The sandbox must be in the started state and in the US region. Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b Example input: `{"sandbox_id":""}` ### `daytona_list_regions` List Regions · Read-only List the regions available to the Daytona organization for creating sandboxes. Returns regions with id, name, regionType (shared, dedicated or custom), proxyUrl and timestamps. Use daytona_list_regions to choose a target for daytona_create_sandbox. Use daytona_list_available_sandbox_classes for what each region supports. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: none. Example input: `{}` ### `daytona_list_registries` List Registries · Read-only List the Docker registries configured in the Daytona organization. Returns registries with id, name, url, username, project, registryType and timestamps. Use daytona_list_registries to see which private registries snapshots can pull from. Use daytona_get_registry for one registry. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: none. Example input: `{}` ### `daytona_list_sandboxes` List Sandboxes · Read-only List sandboxes in the Daytona organization, with filters for name, labels, state, snapshot, region, resources and dates. Returns a page of sandbox summaries (id, name, state, desiredState, snapshot, cpu, memory, disk, labels, target region, createdAt) plus nextCursor. Use daytona_list_sandboxes to browse or find a sandbox ID. Use daytona_get_sandbox for full details of one sandbox. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `created_at_after` (`string`, optional): Only include sandboxes created after this ISO 8601 timestamp. Example: 2024-01-01T00:00:00Z - `created_at_before` (`string`, optional): Only include sandboxes created before this ISO 8601 timestamp. Example: 2024-12-31T23:59:59Z - `cursor` (`string`, optional): Pagination cursor. Pass the nextCursor value from the previous response to get the next page. - `id` (`string`, optional): Filter by sandbox ID prefix (case-insensitive). Example: 3f2b8c1e - `include_errored_deleted` (`boolean`, optional): Also return sandboxes in an error state whose desired state is deleted. Defaults to false. - `is_public` (`boolean`, optional): Filter by whether the sandbox's HTTP preview is public (true) or private (false). - `labels` (`object`, optional): Only return sandboxes that carry all of these labels, as a JSON object of key-value pairs. Example: {"team": "backend"} - `limit` (`integer`, optional): Number of sandboxes per page. Defaults to 100. Example: 20 - `name` (`string`, optional): Filter by sandbox name prefix (case-insensitive). Example: agent- - `order` (`string`, optional): Sort direction: asc or desc. One of: `asc`, `desc`. - `region_ids` (`array`, optional): Only return sandboxes in these region IDs (for Daytona Cloud, us or eu). Example: ["us"] - `snapshots` (`array`, optional): Only return sandboxes created from these snapshot names. Example: ["daytonaio/sandbox:0.4.3"] - `sort` (`string`, optional): Field to sort by: name, cpu, memoryGib, diskGib, lastActivityAt or createdAt. One of: `name`, `cpu`, `memoryGib`, `diskGib`, `lastActivityAt`, `createdAt`. - `states` (`array`, optional): Only return sandboxes in these states, such as started, stopped, archived, paused or error. Example: ["started", "stopped"] Example input: `{}` ### `daytona_list_secrets` List Secrets · Read-only List the organization secrets stored in Daytona (values are never returned). Returns a page of secrets with id, name, description, placeholder, allowed hosts and timestamps, plus a cursor for the next page. Use daytona_list_secrets to find secret names to mount with daytona_create_sandbox or daytona_update_sandbox_secrets. Use daytona_get_secret for one secret. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `cursor` (`string`, optional): Pagination cursor from the previous response. Leave empty for the first page. - `limit` (`integer`, optional): Number of secrets per page. Defaults to 100. Example: 20 - `name` (`string`, optional): Filter by partial secret name. Example: OPENAI - `order` (`string`, optional): Sort direction: asc or desc. Defaults to desc. One of: `asc`, `desc`. - `sort` (`string`, optional): Field to sort by: name, createdAt or updatedAt. Defaults to createdAt. One of: `name`, `createdAt`, `updatedAt`. Example input: `{}` ### `daytona_list_sessions` List Sessions · Read-only List the active shell sessions inside a started Daytona sandbox. Returns sessions with sessionId and the commands run in each (id, command, exitCode). Use daytona_list_sessions to find existing sessions. Use daytona_get_session for one session. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `sandbox_id` (`string`, required): ID of a started sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). The sandbox must be in the started state and in the US region. Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b Example input: `{"sandbox_id":""}` ### `daytona_list_snapshots` List Snapshots · Read-only List snapshots (sandbox templates) available to the Daytona organization, with optional name filter and sorting. Returns a page of snapshots with id, name, imageName, state, size, cpu, gpu, memory, disk, general flag and timestamps, plus total, page and totalPages. Use daytona_list_snapshots to pick a snapshot for daytona_create_sandbox. Use daytona_get_snapshot for one snapshot by ID or name. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `limit` (`integer`, optional): Number of snapshots per page. Defaults to 100. Example: 20 - `name` (`string`, optional): Filter by partial snapshot name. Example: python - `order` (`string`, optional): Sort direction: asc or desc. Defaults to desc. One of: `asc`, `desc`. - `page` (`integer`, optional): Page number, starting at 1. Defaults to 1. - `sort` (`string`, optional): Field to sort by: name, state, lastUsedAt or createdAt. Defaults to lastUsedAt. One of: `name`, `state`, `lastUsedAt`, `createdAt`. - `source_sandbox_id` (`string`, optional): Only return snapshots created from this sandbox ID. Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b Example input: `{}` ### `daytona_list_volumes` List Volumes · Read-only List the persistent volumes in the Daytona organization. Returns volumes with id, name, state, createdAt, updatedAt, lastUsedAt and errorReason. Use daytona_list_volumes to find a volume to mount in daytona_create_sandbox. Use daytona_get_volume_by_name when you know the name. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `include_deleted` (`boolean`, optional): Also return deleted volumes. Defaults to false. Example input: `{}` ### `daytona_search_files` Search Files · Read-only Find files whose names match a glob pattern under a directory inside a started Daytona sandbox. Returns a files array of matching paths. Use daytona_search_files to find files by name or extension. Use daytona_find_in_files to search inside files. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `path` (`string`, required): Directory to search in. Example: /home/daytona/workspace - `pattern` (`string`, required): File name pattern to match. Example: *.py - `sandbox_id` (`string`, required): ID of a started sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). The sandbox must be in the started state and in the US region. Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b Example input: `{"path":"","pattern":"","sandbox_id":""}` ### `daytona_activate_snapshot` Activate Snapshot · Write Activate an inactive Daytona snapshot so it can be used to create sandboxes again. Returns the snapshot object with its updated state. Use daytona_activate_snapshot to restore a snapshot turned off by daytona_deactivate_snapshot. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `snapshot_id` (`string`, required): ID of the snapshot, from the `id` field returned by daytona_list_snapshots. Example: 7b1e2d3c-4a5b-6c7d-8e9f-0a1b2c3d4e5f Example input: `{"snapshot_id":""}` ### `daytona_archive_sandbox` Archive Sandbox · Write Archive a stopped Daytona sandbox, moving its filesystem to cheaper object storage. Returns the updated sandbox object with its id, name, state, resources (cpu, memory, disk), labels and auto-stop/archive/delete settings. Use daytona_archive_sandbox for sandboxes you want to keep but not use soon. Use daytona_stop_sandbox for a short pause, and daytona_start_sandbox to restore an archived one. The sandbox must be stopped first (daytona_stop_sandbox). Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `sandbox_id_or_name` (`string`, required): ID or name of the sandbox. Use daytona_list_sandboxes to find it. Example: my-sandbox Example input: `{"sandbox_id_or_name":""}` ### `daytona_create_folder` Create Folder · Write Create a folder inside a started Daytona sandbox with the given permissions. Returns an empty response on success. Use daytona_create_folder to prepare a directory. Use daytona_execute_command with mkdir -p for nested folders in one call. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `path` (`string`, required): Path of the folder to create. Example: /home/daytona/workspace/output - `sandbox_id` (`string`, required): ID of a started sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). The sandbox must be in the started state and in the US region. Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b - `mode` (`string`, optional): Octal permission mode for the folder. Defaults to 0755. Example: 0755. Default: `0755`. Example input: `{"path":"","sandbox_id":""}` ### `daytona_create_registry` Create Registry · Write Add a private Docker registry with its credentials so Daytona snapshots can pull images from it. Returns the new registry with id, name, url, username, project and registryType. Use daytona_create_registry before creating snapshots from private images with daytona_create_snapshot. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `name` (`string`, required): Display name for the registry. Example: My Docker Hub - `password` (`string`, required): Password or access token for the registry. - `url` (`string`, required): Registry URL. Example: https://registry.hub.docker.com - `username` (`string`, required): Username for the registry. Example: my-docker-user - `project` (`string`, optional): Registry project or namespace, if the registry uses one. Example: my-project Example input: `{"name":"","password":"","url":"","username":""}` ### `daytona_create_sandbox` Create Sandbox · Write Create a new Daytona sandbox from a snapshot (or the default image) with optional resources, environment variables, labels, volumes and lifecycle intervals. Returns the new sandbox object, including its id, name, state, target region, resources and toolboxProxyUrl. Use daytona_create_sandbox to provision a fresh environment. Use daytona_fork_sandbox to copy an existing sandbox, and daytona_start_sandbox to resume a stopped one. The sandbox starts in the creating state; poll daytona_get_sandbox until state is started before using the toolbox tools. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `auto_archive_interval` (`integer`, optional): Minutes a stopped sandbox waits before being archived; 0 uses the maximum interval. Example: 10080 - `auto_delete_interval` (`integer`, optional): Minutes a stopped sandbox waits before being deleted; a negative value disables auto-delete and 0 deletes it as soon as it stops. Example: -1 - `auto_stop_interval` (`integer`, optional): Minutes of inactivity before the sandbox stops automatically; 0 disables auto-stop. Defaults to 15. Example: 30 - `build_info` (`object`, optional): Build the sandbox from a Dockerfile instead of a snapshot. Provide the Dockerfile text as dockerfileContent. Example: {"dockerfileContent": "FROM python:3.12-slim\nRUN pip install requests"} - `cpu` (`integer`, optional): vCPU cores to allocate. Defaults to 1; the default organization limit is 4. Example: 2 - `disk` (`integer`, optional): Disk space in GB to allocate. Defaults to 3; the default organization limit is 10. Example: 10 - `domain_allow_list` (`string`, optional): Comma-separated domains the sandbox may reach. Example: example.com,*.github.com - `env` (`object`, optional): Environment variables for the sandbox, as a JSON object of name-value pairs. Example: {"NODE_ENV": "production"} - `gpu` (`integer`, optional): GPU units to allocate, for GPU-enabled organizations. Example: 1 - `gpu_type` (`array`, optional): Preferred GPU types in order of preference, used with gpu. Allowed values: H100, H200, B300, RTX-PRO-6000, RTX-4090, RTX-5090, MI355X. Example: ["H100"] - `labels` (`object`, optional): Labels to attach to the sandbox, as a JSON object of key-value pairs. Useful for filtering in daytona_list_sandboxes. Example: {"team": "backend"} - `memory` (`integer`, optional): Memory in GB to allocate. Defaults to 1; the default organization limit is 8. Example: 4 - `name` (`string`, optional): Unique name for the sandbox. If omitted, the sandbox ID is used as its name. Example: my-agent-sandbox - `network_allow_list` (`string`, optional): Comma-separated CIDR ranges the sandbox may reach. Example: 192.168.1.0/16,10.0.0.0/24 - `network_block_all` (`boolean`, optional): Block all outbound network access from the sandbox. Defaults to false. - `public` (`boolean`, optional): Whether the sandbox's HTTP preview URLs are publicly accessible without a token. Defaults to false. - `secrets` (`array`, optional): Organization secrets to mount as environment variables. Each entry maps an env var name to a secret name. Example: [{"OPENAI_API_KEY": "openai-prod"}] - `snapshot` (`string`, optional): ID or name of the snapshot to create the sandbox from. Omit to use the organization default. Example: daytonaio/sandbox:0.4.3 - `target` (`string`, optional): Region to create the sandbox in, for example us or eu. Defaults to the organization default region. Toolbox tools in this connector reach US-region sandboxes only. - `ttl_minutes` (`integer`, optional): Maximum lifetime in minutes from creation, regardless of state; 0 disables it. When it elapses the sandbox is destroyed. Example: 1440 - `user` (`string`, optional): Linux user that runs processes inside the sandbox. Example: daytona - `volumes` (`array`, optional): Volumes to mount. Each entry needs the volume ID or name and the mount path inside the sandbox, and can limit the mount to a sub-folder. Example: [{"volumeId": "my-volume", "mountPath": "/data"}] Example input: `{}` ### `daytona_create_sandbox_snapshot` Create Sandbox Snapshot · Write Capture an existing Daytona sandbox as a new reusable snapshot. Returns the updated sandbox object with its id, name, state, resources (cpu, memory, disk), labels and auto-stop/archive/delete settings. Use daytona_create_sandbox_snapshot to save a configured environment as a template. Use daytona_create_snapshot to build one from an image, and daytona_fork_sandbox to copy a sandbox directly. Container sandboxes can be captured while running; VM sandboxes must be stopped unless include_memory is true. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `name` (`string`, required): Name for the new snapshot. Example: my-dev-env-v1 - `sandbox_id_or_name` (`string`, required): ID or name of the sandbox. Use daytona_list_sandboxes to find it. Example: my-sandbox - `include_memory` (`boolean`, optional): Also capture the VM's memory (VM sandboxes only; the sandbox must then be started). Defaults to false. Example input: `{"name":"","sandbox_id_or_name":""}` ### `daytona_create_secret` Create Secret · Write Store a secret in the Daytona organization vault so sandboxes can use it without seeing the raw value. Returns the secret's id, name, description, placeholder and allowed hosts (the value is not returned). Use daytona_create_secret before mounting it with daytona_create_sandbox or daytona_update_sandbox_secrets. Set hosts so the secret is only sent to the services that need it. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `name` (`string`, required): Secret name using letters, numbers, hyphens and underscores. Example: OPENAI_API_KEY - `value` (`string`, required): The secret value to store. - `description` (`string`, optional): Optional description of what the secret is for. Example: OpenAI key for agents - `hosts` (`array`, optional): Hosts this secret may be sent to from a sandbox. A secret with no hosts is substituted into requests to any host, so set this. Example: ["api.openai.com"] Example input: `{"name":"","value":""}` ### `daytona_create_session` Create Session · Write Create a persistent shell session inside a started Daytona sandbox, which keeps working directory and environment between commands. Returns an empty response on success. Use daytona_create_session before daytona_session_execute_command for multi-step or long-running work. Use daytona_execute_command for one-off commands. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `sandbox_id` (`string`, required): ID of a started sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). The sandbox must be in the started state and in the US region. Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b - `session_id` (`string`, required): ID to give the new session; you choose it. Example: build-session Example input: `{"sandbox_id":"","session_id":""}` ### `daytona_create_snapshot` Create Snapshot · Write Create a reusable Daytona snapshot from a container image or a Dockerfile, with default resources for sandboxes created from it. Returns the new snapshot with its id, name, state (it starts in a pending or building state), size and resources. Use daytona_create_snapshot to define a template from an image. Use daytona_create_sandbox_snapshot to capture an existing sandbox instead. Wait until daytona_get_snapshot reports state active before using it in daytona_create_sandbox. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `name` (`string`, required): Unique name for the snapshot. Example: python-data-science - `build_info` (`object`, optional): Build the snapshot from a Dockerfile instead of an image. Provide the Dockerfile text as dockerfileContent. Example: {"dockerfileContent": "FROM python:3.12-slim\nRUN pip install pandas"} - `cpu` (`integer`, optional): CPU cores for sandboxes created from this snapshot. Example: 2 - `disk` (`integer`, optional): Disk space in GB for sandboxes created from this snapshot. Example: 10 - `entrypoint` (`array`, optional): Entrypoint command for the snapshot, as a list of arguments. Example: ["sleep", "infinity"] - `gpu` (`integer`, optional): GPU units for sandboxes created from this snapshot. Example: 0 - `image_name` (`string`, optional): Container image to build the snapshot from, with a specific tag (the :latest tag is rejected). Required unless build_info is given. Example: python:3.12-slim - `memory` (`integer`, optional): Memory in GB for sandboxes created from this snapshot. Example: 4 - `region_id` (`string`, optional): Region where the snapshot is available. Defaults to the organization default region. Example: us Example input: `{"name":""}` ### `daytona_create_ssh_access` Create SSH Access · Write Create a temporary SSH access token for a Daytona sandbox. Returns the SSH access id, token, expiresAt and a ready-to-run sshCommand. Use daytona_create_ssh_access to give a person terminal access. Use daytona_revoke_ssh_access to remove it early. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `sandbox_id_or_name` (`string`, required): ID or name of the sandbox. Use daytona_list_sandboxes to find it. Example: my-sandbox - `expires_in_minutes` (`integer`, optional): How long the SSH access stays valid, in minutes. Defaults to 60. Example: 120 Example input: `{"sandbox_id_or_name":""}` ### `daytona_create_volume` Create Volume · Write Create a persistent volume that can be mounted into Daytona sandboxes to share or keep data. Returns the new volume with its id, name and state. Use daytona_create_volume before mounting storage with the volumes input of daytona_create_sandbox. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `name` (`string`, required): Name for the volume. Example: shared-datasets Example input: `{"name":""}` ### `daytona_deactivate_snapshot` Deactivate Snapshot · Write Deactivate a Daytona snapshot so it is no longer used for new sandboxes, without deleting it. Returns an empty response on success. Use daytona_deactivate_snapshot to retire a template temporarily. Use daytona_activate_snapshot to bring it back, and daytona_delete_snapshot to remove it. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `snapshot_id` (`string`, required): ID of the snapshot, from the `id` field returned by daytona_list_snapshots. Example: 7b1e2d3c-4a5b-6c7d-8e9f-0a1b2c3d4e5f Example input: `{"snapshot_id":""}` ### `daytona_execute_command` Execute Command · Write Run a shell command inside a started Daytona sandbox and wait for it to finish. Returns the command's combined output as result and its exitCode. Use daytona_execute_command for one-off commands that finish within the timeout. Use daytona_run_code to run a code snippet, and daytona_session_execute_command for long-running or stateful work. The sandbox must be started (daytona_start_sandbox). Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `command` (`string`, required): Shell command to run. Example: ls -la && python --version - `sandbox_id` (`string`, required): ID of a started sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). The sandbox must be in the started state and in the US region. Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b - `cwd` (`string`, optional): Working directory for the command. Defaults to the sandbox working directory. Example: /home/daytona/workspace - `envs` (`object`, optional): Extra environment variables for this command, as a JSON object. Example: {"DEBUG": "1"} - `timeout` (`integer`, optional): Maximum run time in seconds. Defaults to 10 seconds; raise it for slower commands. Example: 60 Example input: `{"command":"","sandbox_id":""}` ### `daytona_expire_signed_preview_url` Expire Signed Preview URL · Write Expire a signed preview URL for a Daytona sandbox port before its scheduled expiry. Returns an empty response on success. Use daytona_expire_signed_preview_url to revoke a link created by daytona_get_signed_preview_url. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `port` (`integer`, required): Port number inside the sandbox where your app or server is listening, between 3000 and 9999. Example: 3000 - `sandbox_id_or_name` (`string`, required): ID or name of the sandbox. Use daytona_list_sandboxes to find it. Example: my-sandbox - `token` (`string`, required): Token of the signed preview URL to expire, from the token field of daytona_get_signed_preview_url. Example: jl6wb9z5o3eii Example input: `{"port":3000,"sandbox_id_or_name":"","token":""}` ### `daytona_fork_sandbox` Fork Sandbox · Write Fork a Daytona sandbox into a new sandbox that starts from a copy of its current filesystem. Returns the new (forked) sandbox object with its own id and name. Use daytona_fork_sandbox to branch an environment for parallel experiments. Use daytona_create_sandbox_snapshot to keep a reusable template instead. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `sandbox_id_or_name` (`string`, required): ID or name of the sandbox. Use daytona_list_sandboxes to find it. Example: my-sandbox - `name` (`string`, optional): Name for the forked sandbox. If omitted, a unique name is generated. Example: my-forked-sandbox Example input: `{"sandbox_id_or_name":""}` ### `daytona_git_add` Git Add · Write Stage files in a Git repository inside a started Daytona sandbox. Returns an empty response on success. Use daytona_git_add before daytona_git_commit. Use daytona_git_restore to unstage files. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `files` (`array`, required): Files to stage, relative to the repository. Use ["."] to stage everything. Example: ["src/main.py", "README.md"] - `path` (`string`, required): Path of the Git repository inside the sandbox, absolute or relative to the working directory. Example: workspace/my-repo - `sandbox_id` (`string`, required): ID of a started sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). The sandbox must be in the started state and in the US region. Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b Example input: `{"files":["src/main.py","README.md"],"path":"","sandbox_id":""}` ### `daytona_git_add_remote` Git Add Remote · Write Add or overwrite a remote in a Git repository inside a started Daytona sandbox. Returns an empty response on success. Use daytona_git_add_remote after daytona_git_init, then daytona_git_push. Use daytona_git_list_remotes to see existing remotes. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `name` (`string`, required): Remote name. Example: origin - `path` (`string`, required): Path of the Git repository inside the sandbox, absolute or relative to the working directory. Example: workspace/my-repo - `sandbox_id` (`string`, required): ID of a started sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). The sandbox must be in the started state and in the US region. Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b - `url` (`string`, required): Remote URL. Example: https://github.com/acme/app.git - `fetch` (`boolean`, optional): Fetch from the remote right after adding it. Defaults to false. - `overwrite` (`boolean`, optional): Replace an existing remote with the same name. Defaults to false. Example input: `{"name":"","path":"","sandbox_id":"","url":""}` ### `daytona_git_checkout` Git Checkout · Write Switch a Git repository inside a started Daytona sandbox to another branch or commit. Returns an empty response on success. Use daytona_git_checkout to change branches. Use daytona_git_create_branch first for a new branch. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `branch` (`string`, required): Branch name or commit hash to check out. Example: main - `path` (`string`, required): Path of the Git repository inside the sandbox, absolute or relative to the working directory. Example: workspace/my-repo - `sandbox_id` (`string`, required): ID of a started sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). The sandbox must be in the started state and in the US region. Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b Example input: `{"branch":"","path":"","sandbox_id":""}` ### `daytona_git_clone` Git Clone · Write Clone a Git repository into a folder inside a started Daytona sandbox, optionally at a branch or commit and with credentials. Returns an empty response on success. Use daytona_git_clone to bring code into a sandbox. Use daytona_git_init to start a new repository, and daytona_git_pull to update an existing clone. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `path` (`string`, required): Destination folder inside the sandbox. Example: workspace/hello-world - `sandbox_id` (`string`, required): ID of a started sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). The sandbox must be in the started state and in the US region. Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b - `url` (`string`, required): Repository URL to clone. Example: https://github.com/octocat/Hello-World.git - `branch` (`string`, optional): Branch to check out. Defaults to the remote's default branch. Example: main - `commit_id` (`string`, optional): Specific commit to check out after cloning. Example: 7fd1a60b01f91b314f59955a4e4d4e80d8edf11d - `depth` (`integer`, optional): Create a shallow clone with this many commits of history. Example: 1 - `password` (`string`, optional): Password or personal access token for an authenticated remote. Leave empty for public repositories. - `username` (`string`, optional): Username for an authenticated remote. For GitHub, any non-empty value works with a token as the password. Example: git Example input: `{"path":"","sandbox_id":"","url":""}` ### `daytona_git_commit` Git Commit · Write Commit the staged changes in a Git repository inside a started Daytona sandbox. Returns the new commit hash. Use daytona_git_commit after daytona_git_add, then daytona_git_push to publish. Use daytona_git_status to review changes first. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `author` (`string`, required): Author name for the commit. Example: Jane Doe - `email` (`string`, required): Author email for the commit. Example: jane@example.com - `message` (`string`, required): Commit message. Example: Fix off-by-one error in parser - `path` (`string`, required): Path of the Git repository inside the sandbox, absolute or relative to the working directory. Example: workspace/my-repo - `sandbox_id` (`string`, required): ID of a started sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). The sandbox must be in the started state and in the US region. Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b - `allow_empty` (`boolean`, optional): Allow a commit with no changes. Defaults to false. Example input: `{"author":"","email":"","message":"","path":"","sandbox_id":""}` ### `daytona_git_configure_user` Git Configure User · Write Set the Git user name and email inside a started Daytona sandbox, globally or for one repository. Returns an empty response on success. Use daytona_git_configure_user before committing with tools that rely on Git's configured identity. daytona_git_commit sets the author per commit. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `email` (`string`, required): Git user email. Example: jane@example.com - `name` (`string`, required): Git user name. Example: Jane Doe - `sandbox_id` (`string`, required): ID of a started sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). The sandbox must be in the started state and in the US region. Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b - `path` (`string`, optional): Repository path. Required when scope is local. Example: workspace/my-repo - `scope` (`string`, optional): Where to set the identity: global (default), local or system. One of: `global`, `local`, `system`. Example input: `{"email":"","name":"","sandbox_id":""}` ### `daytona_git_create_branch` Git Create Branch · Write Create a new branch in a Git repository inside a started Daytona sandbox. Returns an empty response on success. Use daytona_git_create_branch, then daytona_git_checkout to switch to it. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `name` (`string`, required): Name of the new branch. Example: feature/login - `path` (`string`, required): Path of the Git repository inside the sandbox, absolute or relative to the working directory. Example: workspace/my-repo - `sandbox_id` (`string`, required): ID of a started sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). The sandbox must be in the started state and in the US region. Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b Example input: `{"name":"","path":"","sandbox_id":""}` ### `daytona_git_init` Git Init · Write Initialize a new Git repository in a folder inside a started Daytona sandbox. Returns an empty response on success. Use daytona_git_init to start version control for new code. Use daytona_git_clone to copy an existing repository, then daytona_git_add_remote to connect a remote. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `path` (`string`, required): Path of the Git repository inside the sandbox, absolute or relative to the working directory. Example: workspace/my-repo - `sandbox_id` (`string`, required): ID of a started sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). The sandbox must be in the started state and in the US region. Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b - `bare` (`boolean`, optional): Create a bare repository without a working tree. Defaults to false. - `initial_branch` (`string`, optional): Name of the initial branch. Example: main Example input: `{"path":"","sandbox_id":""}` ### `daytona_git_pull` Git Pull · Write Pull changes from the remote into a Git repository inside a started Daytona sandbox. Returns an empty response on success. Use daytona_git_pull to update an existing clone. Use daytona_git_clone for a new copy. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `path` (`string`, required): Path of the Git repository inside the sandbox, absolute or relative to the working directory. Example: workspace/my-repo - `sandbox_id` (`string`, required): ID of a started sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). The sandbox must be in the started state and in the US region. Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b - `branch` (`string`, optional): Branch to pull. Defaults to the current branch's upstream. Example: main - `password` (`string`, optional): Password or personal access token for an authenticated remote. Leave empty for public repositories. - `remote` (`string`, optional): Remote to pull from. Defaults to origin. - `username` (`string`, optional): Username for an authenticated remote. For GitHub, any non-empty value works with a token as the password. Example: git Example input: `{"path":"","sandbox_id":""}` ### `daytona_git_push` Git Push · Write Push local commits from a Git repository inside a started Daytona sandbox to its remote. Returns an empty response on success. Use daytona_git_push after daytona_git_commit. Use daytona_git_pull to fetch remote changes first. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `path` (`string`, required): Path of the Git repository inside the sandbox, absolute or relative to the working directory. Example: workspace/my-repo - `sandbox_id` (`string`, required): ID of a started sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). The sandbox must be in the started state and in the US region. Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b - `branch` (`string`, optional): Branch to push. Defaults to the current branch. Example: feature/login - `password` (`string`, optional): Password or personal access token for an authenticated remote. Leave empty for public repositories. - `remote` (`string`, optional): Remote to push to. Defaults to origin. - `set_upstream` (`boolean`, optional): Record the pushed branch as the upstream tracking branch. Defaults to false. - `username` (`string`, optional): Username for an authenticated remote. For GitHub, any non-empty value works with a token as the password. Example: git Example input: `{"path":"","sandbox_id":""}` ### `daytona_git_reset` Git Reset · Write Reset the current HEAD of a Git repository inside a started Daytona sandbox to a revision. Returns an empty response on success. Use daytona_git_reset to undo commits or unstage everything. Mode hard discards working-tree changes. Use daytona_git_restore for individual files. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `path` (`string`, required): Path of the Git repository inside the sandbox, absolute or relative to the working directory. Example: workspace/my-repo - `sandbox_id` (`string`, required): ID of a started sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). The sandbox must be in the started state and in the US region. Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b - `files` (`array`, optional): Limit the reset to these paths. Example: ["src/main.py"] - `mode` (`string`, optional): Reset mode: soft, mixed (default), hard, merge or keep. hard discards uncommitted changes. One of: `soft`, `mixed`, `hard`, `merge`, `keep`. - `target` (`string`, optional): Revision to reset to. Defaults to HEAD. Example: HEAD~1 Example input: `{"path":"","sandbox_id":""}` ### `daytona_git_restore` Git Restore · Write Restore working-tree files or unstage changes in a Git repository inside a started Daytona sandbox. Returns an empty response on success. Use daytona_git_restore to discard edits to specific files or unstage them. Use daytona_git_reset to move HEAD. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `files` (`array`, required): Files to restore, relative to the repository. Example: ["src/main.py"] - `path` (`string`, required): Path of the Git repository inside the sandbox, absolute or relative to the working directory. Example: workspace/my-repo - `sandbox_id` (`string`, required): ID of a started sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). The sandbox must be in the started state and in the US region. Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b - `source` (`string`, optional): Revision to restore file contents from instead of the index. Example: HEAD~1 - `staged` (`boolean`, optional): Restore the staging area for these files (unstage them). - `worktree` (`boolean`, optional): Restore the working-tree copy of these files (discard edits). Example input: `{"files":["src/main.py"],"path":"","sandbox_id":""}` ### `daytona_move_file` Move File · Write Move or rename a file or folder inside a started Daytona sandbox. Returns an empty response on success. Use daytona_move_file to rename or relocate files. Use daytona_execute_command with cp to copy instead. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `destination` (`string`, required): New path for the file or folder. Example: /home/daytona/workspace/new.txt - `sandbox_id` (`string`, required): ID of a started sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). The sandbox must be in the started state and in the US region. Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b - `source` (`string`, required): Current path of the file or folder. Example: /home/daytona/workspace/old.txt Example input: `{"destination":"","sandbox_id":"","source":""}` ### `daytona_pause_sandbox` Pause Sandbox · Write Pause a running Daytona sandbox, keeping its memory state so it resumes where it left off. Returns the updated sandbox object with its id, name, state, resources (cpu, memory, disk), labels and auto-stop/archive/delete settings. Use daytona_pause_sandbox for VM-class sandboxes that support pausing. Use daytona_stop_sandbox for other sandboxes, and daytona_start_sandbox to resume. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `sandbox_id_or_name` (`string`, required): ID or name of the sandbox. Use daytona_list_sandboxes to find it. Example: my-sandbox Example input: `{"sandbox_id_or_name":""}` ### `daytona_recover_sandbox` Recover Sandbox · Write Recover a Daytona sandbox that is in the error state. Returns the updated sandbox object with its id, name, state, resources (cpu, memory, disk), labels and auto-stop/archive/delete settings. Use daytona_recover_sandbox only for sandboxes whose state is error and that are marked recoverable. Use daytona_start_sandbox for normal stopped sandboxes. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `sandbox_id_or_name` (`string`, required): ID or name of the sandbox. Use daytona_list_sandboxes to find it. Example: my-sandbox - `skip_start` (`boolean`, optional): Leave the sandbox stopped after recovery instead of starting it. Defaults to false. Example input: `{"sandbox_id_or_name":""}` ### `daytona_replace_in_files` Replace in Files · Write Replace a text pattern with a new value in one or more files inside a started Daytona sandbox. Returns one result per file with file, success and any error. Use daytona_replace_in_files for targeted edits. Use daytona_find_in_files first to find which files contain the pattern. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `files` (`array`, required): Paths of the files to edit. Example: ["/home/daytona/workspace/config.py"] - `new_value` (`string`, required): Replacement text. Example: DEBUG = False - `pattern` (`string`, required): Text to find. Example: DEBUG = True - `sandbox_id` (`string`, required): ID of a started sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). The sandbox must be in the started state and in the US region. Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b Example input: `{"files":["/home/daytona/workspace/config.py"],"new_value":"","pattern":"","sandbox_id":""}` ### `daytona_replace_sandbox_labels` Replace Sandbox Labels · Write Replace all labels on a Daytona sandbox with a new set of key-value pairs. Returns the sandbox's labels object after the update. Use daytona_replace_sandbox_labels to tag sandboxes for filtering in daytona_list_sandboxes. Existing labels not in the new set are removed. Read only: no. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `labels` (`object`, required): The complete new set of labels as a JSON object of key-value pairs; it replaces every existing label. Example: {"environment": "dev", "team": "backend"} - `sandbox_id_or_name` (`string`, required): ID or name of the sandbox. Use daytona_list_sandboxes to find it. Example: my-sandbox Example input: `{"labels":{"environment":"dev","team":"backend"},"sandbox_id_or_name":""}` ### `daytona_resize_sandbox` Resize Sandbox · Write Change the CPU, memory or disk allocated to a Daytona sandbox. Returns the updated sandbox object with its id, name, state, resources (cpu, memory, disk), labels and auto-stop/archive/delete settings. Use daytona_resize_sandbox to scale an existing sandbox. Disk can only grow. Set resources at creation time with daytona_create_sandbox. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `sandbox_id_or_name` (`string`, required): ID or name of the sandbox. Use daytona_list_sandboxes to find it. Example: my-sandbox - `cpu` (`integer`, optional): New number of CPU cores (minimum 1). Example: 4 - `disk` (`integer`, optional): New disk size in GB; disk can only be increased. Example: 20 - `memory` (`integer`, optional): New memory size in GB (minimum 1). Example: 8 Example input: `{"sandbox_id_or_name":""}` ### `daytona_run_code` Run Code · Write Run a Python, JavaScript or TypeScript snippet inside a started Daytona sandbox. Returns the program output as result, its exitCode, and artifacts such as matplotlib charts. Use daytona_run_code to execute generated code. Use daytona_execute_command for shell commands. The sandbox must be started (daytona_start_sandbox). Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `code` (`string`, required): Source code to run. Example: print(sum(range(10))) - `language` (`string`, required): Language of the code: python, javascript or typescript. One of: `python`, `javascript`, `typescript`. - `sandbox_id` (`string`, required): ID of a started sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). The sandbox must be in the started state and in the US region. Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b - `argv` (`array`, optional): Command-line arguments passed to the program. Example: ["--verbose"] - `envs` (`object`, optional): Environment variables for the program, as a JSON object. Example: {"MODE": "test"} - `timeout` (`integer`, optional): Maximum run time in seconds. Example: 60 Example input: `{"code":"","language":"python","sandbox_id":""}` ### `daytona_send_session_command_input` Send Session Command Input · Write Send input text to a running command in a shell session inside a started Daytona sandbox, for interactive programs. Returns an empty response on success. Use daytona_send_session_command_input to answer prompts from a command started with daytona_session_execute_command and run_async. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `command_id` (`string`, required): ID of the command, from the cmdId field returned by daytona_session_execute_command. Example: 0b2f7c9e-1a3d-4e5f-8a9b-7c6d5e4f3a2b - `data` (`string`, required): Text to send to the command's standard input. Include a trailing newline to submit a line. Example: y\n - `sandbox_id` (`string`, required): ID of a started sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). The sandbox must be in the started state and in the US region. Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b - `session_id` (`string`, required): ID of the shell session, as chosen in daytona_create_session. Example: build-session Example input: `{"command_id":"","data":"","sandbox_id":"","session_id":""}` ### `daytona_session_execute_command` Session Execute Command · Write Run a command in an existing shell session inside a started Daytona sandbox, optionally in the background. Returns the cmdId plus, for synchronous runs, exitCode, output, stdout and stderr. Use daytona_session_execute_command for commands that depend on earlier state or run long (set run_async). Use daytona_get_session_command_logs to read output of async commands. Create the session first with daytona_create_session. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `command` (`string`, required): Shell command to run in the session. Example: npm install && npm run build - `sandbox_id` (`string`, required): ID of a started sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). The sandbox must be in the started state and in the US region. Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b - `session_id` (`string`, required): ID of the shell session, as chosen in daytona_create_session. Example: build-session - `run_async` (`boolean`, optional): Return immediately with a cmdId instead of waiting for the command to finish. Defaults to false. - `suppress_input_echo` (`boolean`, optional): Do not echo input sent with daytona_send_session_command_input into the output. Defaults to false. Example input: `{"command":"","sandbox_id":"","session_id":""}` ### `daytona_set_file_permissions` Set File Permissions · Write Set the permission mode, owner or group of a file or folder inside a started Daytona sandbox. Returns an empty response on success. Use daytona_set_file_permissions to make a script executable or change ownership. Use daytona_get_file_info to check the current values. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `path` (`string`, required): Path of the file or folder. Example: /home/daytona/workspace/run.sh - `sandbox_id` (`string`, required): ID of a started sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). The sandbox must be in the started state and in the US region. Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b - `group` (`string`, optional): New group, as a group name or GID. Example: daytona - `mode` (`string`, optional): Permission mode in octal. Example: 0755 - `owner` (`string`, optional): New owner, as a username or UID. Example: daytona Example input: `{"path":"","sandbox_id":""}` ### `daytona_set_sandbox_autoarchive_interval` Set Sandbox Auto-Archive Interval · Write Set how many minutes a stopped Daytona sandbox waits before it is archived automatically. Returns the updated sandbox object with its id, name, state, resources (cpu, memory, disk), labels and auto-stop/archive/delete settings. Use daytona_set_sandbox_autoarchive_interval to move long-stopped sandboxes to cheaper storage. Use daytona_set_sandbox_autostop_interval for the running-to-stopped step. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `interval` (`integer`, required): Minutes a stopped sandbox waits before being archived; 0 uses the maximum interval. Example: 10080 - `sandbox_id_or_name` (`string`, required): ID or name of the sandbox. Use daytona_list_sandboxes to find it. Example: my-sandbox Example input: `{"interval":10080,"sandbox_id_or_name":""}` ### `daytona_set_sandbox_autodelete_interval` Set Sandbox Auto-Delete Interval · Write Set how many minutes a stopped Daytona sandbox waits before it is deleted automatically. Returns the updated sandbox object with its id, name, state, resources (cpu, memory, disk), labels and auto-stop/archive/delete settings. Use daytona_set_sandbox_autodelete_interval to clean up throwaway sandboxes. Use daytona_set_sandbox_ttl for a hard lifetime that applies in any state. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `interval` (`integer`, required): Minutes a stopped sandbox waits before deletion; a negative value disables auto-delete and 0 deletes it as soon as it stops. Example: 60 - `sandbox_id_or_name` (`string`, required): ID or name of the sandbox. Use daytona_list_sandboxes to find it. Example: my-sandbox Example input: `{"interval":60,"sandbox_id_or_name":""}` ### `daytona_set_sandbox_autopause_interval` Set Sandbox Auto-Pause Interval · Write Set how many minutes of inactivity a Daytona sandbox waits before pausing automatically. Returns the updated sandbox object with its id, name, state, resources (cpu, memory, disk), labels and auto-stop/archive/delete settings. Use daytona_set_sandbox_autopause_interval for sandbox classes that support pausing. Use daytona_set_sandbox_autostop_interval for all other sandboxes. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `interval` (`integer`, required): Minutes of inactivity before the sandbox pauses; 0 disables auto-pause. Example: 60 - `sandbox_id_or_name` (`string`, required): ID or name of the sandbox. Use daytona_list_sandboxes to find it. Example: my-sandbox Example input: `{"interval":60,"sandbox_id_or_name":""}` ### `daytona_set_sandbox_autostop_interval` Set Sandbox Auto-Stop Interval · Write Set how many minutes of inactivity a Daytona sandbox waits before stopping automatically. Returns the updated sandbox object with its id, name, state, resources (cpu, memory, disk), labels and auto-stop/archive/delete settings. Use daytona_set_sandbox_autostop_interval to control idle cost. Use daytona_set_sandbox_autoarchive_interval and daytona_set_sandbox_autodelete_interval for what happens after it stops. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `interval` (`integer`, required): Minutes of inactivity before the sandbox stops; 0 disables auto-stop. Example: 30 - `sandbox_id_or_name` (`string`, required): ID or name of the sandbox. Use daytona_list_sandboxes to find it. Example: my-sandbox Example input: `{"interval":30,"sandbox_id_or_name":""}` ### `daytona_set_sandbox_public` Set Sandbox Public Status · Write Make a Daytona sandbox's HTTP preview URLs public or private. Returns the updated sandbox object with its id, name, state, resources (cpu, memory, disk), labels and auto-stop/archive/delete settings. Use daytona_set_sandbox_public to share a running app without a token. Use daytona_get_signed_preview_url to share one port temporarily instead. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `is_public` (`boolean`, required): true makes preview URLs reachable without a token; false requires the preview token. - `sandbox_id_or_name` (`string`, required): ID or name of the sandbox. Use daytona_list_sandboxes to find it. Example: my-sandbox Example input: `{"is_public":true,"sandbox_id_or_name":""}` ### `daytona_set_sandbox_ttl` Set Sandbox TTL · Write Set a maximum lifetime for a Daytona sandbox, counted from now; when it elapses the sandbox is destroyed even if stopped, paused or archived. Returns the updated sandbox object with its id, name, state, resources (cpu, memory, disk), labels and auto-stop/archive/delete settings. Use daytona_set_sandbox_ttl for a hard expiry. Use daytona_set_sandbox_autodelete_interval to delete only after the sandbox stops. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `sandbox_id_or_name` (`string`, required): ID or name of the sandbox. Use daytona_list_sandboxes to find it. Example: my-sandbox - `ttl_minutes` (`integer`, required): Lifetime in minutes from now; 0 disables the TTL. Example: 1440 Example input: `{"sandbox_id_or_name":"","ttl_minutes":1440}` ### `daytona_start_sandbox` Start Sandbox · Write Start a stopped or archived Daytona sandbox, or resume a paused one. Returns the updated sandbox object with its id, name, state, resources (cpu, memory, disk), labels and auto-stop/archive/delete settings. Use daytona_start_sandbox before running commands in a stopped sandbox. Use daytona_create_sandbox to make a new one, and daytona_recover_sandbox for a sandbox in the error state. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `sandbox_id_or_name` (`string`, required): ID or name of the sandbox. Use daytona_list_sandboxes to find it. Example: my-sandbox Example input: `{"sandbox_id_or_name":""}` ### `daytona_stop_sandbox` Stop Sandbox · Write Stop a running Daytona sandbox, keeping its filesystem so it can be started again. Returns the updated sandbox object with its id, name, state, resources (cpu, memory, disk), labels and auto-stop/archive/delete settings. Use daytona_stop_sandbox to save compute while keeping the sandbox. Use daytona_pause_sandbox to keep memory state, daytona_archive_sandbox for long-term storage, and daytona_delete_sandbox to remove it. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `sandbox_id_or_name` (`string`, required): ID or name of the sandbox. Use daytona_list_sandboxes to find it. Example: my-sandbox - `force` (`boolean`, optional): Stop with SIGKILL instead of SIGTERM. Defaults to false. Example input: `{"sandbox_id_or_name":""}` ### `daytona_update_registry` Update Registry · Write Update the name, URL, credentials or project of a Docker registry in Daytona. Returns the updated registry. Use daytona_update_registry to rotate registry credentials. Name, URL and username are always required by the API. Read only: no. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `name` (`string`, required): Display name for the registry. Example: My Docker Hub - `registry_id` (`string`, required): ID of the Docker registry, from the `id` field returned by daytona_list_registries. Example: 123e4567-e89b-12d3-a456-426614174000 - `url` (`string`, required): Registry URL. Example: https://registry.hub.docker.com - `username` (`string`, required): Username for the registry. Example: my-docker-user - `password` (`string`, optional): New password or access token. Leave empty to keep the current one. - `project` (`string`, optional): Registry project or namespace. Example: my-project Example input: `{"name":"","registry_id":"","url":"","username":""}` ### `daytona_update_sandbox_network_settings` Update Sandbox Network Settings · Write Change the outbound network policy of a running Daytona sandbox: block all traffic, restore access, or set CIDR and domain allow lists. Returns the updated sandbox object with its id, name, state, resources (cpu, memory, disk), labels and auto-stop/archive/delete settings. Use daytona_update_sandbox_network_settings to lock down or open up a sandbox after creation. Set the initial policy in daytona_create_sandbox. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `sandbox_id_or_name` (`string`, required): ID or name of the sandbox. Use daytona_list_sandboxes to find it. Example: my-sandbox - `domain_allow_list` (`string`, optional): Comma-separated domains the sandbox may reach. Example: example.com,*.github.com - `network_allow_list` (`string`, optional): Comma-separated CIDR ranges the sandbox may reach. Example: 10.0.0.0/24,192.168.1.0/16 - `network_block_all` (`boolean`, optional): true blocks all outbound network access; false restores it. Example input: `{"sandbox_id_or_name":""}` ### `daytona_update_sandbox_secrets` Update Sandbox Secrets · Write Replace the set of organization secrets mounted in a Daytona sandbox as environment variables. Returns the updated sandbox object with its id, name, state, resources (cpu, memory, disk), labels and auto-stop/archive/delete settings. Use daytona_update_sandbox_secrets to attach, detach or rotate secrets on an existing sandbox. Create the secrets first with daytona_create_secret. A sandbox created without any secrets must be restarted for newly attached secrets to work. Read only: no. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `sandbox_id_or_name` (`string`, required): ID or name of the sandbox. Use daytona_list_sandboxes to find it. Example: my-sandbox - `secrets` (`array`, required): The complete list of secrets to mount; it replaces the current set. Each entry maps an env var name to a secret name. Pass an empty list to detach all. Example: [{"OPENAI_API_KEY": "openai-prod"}] Example input: `{"sandbox_id_or_name":"","secrets":[{"OPENAI_API_KEY":"openai-prod"}]}` ### `daytona_update_secret` Update Secret · Write Update the value, description or allowed hosts of a Daytona secret. Returns the updated secret metadata (the value is not returned). Use daytona_update_secret to rotate a secret; sandboxes that mount it pick up the new value within seconds. Read only: no. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `secret_id` (`string`, required): ID of the secret, from the `id` field returned by daytona_list_secrets. Example: 123e4567-e89b-12d3-a456-426614174000 - `description` (`string`, optional): New description. Example: OpenAI key for agents - `hosts` (`array`, optional): New list of hosts this secret may be sent to. Example: ["api.openai.com"] - `value` (`string`, optional): New secret value. Leave empty to keep the current one. Example input: `{"secret_id":""}` ### `daytona_delete_file` Delete File · Destructive Delete a file or folder inside a started Daytona sandbox. Returns an empty response on success. Use daytona_delete_file to remove files. Set recursive to true to delete a folder and its contents. Read only: no. Destructive: yes. Idempotent (safe to retry): yes. Inputs: - `path` (`string`, required): Path of the file or folder to delete. Example: /home/daytona/workspace/tmp.txt - `sandbox_id` (`string`, required): ID of a started sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). The sandbox must be in the started state and in the US region. Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b - `recursive` (`boolean`, optional): Delete a folder and everything in it. Required for non-empty folders. Defaults to false. Example input: `{"path":"","sandbox_id":""}` ### `daytona_delete_registry` Delete Registry · Destructive Delete a Docker registry configuration from Daytona. Returns an empty response on success. Use daytona_delete_registry to remove registry credentials you no longer need. Read only: no. Destructive: yes. Idempotent (safe to retry): yes. Inputs: - `registry_id` (`string`, required): ID of the Docker registry, from the `id` field returned by daytona_list_registries. Example: 123e4567-e89b-12d3-a456-426614174000 Example input: `{"registry_id":""}` ### `daytona_delete_sandbox` Delete Sandbox · Destructive Permanently delete a Daytona sandbox and its filesystem. Returns the sandbox object with its desiredState set to destroyed. Use daytona_delete_sandbox only when the sandbox is no longer needed. Use daytona_stop_sandbox or daytona_archive_sandbox to keep it for later. Read only: no. Destructive: yes. Idempotent (safe to retry): yes. Inputs: - `sandbox_id_or_name` (`string`, required): ID or name of the sandbox. Use daytona_list_sandboxes to find it. Example: my-sandbox Example input: `{"sandbox_id_or_name":""}` ### `daytona_delete_secret` Delete Secret · Destructive Delete a secret from the Daytona organization vault. Returns an empty response on success. Use daytona_delete_secret to remove a secret you no longer need. Detach it from sandboxes first with daytona_update_sandbox_secrets. Read only: no. Destructive: yes. Idempotent (safe to retry): yes. Inputs: - `secret_id` (`string`, required): ID of the secret, from the `id` field returned by daytona_list_secrets. Example: 123e4567-e89b-12d3-a456-426614174000 Example input: `{"secret_id":""}` ### `daytona_delete_session` Delete Session · Destructive Delete a shell session inside a started Daytona sandbox and end its processes. Returns an empty response on success. Use daytona_delete_session to clean up after daytona_session_execute_command work is done. Read only: no. Destructive: yes. Idempotent (safe to retry): yes. Inputs: - `sandbox_id` (`string`, required): ID of a started sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). The sandbox must be in the started state and in the US region. Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b - `session_id` (`string`, required): ID of the shell session, as chosen in daytona_create_session. Example: build-session Example input: `{"sandbox_id":"","session_id":""}` ### `daytona_delete_snapshot` Delete Snapshot · Destructive Permanently delete a Daytona snapshot. Returns an empty response on success. Use daytona_delete_snapshot to remove a template you no longer need. Use daytona_deactivate_snapshot to keep it but stop it being used. Read only: no. Destructive: yes. Idempotent (safe to retry): yes. Inputs: - `snapshot_id` (`string`, required): ID of the snapshot, from the `id` field returned by daytona_list_snapshots. Example: 7b1e2d3c-4a5b-6c7d-8e9f-0a1b2c3d4e5f Example input: `{"snapshot_id":""}` ### `daytona_delete_volume` Delete Volume · Destructive Mark a Daytona volume for deletion. Returns an empty response on success; returns 409 if a sandbox still uses the volume. Use daytona_delete_volume to remove storage you no longer need. Delete or reconfigure the sandboxes that mount it first. Read only: no. Destructive: yes. Idempotent (safe to retry): yes. Inputs: - `volume_id` (`string`, required): ID of the volume, from the `id` field returned by daytona_list_volumes. Example: 9d8c7b6a-5e4f-4a3b-2c1d-0e9f8a7b6c5d Example input: `{"volume_id":""}` ### `daytona_git_delete_branch` Git Delete Branch · Destructive Delete a local branch from a Git repository inside a started Daytona sandbox. Returns an empty response on success. Use daytona_git_delete_branch to clean up merged branches. It does not delete the branch on the remote. Read only: no. Destructive: yes. Idempotent (safe to retry): yes. Inputs: - `name` (`string`, required): Name of the branch to delete. Example: feature/old-experiment - `path` (`string`, required): Path of the Git repository inside the sandbox, absolute or relative to the working directory. Example: workspace/my-repo - `sandbox_id` (`string`, required): ID of a started sandbox (the UUID in the `id` field from daytona_list_sandboxes or daytona_get_sandbox, not the name). The sandbox must be in the started state and in the US region. Example: 3f2b8c1e-5a4d-4e6f-9b7a-1c2d3e4f5a6b Example input: `{"name":"","path":"","sandbox_id":""}` ### `daytona_revoke_ssh_access` Revoke SSH Access · Destructive Revoke SSH access to a Daytona sandbox, either one token or all of them. Returns the sandbox object. Use daytona_revoke_ssh_access to cut off access granted by daytona_create_ssh_access. Read only: no. Destructive: yes. Idempotent (safe to retry): yes. Inputs: - `sandbox_id_or_name` (`string`, required): ID or name of the sandbox. Use daytona_list_sandboxes to find it. Example: my-sandbox - `token` (`string`, optional): SSH access token to revoke. Leave empty to revoke all SSH access for the sandbox. Example: abc123def456 Example input: `{"sandbox_id_or_name":""}` ## Related Other Developer Tools connectors ([all 117](/agentkit/connectors/?category=developer-tools)): - [GitHub](/agentkit/connectors/github/): Scalekit connector, OAuth, 217 tools - [Microsoft Entra ID](/agentkit/connectors/microsoftentraid/): Scalekit connector, OAuth, 82 tools - [Datadog](/agentkit/connectors/datadog/): Scalekit connector, API key, 105 tools --- ## More Scalekit documentation | Resource | What it contains | When to use it | |----------|-----------------|----------------| | [/llms.txt](/llms.txt) | Structured index with routing hints per product area | Start here — find which documentation set covers your topic before loading full content | | [/llms-full.txt](/llms-full.txt) | Complete documentation for all Scalekit products in one file | Use when you need exhaustive context across multiple products or when the topic spans several areas | | [sitemap-0.xml](https://docs.scalekit.com/sitemap-0.xml) | Full URL list of every documentation page | Use to discover specific page URLs you can fetch for targeted, page-level answers |