Basic Sandbox Management

Create, start, stop, and manage sandbox lifecycle

This example demonstrates the fundamental operations for working with sandboxes in Daytona.

What You’ll Learn

• Creating a new sandbox
• Setting labels and metadata
• Starting and stopping sandboxes
• Retrieving sandbox information
• Listing all sandboxes
• Deleting sandboxes

Complete Example

Python

from daytona import Daytona


def main():
    daytona = Daytona()

    print("Creating sandbox")
    sandbox = daytona.create()
    print("Sandbox created")

    _ = sandbox.set_labels(
        {
            "public": "true",
        }
    )

    print("Stopping sandbox")
    daytona.stop(sandbox)
    print("Sandbox stopped")

    print("Starting sandbox")
    daytona.start(sandbox)
    print("Sandbox started")

    print("Getting existing sandbox")
    existing_sandbox = daytona.get(sandbox.id)
    print("Get existing sandbox")

    response = existing_sandbox.process.exec('echo "Hello World from exec!"', cwd="/home/daytona", timeout=10)
    if response.exit_code != 0:
        print(f"Error: {response.exit_code} {response.result}")
    else:
        print(response.result)

    result = daytona.list()
    print("Total sandboxes count:", result.total)

    print(f"Printing first sandbox -> id: {result.items[0].id} state: {result.items[0].state}")

    print("Removing sandbox")
    daytona.delete(sandbox)
    print("Sandbox removed")


if __name__ == "__main__":
    main()

TypeScript

import { Daytona } from '@daytonaio/sdk'

async function main() {
  const daytona = new Daytona()

  console.log('Creating sandbox')
  const sandbox = await daytona.create()
  console.log('Sandbox created')

  await sandbox.setLabels({
    public: 'true',
  })

  console.log('Stopping sandbox')
  await sandbox.stop()
  console.log('Sandbox stopped')

  console.log('Starting sandbox')
  await sandbox.start()
  console.log('Sandbox started')

  console.log('Getting existing sandbox')
  const existingSandbox = await daytona.get(sandbox.id)
  console.log('Got existing sandbox')

  const response = await existingSandbox.process.executeCommand(
    'echo "Hello World from exec!"',
    undefined,
    undefined,
    10,
  )
  if (response.exitCode !== 0) {
    console.error(`Error: ${response.exitCode} ${response.result}`)
  } else {
    console.log(response.result)
  }

  const result = await daytona.list()
  console.log('Total sandboxes count:', result.total)

  console.log(`Printing first sandbox -> id: ${result.items[0].id} state: ${result.items[0].state}`)

  console.log('Deleting sandbox')
  await sandbox.delete()
  console.log('Sandbox deleted')
}

main().catch(console.error)

Go

package main

import (
	"context"
	"log"
	"time"

	"github.com/daytonaio/daytona/libs/sdk-go/pkg/daytona"
	"github.com/daytonaio/daytona/libs/sdk-go/pkg/options"
	"github.com/daytonaio/daytona/libs/sdk-go/pkg/types"
)

func main() {
	// Create a new Daytona client using environment variables
	// Set DAYTONA_API_KEY before running
	client, err := daytona.NewClient()
	if err != nil {
		log.Fatalf("Failed to create client: %v", err)
	}

	ctx := context.Background()

	// Create a sandbox with Python
	log.Println("\nCreating sandbox...")
	params := types.SnapshotParams{
		SandboxBaseParams: types.SandboxBaseParams{
			Language: types.CodeLanguagePython,
			EnvVars: map[string]string{
				"EXAMPLE_VAR": "example_value",
			},
		},
	}

	sandbox, err := client.Create(ctx, params, options.WithTimeout(90*time.Second))
	if err != nil {
		log.Fatalf("Failed to create sandbox: %v", err)
	}

	log.Printf("✓ Created sandbox: %s (ID: %s)\n", sandbox.Name, sandbox.ID)

	// Get sandbox info
	homeDir, err := sandbox.GetUserHomeDir(ctx)
	if err != nil {
		log.Fatalf("Failed to get home directory: %v", err)
	}
	log.Printf("Home directory: %s\n", homeDir)

	workDir, err := sandbox.GetWorkingDir(ctx)
	if err != nil {
		log.Fatalf("Failed to get working directory: %v", err)
	}
	log.Printf("Working directory: %s\n", workDir)

	log.Println("Listing all sandboxes...")
	page := 1
	limit := 10
	allSandboxes, err := client.List(ctx, nil, &page, &limit)
	if err != nil {
		log.Fatalf("Failed to list sandboxes: %v", err)
	}

	log.Printf("Total sandboxes: %d\n", allSandboxes.Total)
	for _, sb := range allSandboxes.Items {
		log.Printf("  - %s (State: %s)\n", sb.Name, sb.State)
	}

	// Delete the sandbox
	log.Println("\nCleaning up...")
	if err := sandbox.Delete(ctx); err != nil {
		log.Fatalf("Failed to delete sandbox: %v", err)
	}
	log.Println("✓ Sandbox deleted")

	log.Println("\n✓ All sandbox operations completed successfully!")
}

Expected Output

Creating sandbox
Sandbox created
Stopping sandbox
Sandbox stopped
Starting sandbox
Sandbox started
Getting existing sandbox
Got existing sandbox
Hello World from exec!
Total sandboxes count: 1
Printing first sandbox -> id: sandbox-abc123 state: running
Removing sandbox
Sandbox removed

Key Concepts

Creating a Sandbox

The simplest way to create a sandbox is calling create() with no parameters. This creates a sandbox with default settings:

• Language: Python (default)
• State: Running
• Auto-archive: Enabled (after inactivity)

Setting Labels

Labels are key-value pairs that help organize and identify sandboxes:

sandbox.set_labels({
    "public": "true",
    "environment": "development",
    "team": "backend"
})

Sandbox States

Sandboxes can be in different states:

• running - Sandbox is active and ready to use
• stopped - Sandbox is paused and not consuming compute resources
• archived - Sandbox is archived to save storage costs

Listing Sandboxes

The list() method returns paginated results:

Python

result = daytona.list()
print(f"Total: {result.total}")
for sandbox in result.items:
    print(f"{sandbox.id}: {sandbox.state}")

Best Practices

Always clean up: Delete sandboxes when you’re done to avoid unnecessary costs.

Stopping vs Deleting: Stopping a sandbox preserves its state but you still pay for storage. Deleting removes everything.

Next Steps

File Operations

Learn how to upload and download files

Code Execution

Execute code in your sandboxes