Daytona

What is Daytona about?

Daytona delivers a fast, isolated sandbox infrastructure that lets AI agents run arbitrary code without exposing the host system. It creates sandboxes from any OCI/Docker image, supports unlimited persistence, and is designed for massive parallel AI workflows.

How to use Daytona?

1. Sign up at https://app.daytona.io and generate an API key.
2. Install the SDK of your choice:
   • Python: pip install daytona
   • TypeScript/JavaScript: npm install @daytonaio/sdk
3. Initialise the client with the API key and create a sandbox (e.g., language="python").
4. Use the process.codeRun (Python) or sandbox.process.codeRun (TS) method to execute code inside the sandbox.
5. When finished, delete the sandbox via daytona.remove(sandbox).

Key features of Daytona

• Lightning‑fast sandbox creation – sub‑90 ms from request to ready state.
• Zero‑risk isolation – each sandbox runs in its own runtime, protecting host infrastructure.
• Unlimited persistence – sandboxes can survive indefinitely.
• OCI/Docker compatibility – any container image can serve as the execution environment.
• Programmatic API – file management, Git operations, LSP support, and code execution.
• Future parallelization – planned forked filesystem/memory for massive concurrent workflows.

Use cases of Daytona

• AI agents that need to compile, test, or run generated scripts safely.
• Serverless‑style code execution for dynamic workloads without managing VMs.
• Secure evaluation of untrusted code snippets in education or experimentation platforms.
• Continuous integration pipelines for AI‑generated code patches.
• Research environments where reproducible, isolated executions are required.

FAQ from the Daytona

Q: Do I need to run a server locally? A: No. Daytona is offered as a hosted service; you interact via the SDK and API key.

Q: Which languages are supported? A: Any language available in a Docker/OCI image. The SDK examples show Python, but you can specify any container.

Q: How is data persisted? A: Sandboxes can be kept alive indefinitely, storing files and state across runs.

Q: Is there a limit on concurrent sandboxes? A: Limits depend on your plan; the platform is built for massive parallelism.

Q: How is security enforced? A: Each sandbox runs in an isolated container with restricted network and filesystem access, preventing code from affecting the host or other sandboxes.

 

---

Installation

Python SDK

pip install daytona

TypeScript SDK

npm install @daytonaio/sdk

---

Features

• Lightning-Fast Infrastructure: Sub-90ms Sandbox creation from code to execution.
• Separated & Isolated Runtime: Execute AI-generated code with zero risk to your infrastructure.
• Massive Parallelization for Concurrent AI Workflows: Fork Sandbox filesystem and memory state (Coming soon!)
• Programmatic Control: File, Git, LSP, and Execute API
• Unlimited Persistence: Your Sandboxes can live forever
• OCI/Docker Compatibility: Use any OCI/Docker image to create a Sandbox

---

Quick Start

1. Create an account at https://app.daytona.io
2. Generate a new API key
3. Follow the Getting Started docs to start using the Daytona SDK

Creating your first Sandbox

Python SDK

from daytona import Daytona, DaytonaConfig, CreateSandboxParams

# Initialize the Daytona client
daytona = Daytona(DaytonaConfig(api_key="YOUR_API_KEY"))

# Create the Sandbox instance
sandbox = daytona.create(CreateSandboxParams(language="python"))

# Run code securely inside the Sandbox
response = sandbox.process.code_run('print("Sum of 3 and 4 is " + str(3 + 4))')
if response.exit_code != 0:
    print(f"Error running code: {response.exit_code} {response.result}")
else:
    print(response.result)

# Clean up the Sandbox
daytona.remove(sandbox)

Typescript SDK

import { Daytona } from '@daytonaio/sdk'

async function main() {
  // Initialize the Daytona client
  const daytona = new Daytona({
    apiKey: 'YOUR_API_KEY',
  })

  let sandbox
  try {
    // Create the Sandbox instance
    sandbox = await daytona.create({
      language: 'python',
    })
    // Run code securely inside the Sandbox
    const response = await sandbox.process.codeRun('print("Sum of 3 and 4 is " + str(3 + 4))')
    if (response.exitCode !== 0) {
      console.error('Error running code:', response.exitCode, response.result)
    } else {
      console.log(response.result)
    }
  } catch (error) {
    console.error('Sandbox flow error:', error)
  } finally {
    if (sandbox) await daytona.remove(sandbox)
  }
}

main().catch(console.error)

---

Contributing

Daytona is Open Source under the GNU AFFERO GENERAL PUBLIC LICENSE, and is the copyright of its contributors. If you would like to contribute to the software, read the Developer Certificate of Origin Version 1.1 (https://developercertificate.org/). Afterwards, navigate to the contributing guide to get started.