# Daytona — how to use (mcp.ai)

Connect your Daytona account and use 114 tools for developer tools straight from your AI agent. Connect in one click, no API key needed. Daytona is a development environment management platform that provides cloud-based development workspaces with API access for automation.

## Option A — via MCP (recommended)
Remote MCP endpoint (HTTP, streamable): `https://api.mcp.ai/p_daytona?ms=1787296020000`
Add it as a custom/remote MCP connector in your client (Claude, Cursor, VS Code…), then authenticate when prompted. Once connected, ask the agent to use the server's tools (e.g. `daytona_archive_sandbox`).

## Option B — via direct REST API
Base URL: `https://api.mcp.ai/api/daytona`
Auth: `Authorization: Bearer sk_live_…` — create a workspace API key at https://mcp.ai/settings/api-keys
Discover endpoints: `GET https://api.mcp.ai/api/daytona/_endpoints`

### Endpoints
- `POST https://api.mcp.ai/api/daytona/archive/sandbox` — Archives a sandbox in the Daytona platform. Use this action when you need to archive a sandbox that is no longer needed but should be preserved for future reference. The sandbox will be marked as arch
  - body: { sandboxIdOrName: string }
- `POST https://api.mcp.ai/api/daytona/cancel/organization/invitation` — Cancels a pending organization invitation. Use when you need to revoke an invitation that has been sent but not yet accepted by the recipient. This action is irreversible — once an invitation is cance
  - body: { invitationId: string, organizationId: string }
- `POST https://api.mcp.ai/api/daytona/checkout/git` — [DEPRECATED] Checkout a branch or commit in a git repository within a sandbox. Use this action when you need to switch branches or checkout a specific commit in a git repository that exists within a s
  - body: { path: string, branch: string, sandboxId: string }
- `POST https://api.mcp.ai/api/daytona/clone/repository` — Clones a Git repository into a sandbox toolbox. Use this action when you need to clone a public or private Git repository into a specific directory within a sandbox. Supports optional branch selection
  - body: { url: string, path: string, branch?: string, password?: string, username?: string, commit_id?: string, sandboxId: string }
- `POST https://api.mcp.ai/api/daytona/create/api/key` — Creates a new API key for the organization. Use when you need to generate a new API key that can be used to authenticate API requests. The created API key value is only returned once in the response a
  - body: { name: string, expiresAt?: string, permissions: string[] }
- `POST https://api.mcp.ai/api/daytona/create/backup` — Initiates a backup operation for an existing sandbox environment. Use this action when you need to create a point-in-time snapshot of a sandbox that can be used for restoration or cloning purposes. Th
  - body: { sandboxIdOrName: string }
- `POST https://api.mcp.ai/api/daytona/create/folder/files` — Creates a new folder inside a sandbox's filesystem. Use this action when you need to create a directory within a running sandbox's filesystem. This is useful for organizing files, preparing directory 
  - body: { mode: string, path: string, sandboxId: string }
- `POST https://api.mcp.ai/api/daytona/create/organization` — Creates a new organization in Daytona. Use this action when you need to set up a new organization with a specific name and default region configuration. This action creates a top-level organization en
  - body: { name: string, defaultRegionId: string }
- `POST https://api.mcp.ai/api/daytona/create/organization/invitation` — Creates an invitation to join an organization with specified roles and permissions. The invitation will be sent to the provided email address. Use this action when you need to invite a new member to a
  - body: { role: string, email: string, expiresAt?: string, organizationId: string, assignedRoleIds: string[] }
- `POST https://api.mcp.ai/api/daytona/create/organization/role` — Creates a new organization role with specified permissions. Use this action when you need to define custom roles for organization members, allowing fine-grained control over what resources they can ac
  - body: { name: string, description: string, permissions: string[], organizationId: string }
- `POST https://api.mcp.ai/api/daytona/create/process/session` — Creates a new session in the sandbox for process management. Use this action when you need to establish a new process session within a running sandbox environment. This enables managing process execut
  - body: { sandboxId: string, sessionId: string }
- `POST https://api.mcp.ai/api/daytona/create/pty/session` — Creates a new PTY (pseudo-terminal) session in a sandbox. Use this action when you need to establish an interactive terminal session within a running sandbox environment. This enables real-time comman
  - body: { id: string, cwd?: string, cols?: integer, envs?: object, rows?: integer, lazyStart?: boolean, sandboxId: string }
- `POST https://api.mcp.ai/api/daytona/create/registry` — Creates a new Docker registry for the organization. Use when you need to register a new container registry (such as Docker Hub, GCR, ECR, or other Docker registries) so that Daytona can pull images fr
  - body: { url: string, name: string, project?: string, password: string, username: string }
- `POST https://api.mcp.ai/api/daytona/create/sandbox` — Creates a new sandbox environment for development or testing purposes. Use this action when you need to provision a new isolated environment with configurable compute resources (CPU, memory, GPU), net
  - body: { cpu?: integer, env?: object, gpu?: integer, disk?: integer, name?: string, user?: string, labels?: object, memory?: integer, public?: boolean, target?: string, gpuType?: string[], volumes?: object[], snapshot?: string, buildInfo?: object, linkedSandbox?: string, networkBlockAll?: boolean, autoStopInterval?: integer, networkAllowList?: string, autoDeleteInterval?: integer, autoArchiveInterval?: integer }
- `POST https://api.mcp.ai/api/daytona/create/snapshot` — Creates a new snapshot resource that can be used as a base image for sandboxes. Use this action when you need to create a new snapshot with specific compute resources (CPU, memory, GPU, disk) and a co
  - body: { cpu?: integer, gpu?: integer, disk?: integer, name: string, memory?: integer, gpuType?: string[], regionId?: string, buildInfo?: object, imageName?: string, entrypoint?: string[], sandboxClass?: string }
- `POST https://api.mcp.ai/api/daytona/create/ssh/access` — Creates SSH access credentials for a sandbox environment. Use this action when you need to establish an SSH connection to a sandbox for administrative tasks, file transfers, or development operations.
  - body: { sandboxIdOrName: string, expiresInMinutes?: integer }
- `POST https://api.mcp.ai/api/daytona/create/volume` — Creates a new volume for storing data that can be attached to sandboxes. Use this action when you need to provision persistent storage for your sandbox environments. Volumes persist data across sandbo
  - body: { name: string }
- `POST https://api.mcp.ai/api/daytona/deactivate/snapshot` — Deactivates a snapshot in the Daytona platform. Use this action when you need to deactivate a snapshot that is currently active. This will stop the snapshot from being used for new sandbox creations. 
  - body: { id: string }
- `POST https://api.mcp.ai/api/daytona/delete/api/key` — Deletes an API key by its name. Use when you need to revoke access for an API key that is no longer needed or has been compromised. This action is irreversible — once an API key is deleted, it cannot 
  - body: { name: string }
- `POST https://api.mcp.ai/api/daytona/delete/api/key/user` — Deletes an API key for a specific user. Use when you need to remove an existing API key associated with a user account, such as when cleaning up unused credentials or revoking access. This action is i
  - body: { name: string, userId: string }
- `POST https://api.mcp.ai/api/daytona/delete/files` — Deletes a file inside a sandbox by its path. Use when you need to permanently remove a file from a sandbox that is no longer needed. This action is irreversible — once a file is deleted, it cannot be 
  - body: { path: string, recursive?: boolean, sandboxId: string }
- `POST https://api.mcp.ai/api/daytona/delete/git/branch` — Deletes a branch from a git repository inside a sandbox by its name. Use when you need to permanently remove a git branch that is no longer needed. This action is irreversible — once a branch is delet
  - body: { name: string, path: string, sandboxId: string }
- `POST https://api.mcp.ai/api/daytona/delete/organization` — Deletes an organization. Use when you need to permanently remove an organization from the system, including all associated data, members, and resources. This action is irreversible — once an organizat
  - body: { organizationId: string }
- `POST https://api.mcp.ai/api/daytona/delete/organization/otel/config` — Deletes the OpenTelemetry (OTEL) configuration for an organization. Use this action when you need to remove the OpenTelemetry settings that were previously configured for an organization's observabili
  - body: { organizationId: string }
- `POST https://api.mcp.ai/api/daytona/delete/organization/role` — Deletes an organization role. Use when you need to permanently remove a role from an organization, such as cleaning up unused custom roles or removing roles that are no longer needed. This action is i
  - body: { roleId: string, organizationId: string }
- `POST https://api.mcp.ai/api/daytona/delete/pty/session` — Deletes a PTY session and terminates the associated process. Use this action when you need to clean up an active PTY session that is no longer needed. This will terminate any process running in that s
  - body: { sandboxId: string, sessionId: string }
- `POST https://api.mcp.ai/api/daytona/delete/recording` — Deletes a recording from the Daytona platform by its ID. Use when you need to permanently remove a recording that is no longer needed. This action is irreversible — once a recording is deleted, it can
  - body: { id: string }
- `POST https://api.mcp.ai/api/daytona/delete/registry` — Deletes a Docker registry from the Daytona platform. Use when you need to remove an existing Docker registry configuration. This is an irreversible operation — once a registry is deleted, it cannot be
  - body: { id: string }
- `POST https://api.mcp.ai/api/daytona/delete/sandbox` — Deletes a sandbox from the Daytona platform by its ID or name. Use when you need to permanently remove a sandbox that is no longer needed. This action is irreversible — once a sandbox is deleted, it c
  - body: { sandboxIdOrName: string }
- `POST https://api.mcp.ai/api/daytona/delete/session` — Deletes a session from the Daytona platform by its ID. Use when you need to permanently remove a session that is no longer needed. This action is irreversible — once a session is deleted, it cannot be
  - body: { sandboxId: string, sessionId: string }
- `POST https://api.mcp.ai/api/daytona/delete/snapshot` — Deletes a snapshot from the Daytona platform by its ID. Use when you need to permanently remove a snapshot that is no longer needed. This action is irreversible — once a snapshot is deleted, it cannot
  - body: { id: string }
- `POST https://api.mcp.ai/api/daytona/delete/volume` — Deletes a volume from the Daytona platform by its ID. Use when you need to permanently remove a volume that is no longer needed. This action is irreversible — once a volume is deleted, it cannot be re
  - body: { volumeId: string }
- `POST https://api.mcp.ai/api/daytona/download/file/deprecated` — [DEPRECATED] Downloads a file from a sandbox's toolbox filesystem. Use this action when you need to retrieve a file from the sandbox's toolbox. Note: This endpoint is deprecated. Consider using an alt
  - body: { path: string, sandboxId: string }
- `POST https://api.mcp.ai/api/daytona/download/files` — Downloads multiple files from a sandbox as a multipart/form-data bundle. Use this action when you need to retrieve multiple files from a sandbox in a single operation. The files are returned as a stre
  - body: { paths: string[], sandboxId: string }
- `POST https://api.mcp.ai/api/daytona/enroll/in/sms/mfa` — Enrolls the authenticated user in SMS-based multi-factor authentication. Use when you need to enable SMS-based MFA for the authenticated user account. This action initiates the enrollment process and 
- `POST https://api.mcp.ai/api/daytona/execute/command` — Executes a shell command within a running sandbox via the toolbox proxy. Use this action when you need to run shell commands, scripts, or any executable commands inside a sandbox environment. This is 
  - body: { cwd?: string, envs?: object, command: string, timeout?: integer, sandboxId: string }
- `POST https://api.mcp.ai/api/daytona/expire/signed/port/preview/url` — Expires a signed preview URL for a sandbox port. Use this action when you need to immediately invalidate a signed preview URL for a specific port on a sandbox, revoking access for anyone holding the t
  - body: { port: integer, token: string, sandboxIdOrName: string }
- `POST https://api.mcp.ai/api/daytona/find/in/files/deprecated` — [DEPRECATED] Searches for text or patterns in files within a sandbox. Use this action when you need to find occurrences of a specific text or pattern across files in a sandbox. This is useful for code
  - body: { path: string, pattern: string, sandboxId: string }
- `POST https://api.mcp.ai/api/daytona/focus/accessibility/node` — Focuses an accessibility node in a sandbox's computer use system. Use this action when you need to programmatically set focus to a specific accessibility node within a sandbox's desktop environment. T
  - body: { id: string, sandboxId: string }
- `POST https://api.mcp.ai/api/daytona/get/api/key` — Retrieves an API key by its name. Use when you need to retrieve details about a specific API key, including its creation date, expiration, permissions, and usage statistics. This is a read-only operat
  - body: { name: string }
- `POST https://api.mcp.ai/api/daytona/get/available/account/providers` — Retrieves all available account providers that can be used to authenticate and link accounts. Use when you need to discover which account providers (such as GitHub, GitLab, Google) are available for l
- `POST https://api.mcp.ai/api/daytona/get/build/logs/url` — Retrieves the build logs URL for a specific sandbox by its ID or name. Use this action when you need to access build logs for a sandbox, such as during troubleshooting build failures, monitoring build
  - body: { sandboxIdOrName: string }
- `POST https://api.mcp.ai/api/daytona/get/commit/history` — Gets commit history from a repository in a sandbox toolbox. Use this action when you need to retrieve the commit history including: - Commit hash - Author name and email - Commit message - Timestamp T
  - body: { path: string, sandboxId: string }
- `POST https://api.mcp.ai/api/daytona/get/computer/use/status` — Retrieves the status of all VNC desktop processes in a sandbox. Use this action when you need to check the current state of all VNC desktop processes running within a sandbox. The status can indicate 
  - body: { sandboxId: string }
- `POST https://api.mcp.ai/api/daytona/get/config` — Retrieves the Daytona platform configuration including URLs, OIDC settings, analytics, rate limits, and other platform-level settings. Use this action when you need to fetch the current Daytona config
- `POST https://api.mcp.ai/api/daytona/get/display/info` — Retrieves information about displays connected to a sandbox. Use this action when you need to get information about all displays connected to a sandbox, including their dimensions, positions, and acti
  - body: { sandboxId: string }
- `POST https://api.mcp.ai/api/daytona/get/entrypoint/logs` — Retrieves entrypoint logs for a sandbox session. Use this action when you need to fetch the stdout, stderr, and combined output logs from an entrypoint process running within a sandbox. This is useful
  - body: { follow?: boolean, sandboxId: string }
- `POST https://api.mcp.ai/api/daytona/get/file/info` — [DEPRECATED] Gets file info inside a sandbox toolbox. Use this action when you need to retrieve detailed information about a specific file or directory within a sandbox toolbox, including its size, pe
  - body: { path: string, sandboxId: string }
- `POST https://api.mcp.ai/api/daytona/get/git/history/deprecated` — [DEPRECATED] Get commit history from a git repository in a sandbox toolbox. Use this action when you need to retrieve the commit history of a git repository within a sandbox toolbox. This is a read-on
  - body: { path: string, sandboxId: string }
- `POST https://api.mcp.ai/api/daytona/get/has/sandbox/access` — Checks if the authenticated user has access to a specific sandbox. Use this action when you need to verify whether the current user has permission to access a particular sandbox before performing furt
  - body: { sandboxId: string }
- `POST https://api.mcp.ai/api/daytona/get/health` — Retrieves the current health status of the Daytona service. Use when you need to verify that the Daytona API is running and accessible. This action is read-only and does not modify any data. This acti
- `POST https://api.mcp.ai/api/daytona/get/organization` — Retrieves detailed information about an organization by its unique identifier. Use when you need to fetch organization settings, rate limits, sandbox configurations, suspension status, OpenTelemetry s
  - body: { organization_id: string }
- `POST https://api.mcp.ai/api/daytona/get/organization/audit/logs` — Retrieves audit logs for an organization. Use when you need to track user activities, monitor security events, investigate incidents, or meet compliance requirements. This action supports both page-ba
  - body: { to?: string, from?: string, page?: integer, limit?: integer, nextToken?: string, organizationId: string }
- `POST https://api.mcp.ai/api/daytona/get/organization/invitations/count/user` — Retrieves the count of organization invitations for the authenticated user. Use this action when you need to check how many organization invitations are pending for the currently authenticated user. T
- `POST https://api.mcp.ai/api/daytona/get/organization/usage/overview` — Retrieves the current usage overview for an organization, including CPU, memory, disk, snapshot, and volume usage metrics across all regions. Use this action when you need to check an organization's c
  - body: { organizationId: string }
- `POST https://api.mcp.ai/api/daytona/get/process/status` — Retrieves the status of a specific VNC process in a sandbox. Use this action when you need to check if a particular VNC process (such as xfce4) is currently running within a sandbox. This is useful fo
  - body: { sandboxId: string, processName: string }
- `POST https://api.mcp.ai/api/daytona/get/project/dir/deprecated` — [DEPRECATED] Gets the project directory path within a sandbox toolbox. Use this action when you need to retrieve the project directory path for a specific sandbox toolbox. This is a read-only operatio
  - body: { sandboxId: string }
- `POST https://api.mcp.ai/api/daytona/get/pty/session` — Retrieves information about a PTY (pseudo-terminal) session in a sandbox. Use this action when you need to fetch details about a specific PTY session within a sandbox, including its configuration (ter
  - body: { sandboxId: string, sessionId: string }
- `POST https://api.mcp.ai/api/daytona/get/push/access` — Retrieves temporary storage access credentials for pushing objects to object storage. Use this action when you need to upload or push objects to the Daytona object storage service. The returned creden
- `POST https://api.mcp.ai/api/daytona/get/registry` — Retrieves details of a specific Docker registry by its unique identifier. Use this action when you need to fetch information about a particular Docker registry, including its URL, credentials, project
  - body: { id: string }
- `POST https://api.mcp.ai/api/daytona/get/sandbox` — Retrieves details of a specific sandbox by its ID or name. Use this action when you need to fetch detailed information about a particular sandbox, including its configuration, state, resource quotas, 
  - body: { verbose?: boolean, sandboxIdOrName: string }
- `POST https://api.mcp.ai/api/daytona/get/session/command/logs` — Retrieves logs for a specific command executed within a session. Use this action when you need to fetch the log output of a command that was executed in a sandbox session. The endpoint returns the com
  - body: { follow?: boolean, commandId: string, sandboxId: string, sessionId: string }
- `POST https://api.mcp.ai/api/daytona/get/session/deprecated` — [DEPRECATED] Retrieves details of a specific session in a sandbox toolbox. Use this action when you need to fetch information about a particular session, including its ID and the commands that have be
  - body: { sandboxId: string, sessionId: string }
- `POST https://api.mcp.ai/api/daytona/get/snapshot` — Retrieves details of a specific snapshot by its ID or name. Use this action when you need to fetch detailed information about a particular snapshot, including its configuration, state, resource quotas
  - body: { id: string }
- `POST https://api.mcp.ai/api/daytona/get/snapshot/build/logs` — Retrieves build logs for a specific snapshot. Use this action when you need to access build logs for a snapshot, such as during troubleshooting build failures, monitoring build progress, or retrieving
  - body: { id: string, follow?: boolean }
- `POST https://api.mcp.ai/api/daytona/get/toolbox/proxy/url` — Retrieves the toolbox proxy URL for a sandbox by its ID or name. Use this action when you need to access the toolbox interface of a sandbox, enabling command execution and file management operations. 
  - body: { sandboxIdOrName: string }
- `POST https://api.mcp.ai/api/daytona/get/transient/push/access` — Retrieves temporary registry access credentials for pushing snapshots. Use this action when you need to obtain short-lived authentication credentials to push Docker images or snapshots to the Daytona 
  - body: { regionId?: string }
- `POST https://api.mcp.ai/api/daytona/get/user` — Retrieves the profile of the authenticated user. Use when you need to fetch details about the currently logged-in user, including their ID, email, name, creation date, and associated public keys. This
- `POST https://api.mcp.ai/api/daytona/get/user/home/dir/deprecated` — [DEPRECATED] Gets the user home directory path for a sandbox. Use this action when you need to retrieve the home directory path for a user within a sandbox toolbox. This is a read-only operation that 
  - body: { sandboxId: string }
- `POST https://api.mcp.ai/api/daytona/get/volume` — Retrieves details of a specific volume by its ID. Use this action when you need to fetch information about a particular volume, including its name, state, organization, creation timestamp, and last us
  - body: { volumeId: string }
- `POST https://api.mcp.ai/api/daytona/get/windows` — Retrieves information about all windows in a sandbox. Use this action when you need to get a list of all windows currently open in a sandbox desktop environment. The response includes each window's po
  - body: { sandboxId: string }
- `POST https://api.mcp.ai/api/daytona/get/work/dir` — Gets the current working directory inside a sandbox toolbox. Use this action when you need to retrieve the current working directory path within a sandbox toolbox. This is a read-only operation that d
  - body: { sandboxId: string }
- `POST https://api.mcp.ai/api/daytona/get/work/dir/deprecated` — [DEPRECATED] Retrieves the working directory path of a sandbox toolbox. Use this action when you need to determine the current working directory path within a sandbox toolbox environment. This is a re
  - body: { sandboxId: string }
- `POST https://api.mcp.ai/api/daytona/list/api/keys` — Lists all API keys for the organization. Use when you need to retrieve information about all available API keys, including their names, creation dates, expiration dates, and associated permissions. Th
- `POST https://api.mcp.ai/api/daytona/list/available/regions` — Lists all available regions for the organization. Use this action when you need to retrieve information about all available regions, including their IDs, names, types, and associated URLs (proxy, SSH 
- `POST https://api.mcp.ai/api/daytona/list/files/deprecated` — [DEPRECATED] Lists files and directories in a sandbox toolbox. Use this action when you need to retrieve the list of files and directories in a specific path within a sandbox toolbox. This is a read-o
  - body: { path?: string, sandboxId: string }
- `POST https://api.mcp.ai/api/daytona/list/git/branches` — [DEPRECATED] Lists all git branches from a repository in a sandbox toolbox. Use this action when you need to retrieve the list of git branches from a repository within a sandbox toolbox. This is a rea
  - body: { path: string, sandboxId: string }
- `POST https://api.mcp.ai/api/daytona/list/organization/invitations` — Lists all pending organization invitations. Use this action when you need to retrieve all invitations for an organization, including pending, accepted, declined, or cancelled invitations. This is usef
  - body: { organizationId: string }
- `POST https://api.mcp.ai/api/daytona/list/organization/invitations/user` — Lists all organization invitations for the authenticated user. Use when you need to retrieve pending and past organization invitations that have been sent to or received by the current user, including
- `POST https://api.mcp.ai/api/daytona/list/organization/members` — Lists all members of a specific organization. Use when you need to retrieve information about all organization members, including their names, emails, roles, and assigned permissions. This is a read-o
  - body: { organizationId: string }
- `POST https://api.mcp.ai/api/daytona/list/organization/roles` — Lists all roles available in an organization. Use when you need to retrieve information about all organization roles, including their names, descriptions, permissions, and whether they are global role
  - body: { organizationId: string }
- `POST https://api.mcp.ai/api/daytona/list/organizations` — Lists all organizations that the authenticated user has access to. Use this action when you need to retrieve a list of all organizations available to the authenticated user, including their settings, 
- `POST https://api.mcp.ai/api/daytona/list/process/session` — Lists all active process sessions in a sandbox. Use this action when you need to retrieve information about all active process sessions running within a sandbox. This includes session IDs and command 
  - body: { sandboxId: string }
- `POST https://api.mcp.ai/api/daytona/list/pty/sessions` — Lists all active PTY sessions in a sandbox. Use this action when you need to retrieve information about all active pseudo-terminal (PTY) sessions running within a sandbox. This includes session identi
  - body: { sandboxId: string }
- `POST https://api.mcp.ai/api/daytona/list/registries` — Lists all docker registries available in the organization. Use when you need to retrieve information about all configured docker registries, including their IDs, names, URLs, authentication details, a
- `POST https://api.mcp.ai/api/daytona/list/sandboxes` — Lists all sandboxes for the organization. Use this action when you need to retrieve information about all available sandboxes, including their configuration, state, labels, and resource quotas. This i
  - body: { page?: integer, limit?: integer, cursor?: string, labels?: string, verbose?: boolean, includeErroredDeleted?: boolean }
- `POST https://api.mcp.ai/api/daytona/list/sandboxes/paginated` — Lists all sandboxes with pagination support. Use when you need to retrieve a paginated list of sandboxes for an organization, with optional filtering by name, labels, state, region, CPU/memory/disk sp
  - body: { id?: string, name?: string, page?: integer, sort?: string, limit?: integer, order?: string, labels?: string, maxCpu?: number, minCpu?: number, states?: string[], regions?: string[], snapshots?: string[], maxDiskGiB?: number, minDiskGiB?: number, maxMemoryGiB?: number, minMemoryGiB?: number, lastEventAfter?: string, lastEventBefore?: string, includeErroredDeleted?: boolean }
- `POST https://api.mcp.ai/api/daytona/list/shared/regions` — Tool to list all shared regions. Use when you need to retrieve information about all available shared regions, including their IDs, names, types, and associated URLs (proxy, SSH gateway, snapshot mana
- `POST https://api.mcp.ai/api/daytona/list/snapshots` — Lists all snapshots for the organization. Use this action when you need to retrieve information about all available snapshots, including their configuration, state, resource allocations, and usage inf
  - body: { name?: string, page?: integer, sort?: string, limit?: integer, order?: string }
- `POST https://api.mcp.ai/api/daytona/list/volumes` — Lists all volumes in the organization. Use when you need to retrieve information about all available volumes, including their IDs, names, states, and associated organizations. This is a read-only oper
  - body: { includeDeleted?: boolean }
- `POST https://api.mcp.ai/api/daytona/replace/in/files` — Replaces text or patterns in multiple files within a sandbox. Use this action when you need to perform find-and-replace operations across multiple files in a sandbox. For each file specified, the acti
  - body: { files: string[], pattern: string, newValue: string, sandboxId: string }
- `POST https://api.mcp.ai/api/daytona/replace/sandbox/labels` — Replaces all labels on a sandbox with a new set of key-value pairs. Use this action when you need to update or redefine the labels associated with an existing sandbox. This operation completely replac
  - body: { labels: object, sandboxIdOrName: string }
- `POST https://api.mcp.ai/api/daytona/resize/pty/session` — Resizes an active PTY session with new terminal dimensions. Use this action when you need to change the column and row dimensions of an existing pseudo-terminal (PTY) session within a running sandbox.
  - body: { cols: integer, rows: integer, sandboxId: string, sessionId: string }
- `POST https://api.mcp.ai/api/daytona/revoke/ssh/access` — Revokes SSH access credentials for a sandbox environment. Use this action when you need to invalidate SSH access to a sandbox, either for a specific token or all SSH access. This is useful for securit
  - body: { token?: string, sandboxIdOrName: string }
- `POST https://api.mcp.ai/api/daytona/search/files` — [DEPRECATED] Search for files inside a sandbox toolbox. Use this action when you need to find files matching a specific pattern within a sandbox toolbox. This is a read-only operation that does not mo
  - body: { path: string, pattern: string, sandboxId: string }
- `POST https://api.mcp.ai/api/daytona/set/auto/archive/interval` — Sets the auto-archive interval for a sandbox. Use this action when you need to configure how long a stopped sandbox should be retained before it is automatically archived. The interval specifies the t
  - body: { interval: integer, sandboxIdOrName: string }
- `POST https://api.mcp.ai/api/daytona/set/auto/delete/interval` — Sets the auto-delete interval for a sandbox. Use this action when you need to configure automatic deletion of a sandbox after it is stopped. The interval specifies how many minutes after stopping the 
  - body: { interval: integer, sandboxIdOrName: string }
- `POST https://api.mcp.ai/api/daytona/set/autostop/interval` — Sets the auto-stop interval for a sandbox in the Daytona platform. Use this action when you need to configure how long a sandbox should run idle before automatically stopping. This helps manage resour
  - body: { interval: integer, sandboxIdOrName: string }
- `POST https://api.mcp.ai/api/daytona/start/computer/use` — Starts all VNC desktop processes (Xvfb, xfce4, x11vnc, novnc) for a sandbox. Use this action when you need to start all VNC desktop processes for a sandbox to enable remote desktop access. This action
  - body: { sandboxId: string }
- `POST https://api.mcp.ai/api/daytona/start/lsp/server` — Starts an LSP server process inside a sandbox project. Use this action when you need to initialize an LSP (Language Server Protocol) server within a running sandbox. This enables intelligent code edit
  - body: { sandboxId: string, languageId: string, pathToProject: string }
- `POST https://api.mcp.ai/api/daytona/start/process` — Restarts a specific VNC process within a sandbox in the Daytona platform. Use this action when you need to restart a VNC process (such as xfce4) within a running sandbox. This is helpful when a deskto
  - body: { sandboxId: string, processName: string }
- `POST https://api.mcp.ai/api/daytona/start/sandbox` — Starts a sandbox in the Daytona platform. Use this action when you need to start a sandbox that is stopped or archived, making it ready for use. The sandbox will transition to a running state and be a
  - body: { sandboxIdOrName: string }
- `POST https://api.mcp.ai/api/daytona/stop/lsp/server` — Stops an LSP server process inside a sandbox project. Use this action when you need to stop an LSP (Language Server Protocol) server that is running inside a Daytona sandbox. This is useful for freein
  - body: { sandboxId: string, languageId: string, pathToProject: string }
- `POST https://api.mcp.ai/api/daytona/stop/sandbox` — Stops a running sandbox in the Daytona platform. Use this action when you need to gracefully stop a running sandbox that is no longer needed or should be temporarily shut down. The sandbox can be rest
  - body: { force?: boolean, sandboxIdOrName: string }
- `POST https://api.mcp.ai/api/daytona/take/compressed/screenshot` — Takes a compressed screenshot of the entire screen in a sandbox. Use this action when you need to capture the current visual state of a sandbox's display with compression. The response includes base64
  - body: { scale?: number, format?: string, quality?: integer, sandboxId: string, showCursor?: boolean }
- `POST https://api.mcp.ai/api/daytona/unlink/account` — Unlinks a connected provider account (such as GitHub, GitLab, or Bitbucket) from the authenticated user's Daytona profile. Use when a user wants to remove a connected account or revoke its integration
  - body: { provider: string, providerUserId: string }
- `POST https://api.mcp.ai/api/daytona/update/experimental/config` — Updates experimental configuration for an organization on the Daytona platform. Use this action when you need to configure experimental features such as OpenTelemetry settings for observability. The o
  - body: { otel?: object }
- `POST https://api.mcp.ai/api/daytona/update/last/activity` — Updates the last activity timestamp for a sandbox in the Daytona platform. Use this action when you need to keep a sandbox active by recording activity. This is useful for preventing auto-stop mechani
  - body: { sandboxId: string }
- `POST https://api.mcp.ai/api/daytona/update/organization/invitation` — Updates an organization invitation with new role and permissions. Use when you need to modify an existing organization invitation's role (owner or member) or assigned role permissions. This action all
  - body: { role: string, expiresAt?: string, invitationId: string, organizationId: string, assignedRoleIds: string[] }
- `POST https://api.mcp.ai/api/daytona/update/organization/otel/config` — Updates the OpenTelemetry configuration for an organization. Use this action when you need to configure or update the OTLP endpoint and custom headers for an organization's OpenTelemetry setup. This a
  - body: { headers?: object, endpoint: string, organizationId: string }
- `POST https://api.mcp.ai/api/daytona/update/organization/role` — Updates an organization role with a new name, description, and permissions. Use this action when you need to modify an existing role within an organization, such as changing what the role is called, u
  - body: { name: string, roleId: string, description: string, permissions: string[], organizationId: string }
- `POST https://api.mcp.ai/api/daytona/update/public/status` — Updates the public visibility status of a sandbox in the Daytona platform. Use this action when you need to change whether a sandbox can be accessed publicly via its HTTP preview. Setting a sandbox to
  - body: { isPublic: boolean, sandboxIdOrName: string }
- `POST https://api.mcp.ai/api/daytona/update/registry` — Updates a Docker registry configuration. Use this action when you need to modify the settings of an existing Docker registry, such as updating the registry name, URL, or credentials. This is a modific
  - body: { id: string, url: string, name: string, project?: string, password?: string, username: string }
- `POST https://api.mcp.ai/api/daytona/update/sandbox/default/limited/network/egress` — Updates the sandbox default limited network egress setting for an organization. Use this action when you need to configure whether new sandboxes should have limited network egress enabled by default w
  - body: { organizationId: string, sandboxDefaultLimitedNetworkEgress: boolean }

## Example prompts
- "What can I do in Daytona?"
- "Show me a summary of my Daytona account"

## More
- Page: https://mcp.ai/daytona
- Agent spec (llms.txt): https://mcp.ai/daytona/llms.txt
- Postman collection: https://mcp.ai/daytona/postman.json