---

name: e2b description: Execute AI-generated code in secure isolated E2B cloud sandboxes (SDK v2). Use for running Python/JavaScript/TypeScript/R/Java/Bash code, managing sandbox lifecycle (create, pause, resume, kill, list, connect), running coding agents (Claude Code, Codex, AMP, OpenCode) in sandboxes, git operations inside sandboxes, code contexts for parallel isolated execution, monitoring metrics (CPU, memory, disk), MCP gateway integration (200+ tools), uploading/downloading files, storage bucket mounting (S3, GCS, R2), streaming command output, SSH/PTY access, custom templates with Build System 2.0, and integrating LLMs with code execution capabilities.

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

| Feature | Reference | |---------|-----------| | Getting started | quickstart.md | | Lifecycle & security | sandbox-lifecycle.md | | Code execution & contexts | code-interpreting.md | | File operations | filesystem.md | | Git operations | git-integration.md | | Coding agents | agents.md | | Monitoring & events | monitoring-and-events.md | | Persistence (pause/resume) | persistence.md | | MCP Gateway (200+ tools) | mcp-gateway.md | | Custom templates | custom-templates.md | | Advanced (SSH, PTY, buckets, proxy) | advanced-sandbox.md |

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

| Operation | Python | JavaScript | |-----------|--------|------------| | Create | Sandbox.create() | await Sandbox.create() | | Timeout | set_timeout(60) | setTimeout(60000) (ms) | | Run code | run_code(code) | await runCode(code) | | Kill | kill() | await kill() | | Pause | pause() | await pause() | | Git clone | git.clone(url, path) | await git.clone(url, path) | | Code context | create_code_context() | await createCodeContext() |

Packages: e2b vs e2b-code-interpreter

| Feature | e2b | e2b-code-interpreter | |---------|-------|------------------------| | Sandbox lifecycle | Yes | Yes (inherits) | | Commands (commands.run) | Yes | Yes | | Filesystem | Yes | Yes | | Git integration | Yes | Yes | | run_code() (Jupyter) | No | Yes | | Charts/visualizations | No | Yes | | Code contexts | No | Yes | | Coding agent templates | Yes | No (use e2b) |

Use e2b for: running agents, shell commands, git workflows, file operations. Use e2b-code-interpreter for: data analysis, code execution, charts, multi-language code.

Default Environment Variables

Available in every sandbox:

• E2B_SANDBOX=true
• E2B_SANDBOX_ID - Current sandbox ID
• E2B_TEAM_ID - Team ID
• E2B_TEMPLATE_ID - Template used

Best Practices

1. Always clean up: Use try/finally with kill() or context managers
2. Use absolute paths: /home/user/file.txt not file.txt
3. Handle errors: Check execution.error after run_code()
4. Tag with metadata: Use metadata for tracking user sessions
5. Monitor resources: Check get_metrics() for CPU/memory usage
6. Set appropriate timeouts: Short tasks 60-120s, analysis 300-600s
7. Use code contexts: Isolate parallel code execution within one sandbox
8. Use git API: Prefer sandbox.git.* over shell git commands

Troubleshooting

| Issue | Solution | |-------|----------| | Sandbox() fails in Python | Use Sandbox.create() (SDK v2 breaking change) | | Timeout too quick | Sandbox.create(timeout=300) or set_timeout(300) | | Code fails | Check execution.error for details | | File not found | Use absolute paths, verify with files.list() | | Auth error on secured sandbox | Old template — rebuild with envd >= v0.2.0, or use secure=False | | Rate limited | Check plan limits in sandbox-lifecycle.md | | High resource usage | Check get_metrics(), kill unused sandboxes |