e2b

E2B Sandbox Skill

Secure isolated cloud VMs for executing AI-generated code. Sandboxes start in ~150ms with full code execution, filesystem, git, and network access.

SDK v2 Breaking Change: Python uses Sandbox.create() — not Sandbox(). Secured access is enabled by default.

Quick Reference

Installation

Two packages available — use e2b for base sandbox features, e2b-code-interpreter when you need run_code() (Jupyter-style execution):

# Python — base sandbox (filesystem, commands, git, processes)
pip install e2b

# Python — code interpreter (adds run_code with charts, multi-language)
pip install e2b-code-interpreter

# JavaScript/TypeScript — base sandbox
npm i e2b

# JavaScript/TypeScript — code interpreter
npm i @e2b/code-interpreter

Required environment variable:

E2B_API_KEY=e2b_***  # Get from https://e2b.dev/dashboard?tab=keys

Core Patterns

Pattern 1: One-shot Code Execution

from e2b_code_interpreter import Sandbox

sandbox = Sandbox.create()
execution = sandbox.run_code('print("Hello from E2B!")')
print(execution.text)
sandbox.kill()

import { Sandbox } from '@e2b/code-interpreter'

const sandbox = await Sandbox.create()
const execution = await sandbox.runCode('console.log("Hello!")')
console.log(execution.text)
await sandbox.kill()

Pattern 2: Multi-language Execution

sandbox.run_code('import pandas as pd; df.describe()')       # Python (default)
sandbox.run_code('await fetch(url)', language='js')           # JavaScript
sandbox.run_code('const x: number = 42', language='ts')       # TypeScript
sandbox.run_code('summary(mtcars)', language='r')             # R
sandbox.run_code('System.out.println("hi")', language='java') # Java
sandbox.run_code('ls -la /home/user', language='bash')        # Bash

Pattern 3: File Upload + Analysis

sandbox.files.write('/home/user/data.csv', csv_content)

execution = sandbox.run_code('''
import pandas as pd
df = pd.read_csv('/home/user/data.csv')
df.describe()
''')

result = sandbox.files.read('/home/user/output.png')

Pattern 4: Code Contexts (Isolated Parallel Execution)

ctx_a = sandbox.create_code_context(cwd='/home/user/project-a')
ctx_b = sandbox.create_code_context(cwd='/home/user/project-b')

result_a = sandbox.run_code('import pandas; print("A")', context=ctx_a)
result_b = sandbox.run_code('import numpy; print("B")', context=ctx_b)

Pattern 5: Git Operations

from e2b import Sandbox

sandbox = Sandbox.create()
sandbox.git.clone('https://github.com/user/repo.git', '/home/user/repo',
                  username='user', password=os.environ['GITHUB_TOKEN'])
sandbox.git.checkout_branch('/home/user/repo', 'feature-branch')
sandbox.git.add('/home/user/repo')
sandbox.git.commit('/home/user/repo', 'fix: update config')
sandbox.git.push('/home/user/repo', username='user', password=os.environ['GITHUB_TOKEN'])

Pattern 6: Running Coding Agents

from e2b import Sandbox

sandbox = Sandbox.create(
    template='claude',
    envs={'ANTHROPIC_API_KEY': os.environ['ANTHROPIC_API_KEY']},
    timeout=300
)
result = sandbox.commands.run(
    'claude -p "Write a hello world server" --dangerously-skip-permissions',
    timeout=120
)
print(result.stdout)

See agents.md for Codex, AMP, OpenCode, and more patterns.

Pattern 7: LLM Tool Integration

from anthropic import Anthropic
from e2b_code_interpreter import Sandbox

tools = [{
    "name": "execute_python",
    "description": "Execute python code in sandbox",
    "input_schema": {
        "type": "object",
        "properties": {
            "code": {"type": "string", "description": "Python code to execute"}
        },
        "required": ["code"]
    }
}]

client = Anthropic()
message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Calculate 2+2"}],
    tools=tools
)

if message.stop_reason == "tool_use":
    tool_use = next(b for b in message.content if b.type == "tool_use")
    sandbox = Sandbox.create()
    result = sandbox.run_code(tool_use.input['code'])
    print(result.text)
    sandbox.kill()

Pattern 8: MCP Gateway

from e2b import Sandbox

sandbox = Sandbox.create(
    mcp={
        'github': {'githubPersonalAccessToken': os.environ['GITHUB_TOKEN']},
        'slack': {'botToken': os.environ['SLACK_BOT_TOKEN']}
    }
)
mcp_url = sandbox.get_mcp_url()
mcp_token = sandbox.get_mcp_token()

See mcp-gateway.md for 200+ available integrations.

Pattern 9: Persistence (Pause/Resume)

sandbox = Sandbox.create(auto_pause=True, timeout=600)
sandbox.run_code(code)
sandbox.pause()
saved_id = sandbox.sandbox_id

# Later: Resume
sandbox = Sandbox.connect(saved_id)

Pattern 10: Custom Template (Build System 2.0)

import { Template, waitForPort } from 'e2b'

const template = Template()
  .fromPythonImage('3.12')
  .pipInstall(['pandas', 'numpy', 'matplotlib'])
  .copy('./app', '/home/user/app')
  .setStartCmd('python /home/user/app/server.py', waitForPort(3000))

await Template.build(template, { name: 'my-data-template' })

API Quick Reference

Sandbox Lifecycle

# Create (SDK v2 — always use .create())
sandbox = Sandbox.create()                          # Default 5 min timeout
sandbox = Sandbox.create(timeout=300)               # Custom timeout (seconds)
sandbox = Sandbox.create(envs={'KEY': 'val'})       # With env vars
sandbox = Sandbox.create(metadata={'user': '123'})  # With metadata
sandbox = Sandbox.create(template='my-template')    # Custom template
sandbox = Sandbox.create(secure=False)              # Disable secured access

# Info & timeout
info = sandbox.get_info()
sandbox.set_timeout(60)

# Kill
sandbox.kill()
Sandbox.kill(sandbox_id)

Sandbox Discovery

paginator = Sandbox.list()                                          # List all
sandboxes = paginator.next_items()
paginator = Sandbox.list(query={'state': ['running', 'paused']})    # Filter by state
paginator = Sandbox.list(query={'metadata': {'userId': '123'}})     # Filter by metadata
sandbox = Sandbox.connect(sandbox_id)                               # Connect to existing

Code Execution

execution = sandbox.run_code(code, language='python', envs={'VAR': 'val'})
execution.text          # Combined output
execution.logs.stdout   # Standard output
execution.logs.stderr   # Standard error
execution.results       # Rich results (charts, tables)
execution.error         # Runtime errors

Commands

result = sandbox.commands.run('ls -la')
result = sandbox.commands.run('cmd', envs={'VAR': 'val'})
result = sandbox.commands.run('cmd', background=True)
result = sandbox.commands.run('cmd', on_stdout=callback, on_stderr=callback)

Files

sandbox.files.write('/home/user/file.txt', content)     # Write single file
sandbox.files.write_files([('/path/a', data_a), ...])    # Write multiple files
content = sandbox.files.read('/home/user/file.txt')      # Read file
info = sandbox.files.get_info('/home/user/file.txt')     # File metadata
files = sandbox.files.list('/home/user')                 # List directory
watcher = sandbox.files.watch_dir('/path')               # Watch changes

Git

sandbox.git.clone(url, path, username=..., password=...)
sandbox.git.branches(path)
sandbox.git.create_branch(path, 'branch-name')
sandbox.git.checkout_branch(path, 'branch-name')
sandbox.git.add(path)
sandbox.git.commit(path, 'message')
sandbox.git.push(path, username=..., password=...)
sandbox.git.pull(path)

Code Contexts

ctx = sandbox.create_code_context(cwd='/path', language='python')
result = sandbox.run_code('print("isolated")', context=ctx)
contexts = sandbox.list_code_contexts()
sandbox.remove_code_context(ctx.id)

Monitoring

metrics = sandbox.get_metrics()
# Returns list of SandboxMetric: cpu_used_pct, cpu_count, mem_used, mem_total, disk_used, disk_total

Python vs JavaScript API

Packages: e2b vs e2b-code-interpreter

Use e2b for: running agents, s

Content truncated.