Quickstart

Create your first Daytona sandbox in under 5 minutes

Get started with Daytona by creating and running your first sandbox. This guide will walk you through the complete process from setup to execution.

Prerequisites

Before you begin, make sure you have:

• A Daytona account (sign up here)
• An API key (create one)
• Python, Node.js, Go, or Ruby installed

Create your first sandbox

1. Install the SDK

   Choose your preferred language and install the Daytona SDK:

   pip

   pip install daytona
   
2. Set your API key

   Set your API key as an environment variable:

   bash

   export DAYTONA_API_KEY="your-api-key-here"
   

   You can also pass the API key directly in your code. See the authentication guide for more options.

3. Create and run a sandbox

   Create a simple program that creates a sandbox and runs code inside it:

   Python

   from daytona import Daytona
   
   # Initialize the Daytona client
   daytona = Daytona()
   
   # Create the sandbox
   sandbox = daytona.create()
   
   # Run code securely inside the sandbox
   response = sandbox.process.code_run('print("Sum of 3 and 4 is", 3 + 4)')
   print(response.result)
   
   # Clean up
   daytona.delete(sandbox)
   

   TypeScript

   import { Daytona } from '@daytonaio/sdk'
   
   async function main() {
     // Initialize the Daytona client
     const daytona = new Daytona()
   
     let sandbox
     try {
       // Create the sandbox
       sandbox = await daytona.create()
   
       // Run code securely inside the sandbox
       const response = await sandbox.process.codeRun(
         'console.log("Sum of 3 and 4 is", 3 + 4)'
       )
       console.log(response.result)
     } finally {
       if (sandbox) await daytona.delete(sandbox)
     }
   }
   
   main().catch(console.error)
   

   Go

   package main
   
   import (
     "context"
     "fmt"
     "log"
   
     "github.com/daytonaio/daytona/libs/sdk-go/pkg/daytona"
     "github.com/daytonaio/daytona/libs/sdk-go/pkg/types"
   )
   
   func main() {
     // Initialize the Daytona client
     client, err := daytona.NewClient()
     if err != nil {
       log.Fatal(err)
     }
   
     ctx := context.Background()
   
     // Create the sandbox
     params := types.SnapshotParams{
       SandboxBaseParams: types.SandboxBaseParams{
         Language: types.CodeLanguagePython,
       },
     }
   
     sandbox, _, err := client.Create(ctx, params)
     if err != nil {
       log.Fatal(err)
     }
     defer sandbox.Delete(ctx)
   
     // Run code securely inside the sandbox
     response, err := sandbox.Process.ExecuteCommand(
       ctx,
       `python3 -c "print('Sum of 3 and 4 is', 3 + 4)"`,
     )
     if err != nil {
       log.Fatal(err)
     }
   
     fmt.Println(response.Result)
   }
   

   Ruby

   require 'daytona'
   
   # Initialize the Daytona client
   daytona = Daytona::Client.new
   
   begin
     # Create the sandbox
     sandbox = daytona.create
   
     # Run code securely inside the sandbox
     response = sandbox.process.code_run('puts "Sum of 3 and 4 is #{3 + 4}"')
     puts response.result
   ensure
     # Clean up
     daytona.delete(sandbox) if sandbox
   end
   
4. Run your program

   Execute your program and you’ll see the output:

   Sum of 3 and 4 is 7
   

   Congratulations! You’ve successfully created your first Daytona sandbox and executed code inside it.

What just happened?

Let’s break down what your program did:

1. Initialized the client - Connected to the Daytona API using your API key
2. Created a sandbox - Launched an isolated execution environment in under 90ms
3. Executed code - Ran Python code safely inside the sandbox
4. Retrieved output - Got the results back to your application
5. Cleaned up - Deleted the sandbox to free up resources

Next steps

Explore file operations

Upload, download, and manage files in your sandbox

Git operations

Clone repositories and manage Git workflows

Process management

Execute commands and manage processes

Language Server Protocol

Add code intelligence with LSP support