Daytona Python SDK
The official Python SDK for Daytona, a secure and elastic infrastructure for running AI-generated code. Daytona provides full composable computers — sandboxes — that you can manage programmatically using the Daytona SDK.
The SDK provides an interface for sandbox management, file system operations, Git operations, language server protocol support, process and code execution, and computer use. For more information, see the documentation.
Installation
Install the package using pip:
pip install daytona
Get API key
Generate an API key from the Daytona Dashboard ↗ to authenticate SDK requests and access Daytona services. For more information, see the API keys documentation.
Configuration
Configure the SDK using environment variables or by passing a configuration object:
DAYTONA_API_KEY: Your Daytona API keyDAYTONA_API_URL: The Daytona API URLDAYTONA_TARGET: Your target region environment (e.g.us,eu)
from daytona import Daytona, DaytonaConfig
# Initialize with environment variables
daytona = Daytona()
# Initialize with configuration object
config = DaytonaConfig(
api_key="YOUR_API_KEY",
api_url="YOUR_API_URL",
target="us"
)
Create a sandbox
Create a sandbox to run your code securely in an isolated environment.
from daytona import Daytona, DaytonaConfig
config = DaytonaConfig(api_key="YOUR_API_KEY")
daytona = Daytona(config)
sandbox = daytona.create()
response = sandbox.process.code_run('print("Hello World")')
Examples and guides
Daytona provides examples and guides for common sandbox operations, best practices, and a wide range of topics, from basic usage to advanced topics, showcasing various types of integrations between Daytona and other tools.
Create a sandbox with custom resources
Create a sandbox with custom resources (CPU, memory, disk).
from daytona import Daytona, CreateSandboxFromImageParams, Image, Resources
daytona = Daytona()
sandbox = daytona.create(
CreateSandboxFromImageParams(
image=Image.debian_slim("3.12"),
resources=Resources(cpu=2, memory=4, disk=8)
)
)
Create an ephemeral sandbox
Create an ephemeral sandbox that is automatically deleted when stopped.
from daytona import Daytona, CreateSandboxFromSnapshotParams
daytona = Daytona()
sandbox = daytona.create(
CreateSandboxFromSnapshotParams(ephemeral=True, auto_stop_interval=5)
)
Create a sandbox from a snapshot
Create a sandbox from a snapshot.
from daytona import Daytona, CreateSandboxFromSnapshotParams
daytona = Daytona()
sandbox = daytona.create(
CreateSandboxFromSnapshotParams(
snapshot="my-snapshot-name",
language="python"
)
)
Execute Commands
Execute commands in the sandbox.
# Execute a shell command
response = sandbox.process.exec('echo "Hello, World!"')
print(response.result)
# Run Python code
response = sandbox.process.code_run('''
x = 10
y = 20
print(f"Sum: {x + y}")
''')
print(response.result)
File Operations
Upload, download, and search files in the sandbox.
# Upload a file
sandbox.fs.upload_file(b'Hello, World!', 'path/to/file.txt')
# Download a file
content = sandbox.fs.download_file('path/to/file.txt')
# Search for files
matches = sandbox.fs.find_files(root_dir, 'search_pattern')
Git Operations
Clone, list branches, and add files to the sandbox.
# Clone a repository
sandbox.git.clone('https://github.com/example/repo', 'path/to/clone')
# List branches
branches = sandbox.git.branches('path/to/repo')
# Add files
sandbox.git.add('path/to/repo', ['file1.txt', 'file2.txt'])
Language Server Protocol
Create and start a language server to get code completions, document symbols, and more.
# Create and start a language server
lsp = sandbox.create_lsp_server('python', 'path/to/project')
lsp.start()
# Notify the lsp for the file
lsp.did_open('path/to/file.py')
# Get document symbols
symbols = lsp.document_symbols('path/to/file.py')
# Get completions
completions = lsp.completions('path/to/file.py', {"line": 10, "character": 15})
Code in _sync directory shouldn't be edited directly. It should be generated from the corresponding async code in the _async directory using the SDK generation scripts in the scripts directory.
List method return shapes
Each list method returns a different shape depending on the resource. The table below shows the exact return type and how to access the elements.
| Method | Return type (sync) | Return type (async) | Shape | Access elements |
|---|---|---|---|---|
daytona.snapshot.list(page?, limit?) |
PaginatedSnapshots |
PaginatedSnapshots |
Paginated wrapper | result.items |
daytona.secret.list(cursor?, limit?, ...) |
ListSecretsResponse |
ListSecretsResponse |
Cursor-paginated wrapper | page.items |
daytona.volume.list() |
list[Volume] |
list[Volume] |
Bare list | iterate directly |
daytona.list(query?) |
Iterator[Sandbox] |
AsyncIterator[Sandbox] |
Lazy iterator | for sandbox in daytona.list() |
PaginatedSnapshots and ListSecretsResponse are wrapper objects, not lists. Calling list methods like .append() directly on them raises AttributeError. Always go through .items:
# snapshots — page-number pagination
result = daytona.snapshot.list(page=1, limit=20)
# result.items → list[Snapshot]
# result.total → int (total across all pages)
# result.page → int (current page, 1-indexed)
# result.total_pages → int
for snapshot in result.items:
print(snapshot.name)
# secrets — cursor pagination
cursor = None
while True:
page = daytona.secret.list(cursor=cursor, limit=50)
# page.items → list[Secret]
# page.total → int
# page.next_cursor → str | None (None = no more pages)
for secret in page.items:
print(secret.name)
if page.next_cursor is None:
break
cursor = page.next_cursor
# volumes — bare list, iterate directly
volumes = daytona.volume.list()
for vol in volumes:
print(vol.name)
# sandboxes — lazy iterator, fetches pages on demand
from daytona import ListSandboxesQuery
for sandbox in daytona.list(ListSandboxesQuery(labels={"env": "dev"})):
print(sandbox.id)
The async client (AsyncDaytona) uses the same field names. Replace for sandbox in with async for sandbox in for the sandbox iterator.
Download files
Download the file for your platform. If you're not sure which to choose, learn more about installing packages.
Source Distribution
Built Distribution
Filter files by name, interpreter, ABI, and platform.
If you're not sure about the file name format, learn more about wheel file names.
Copy a direct link to the current filters
File details
Details for the file daytona-0.205.0.tar.gz.
File metadata
- Download URL: daytona-0.205.0.tar.gz
- Upload date:
- Size: 188.1 kB
- Tags: Source
- Uploaded using Trusted Publishing? No
- Uploaded via:
poetry/2.3.2 CPython/3.13.12 Linux/6.8.0-137-generic
File hashes
| Algorithm | Hash digest | |
|---|---|---|
| SHA256 |
ed55eb3fac5d8f21e2cf7c293e09dfe15ac9838764d595e07802a8e656710837
|
|
| MD5 |
91ca746ca95144c2bc04effd6079040c
|
|
| BLAKE2b-256 |
a6c37d8a94920ddff6377f47efcba59084cb5bc4ba5aec820e84aaae53fbfd25
|
File details
Details for the file daytona-0.205.0-py3-none-any.whl.
File metadata
- Download URL: daytona-0.205.0-py3-none-any.whl
- Upload date:
- Size: 225.3 kB
- Tags: Python 3
- Uploaded using Trusted Publishing? No
- Uploaded via:
poetry/2.3.2 CPython/3.13.12 Linux/6.8.0-137-generic
File hashes
| Algorithm | Hash digest | |
|---|---|---|
| SHA256 |
956a44cb37155d082115739e139217f4cb5accd8d9c3a8d64c1c7434622a8e5d
|
|
| MD5 |
41c2bbcf8c4cb5bb93ba56bd9a402a9f
|
|
| BLAKE2b-256 |
75431a8339f5c55fa782074f3563040c43f2919209aba8c68eef4d445d56ad54
|
