diff --git a/docs.json b/docs.json
index f1410c9..5a821c2 100644
--- a/docs.json
+++ b/docs.json
@@ -37,157 +37,60 @@
]
},
"docs/api-key",
- "docs/cookbook",
- "docs/support"
+ "docs/sdks-explained"
]
},
{
- "group": "Code Interpreting",
+ "group": "Use Case Examples",
"pages": [
- {
- "group": "Analyze data with AI",
- "pages": [
- "docs/code-interpreting/analyze-data-with-ai",
- "docs/code-interpreting/analyze-data-with-ai/pre-installed-libraries"
- ]
- },
- {
- "group": "Charts & visualizations",
- "pages": [
- "docs/code-interpreting/create-charts-visualizations",
- "docs/code-interpreting/create-charts-visualizations/static-charts",
- "docs/code-interpreting/create-charts-visualizations/interactive-charts"
- ]
- },
- "docs/code-interpreting/streaming",
- {
- "group": "Supported languages",
- "pages": [
- "docs/code-interpreting/supported-languages",
- "docs/code-interpreting/supported-languages/python",
- "docs/code-interpreting/supported-languages/javascript",
- "docs/code-interpreting/supported-languages/r",
- "docs/code-interpreting/supported-languages/java",
- "docs/code-interpreting/supported-languages/bash"
- ]
- }
+ "docs/use-cases/linux-desktop",
+ "docs/use-cases/deep-research-agents",
+ "docs/use-cases/ai-data-analysis-visualization",
+ "docs/use-cases/reinforcement-learning",
+ "docs/use-cases/vibe-coding"
]
},
{
"group": "Sandbox",
"pages": [
- "docs/sandbox",
- "docs/sandbox/lifecycle-events-api",
- "docs/sandbox/lifecycle-events-webhooks",
+ "docs/sandbox/intro",
+ "docs/sandbox/executing-code",
+ "docs/sandbox/reading-output",
"docs/sandbox/persistence",
- "docs/sandbox/metrics",
- "docs/sandbox/metadata",
- "docs/sandbox/environment-variables",
- "docs/sandbox/list",
- "docs/sandbox/connect",
- "docs/sandbox/internet-access",
- "docs/sandbox/connect-bucket",
- "docs/sandbox/rate-limits",
- "docs/sandbox/secured-access"
+ "docs/sandbox/security"
]
},
{
"group": "Templates",
"pages": [
- "docs/template/quickstart",
- "docs/template/how-it-works",
- "docs/template/user-and-workdir",
- "docs/template/caching",
- "docs/template/base-image",
- "docs/template/private-registries",
- "docs/template/defining-template",
- "docs/template/start-ready-command",
- "docs/template/build",
- "docs/template/logging",
- "docs/template/error-handling",
- {
- "group": "Examples",
- "pages": [
- "docs/template/examples/nextjs",
- "docs/template/examples/nextjs-bun",
- "docs/template/examples/expo",
- "docs/template/examples/desktop",
- "docs/template/examples/claude-code"
- ]
- },
- "docs/template/migration-v2",
- {
- "group": "Legacy Docs",
- "pages": [
- "docs/sandbox-template",
- "docs/sandbox-template/start-cmd",
- "docs/sandbox-template/ready-cmd",
- "docs/sandbox-template/customize-cpu-ram"
- ]
- }
+ "docs/templates/intro"
]
},
{
- "group": "Filesystem",
+ "group": "Code Interpreter",
"pages": [
- "docs/filesystem",
- "docs/filesystem/read-write",
- "docs/filesystem/info",
- "docs/filesystem/watch",
- "docs/filesystem/upload",
- "docs/filesystem/download"
+ "docs/code-interpreter"
]
},
{
- "group": "Commands",
+ "group": "Desktop",
"pages": [
- "docs/commands",
- "docs/commands/streaming",
- "docs/commands/background"
+ "docs/desktop/intro"
]
},
{
- "group": "MCP Gateway",
+ "group": "Dashboard",
"pages": [
- "docs/mcp",
- "docs/mcp/quickstart",
- "docs/mcp/available-servers",
- "docs/mcp/custom-templates",
- "docs/mcp/custom-servers",
- "docs/mcp/examples"
+ "docs/dashboard/billing",
+ "docs/dashboard/usage",
+ "docs/dashboard/webhooks",
+ "docs/dashboard/templates"
]
},
{
- "group": "CLI",
+ "group": "FAQ",
"pages": [
- "docs/cli",
- "docs/cli/auth",
- "docs/cli/list-sandboxes",
- "docs/cli/shutdown-sandboxes"
- ]
- },
- {
- "group": "Deployment",
- "pages": ["docs/byoc"]
- },
- {
- "group": "Migration",
- "pages": ["docs/migration/v2"]
- },
- {
- "group": "Troubleshooting",
- "pages": [
- {
- "group": "SDKs",
- "pages": ["docs/troubleshooting/sdks/workers-edge-runtime"]
- },
- {
- "group": "Templates",
- "pages": [
- "docs/troubleshooting/templates/build-authentication-error",
- "docs/troubleshooting/templates/49999-port-not-open"
- ]
- }
+ "docs/faq"
]
}
]
diff --git a/docs.mdx b/docs.mdx
index a330775..ec04f59 100644
--- a/docs.mdx
+++ b/docs.mdx
@@ -4,37 +4,41 @@ sidebarTitle: Home
icon: house
---
-import { Concepts } from '/snippets/Concepts.jsx';
-import { CodeInterpreting } from '/snippets/CodeInterpreting.jsx';
import { Quickstart } from '/snippets/Quickstart.jsx';
+import { CodeInterpreting } from '/snippets/CodeInterpreting.jsx';
-Here you'll find all the guides, concepts, and SDK references for developing with E2B.
+## What is E2B?
-
-```bash JavaScript & TypeScript
-npm i @e2b/code-interpreter
-```
-```bash Python
-pip install e2b-code-interpreter
-```
-
+E2B provides isolated sandboxes that let agents safely execute code, process data, and run tools. Our [SDKs](/docs/sdks-explained) make it easy to start and manage these environments.
-## What is E2B?
-E2B is an [open-source](https://github.com/e2b-dev) infrastructure that allows you to run AI-generated code in secure isolated sandboxes in the cloud.
-To start and control sandboxes, use our [Python SDK](https://pypi.org/project/e2b/) or [JavaScript SDK](https://www.npmjs.com/package/e2b).
+## E2B Building Blocks
+
+A quick overview of the core building blocks you'll interact with when using E2B.
+
+- [**Sandbox**]() — A fast, secure Linux VM created on demand for your agent
+
+- [**Template**]() — Defines what environment a sandbox starts with
+
+## How to use the docs
+
+The documentation is split into three main sections:
+
+- [**Quickstart**](#quickstart) — Step-by-step tutorials that walk you through spinning up your first E2B sandboxes.
-Some of the typical use cases for E2B are AI data analysis or visualization, running AI-generated code of various languages, playground for coding agents, environment for codegen evals, or running full AI-generated apps like in [Fragments](https://github.com/e2b-dev/fragments).
+- [**Examples**](#examples) — In-depth tutorials focused on specific use cases. Pick the topics that match what you're building.
-### Under the hood
-The E2B Sandbox is a small isolated VM the can be started very quickly (~150ms). You can think of it as a small computer for the AI model. You can run many sandboxes at once. Typically, you run separate sandbox for each LLM, user, or AI agent session in your app.
-For example, if you were building an AI data analysis chatbot, you would start the sandbox for every user session.
+- [**API/SDK Reference**](https://e2b.dev/docs/sdk-reference) — A complete technical reference for every feature, component, and configuration option.
-## Quickstart
-
+## 🚀 Quickstart.
-## Code interpreting with AI
-
+
-## Learn the core concepts
-
+## 🧠 Examples
+
+
+
+
+
+
+
diff --git a/docs/code-interpreter.mdx b/docs/code-interpreter.mdx
new file mode 100644
index 0000000..db68a6c
--- /dev/null
+++ b/docs/code-interpreter.mdx
@@ -0,0 +1,213 @@
+---
+title: "Code Interpreter"
+description: "Multi-language code execution with pre-installed data science libraries, visualization support, and built on top of the core E2B SDK."
+icon: "code"
+---
+
+# Code Interpreter
+
+Built on top of `e2b` with added support for multi-language code execution (Python, JavaScript, R, Java, Bash), pre-installed data science libraries, and visualization capabilities.
+
+
+Includes **all features from `e2b`** plus specialized code execution methods and pre-configured environment.
+
+
+## Installation
+
+
+```bash Python
+pip install e2b-code-interpreter
+```
+
+```bash JavaScript
+npm install @e2b/code-interpreter
+```
+
+
+## Quick Start
+
+
+```python Python
+from e2b_code_interpreter import Sandbox
+
+# Create code interpreter
+sbx = Sandbox()
+
+# Execute Python with visualization
+execution = sbx.run_code("""
+import matplotlib.pyplot as plt
+plt.plot([1, 2, 3, 4])
+plt.ylabel('some numbers')
+plt.savefig('chart.png')
+""")
+
+# Access results
+for result in execution.results:
+ print(result)
+
+sbx.close()
+```
+
+```typescript JavaScript
+import { Sandbox } from '@e2b/code-interpreter'
+
+// Create code interpreter
+const sbx = await Sandbox.create()
+
+// Execute Python with visualization
+const execution = await sbx.runCode(`
+import matplotlib.pyplot as plt
+plt.plot([1, 2, 3, 4])
+plt.ylabel('some numbers')
+plt.savefig('chart.png')
+`)
+
+// Access results
+execution.results.forEach(result => console.log(result))
+
+await sbx.close()
+```
+
+
+## Supported Languages
+
+
+
+ Full Python support with data science libraries
+
+
+ Node.js runtime for JavaScript execution
+
+
+ Statistical computing with R
+
+
+ Java code execution
+
+
+ Shell scripts and commands
+
+
+
+## Pre-installed Libraries
+
+The code interpreter comes with popular data science and visualization libraries:
+
+
+
+ - **Data Analysis:** pandas, numpy, scipy
+ - **Visualization:** matplotlib, seaborn, plotly
+ - **Machine Learning:** scikit-learn
+ - **And many more...**
+
+ [View full list →](/docs/code-interpreting/analyze-data-with-ai/pre-installed-libraries)
+
+
+
+ - **Node.js built-in modules**
+ - **Popular npm packages** (install as needed)
+
+
+
+## Features
+
+### Code Execution Results
+
+Access execution results including stdout, stderr, charts, and data:
+
+
+```python Python
+execution = sbx.run_code("print('Hello'); 2 + 2")
+
+for result in execution.results:
+ if result.type == "stdout":
+ print(result.text)
+ elif result.type == "result":
+ print(result.data)
+```
+
+```typescript JavaScript
+const execution = await sbx.runCode("console.log('Hello'); 2 + 2")
+
+execution.results.forEach(result => {
+ if (result.type === 'stdout') {
+ console.log(result.text)
+ } else if (result.type === 'result') {
+ console.log(result.data)
+ }
+})
+```
+
+
+### Chart Generation
+
+Create and retrieve visualizations:
+
+
+```python Python
+execution = sbx.run_code("""
+import matplotlib.pyplot as plt
+import numpy as np
+
+x = np.linspace(0, 10, 100)
+plt.plot(x, np.sin(x))
+plt.title('Sine Wave')
+plt.savefig('plot.png')
+""")
+
+# Charts are available in results
+for result in execution.results:
+ if result.type == "image":
+ print(f"Chart saved: {result.url}")
+```
+
+```typescript JavaScript
+const execution = await sbx.runCode(`
+import matplotlib.pyplot as plt
+import numpy as np
+
+x = np.linspace(0, 10, 100)
+plt.plot(x, np.sin(x))
+plt.title('Sine Wave')
+plt.savefig('plot.png')
+`)
+
+// Charts are available in results
+execution.results.forEach(result => {
+ if (result.type === 'image') {
+ console.log(`Chart saved: ${result.url}`)
+ }
+})
+```
+
+
+## Use Cases
+
+
+
+ Build AI agents that analyze datasets and create visualizations
+
+
+ Create Jupyter-like environments for interactive coding
+
+
+ Generate reports with code, analysis, and charts
+
+
+ Run student code safely in sandboxed environments
+
+
+
+## Related Resources
+
+
+
+ Full list of available libraries
+
+
+ Chart generation guide
+
+
+ Complete API documentation
+
+
diff --git a/docs/dashboard/billing.mdx b/docs/dashboard/billing.mdx
new file mode 100644
index 0000000..f317ad1
--- /dev/null
+++ b/docs/dashboard/billing.mdx
@@ -0,0 +1,9 @@
+---
+title: "Billing"
+description: "Manage your E2B subscription, view pricing plans, and understand billing for sandbox usage, compute time, and storage."
+icon: "credit-card"
+---
+
+# Billing
+
+Content coming soon.
diff --git a/docs/dashboard/templates.mdx b/docs/dashboard/templates.mdx
new file mode 100644
index 0000000..00a55e0
--- /dev/null
+++ b/docs/dashboard/templates.mdx
@@ -0,0 +1,9 @@
+---
+title: "Templates"
+description: "Manage your custom sandbox templates in the E2B dashboard, including creating, editing, and deploying templates for your team."
+icon: "layer-group"
+---
+
+# Templates
+
+Content coming soon.
diff --git a/docs/dashboard/usage.mdx b/docs/dashboard/usage.mdx
new file mode 100644
index 0000000..dcdd291
--- /dev/null
+++ b/docs/dashboard/usage.mdx
@@ -0,0 +1,9 @@
+---
+title: "Usage"
+description: "Monitor your E2B usage metrics including active sandboxes, compute hours, API calls, and resource consumption across your projects."
+icon: "chart-simple"
+---
+
+# Usage
+
+Content coming soon.
diff --git a/docs/dashboard/webhooks.mdx b/docs/dashboard/webhooks.mdx
new file mode 100644
index 0000000..1c0b72f
--- /dev/null
+++ b/docs/dashboard/webhooks.mdx
@@ -0,0 +1,9 @@
+---
+title: "Webhooks"
+description: "Configure webhooks to receive real-time notifications about sandbox events, lifecycle changes, and system updates from E2B."
+icon: "webhook"
+---
+
+# Webhooks
+
+Content coming soon.
diff --git a/docs/desktop/intro.mdx b/docs/desktop/intro.mdx
new file mode 100644
index 0000000..33afe6f
--- /dev/null
+++ b/docs/desktop/intro.mdx
@@ -0,0 +1,118 @@
+---
+title: "Desktop Intro"
+description: "Full Linux desktop environment with GUI, browser automation, and window management built on top of the E2B SDK."
+icon: "desktop"
+---
+
+# Desktop
+
+Built on top of `e2b` with a full Linux desktop environment including GUI, browser, and window management capabilities.
+
+
+Includes **all features from `e2b`** plus desktop-specific methods like `getDesktopUrl()` and pre-configured GUI environment.
+
+
+## Installation
+
+
+```bash Python
+pip install e2b-desktop
+```
+
+```bash JavaScript
+npm install @e2b/desktop
+```
+
+
+## Quick Start
+
+
+```python Python
+from e2b_desktop import Sandbox
+
+# Create desktop sandbox
+sbx = Sandbox.create()
+
+# Get desktop URL
+desktop_url = sbx.get_desktop_url()
+print(f"Access desktop at: {desktop_url}")
+
+# Run GUI application
+sbx.commands.run("firefox https://example.com")
+```
+
+```typescript JavaScript
+import { Sandbox } from '@e2b/desktop'
+
+// Create desktop sandbox
+const sbx = await Sandbox.create()
+
+// Get desktop URL
+const desktopUrl = await sbx.getDesktopUrl()
+console.log(`Access desktop at: ${desktopUrl}`)
+
+// Run GUI application
+await sbx.commands.run('firefox https://example.com')
+```
+
+
+## Features
+
+### Remote Desktop Access
+
+Access a full Linux desktop environment in your browser:
+
+- **Window Management:** Run multiple applications with full window controls
+- **Browser Access:** Remote desktop URL for web-based access
+- **Screen Resolution:** Configurable display settings
+- **Clipboard Support:** Copy/paste between local and remote environments
+
+### Pre-installed Applications
+
+The desktop comes with common applications:
+
+
+
+ Firefox, Chromium for browser automation
+
+
+ Text editors, terminals, and dev utilities
+
+
+ Image viewers and basic media players
+
+
+ File managers and system monitors
+
+
+
+## Use Cases
+
+
+
+ Automate web interactions with visual feedback
+
+
+ Test applications requiring GUI in isolated environments
+
+
+ Record application behavior and workflows
+
+
+ Cloud-based development with full desktop access
+
+
+
+## Related Resources
+
+
+
+ Complete walkthrough and examples
+
+
+ Complete API documentation
+
+
+ Customize your desktop environment
+
+
diff --git a/docs/faq.mdx b/docs/faq.mdx
new file mode 100644
index 0000000..15c02a2
--- /dev/null
+++ b/docs/faq.mdx
@@ -0,0 +1,9 @@
+---
+title: "FAQ"
+description: "Frequently asked questions about E2B sandboxes, templates, pricing, security, performance, and common troubleshooting scenarios."
+icon: "circle-question"
+---
+
+# FAQ
+
+Content coming soon.
diff --git a/docs/sandbox/executing-code.mdx b/docs/sandbox/executing-code.mdx
new file mode 100644
index 0000000..9af3719
--- /dev/null
+++ b/docs/sandbox/executing-code.mdx
@@ -0,0 +1,9 @@
+---
+title: "Executing Code"
+description: "Run code and shell commands in E2B sandboxes with support for multiple languages, streaming output, background processes, and real-time execution control."
+icon: "terminal"
+---
+
+# Executing Code
+
+Content coming soon.
diff --git a/docs/sandbox/intro.mdx b/docs/sandbox/intro.mdx
new file mode 100644
index 0000000..c543838
--- /dev/null
+++ b/docs/sandbox/intro.mdx
@@ -0,0 +1,9 @@
+---
+title: "Sandbox Intro"
+description: "E2B sandboxes provide secure, isolated cloud environments for running untrusted code with full control over execution, filesystem, and networking."
+icon: "cube"
+---
+
+# Sandbox Intro
+
+Content coming soon.
diff --git a/docs/sandbox/persistence.mdx b/docs/sandbox/persistence.mdx
index 29f3939..0f4bc88 100644
--- a/docs/sandbox/persistence.mdx
+++ b/docs/sandbox/persistence.mdx
@@ -1,295 +1,9 @@
---
-title: "Sandbox persistence"
-sidebarTitle: Persistence
+title: "Persistence"
+description: "Manage persistent storage in E2B sandboxes with volumes that survive across sandbox sessions, enabling stateful workflows and long-term data retention."
+icon: "database"
---
-
-Sandbox persistence is currently in public beta:
-1. Consider [some limitations](#limitations-while-in-beta).
-2. The persistence is free for all users during the beta.
-
+# Persistence
-The sandbox persistence allows you to pause your sandbox and resume it later from the same state it was in when you paused it.
-
-This includes not only state of the sandbox's filesystem but also the sandbox's memory. This means all running processes, loaded variables, data, etc.
-
-## Sandbox State Transitions
-
-Understanding how sandboxes transition between different states is crucial for managing their lifecycle effectively. Here's a diagram showing the possible state transitions:
-
-
-
-
-
-### State descriptions
-
-- **Running**: The sandbox is actively running and can execute code. This is the initial state after creation.
-- **Paused**: The sandbox execution is suspended but its state is preserved.
-- **Killed**: The sandbox is terminated and all resources are released. This is a terminal state.
-
-### Changing sandbox's state
-
-
-```js JavaScript & TypeScript
-import { Sandbox } from '@e2b/code-interpreter'
-
-const sandbox = await Sandbox.create() // Starts in Running state
-
-// Pause the sandbox
-await sandbox.betaPause() // Running → Paused
-
-// Resume the sandbox
-await sandbox.connect() // Running/Paused → Running
-
-// Kill the sandbox (from any state)
-await sandbox.kill() // Running/Paused → Killed
-```
-
-```python Python
-from e2b_code_interpreter import Sandbox
-
-sandbox = Sandbox.create() # Starts in Running state
-
-# Pause the sandbox
-sandbox.betaPause() # Running → Paused
-
-# Resume the sandbox
-sandbox.connect() # Running/Paused → Running
-
-# Kill the sandbox (from any state)
-sandbox.kill() # Running/Paused → Killed
-```
-
-
-## Pausing sandbox
-When you pause a sandbox, both the sandbox's filesystem and memory state will be saved. This includes all the files in the sandbox's filesystem and all the running processes, loaded variables, data, etc.
-
-
-```js JavaScript & TypeScript highlight={8-9}
-import { Sandbox } from '@e2b/code-interpreter'
-
-const sbx = await Sandbox.create()
-console.log('Sandbox created', sbx.sandboxId)
-
-// Pause the sandbox
-// You can save the sandbox ID in your database to resume the sandbox later
-await sbx.betaPause()
-console.log('Sandbox paused', sbx.sandboxId)
-```
-```python Python highlight={8-9}
-from e2b_code_interpreter import Sandbox
-
-sbx = Sandbox.create()
-print('Sandbox created', sbx.sandbox_id)
-
-# Pause the sandbox
-# You can save the sandbox ID in your database to resume the sandbox later
-sbx.beta_pause()
-print('Sandbox paused', sbx.sandbox_id)
-```
-
-
-
-## Resuming sandbox
-When you resume a sandbox, it will be in the same state it was in when you paused it.
-This means that all the files in the sandbox's filesystem will be restored and all the running processes, loaded variables, data, etc. will be restored.
-
-
-```js JavaScript & TypeScript highlight={12-13}
-import { Sandbox } from '@e2b/code-interpreter'
-
-const sbx = await Sandbox.create()
-console.log('Sandbox created', sbx.sandboxId)
-
-// Pause the sandbox
-// You can save the sandbox ID in your database to resume the sandbox later
-await sbx.betaPause()
-console.log('Sandbox paused', sbx.sandboxId)
-
-// Connect to the sandbox (it will automatically resume the sandbox, if paused)
-const sameSbx = await sbx.connect()
-console.log('Connected to the sandbox', sameSbx.sandboxId)
-```
-```python Python highlight={12-13}
-from e2b_code_interpreter import Sandbox
-
-sbx = Sandbox.create()
-print('Sandbox created', sbx.sandbox_id)
-
-# Pause the sandbox
-# You can save the sandbox ID in your database to resume the sandbox later
-sbx.beta_pause()
-print('Sandbox paused', sbx.sandbox_id)
-
-# Connect to the sandbox (it will automatically resume the sandbox, if paused)
-same_sbx = sbx.connect()
-print('Connected to the sandbox', same_sbx.sandbox_id)
-```
-
-
-## Listing paused sandboxes
-You can list all paused sandboxes by calling the `Sandbox.list` method and supplying the `state` query parameter.
-More information about using the method can be found in [List Sandboxes](/docs/sandbox/list).
-
-
-```js JavaScript & TypeScript highlight={4,7}
-import { Sandbox, SandboxInfo } from '@e2b/code-interpreter'
-
-// List all paused sandboxes
-const paginator = Sandbox.list({ query: { state: ['paused'] } })
-
-// Get the first page of paused sandboxes
-const sandboxes = await paginator.nextItems()
-
-// Get all paused sandboxes
-while (paginator.hasNext) {
- const items = await paginator.nextItems()
- sandboxes.push(...items)
-}
-```
-```python Python highlight={4,7}
-# List all paused sandboxes
-from e2b_code_interpreter import Sandbox, SandboxQuery, SandboxState
-
-paginator = Sandbox.list(SandboxQuery(state=[SandboxState.PAUSED]))
-
-# Get the first page of paused sandboxes
-sandboxes = paginator.next_items()
-
-# Get all paused sandboxes
-while paginator.has_next:
- items = paginator.next_items()
- sandboxes.extend(items)
-```
-
-
-## Removing paused sandboxes
-
-You can remove paused sandboxes by calling the `kill` method on the Sandbox instance.
-
-
-```js JavaScript & TypeScript highlight={11,14}
-import { Sandbox } from '@e2b/code-interpreter'
-
-const sbx = await Sandbox.create()
-console.log('Sandbox created', sbx.sandboxId)
-
-// Pause the sandbox
-// You can save the sandbox ID in your database to resume the sandbox later
-await sbx.betaPause()
-
-// Remove the sandbox
-await sbx.kill()
-
-// Remove sandbox by id
-await Sandbox.kill(sbx.sandboxId)
-```
-```python Python highlight={9,12}
-from e2b_code_interpreter import Sandbox
-
-sbx = Sandbox.create()
-
-# Pause the sandbox
-sbx.beta_pause()
-
-# Remove the sandbox
-sbx.kill()
-
-# Remove sandbox by id
-Sandbox.kill(sbx.sandbox_id)
-```
-
-
-## Sandbox's timeout
-When you connect to a sandbox, the sandbox's timeout is reset to the default timeout of an E2B sandbox - 5 minutes.
-
-You can pass a custom timeout to the `Sandbox.connect()`/`Sandbox.connect()` method like this:
-
-
-```js JavaScript & TypeScript
-import { Sandbox } from '@e2b/code-interpreter'
-
-const sbx = await Sandbox.connect(sandboxId, { timeoutMs: 60 * 1000 }) // 60 seconds
-```
-```python Python
-from e2b_code_interpreter import Sandbox
-
-sbx = Sandbox.connect(sandbox_id, timeout=60) # 60 seconds
-```
-
-
-
-### Auto-pause (beta)
-
-**Note: Auto-pause is currently in beta and available through `Sandbox.betaCreate()`/`Sandbox.beta_create()` method.**
-
-Sandboxes can now automatically pause after they time out. When a sandbox is paused, it stops consuming compute but preserves its state. The default inactivity timeout is 10 minutes. You can change the timeout by passing the `timeoutMs`/`timeout` parameter to the `Sandbox.connect()`/`Sandbox.connect()` method.
-
-
-```js JavaScript & TypeScript
-import { Sandbox } from '@e2b/code-interpreter'
-
-// Create sandbox with auto-pause enabled
-const sandbox = await Sandbox.betaCreate({
- autoPause: true,
- timeoutMs: 10 * 60 * 1000 // Optional: change the default timeout (10 minutes)
-})
-```
-```python Python
-from e2b_code_interpreter import Sandbox
-
-# Create sandbox with auto-pause enabled (Beta)
-sandbox = Sandbox.beta_create(
- auto_pause=True, # Auto-pause after the sandbox times out
- timeout=10 * 60, # Optional: change the default timeout (10 minutes)
-)
-```
-
-
-The auto-pause is persistent, meaning that if your sandbox resumes and it times out, it will be automatically paused again.
-
-If you `.kill()` the sandbox, it will be permanently deleted and you won't be able to resume it.
-
-
-```js JavaScript & TypeScript
-import { Sandbox } from '@e2b/code-interpreter'
-
-// Create sandbox with auto-pause enabled (Beta)
-const sandbox = await Sandbox.betaCreate({
- autoPause: true // Auto-pause after the sandbox times out
-})
-```
-```python Python
-from e2b_code_interpreter import Sandbox
-
-# Create sandbox with auto-pause enabled (Beta)
-sandbox = Sandbox.beta_create(
- auto_pause=True # Auto-pause after the sandbox times out
-)
-```
-
-
-## Network
-If you have a service (for example a server) running inside your sandbox and you pause the sandbox, the service won't be accessible from the outside and all the clients will be disconnected.
-If you resume the sandbox, the service will be accessible again but you need to connect clients again.
-
-
-## Limitations while in beta
-
-### Lifecycle duration
-- A sandbox can exist for **up to 30 days** from the initial `create` call.
-- After 30 days, sandbox data **may be deleted** and the sandbox can no longer be resumed.
-- Attempting to resume a deleted or non-existent sandbox will result in:
- - `NotFoundError` in the JavaScript SDK
- - `NotFoundException` in the Python SDK
-
-### Pause and resume performance
-- Pausing a sandbox takes approximately **4 seconds per 1 GiB of RAM**
-- Resuming a sandbox takes approximately **1 second**
-
-### Continuous runtime limits
-- A sandbox can remain running (without being paused) for:
- - **24 hours** on the **Pro tier**
- - **1 hour** on the **Base tier**
-- After a sandbox is paused and resumed, the continuous runtime limit is **reset**
-- The **30-day total lifetime limit** still applies regardless of how many times the sandbox is paused or resumed
+Content coming soon.
diff --git a/docs/sandbox/reading-output.mdx b/docs/sandbox/reading-output.mdx
new file mode 100644
index 0000000..66e7384
--- /dev/null
+++ b/docs/sandbox/reading-output.mdx
@@ -0,0 +1,9 @@
+---
+title: "Reading Output"
+description: "Capture stdout, stderr, and exit codes from code execution in E2B sandboxes with support for real-time streaming, line-by-line processing, and buffered output handling."
+icon: "scroll"
+---
+
+# Reading Output
+
+Content coming soon.
diff --git a/docs/sandbox/security.mdx b/docs/sandbox/security.mdx
new file mode 100644
index 0000000..50ee389
--- /dev/null
+++ b/docs/sandbox/security.mdx
@@ -0,0 +1,9 @@
+---
+title: "Security"
+description: "Learn about E2B's security model including sandbox isolation, network policies, resource limits, and best practices for running untrusted code safely in production environments."
+icon: "shield-halved"
+---
+
+# Security
+
+Content coming soon.
diff --git a/docs/sdks-explained.mdx b/docs/sdks-explained.mdx
new file mode 100644
index 0000000..8e90fdb
--- /dev/null
+++ b/docs/sdks-explained.mdx
@@ -0,0 +1,228 @@
+---
+title: "SDKs Explained"
+description: "E2B offers three SDK packages, each available in **Python** and **JavaScript/TypeScript**."
+icon: "code"
+---
+
+
+**Architecture:** `e2b-code-interpreter` and `e2b-desktop` are built on top of the core `e2b` SDK. All classes, methods, and features from `e2b` are available in the specialized SDKs.
+
+
+
+
+ Core SDK - Foundation
+
+
+ e2b + code execution environment
+
+
+ e2b + Linux desktop GUI
+
+
+
+---
+
+
+## e2b
+
+General-purpose sandboxes for running any code, commands, or processes.
+
+**Use when:** Building custom AI agents, running untrusted code, or need full control over the environment.
+
+### Installation
+
+
+```bash Python
+pip install e2b
+```
+
+```bash JavaScript
+npm install e2b
+```
+
+
+### Quick Start
+
+
+```python Python
+from e2b import Sandbox
+
+# Create sandbox
+sbx = Sandbox.create()
+
+# Run command
+result = sbx.commands.run("echo 'Hello from E2B'")
+print(result.stdout)
+
+# Run Python code
+result = sbx.commands.run("whoami")
+print(result.stdout)
+```
+
+```typescript JavaScript
+import { Sandbox } from 'e2b'
+
+// Create sandbox
+const sbx = await Sandbox.create()
+
+// Run command
+const result = await sbx.commands.run("echo 'Hello from E2B'")
+console.log(result.stdout)
+
+// Run Node.js code
+const result2 = await sbx.commands.run("whoami")
+console.log(result2.stdout)
+```
+
+
+
+ Complete API documentation
+
+
+---
+
+
+## e2b-code-interpreter
+
+Built on top of `e2b` with added support for multi-language code execution (Python, JavaScript, R, Java, Bash), pre-installed data science libraries, and visualization capabilities.
+
+
+Includes **all features from `e2b`** plus specialized code execution methods and pre-configured environment.
+
+
+**Use when:** Building AI data analysts, code execution environments, or need chart generation.
+
+### Installation
+
+
+```bash Python
+pip install e2b-code-interpreter
+```
+
+```bash JavaScript
+npm install @e2b/code-interpreter
+```
+
+
+### Quick Start
+
+
+```python Python
+from e2b_code_interpreter import Sandbox
+
+# Create code interpreter
+sbx = Sandbox.create()
+
+# Execute code with results
+execution = sbx.run_code("print('Hello from E2B'); 2 + 2")
+
+# Access results
+for result in execution.results:
+ print(result)
+```
+
+```typescript JavaScript
+import { Sandbox } from '@e2b/code-interpreter'
+
+// Create code interpreter
+const sbx = await Sandbox.create()
+
+// Execute code with results
+const execution = await sbx.runCode("console.log('Hello from E2B'); 2 + 2")
+
+// Access results
+execution.results.forEach(result => console.log(result))
+```
+
+
+
+ Detailed documentation, examples, and supported languages
+
+
+---
+
+
+## e2b-desktop
+
+Built on top of `e2b` with a full Linux desktop environment including GUI, browser, and window management.
+
+
+Includes **all features from `e2b`** plus desktop-specific methods like `getDesktopUrl()` and pre-configured GUI environment.
+
+
+**Use when:** Browser automation, visual testing, or applications requiring a desktop UI.
+
+### Installation
+
+
+```bash Python
+pip install e2b-desktop
+```
+
+```bash JavaScript
+npm install @e2b/desktop
+```
+
+
+### Quick Start
+
+
+```python Python
+from e2b_desktop import Sandbox
+
+# Create desktop sandbox
+sbx = Sandbox.create()
+
+# Get desktop URL
+desktop_url = sbx.get_desktop_url()
+print(f"Access desktop at: {desktop_url}")
+
+# Run GUI application
+sbx.commands.run("firefox https://example.com")
+```
+
+```typescript JavaScript
+import { Sandbox } from '@e2b/desktop'
+
+// Create desktop sandbox
+const sbx = await Sandbox.create()
+
+// Get desktop URL
+const desktopUrl = await sbx.getDesktopUrl()
+console.log(`Access desktop at: ${desktopUrl}`)
+
+// Run GUI application
+await sbx.commands.run('firefox https://example.com')
+```
+
+
+
+ Full walkthrough and examples
+
+
+---
+
+## Choosing the Right SDK
+
+
+
+ - Want default Ubuntu VM
+ - Want to use [MCP-Gateway]()
+ - Do not need to use code [interpreter specific functions]()
+
+
+
+ - AI data analysis and visualization
+ - Multi-language code execution (Python, JavaScript, R, Java, Bash)
+ - Need data science libraries pre-installed
+ - Generating charts, plots, or reports
+ - Jupyter-like code execution environment
+
+
+
+ - Browser automation with visual feedback
+ - Testing applications that require a GUI
+ - Screen recording or screenshots
+ - Running desktop applications in the cloud
+
+
diff --git a/docs/templates/intro.mdx b/docs/templates/intro.mdx
new file mode 100644
index 0000000..f6ca82b
--- /dev/null
+++ b/docs/templates/intro.mdx
@@ -0,0 +1,9 @@
+---
+title: "Templates Intro"
+description: "Create custom sandbox templates with pre-installed dependencies, configurations, and tools to quickly spin up consistent development environments for your AI agents."
+icon: "layer-group"
+---
+
+# Templates Intro
+
+Content coming soon.
diff --git a/docs/use-cases/ai-data-analysis-visualization.mdx b/docs/use-cases/ai-data-analysis-visualization.mdx
new file mode 100644
index 0000000..2b885e9
--- /dev/null
+++ b/docs/use-cases/ai-data-analysis-visualization.mdx
@@ -0,0 +1,9 @@
+---
+title: "AI Data Analysis & Visualization"
+description: "Enable AI agents to analyze datasets, generate insights, create charts and visualizations, and perform statistical analysis using Python libraries like pandas, matplotlib, and seaborn."
+icon: "chart-line"
+---
+
+# AI Data Analysis & Visualization
+
+Content coming soon.
diff --git a/docs/use-cases/deep-research-agents.mdx b/docs/use-cases/deep-research-agents.mdx
new file mode 100644
index 0000000..71f5e8e
--- /dev/null
+++ b/docs/use-cases/deep-research-agents.mdx
@@ -0,0 +1,62 @@
+---
+title: "Deep Research Agents"
+description: "Build AI agents that perform comprehensive research by executing code, analyzing data, running experiments, and iterating on findings in isolated sandbox environments."
+icon: "magnifying-glass-chart"
+---
+
+## Related Guides
+
+
+
+ Create and manage E2B sandboxes
+
+
+ Run code in sandboxes
+
+
+ Capture execution results
+
+
+ Save data across sessions
+
+
+ Create charts from findings
+
+
+ Custom sandbox templates
+
+
+
+## Project Structure
+
+
+```ts JavaScript && TypeScript
+research-agent/
+├── agent/
+│ ├── orchestrator.py // Main agent logic
+│ ├── tools.py // Research tools (web search, code execution)
+│ └── memory.py // Research state management
+├── sandbox/
+│ ├── setup.py // Sandbox initialization
+│ └── analysis.py // Data analysis helpers
+├── config.py // Configuration (API keys, models)
+└── main.py // Entry point
+```
+```python Python
+research-agent/
+├── agent/
+│ ├── orchestrator.py # Main agent logic
+│ ├── tools.py # Research tools (web search, code execution)
+│ └── memory.py # Research state management
+├── sandbox/
+│ ├── setup.py # Sandbox initialization
+│ └── analysis.py # Data analysis helpers
+├── config.py # Configuration (API keys, models)
+└── main.py # Entry point
+```
+
+---
+
+## Implementation
+
+Content coming soon.
diff --git a/docs/use-cases/linux-desktop.mdx b/docs/use-cases/linux-desktop.mdx
new file mode 100644
index 0000000..94c9e10
--- /dev/null
+++ b/docs/use-cases/linux-desktop.mdx
@@ -0,0 +1,9 @@
+---
+title: "Linux Desktop"
+description: "Run full Linux desktop environments in E2B sandboxes with GUI support, window management, and remote access capabilities for browser automation, visual testing, and interactive applications."
+icon: "desktop"
+---
+
+# Linux Desktop
+
+Content coming soon.
diff --git a/docs/use-cases/reinforcement-learning.mdx b/docs/use-cases/reinforcement-learning.mdx
new file mode 100644
index 0000000..8040ebd
--- /dev/null
+++ b/docs/use-cases/reinforcement-learning.mdx
@@ -0,0 +1,9 @@
+---
+title: "Reinforcement Learning"
+description: "Train and evaluate reinforcement learning agents in secure sandbox environments with support for simulation frameworks, custom environments, and parallel training workflows."
+icon: "brain-circuit"
+---
+
+# Reinforcement Learning
+
+Content coming soon.
diff --git a/docs/use-cases/vibe-coding.mdx b/docs/use-cases/vibe-coding.mdx
new file mode 100644
index 0000000..363fb86
--- /dev/null
+++ b/docs/use-cases/vibe-coding.mdx
@@ -0,0 +1,9 @@
+---
+title: "Vibe Coding"
+description: "Experience AI-powered coding with real-time code execution, instant feedback, and interactive development where AI agents write, test, and iterate on code in live sandbox environments."
+icon: "wand-magic-sparkles"
+---
+
+# Vibe Coding
+
+Content coming soon.