diff --git a/docs.json b/docs.json
index 34728932..a37749ae 100644
--- a/docs.json
+++ b/docs.json
@@ -67,62 +67,26 @@
               "docs/agents/opencode"
             ]
           },
-          {
-            "group": "Code interpreting",
-            "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",
-              "docs/code-interpreting/contexts",
-              {
-                "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"
-                ]
-              }
-            ]
-          },
           {
             "group": "Sandbox",
             "pages": [
               "docs/sandbox",
-              "docs/sandbox/lifecycle-events-api",
-              "docs/sandbox/lifecycle-events-webhooks",
+              "docs/sandbox/lifecycle",
               "docs/sandbox/persistence",
-              "docs/sandbox/snapshots",
-              "docs/sandbox/auto-resume",
-              "docs/sandbox/git-integration",
-              "docs/sandbox/metrics",
-              "docs/sandbox/metadata",
+              "docs/sandbox/commands",
+              "docs/sandbox/cli",
+              "docs/sandbox/filesystem",
               "docs/sandbox/environment-variables",
-              "docs/sandbox/list",
-              "docs/sandbox/connect",
-              "docs/sandbox/internet-access",
-              "docs/sandbox/pty",
-              "docs/sandbox/ssh-access",
               "docs/sandbox/connect-bucket",
-              "docs/sandbox/rate-limits",
-              "docs/sandbox/secured-access",
-              "docs/sandbox/ip-tunneling",
-              "docs/sandbox/custom-domain"
+              "docs/sandbox/security",
+              "docs/sandbox/observability",
+              "docs/sandbox/runtime-customization",
+              "docs/sandbox/git-integration",
+              "docs/sandbox/proxy-tunneling",
+              "docs/sandbox/custom-domain",
+              "docs/sandbox/volumes",
+              "docs/sandbox/mcp",
+              "docs/sandbox/mcp/available-servers"
             ]
           },
           {
@@ -156,57 +120,36 @@
             ]
           },
           {
-            "group": "Filesystem",
-            "pages": [
-              "docs/filesystem",
-              "docs/filesystem/read-write",
-              "docs/filesystem/info",
-              "docs/filesystem/watch",
-              "docs/filesystem/upload",
-              "docs/filesystem/download"
-            ]
-          },
-          {
-            "group": "Volumes",
-            "pages": [
-              "docs/volumes",
-              "docs/volumes/manage",
-              "docs/volumes/mount",
-              "docs/volumes/read-write",
-              "docs/volumes/info",
-              "docs/volumes/upload",
-              "docs/volumes/download"
-            ]
-          },
-          {
-            "group": "Commands",
-            "pages": [
-              "docs/commands",
-              "docs/commands/streaming",
-              "docs/commands/background"
-            ]
-          },
-          {
-            "group": "MCP gateway",
-            "pages": [
-              "docs/mcp",
-              "docs/mcp/quickstart",
-              "docs/mcp/available-servers",
-              "docs/mcp/custom-templates",
-              "docs/mcp/custom-servers",
-              "docs/mcp/examples"
-            ]
-          },
-          {
-            "group": "CLI",
+            "group": "Code interpreting",
             "pages": [
-              "docs/cli",
-              "docs/cli/auth",
-              "docs/cli/list-sandboxes",
-              "docs/cli/create-sandbox",
-              "docs/cli/connect-to-sandbox",
-              "docs/cli/exec-command",
-              "docs/cli/shutdown-sandboxes"
+              {
+                "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",
+              "docs/code-interpreting/contexts",
+              {
+                "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"
+                ]
+              }
             ]
           },
           {
@@ -228,6 +171,14 @@
               "docs/troubleshooting/templates/49999-port-not-open",
               "docs/troubleshooting/pip-install-error"
             ]
+          },
+          {
+            "group": "Page Templates (Preview)",
+            "pages": [
+              "templates/preview-code-example",
+              "templates/preview-use-case",
+              "templates/preview-guide"
+            ]
           }
         ]
       },
@@ -3712,6 +3663,156 @@
     }
   },
   "redirects": [
+    {
+      "source": "/docs/cli",
+      "destination": "/docs/sandbox/cli",
+      "permanent": true
+    },
+    {
+      "source": "/docs/cli/auth",
+      "destination": "/docs/sandbox/cli",
+      "permanent": true
+    },
+    {
+      "source": "/docs/cli/list-sandboxes",
+      "destination": "/docs/sandbox/cli",
+      "permanent": true
+    },
+    {
+      "source": "/docs/cli/create-sandbox",
+      "destination": "/docs/sandbox/cli",
+      "permanent": true
+    },
+    {
+      "source": "/docs/cli/connect-to-sandbox",
+      "destination": "/docs/sandbox/cli",
+      "permanent": true
+    },
+    {
+      "source": "/docs/cli/exec-command",
+      "destination": "/docs/sandbox/cli",
+      "permanent": true
+    },
+    {
+      "source": "/docs/cli/shutdown-sandboxes",
+      "destination": "/docs/sandbox/cli",
+      "permanent": true
+    },
+    {
+      "source": "/docs/sandbox/configuration",
+      "destination": "/docs/sandbox/environment-variables",
+      "permanent": true
+    },
+    {
+      "source": "/docs/filesystem",
+      "destination": "/docs/sandbox/filesystem",
+      "permanent": true
+    },
+    {
+      "source": "/docs/filesystem/read-write",
+      "destination": "/docs/sandbox/filesystem",
+      "permanent": true
+    },
+    {
+      "source": "/docs/filesystem/info",
+      "destination": "/docs/sandbox/filesystem",
+      "permanent": true
+    },
+    {
+      "source": "/docs/filesystem/watch",
+      "destination": "/docs/sandbox/filesystem",
+      "permanent": true
+    },
+    {
+      "source": "/docs/filesystem/upload",
+      "destination": "/docs/sandbox/filesystem",
+      "permanent": true
+    },
+    {
+      "source": "/docs/filesystem/download",
+      "destination": "/docs/sandbox/filesystem",
+      "permanent": true
+    },
+    {
+      "source": "/docs/volumes",
+      "destination": "/docs/sandbox/volumes",
+      "permanent": true
+    },
+    {
+      "source": "/docs/volumes/manage",
+      "destination": "/docs/sandbox/volumes",
+      "permanent": true
+    },
+    {
+      "source": "/docs/volumes/mount",
+      "destination": "/docs/sandbox/volumes",
+      "permanent": true
+    },
+    {
+      "source": "/docs/volumes/read-write",
+      "destination": "/docs/sandbox/volumes",
+      "permanent": true
+    },
+    {
+      "source": "/docs/volumes/info",
+      "destination": "/docs/sandbox/volumes",
+      "permanent": true
+    },
+    {
+      "source": "/docs/volumes/upload",
+      "destination": "/docs/sandbox/volumes",
+      "permanent": true
+    },
+    {
+      "source": "/docs/volumes/download",
+      "destination": "/docs/sandbox/volumes",
+      "permanent": true
+    },
+    {
+      "source": "/docs/commands",
+      "destination": "/docs/sandbox/commands",
+      "permanent": true
+    },
+    {
+      "source": "/docs/commands/streaming",
+      "destination": "/docs/sandbox/commands",
+      "permanent": true
+    },
+    {
+      "source": "/docs/commands/background",
+      "destination": "/docs/sandbox/commands",
+      "permanent": true
+    },
+    {
+      "source": "/docs/mcp",
+      "destination": "/docs/sandbox/mcp",
+      "permanent": true
+    },
+    {
+      "source": "/docs/mcp/quickstart",
+      "destination": "/docs/sandbox/mcp",
+      "permanent": true
+    },
+    {
+      "source": "/docs/mcp/available-servers",
+      "destination": "/docs/sandbox/mcp/available-servers",
+      "permanent": true
+    },
+    {
+      "source": "/docs/mcp/custom-templates",
+      "destination": "/docs/sandbox/mcp",
+      "permanent": true
+    },
+    {
+      "source": "/docs/mcp/custom-servers",
+      "destination": "/docs/sandbox/mcp",
+      "permanent": true
+    },
+    {
+      "source": "/docs/mcp/examples",
+      "destination": "/docs/sandbox/mcp",
+      "permanent": true
+    },
     {
       "source": "/docs/template/aliases",
       "destination": "/docs/template/names",
@@ -3834,17 +3935,17 @@
     },
     {
       "source": "/docs/legacy/sandbox/api/reconnect",
-      "destination": "/docs/sandbox/connect",
+      "destination": "/docs/sandbox/lifecycle",
       "permanent": true
     },
     {
       "source": "/docs/legacy/sandbox/api/url",
-      "destination": "/docs/sandbox/internet-access",
+      "destination": "/docs/sandbox/security",
       "permanent": true
     },
     {
       "source": "/docs/legacy/sandbox/api/metadata",
-      "destination": "/docs/sandbox/metadata",
+      "destination": "/docs/sandbox/lifecycle",
       "permanent": true
     },
     {
@@ -3961,6 +4062,86 @@
       "source": "/docs/git",
       "destination": "/docs/sandbox/git-integration",
       "permanent": true
+    },
+    {
+      "source": "/docs/sandbox/snapshots",
+      "destination": "/docs/sandbox/persistence",
+      "permanent": true
+    },
+    {
+      "source": "/docs/sandbox/auto-resume",
+      "destination": "/docs/sandbox/persistence",
+      "permanent": true
+    },
+    {
+      "source": "/docs/sandbox/list",
+      "destination": "/docs/sandbox/lifecycle",
+      "permanent": true
+    },
+    {
+      "source": "/docs/sandbox/connect",
+      "destination": "/docs/sandbox/lifecycle",
+      "permanent": true
+    },
+    {
+      "source": "/docs/sandbox/metadata",
+      "destination": "/docs/sandbox/lifecycle",
+      "permanent": true
+    },
+    {
+      "source": "/docs/sandbox/lifecycle-events-api",
+      "destination": "/docs/sandbox/observability",
+      "permanent": true
+    },
+    {
+      "source": "/docs/sandbox/lifecycle-events-webhooks",
+      "destination": "/docs/sandbox/observability",
+      "permanent": true
+    },
+    {
+      "source": "/docs/sandbox/metrics",
+      "destination": "/docs/sandbox/observability",
+      "permanent": true
+    },
+    {
+      "source": "/docs/sandbox/secured-access",
+      "destination": "/docs/sandbox/security",
+      "permanent": true
+    },
+    {
+      "source": "/docs/sandbox/internet-access",
+      "destination": "/docs/sandbox/security",
+      "permanent": true
+    },
+    {
+      "source": "/docs/sandbox/rate-limits",
+      "destination": "/docs/sandbox/security",
+      "permanent": true
+    },
+    {
+      "source": "/docs/sandbox/pty",
+      "destination": "/docs/sandbox/commands",
+      "permanent": true
+    },
+    {
+      "source": "/docs/sandbox/ssh-access",
+      "destination": "/docs/sandbox/commands",
+      "permanent": true
+    },
+    {
+      "source": "/docs/sandbox/ip-tunneling",
+      "destination": "/docs/sandbox/proxy-tunneling",
+      "permanent": true
+    },
+    {
+      "source": "/docs/use-cases/agent-browser",
+      "destination": "/docs/use-cases/computer-use",
+      "permanent": true
+    },
+    {
+      "source": "/docs/use-cases/browser-use",
+      "destination": "/docs/use-cases/computer-use",
+      "permanent": true
     }
   ]
 }
diff --git a/docs/agents/amp.mdx b/docs/agents/amp.mdx
index 197b7081..849b61f2 100644
--- a/docs/agents/amp.mdx
+++ b/docs/agents/amp.mdx
@@ -8,7 +8,7 @@ icon: "/images/icons/amp.svg"
 
 ## CLI
 
-Create a sandbox with the [E2B CLI](/docs/cli).
+Create a sandbox with the [E2B CLI](/docs/sandbox/cli).
 
 ```bash
 e2b sbx create amp
@@ -304,7 +304,7 @@ python build.py
   <Card title="Git integration" icon="code-branch" href="/docs/sandbox/git-integration">
     Clone repos, manage branches, and push changes
   </Card>
-  <Card title="SSH access" icon="terminal" href="/docs/sandbox/ssh-access">
+  <Card title="SSH access" icon="terminal" href="/docs/sandbox/commands#ssh-access">
     Connect to the sandbox via SSH for interactive sessions
   </Card>
 </CardGroup>
diff --git a/docs/agents/claude-code.mdx b/docs/agents/claude-code.mdx
index 68c3423a..ddf3ae52 100644
--- a/docs/agents/claude-code.mdx
+++ b/docs/agents/claude-code.mdx
@@ -8,7 +8,7 @@ icon: "/images/icons/claude-code.svg"
 
 ## CLI
 
-Create a sandbox with the [E2B CLI](/docs/cli).
+Create a sandbox with the [E2B CLI](/docs/sandbox/cli).
 
 ```bash
 e2b sbx create claude
@@ -326,7 +326,7 @@ sandbox.kill()
 
 ## Connect MCP tools
 
-Claude Code has built-in support for [MCP](https://modelcontextprotocol.io/). E2B provides an [MCP gateway](/docs/mcp) that gives Claude access to 200+ tools from the [Docker MCP Catalog](https://hub.docker.com/mcp).
+Claude Code has built-in support for [MCP](https://modelcontextprotocol.io/). E2B provides an [MCP gateway](/docs/sandbox/mcp) that gives Claude access to 200+ tools from the [Docker MCP Catalog](https://hub.docker.com/mcp).
 
 <CodeGroup>
 ```typescript JavaScript & TypeScript
@@ -447,7 +447,7 @@ python build.py
 ## Related guides
 
 <CardGroup cols={3}>
-  <Card title="MCP tools" icon="plug" href="/docs/mcp">
+  <Card title="MCP tools" icon="plug" href="/docs/sandbox/mcp">
     Connect Claude Code to 200+ MCP tools
   </Card>
   <Card title="Sandbox persistence" icon="clock" href="/docs/sandbox/persistence">
diff --git a/docs/agents/codex.mdx b/docs/agents/codex.mdx
index 7b6f854f..967a36a4 100644
--- a/docs/agents/codex.mdx
+++ b/docs/agents/codex.mdx
@@ -8,7 +8,7 @@ icon: "/images/icons/codex.svg"
 
 ## CLI
 
-Create a sandbox with the [E2B CLI](/docs/cli).
+Create a sandbox with the [E2B CLI](/docs/sandbox/cli).
 
 ```bash
 e2b sbx create codex
@@ -360,7 +360,7 @@ python build.py
   <Card title="Git integration" icon="code-branch" href="/docs/sandbox/git-integration">
     Clone repos, manage branches, and push changes
   </Card>
-  <Card title="SSH access" icon="terminal" href="/docs/sandbox/ssh-access">
+  <Card title="SSH access" icon="terminal" href="/docs/sandbox/commands#ssh-access">
     Connect to the sandbox via SSH for interactive sessions
   </Card>
 </CardGroup>
diff --git a/docs/agents/openclaw.mdx b/docs/agents/openclaw.mdx
index 20165972..f8265a97 100644
--- a/docs/agents/openclaw.mdx
+++ b/docs/agents/openclaw.mdx
@@ -8,7 +8,7 @@ icon: "/images/icons/openclaw-v2.svg"
 
 ## CLI
 
-Create a sandbox with the [E2B CLI](/docs/cli).
+Create a sandbox with the [E2B CLI](/docs/sandbox/cli).
 
 ```bash
 e2b sbx create openclaw
@@ -506,7 +506,7 @@ python build.py
   <Card title="Git integration" icon="code-branch" href="/docs/sandbox/git-integration">
     Clone repos, manage branches, and push changes
   </Card>
-  <Card title="SSH access" icon="terminal" href="/docs/sandbox/ssh-access">
+  <Card title="SSH access" icon="terminal" href="/docs/sandbox/commands#ssh-access">
     Connect to the sandbox via SSH for interactive sessions
   </Card>
 </CardGroup>
diff --git a/docs/agents/opencode.mdx b/docs/agents/opencode.mdx
index a5cee3b1..b09127ca 100644
--- a/docs/agents/opencode.mdx
+++ b/docs/agents/opencode.mdx
@@ -8,7 +8,7 @@ icon: "/images/icons/opencode.svg"
 
 ## CLI
 
-Create a sandbox with the [E2B CLI](/docs/cli).
+Create a sandbox with the [E2B CLI](/docs/sandbox/cli).
 
 ```bash
 e2b sbx create opencode
@@ -284,7 +284,7 @@ python build.py
   <Card title="Git integration" icon="code-branch" href="/docs/sandbox/git-integration">
     Clone repos, manage branches, and push changes
   </Card>
-  <Card title="SSH access" icon="terminal" href="/docs/sandbox/ssh-access">
+  <Card title="SSH access" icon="terminal" href="/docs/sandbox/commands#ssh-access">
     Connect to the sandbox via SSH for interactive sessions
   </Card>
 </CardGroup>
diff --git a/docs/billing.mdx b/docs/billing.mdx
index 752646e5..4b71c21e 100644
--- a/docs/billing.mdx
+++ b/docs/billing.mdx
@@ -21,7 +21,7 @@ E2B uses [usage-based pricing](#usage-based-pricing) - you pay only for what you
 Pro plan includes 100 concurrent sandboxes. Higher concurrency up to 1,100 is available as a purchasable [add-on](https://e2b.dev/dashboard?tab=billing).
 </Note>
 
-Plans have different [API rate limits](/docs/sandbox/rate-limits).
+Plans have different [API rate limits](/docs/sandbox/security#rate-limits).
 
 To upgrade your plan or purchase add-ons, visit the [dashboard billing tab](https://e2b.dev/dashboard?tab=billing). For Enterprise plans, [contact sales](mailto:enterprise@e2b.dev).
 
@@ -96,8 +96,8 @@ Check your usage and costs in the [dashboard usage tab](https://e2b.dev/dashboar
     - **Pause sandboxes when idle** - Use `sbx.pause()` to stop billing while keeping state available for later
     - **Kill sandboxes you no longer need** - Use `sbx.kill()` to stop billing and release resources permanently
     - **Allocate only what you need** - Start with default resources (2 vCPU, 1 GB RAM) and increase only if necessary
-    - **Monitor actively running sandboxes** - Use the [CLI](/docs/cli/list-sandboxes) or [dashboard](https://e2b.dev/dashboard?tab=usage) to track active sandboxes
-    - **Use lifecycle events** - Set up [webhooks](/docs/sandbox/lifecycle-events-webhooks) to get notified when sandboxes are created
+    - **Monitor actively running sandboxes** - Use the [CLI](/docs/sandbox/cli#list-sandboxes) or [dashboard](https://e2b.dev/dashboard?tab=usage) to track active sandboxes
+    - **Use lifecycle events** - Set up [webhooks](/docs/sandbox/observability#lifecycle-webhooks) to get notified when sandboxes are created
   </Accordion>
 
   <Accordion title="Do I pay for stopped sandboxes?">
diff --git a/docs/cli.mdx b/docs/cli.mdx
deleted file mode 100644
index 25b76f6b..00000000
--- a/docs/cli.mdx
+++ /dev/null
@@ -1,26 +0,0 @@
----
-title: "E2B CLI"
-sidebarTitle: Installation
----
-
-E2B CLI is a command line tool that allows you to manage and interact with sandboxes and [templates](/docs/template/quickstart).
-
-## Installation
-
-**Using Homebrew (on macOS)**
-
-<CodeGroup>
-```bash Terminal
-brew install e2b
-```
-</CodeGroup>
-
-**Using NPM**
-
-You can install E2B CLI using the following command:
-
-<CodeGroup>
-```bash Terminal
-npm i -g @e2b/cli
-```
-</CodeGroup>
diff --git a/docs/cli/auth.mdx b/docs/cli/auth.mdx
deleted file mode 100644
index 1ef2efa3..00000000
--- a/docs/cli/auth.mdx
+++ /dev/null
@@ -1,34 +0,0 @@
----
-title: "Authentication in CLI"
-sidebarTitle: Authentication
----
-
-There are two ways to authenticate with the E2B CLI:
-
-## Option 1: browser authentication
-
-<Warning>
-This option requires an interactive browser environment.
-</Warning>
-
-Run the following command to sign in through your browser:
-
-```bash
-e2b auth login
-```
-
-This will open your default browser and prompt you to authenticate with your E2B account.
-
-## Option 2: setup environment variables
-
-Set your environment variables:
-
-```bash
-export E2B_API_KEY=your_api_key_here
-export E2B_ACCESS_TOKEN=your_acces_token_here
-```
-
-<Info>
-Learn more about obtaining and managing your API key and access token on the [API Key page](/docs/api-key).
-</Info>
-
diff --git a/docs/cli/connect-to-sandbox.mdx b/docs/cli/connect-to-sandbox.mdx
deleted file mode 100644
index 4315da98..00000000
--- a/docs/cli/connect-to-sandbox.mdx
+++ /dev/null
@@ -1,15 +0,0 @@
----
-title: "Connect to sandbox"
----
-
-You can connect an interactive terminal to an already running sandbox.
-
-<CodeGroup>
-```bash Terminal
-e2b sandbox connect <sandbox-id>
-```
-</CodeGroup>
-
-Unlike the `create` command, `connect` does not kill the sandbox when you disconnect. When you exit the terminal, only your terminal session is closed—the sandbox continues running.
-
-Once connected, you can inspect the sandbox filesystem and processes to debug or experiment, or use it as a dedicated environment for running agents instead of your local computer.
diff --git a/docs/cli/create-sandbox.mdx b/docs/cli/create-sandbox.mdx
deleted file mode 100644
index f7e90c65..00000000
--- a/docs/cli/create-sandbox.mdx
+++ /dev/null
@@ -1,25 +0,0 @@
----
-title: "Create sandbox"
----
-
-You can create a sandbox and connect an interactive terminal to it.
-
-<CodeGroup>
-```bash Terminal
-e2b sandbox create <template>
-```
-</CodeGroup>
-
-For example, to create a sandbox from the `base` template:
-
-```bash
-e2b sandbox create base
-```
-
-This will:
-1. Create a new sandbox from the specified template
-2. Connect your terminal to the sandbox
-3. Keep the sandbox alive while you're connected
-4. Automatically kill the sandbox when you exit the terminal
-
-Once connected, you can inspect the sandbox filesystem and processes to debug or experiment, or use it as a dedicated environment for running agents instead of your local computer.
diff --git a/docs/cli/exec-command.mdx b/docs/cli/exec-command.mdx
deleted file mode 100644
index a97826cb..00000000
--- a/docs/cli/exec-command.mdx
+++ /dev/null
@@ -1,51 +0,0 @@
----
-title: "Execute commands in sandbox"
----
-
-You can execute commands in a running sandbox.
-
-<CodeGroup>
-```bash Terminal
-e2b sandbox exec <sandbox-id> <command>
-```
-</CodeGroup>
-
-### Pipe command from stdin
-
-You can pipe directly into the sandbox as well:
-
-```bash
-echo "foo" | e2b sandbox exec <sandbox-id> <command>
-```
-
-### Run in background
-
-Use the `--background` flag to run a command in the background and return immediately. The command will print the process ID (PID) to stderr:
-
-```bash
-e2b sandbox exec --background <sandbox-id> "sleep 60 && echo done"
-```
-
-### Set working directory
-
-Use the `--cwd` flag to specify the working directory for the command:
-
-```bash
-e2b sandbox exec --cwd /home/user <sandbox-id> ls
-```
-
-### Run as specific user
-
-Use the `--user` flag to run the command as a specific user:
-
-```bash
-e2b sandbox exec --user root <sandbox-id> apt-get update
-```
-
-### Set environment variables
-
-Use the `--env` flag to set environment variables. This flag can be repeated for multiple variables:
-
-```bash
-e2b sandbox exec --env NODE_ENV=production --env DEBUG=true <sandbox-id> node app.js
-```
diff --git a/docs/cli/list-sandboxes.mdx b/docs/cli/list-sandboxes.mdx
deleted file mode 100644
index 4ecc8374..00000000
--- a/docs/cli/list-sandboxes.mdx
+++ /dev/null
@@ -1,55 +0,0 @@
----
-title: "List sandboxes"
----
-
-You can list all sandboxes using the following command:
-
-<CodeGroup>
-```bash Terminal
-e2b sandbox list
-```
-</CodeGroup>
-
-This will return running sandboxes, you can specify `--state` to get paused or both.
-
-### Filter by state
-
-To filter the sandboxes by their state you can specify the `--state` flag, which can either be "**running**", "**paused**" or both.
-
-```bash
-e2b sandbox list --state running,paused
-```
-
-### Filter by metadata
-
-To filter the sandboxes by their metadata, use the `--metadata` flag.
-
-```bash
-e2b sandbox list --metadata key1=value1,key2=value2
-```
-
-### List limit
-
-To limit the amount of sandboxes returned by the command, use the `--limit` flag.
-
-```bash
-e2b sandbox list --limit 10
-```
-
-By default, the command will return all sandboxes.
-
-### Output format
-
-To output the sandboxes in JSON format, use the `--format` flag.
-
-**Pretty print (default)**
-
-```bash
-e2b sandbox list --format pretty
-```
-
-**JSON**
-
-```bash
-e2b sandbox list --format json
-```
diff --git a/docs/cli/shutdown-sandboxes.mdx b/docs/cli/shutdown-sandboxes.mdx
deleted file mode 100644
index 54c12f90..00000000
--- a/docs/cli/shutdown-sandboxes.mdx
+++ /dev/null
@@ -1,45 +0,0 @@
----
-title: "Shutdown running sandboxes"
----
-
-You can shutdown single or all running sandboxes with the E2B CLI.
-
-## Shutdown single or multiple sandboxes
-
-To shutdown a single or multiple sandboxes, run the following command:
-
-<CodeGroup>
-```bash Terminal
-e2b sandbox kill <sandbox-id1> <sandbox-id2> <sandbox-id3>
-```
-</CodeGroup>
-
-## Shutdown all sandboxes
-
-To shutdown all running sandboxes, run the following command:
-
-<CodeGroup>
-```bash Terminal
-e2b sandbox kill --all
-```
-</CodeGroup>
-
-Further, you can filter the sandboxes to be shutdown by state, metadata or both.
-
-<CodeGroup>
-```bash Terminal
-e2b sandbox kill --all --state=running,paused
-```
-</CodeGroup>
-
-<CodeGroup>
-```bash Terminal
-e2b sandbox kill --all --metadata=key=value
-```
-</CodeGroup>
-
-<CodeGroup>
-```bash Terminal
-e2b sandbox kill --all --state=running,paused --metadata=key=value
-```
-</CodeGroup>
diff --git a/docs/commands.mdx b/docs/commands.mdx
deleted file mode 100644
index ffd1c222..00000000
--- a/docs/commands.mdx
+++ /dev/null
@@ -1,23 +0,0 @@
----
-title: "Running commands in sandbox"
-sidebarTitle: Overview
----
-
-You can run terminal commands inside the sandbox using the `commands.run()` method.
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Sandbox } from '@e2b/code-interpreter'
-
-const sandbox = await Sandbox.create()
-const result = await sandbox.commands.run('ls -l')
-console.log(result)
-```
-```python Python
-from e2b_code_interpreter import Sandbox
-
-sandbox = Sandbox.create()
-result = sandbox.commands.run('ls -l')
-print(result)
-```
-</CodeGroup>
diff --git a/docs/commands/background.mdx b/docs/commands/background.mdx
deleted file mode 100644
index 66e40b71..00000000
--- a/docs/commands/background.mdx
+++ /dev/null
@@ -1,45 +0,0 @@
----
-title: "Running commands in background"
-sidebarTitle: Run commands in background
----
-
-To run commands in background, pass the `background` option to the `commands.run()` method. This will return immediately and the command will continue to run in the sandbox.
-You can then later kill the command using the `commands.kill()` method.
-
-<CodeGroup>
-```js JavaScript & TypeScript highlight={7}
-import { Sandbox } from '@e2b/code-interpreter'
-
-const sandbox = await Sandbox.create()
-
-// Start the command in the background
-const command = await sandbox.commands.run('echo hello; sleep 10; echo world', {
-  background: true,
-  onStdout: (data) => {
-    console.log(data)
-  },
-})
-
-// Kill the command
-await command.kill()
-```
-```python Python highlight={6}
-from e2b_code_interpreter import Sandbox
-
-sandbox = Sandbox.create()
-
-# Start the command in the background
-command = sandbox.commands.run('echo hello; sleep 10; echo world', background=True)
-
-# Get stdout and stderr from the command running in the background.
-# You can run this code in a separate thread or use command.wait() to wait for the command to finish.
-for stdout, stderr, _ in command:
-    if stdout:
-        print(stdout)
-    if stderr:
-        print(stderr)
-
-# Kill the command
-command.kill()
-```
-</CodeGroup>
diff --git a/docs/commands/streaming.mdx b/docs/commands/streaming.mdx
deleted file mode 100644
index 39bb2531..00000000
--- a/docs/commands/streaming.mdx
+++ /dev/null
@@ -1,33 +0,0 @@
----
-title: "Streaming command output"
-sidebarTitle: Streaming
----
-
-To stream command output as it is being executed, pass the `onStdout`, `onStderr` callbacks to the `commands.run()` method in JavaScript
-or the `on_stdout`, `on_stderr` callbacks to the `commands.run()` method in Python.
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Sandbox } from '@e2b/code-interpreter'
-
-const sandbox = await Sandbox.create()
-
-const result = await sandbox.commands.run('echo hello; sleep 1; echo world', {
-  onStdout: (data) => {
-    console.log(data)
-  },
-  onStderr: (data) => {
-    console.log(data)
-  },
-})
-console.log(result)
-```
-```python Python
-from e2b_code_interpreter import Sandbox
-
-sandbox = Sandbox.create()
-
-result = sandbox.commands.run('echo hello; sleep 1; echo world', on_stdout=lambda data: print(data), on_stderr=lambda data: print(data))
-print(result)
-```
-</CodeGroup>
diff --git a/docs/filesystem.mdx b/docs/filesystem.mdx
deleted file mode 100644
index ad4e1810..00000000
--- a/docs/filesystem.mdx
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: "Filesystem"
-sidebarTitle: Overview
----
-
-Each E2B Sandbox has its own isolated filesystem. The [Hobby tier](https://e2b.dev/pricing) sandboxes come with 10 GB of the free disk space and [Pro tier](https://e2b.dev/pricing) sandboxes come with 20 GB.
-
-With E2B SDK you can:
-- [Read and write files to the sandbox.](/docs/filesystem/read-write)
-- [Watch directory for changes.](/docs/filesystem/watch)
-- [Upload data to the sandbox.](/docs/filesystem/upload)
-- [Download data from the sandbox.](/docs/filesystem/download)
-
diff --git a/docs/filesystem/download.mdx b/docs/filesystem/download.mdx
deleted file mode 100644
index bdd178e8..00000000
--- a/docs/filesystem/download.mdx
+++ /dev/null
@@ -1,70 +0,0 @@
----
-sidebarTitle: Download data
-title: "Download data from sandbox"
----
-
-You can download data from the sandbox using the `files.read()` method.
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import fs from 'fs'
-import { Sandbox } from '@e2b/code-interpreter'
-
-const sandbox = await Sandbox.create()
-
-// Read file from sandbox
-const content = await sandbox.files.read('/path/in/sandbox')
-// Write file to local filesystem
-fs.writeFileSync('/local/path', content)
-```
-```python Python
-from e2b_code_interpreter import Sandbox
-
-sandbox = Sandbox.create()
-
-# Read file from sandbox
-content = sandbox.files.read('/path/in/sandbox')
-# Write file to local filesystem
-with open('/local/path', 'w') as file:
-  file.write(content)
-```
-</CodeGroup>
-
-
-## Download with pre-signed URL
-
-Sometimes, you may want to let users from unauthorized environments, like a browser, download files from the sandbox.
-For this use case, you can use pre-signed URLs to let users download files securely.
-
-All you need to do is create a sandbox with the `secure: true` option. A download URL will then be generated with a signature that allows only authorized users to access files.
-You can optionally set an expiration time for the URL so that it will be valid only for a limited time.
-<CodeGroup>
-```js JavaScript & TypeScript
-import fs from 'fs'
-import { Sandbox } from '@e2b/code-interpreter'
-
-// Start a secured sandbox (all operations must be authorized by default)
-const sandbox = await Sandbox.create(template, { secure: true })
-
-// Create a pre-signed URL for file download with a 10 second expiration
-const publicUrl = await sandbox.downloadUrl(
-  'demo.txt', {
-    useSignatureExpiration: 10_000, // optional
-  },
-)
-
-// Download a file with a pre-signed URL (this can be used in any environment, such as a browser)
-const res = await fetch(publicUrl)
-const content = await res.text()
-```
-```python Python
-from e2b import Sandbox
-
-# Start a secured sandbox (all operations must be authorized by default)
-sandbox = Sandbox.create(timeout=12_000, secure=True)
-
-# Create a pre-signed URL for file download with a 10 second expiration
-# The user only has to visit the URL to download the file, this also works in a browser.
-signed_url = sbx.download_url(path="demo.txt", user="user", use_signature_expiration=10_000)
-```
-</CodeGroup>
diff --git a/docs/filesystem/info.mdx b/docs/filesystem/info.mdx
deleted file mode 100644
index 47d8858e..00000000
--- a/docs/filesystem/info.mdx
+++ /dev/null
@@ -1,116 +0,0 @@
----
-title: "Get information about a file or directory"
-sidebarTitle: File & directory metadata
----
-
-You can get information about a file or directory using the `files.getInfo()` / `files.get_info()` methods. Information such as file name, type, and path is returned.
-
-### Getting information about a file
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Sandbox } from '@e2b/code-interpreter'
-
-const sandbox = await Sandbox.create()
-
-// Create a new file
-await sandbox.files.write('test_file.txt', 'Hello, world!')
-
-// Get information about the file
-const info = await sandbox.files.getInfo('test_file.txt')
-
-console.log(info)
-// {
-//   name: 'test_file.txt',
-//   type: 'file',
-//   path: '/home/user/test_file.txt',
-//   size: 13,
-//   mode: 0o644, 
-//   permissions: '-rw-r--r--',
-//   owner: 'user',
-//   group: 'user',
-//   modifiedTime: '2025-05-26T12:00:00.000Z',
-//   symlinkTarget: null
-// }
-```
-```python Python
-from e2b_code_interpreter import Sandbox
-
-sandbox = Sandbox.create()
-
-# Create a new file
-sandbox.files.write('test_file', 'Hello, world!')
-
-# Get information about the file
-info = sandbox.files.get_info('test_file')
-
-print(info)
-# EntryInfo(
-#   name='test_file.txt',
-#   type=<FileType.FILE: 'file'>,
-#   path='/home/user/test_file.txt',
-#   size=13,
-#   mode=0o644,
-#   permissions='-rw-r--r--',
-#   owner='user',
-#   group='user',
-#   modified_time='2025-05-26T12:00:00.000Z',
-#   symlink_target=None
-# )
-```
-</CodeGroup>
-
-### Getting information about a directory
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Sandbox } from '@e2b/code-interpreter'
-
-const sandbox = await Sandbox.create()
-
-// Create a new directory
-await sandbox.files.makeDir('test_dir')
-
-// Get information about the directory
-const info = await sandbox.files.getInfo('test_dir')
-
-console.log(info)
-// {
-//   name: 'test_dir',
-//   type: 'dir',
-//   path: '/home/user/test_dir',
-//   size: 0,
-//   mode: 0o755,
-//   permissions: 'drwxr-xr-x',
-//   owner: 'user',
-//   group: 'user',
-//   modifiedTime: '2025-05-26T12:00:00.000Z',
-//   symlinkTarget: null
-// }
-```
-```python Python
-from e2b_code_interpreter import Sandbox
-
-sandbox = Sandbox.create()
-
-# Create a new directory
-sandbox.files.make_dir('test_dir')
-
-# Get information about the directory
-info = sandbox.files.get_info('test_dir')
-
-print(info)
-# EntryInfo(
-#   name='test_dir',
-#   type=<FileType.DIR: 'dir'>,
-#   path='/home/user/test_dir',
-#   size=0,
-#   mode=0o755,
-#   permissions='drwxr-xr-x',
-#   owner='user',
-#   group='user',
-#   modified_time='2025-05-26T12:00:00.000Z',
-#   symlink_target=None
-# )
-```
-</CodeGroup>
diff --git a/docs/filesystem/read-write.mdx b/docs/filesystem/read-write.mdx
deleted file mode 100644
index 187b1503..00000000
--- a/docs/filesystem/read-write.mdx
+++ /dev/null
@@ -1,71 +0,0 @@
----
-title: "Read & write files"
-sidebarTitle: Read & write
----
-
-## Reading files
-
-You can read files from the sandbox filesystem using the `files.read()` method.
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Sandbox } from '@e2b/code-interpreter'
-
-const sandbox = await Sandbox.create()
-const fileContent = await sandbox.files.read('/path/to/file')
-```
-```python Python
-from e2b_code_interpreter import Sandbox
-
-sandbox = Sandbox.create()
-file_content = sandbox.files.read('/path/to/file')
-```
-</CodeGroup>
-
-## Writing single files
-
-You can write single files to the sandbox filesystem using the `files.write()` method.
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Sandbox } from '@e2b/code-interpreter'
-
-const sandbox = await Sandbox.create()
-
-await sandbox.files.write('/path/to/file', 'file content')
-```
-```python Python
-from e2b_code_interpreter import Sandbox
-
-sandbox = Sandbox.create()
-
-sandbox.files.write('/path/to/file', 'file content')
-```
-</CodeGroup>
-
-## Writing multiple files
-
-You can also write multiple files to the sandbox.
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Sandbox } from '@e2b/code-interpreter'
-
-const sandbox = await Sandbox.create()
-
-await sandbox.files.write([
-    { path: '/path/to/a', data: 'file content' },
-    { path: '/another/path/to/b', data: 'file content' }
-])
-```
-```python Python
-from e2b_code_interpreter import Sandbox
-
-sandbox = Sandbox.create()
-
-sandbox.files.write_files([
-    { "path": "/path/to/a", "data": "file content" },
-    { "path": "another/path/to/b", "data": "file content" }
-])
-```
-</CodeGroup>
\ No newline at end of file
diff --git a/docs/filesystem/upload.mdx b/docs/filesystem/upload.mdx
deleted file mode 100644
index befeb989..00000000
--- a/docs/filesystem/upload.mdx
+++ /dev/null
@@ -1,160 +0,0 @@
----
-title: "Upload data to sandbox"
-sidebarTitle: Upload data
----
-
-You can upload data to the sandbox using the `files.write()` method.
-
-## Upload single file
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import fs from 'fs'
-import { Sandbox } from '@e2b/code-interpreter'
-
-const sandbox = await Sandbox.create()
-
-// Read file from local filesystem
-const content = fs.readFileSync('/local/path')
-// Upload file to sandbox
-await sandbox.files.write('/path/in/sandbox', content)
-```
-```python Python
-from e2b_code_interpreter import Sandbox
-
-sandbox = Sandbox.create()
-
-# Read file from local filesystem
-with open("path/to/local/file", "rb") as file:
-  # Upload file to sandbox
-  sandbox.files.write("/path/in/sandbox", file)
-```
-</CodeGroup>
-
-## Upload with pre-signed URL
-
-Sometimes, you may want to let users from unauthorized environments, like a browser, upload files to the sandbox.
-For this use case, you can use pre-signed URLs to let users upload files securely.
-
-All you need to do is create a sandbox with the `secure: true` option. An upload URL will then be generated with a signature that allows only authorized users to upload files.
-You can optionally set an expiration time for the URL so that it will be valid only for a limited time.
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Sandbox } from '@e2b/code-interpreter'
-
-// Start a secured sandbox (all operations must be authorized by default)
-const sandbox = await Sandbox.create(template, { secure: true })
-
-// Create a pre-signed URL for file upload with a 10 second expiration
-const publicUploadUrl = await sandbox.uploadUrl(
-  'demo.txt', {
-    useSignatureExpiration: 10_000, // optional
-  },
-)
-
-// Upload a file with a pre-signed URL (this can be used in any environment, such as a browser)
-const form = new FormData()
-form.append('file', 'file content')
-
-await fetch(publicUploadUrl, { method: 'POST', body: form })
-
-// File is now available in the sandbox and you can read it
-const content = sandbox.files.read('/path/in/sandbox')
-```
-```python Python
-from e2b import Sandbox
-import requests
-
-# Start a secured sandbox (all operations must be authorized by default)
-sandbox = Sandbox.create(timeout=12_000, secure=True)
-
-# Create a pre-signed URL for file upload with a 10 second expiration
-signed_url = sandbox.upload_url(path="demo.txt", user="user", use_signature_expiration=10_000)
-
-form_data = {"file":"file content"}
-requests.post(signed_url, data=form_data)
-
-# File is now available in the sandbox and you can read it
-content = sandbox.files.read('/path/in/sandbox')
-```
-</CodeGroup>
-
-## Upload directory / multiple files
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Sandbox } from '@e2b/code-interpreter'
-
-const sandbox = await Sandbox.create()
-
-// Read all files in the directory and store their paths and contents in an array
-const readDirectoryFiles = (directoryPath) => {
-  // Read all files in the local directory
-  const files = fs.readdirSync(directoryPath);
-
-  // Map files to objects with path and data
-  const filesArray = files
-    .filter(file => {
-      const fullPath = path.join(directoryPath, file);
-      // Skip if it's a directory
-      return fs.statSync(fullPath).isFile();
-    })
-    .map(file => {
-      const filePath = path.join(directoryPath, file);
-    
-      // Read the content of each file
-      return {
-        path: filePath,
-        data: fs.readFileSync(filePath, 'utf8')
-      };
-    });
-
-  return filesArray;
-};
-
-// Usage example
-const files = readDirectoryFiles('/local/dir');
-console.log(files); 
-// [
-//   { path: '/local/dir/file1.txt', data: 'File 1 contents...' },
-//   { path: '/local/dir/file2.txt', data: 'File 2 contents...' },
-//   ...
-// ]
-
-await sandbox.files.write(files)
-```
-```python Python
-import os
-from e2b_code_interpreter import Sandbox
-
-sandbox = Sandbox.create()
-
-def read_directory_files(directory_path):
-    files = []
-    
-    # Iterate through all files in the directory
-    for filename in os.listdir(directory_path):
-        file_path = os.path.join(directory_path, filename)
-        
-        # Skip if it's a directory
-        if os.path.isfile(file_path):
-            # Read file contents in binary mode
-            with open(file_path, "rb") as file:
-                files.append({
-                    'path': file_path,
-                    'data': file.read()
-                })
-    
-    return files
-
-files = read_directory_files("/local/dir")
-print(files)
-# [
-#  {"path": "/local/dir/file1.txt", "data": "File 1 contents..." },
-#   { "path": "/local/dir/file2.txt", "data": "File 2 contents..." },
-#   ...
-# ]
-
-sandbox.files.write_files(files)
-```
-</CodeGroup>
\ No newline at end of file
diff --git a/docs/filesystem/watch.mdx b/docs/filesystem/watch.mdx
deleted file mode 100644
index 55fe18f4..00000000
--- a/docs/filesystem/watch.mdx
+++ /dev/null
@@ -1,98 +0,0 @@
----
-title: "Watch sandbox directory for changes"
-sidebarTitle: Watch directory for changes
----
-
-You can watch a directory for changes using the `files.watchDir()` method in JavaScript and `files.watch_dir()` method in Python.
-
-<Note>
-Since events are tracked asynchronously, their delivery may be delayed.
-It's recommended not to collect or close watcher immediately after making a change.
-</Note>
-
-<CodeGroup>
-```js JavaScript & TypeScript highlight={7-12}
-import { Sandbox, FilesystemEventType } from '@e2b/code-interpreter'
-
-const sandbox = await Sandbox.create()
-const dirname = '/home/user'
-
-// Start watching directory for changes
-const handle = await sandbox.files.watchDir(dirname, async (event) => {
-  console.log(event)
-  if (event.type === FilesystemEventType.WRITE) {
-    console.log(`wrote to file ${event.name}`)
-  }
-})
-
-// Trigger file write event
-await sandbox.files.write(`${dirname}/my-file`, 'hello')
-```
-```python Python highlight={7,12-16}
-from e2b_code_interpreter import Sandbox, FilesystemEventType
-
-sandbox = Sandbox.create()
-dirname = '/home/user'
-
-# Watch directory for changes
-handle = sandbox.files.watch_dir(dirname)
-# Trigger file write event
-sandbox.files.write(f"{dirname}/my-file", "hello")
-
-# Retrieve the latest new events since the last `get_new_events()` call
-events = handle.get_new_events()
-for event in events:
-  print(event)
-  if event.type == FilesystemEventType.WRITE:
-    print(f"wrote to file {event.name}")
-```
-</CodeGroup>
-
-
-## Recursive watching
-
-You can enable recursive watching using the parameter `recursive`.
-
-<Note>
-When rapidly creating new folders (e.g., deeply nested path of folders), events other than `CREATE` might not be emitted. To avoid this behavior, create the required folder structure in advance.
-</Note>
-
-<CodeGroup>
-```js JavaScript & TypeScript highlight={13,17}
-import { Sandbox, FilesystemEventType } from '@e2b/code-interpreter'
-
-const sandbox = await Sandbox.create()
-const dirname = '/home/user'
-
-// Start watching directory for changes
-const handle = await sandbox.files.watchDir(dirname, async (event) => {
-  console.log(event)
-  if (event.type === FilesystemEventType.WRITE) {
-    console.log(`wrote to file ${event.name}`)
-  }
-}, {
-  recursive: true
-})
-
-// Trigger file write event
-await sandbox.files.write(`${dirname}/my-folder/my-file`, 'hello')
-```
-```python Python highlight={7,9}
-from e2b_code_interpreter import Sandbox, FilesystemEventType
-
-sandbox = Sandbox.create()
-dirname = '/home/user'
-
-# Watch directory for changes
-handle = sandbox.files.watch_dir(dirname, recursive=True)
-# Trigger file write event
-sandbox.files.write(f"{dirname}/my-folder/my-file", "hello")
-
-# Retrieve the latest new events since the last `get_new_events()` call
-events = handle.get_new_events()
-for event in events:
-  print(event)
-  if event.type == FilesystemEventType.WRITE:
-    print(f"wrote to file {event.name}")
-```
-</CodeGroup>
diff --git a/docs/mcp.mdx b/docs/mcp.mdx
deleted file mode 100644
index 8c0b969c..00000000
--- a/docs/mcp.mdx
+++ /dev/null
@@ -1,108 +0,0 @@
----
-title: Overview
-description: Connect to 200+ tools through the Model Context Protocol
----
-
-E2B provides a batteries-included MCP gateway that runs inside sandboxes, giving you type-safe access to 200+ MCP tools from the [Docker MCP Catalog](https://hub.docker.com/mcp) or [custom MCPs](/docs/mcp/custom-servers) through a unified interface. This integration gives developers instant access to tools like [Browserbase](https://www.browserbase.com/), [Exa](https://exa.ai/), [Notion](https://www.notion.so/), [Stripe](https://stripe.com/), or [GitHub](https://github.com/).
-
-The [Model Context Protocol (MCP)](https://modelcontextprotocol.io/docs/getting-started/intro) is an open standard for connecting AI models to external tools and data sources. E2B sandboxes provide an ideal environment for running MCP tools, giving AI full access to an internet-connected Linux machine where it can safely install packages, write files, run terminal commands, and AI-generated code.
-
-<Frame>
-    <img src="/images/mcp-overview.png" />
-</Frame>
-
-<CodeGroup>
-
-```typescript TypeScript
-import Sandbox from 'e2b'
-
-const sbx = await Sandbox.create({
-    mcp: {
-        browserbase: {
-            apiKey: process.env.BROWSERBASE_API_KEY!,
-            geminiApiKey: process.env.GEMINI_API_KEY!,
-            projectId: process.env.BROWSERBASE_PROJECT_ID!,
-        },
-        exa: {
-            apiKey: process.env.EXA_API_KEY!,
-        },
-        airtable: {
-            airtableApiKey: process.env.AIRTABLE_API_KEY!,
-        },
-    },
-});
-
-const mcpUrl = sbx.getMcpUrl();
-const mcpToken = await sbx.getMcpToken();
-
-// You can now connect the gateway to any MCP client, for example claude:
-// This also works for your local claude!
-await sbx.commands.run(`claude mcp add --transport http e2b-mcp-gateway ${mcpUrl} --header "Authorization: Bearer ${mcpToken}"`, { timeoutMs: 0, onStdout: console.log, onStderr: console.log });
-
-await sbx.commands.run(
-    `echo 'Use browserbase and exa to research open positions at e2b.dev. Collect your findings in Airtable.' | claude -p --dangerously-skip-permissions`,
-    { timeoutMs: 0, onStdout: console.log, onStderr: console.log }
-)
-
-```
-
-```python Python
-import asyncio
-from e2b import AsyncSandbox
-import os
-import dotenv
-
-dotenv.load_dotenv()
-
-async def main():
-    sbx = await AsyncSandbox.create(mcp={
-        "browserbase": {
-            "apiKey": os.getenv("BROWSERBASE_API_KEY"),
-            "geminiApiKey": os.getenv("GEMINI_API_KEY"),
-            "projectId": os.getenv("BROWSERBASE_PROJECT_ID"),
-        },
-        "exa": {
-            "apiKey": os.getenv("EXA_API_KEY"),
-        },
-        "airtable": {
-            "airtableApiKey": os.getenv("AIRTABLE_API_KEY"),
-        },
-    })
-
-    mcp_url = sbx.get_mcp_url()
-    mcp_token = await sbx.get_mcp_token()
-
-    # You can now connect the gateway to any MCP client, for example claude:
-    # This also works for your local claude!
-    await sbx.commands.run(f'claude mcp add --transport http e2b-mcp-gateway {mcp_url} --header "Authorization: Bearer {mcp_token}"', timeout=0, on_stdout=print, on_stderr=print)
-
-    await sbx.commands.run(
-        "echo 'Use browserbase and exa to research open positions at e2b.dev. Collect your findings in Airtable.' | claude -p --dangerously-skip-permissions",
-        timeout=0, on_stdout=print, on_stderr=print
-    )
-
-if __name__ == "__main__":
-    asyncio.run(main())
-```
-
-</CodeGroup>
-
-## Documentation
-
-<CardGroup cols={2}>
-  <Card title="Quickstart" icon="rocket" href="/docs/mcp/quickstart">
-    Get started with MCP
-  </Card>
-  <Card title="Available servers" icon="server" href="/docs/mcp/available-servers">
-    Browse 200+ pre-built MCP servers
-  </Card>
-  <Card title="Custom templates" icon="cube" href="/docs/mcp/custom-templates">
-    Prepull MCP servers for faster runtime
-  </Card>
-  <Card title="Custom servers" icon="github" href="/docs/mcp/custom-servers">
-    Use custom MCP servers from GitHub
-  </Card>
-  <Card title="Examples" icon="code" href="/docs/mcp/examples">
-    See examples
-  </Card>
-</CardGroup>
diff --git a/docs/mcp/custom-servers.mdx b/docs/mcp/custom-servers.mdx
deleted file mode 100644
index 6549761e..00000000
--- a/docs/mcp/custom-servers.mdx
+++ /dev/null
@@ -1,69 +0,0 @@
----
-title: Custom servers
-description: Use custom MCP servers from GitHub repositories
----
-
-In addition to the 200+ pre-built MCP servers from the [Docker MCP Catalog](https://hub.docker.com/mcp), you can run custom MCP servers directly from public GitHub repositories.
-
-## How it works
-
-When you specify a GitHub repository, E2B will:
-1. Clone the repository into the sandbox
-2. Run the `installCmd` (optional) to install dependencies
-3. Run the `runCmd` to start the MCP server with stdio transport
-
-The `runCmd` must start an MCP server that follows the [MCP specification](https://modelcontextprotocol.io/specification/2025-06-18) and communicates via stdio (standard input/output).
-
-## Using a custom MCP server
-
-<CodeGroup>
-
-```typescript TypeScript
-import Sandbox from 'e2b'
-
-const sandbox = await Sandbox.create({
-    mcp: {
-        'github/modelcontextprotocol/servers': {
-            installCmd: 'npm install',
-            runCmd: 'sudo npx -y @modelcontextprotocol/server-filesystem /root',
-        },
-    },
-});
-```
-
-```python Python
-from e2b import Sandbox
-import os
-
-sbx = Sandbox.create(
-    mcp={
-        "github/modelcontextprotocol/servers": {
-                "install_cmd": "npm install",
-                "run_cmd": "sudo npx -y @modelcontextprotocol/server-filesystem /root",
-        },
-    }
-)
-```
-
-</CodeGroup>
-
-## Configuration
-
-<ParamField path="installCmd" type="string">
-  Optional command to run before starting the MCP server. Use this to install dependencies (e.g., `npm install`, `pip install -r requirements.txt`).
-</ParamField>
-
-<ParamField path="runCmd" type="string" required>
-  Command to start the MCP server. Must launch a stdio-enabled MCP server.
-</ParamField>
-
-<Note>
-**Important for npx-based servers:** Always include `installCmd: 'npm install'` (or equivalent) when using `npx` in your `runCmd`. Without installing dependencies first, npx will try to use the local repository and fail.
-</Note>
-
-## Troubleshooting
-
-If your custom MCP server doesn't work as expected:
-
-1. Explore the sandbox either via the [dashboard](https://e2b.dev/dashboard) or by connecting to it via `e2b connect <sandbox-id>`
-2. Check the gateway log file with `sudo cat /var/log/mcp-gateway/gateway.log`.
\ No newline at end of file
diff --git a/docs/mcp/custom-templates.mdx b/docs/mcp/custom-templates.mdx
deleted file mode 100644
index d23ca86e..00000000
--- a/docs/mcp/custom-templates.mdx
+++ /dev/null
@@ -1,112 +0,0 @@
----
-title: Custom templates
-description: Use MCP servers with custom sandbox templates
----
-
-You can prepull MCP server Docker images during template build time to significantly improve runtime performance.
-## How it works
-
-When you build a template with prepulled MCP servers, the Docker images for those servers are downloaded and cached during the build process. This means when you create a sandbox from that template, the MCP servers are ready to use immediately without waiting for image downloads.
-
-<Info>
-You must use the MCP gateway enabled template (`mcp-gateway`) as your base template to use this feature.
-</Info>
-
-## Building a template with MCP servers
-
-Use the `addMcpServer()` method (TypeScript) or `add_mcp_server()` method (Python) to prepull MCP server images during template build. You can pass a single server or an array of servers.
-
-The server names (like `"browserbase"` and `"exa"`) correspond to the keys defined in the [Available Servers](/docs/mcp/available-servers) documentation.
-
-<CodeGroup>
-
-```typescript JavaScript & TypeScript
-import "dotenv/config";
-import { Template, defaultBuildLogger } from 'e2b';
-
-export const template = Template()
-  .fromTemplate("mcp-gateway")
-  .addMcpServer(["browserbase", "exa"]);
-
-await Template.build(template, 'my-mcp-gateway', {
-  cpuCount: 8,
-  memoryMB: 8192,
-  onBuildLogs: defaultBuildLogger(),
-});
-```
-
-```python Python
-from dotenv import load_dotenv
-from e2b import Template, default_build_logger
-
-load_dotenv()
-
-template = (
-    Template()
-    .from_template("mcp-gateway")
-    .add_mcp_server(["browserbase", "exa"])
-)
-
-Template.build(
-    template,
-    'my-mcp-gateway',
-    cpu_count=8,
-    memory_mb=8192,
-    on_build_logs=default_build_logger(),
-)
-```
-
-</CodeGroup>
-
-## Using the template
-
-Once built, create sandboxes from your template. You still need to provide the configuration for each MCP server.
-
-<CodeGroup>
-
-```typescript JavaScript & TypeScript
-import { Sandbox } from 'e2b';
-
-const sandbox = await Sandbox.create({
-    template: "my-mcp-gateway",
-    mcp: {
-        browserbase: {
-            apiKey: process.env.BROWSERBASE_API_KEY!,
-            geminiApiKey: process.env.GEMINI_API_KEY!,
-            projectId: process.env.BROWSERBASE_PROJECT_ID!,
-        },
-        exa: {
-            apiKey: process.env.EXA_API_KEY!,
-        },
-    },
-});
-
-```
-
-```python Python
-from e2b import Sandbox
-import os
-
-sbx = Sandbox.create(
-    template="my-mcp-gateway",
-    mcp={
-        "browserbase": {
-            "apiKey": os.getenv("BROWSERBASE_API_KEY"),
-            "geminiApiKey": os.getenv("GEMINI_API_KEY"),
-            "projectId": os.getenv("BROWSERBASE_PROJECT_ID"),
-        },
-        "exa": {
-            "apiKey": os.getenv("EXA_API_KEY"),
-        },
-    }
-)
-```
-
-</CodeGroup>
-
-## Learn more
-
-For more information about working with templates, see:
-- [Template Quickstart](/docs/template/quickstart) - Get started with custom templates
-- [Defining Templates](/docs/template/defining-template) - Learn all template configuration options
-- [Template Build](/docs/template/build) - Understand the build process
diff --git a/docs/mcp/examples.mdx b/docs/mcp/examples.mdx
deleted file mode 100644
index a13f35d5..00000000
--- a/docs/mcp/examples.mdx
+++ /dev/null
@@ -1,28 +0,0 @@
----
-title: Examples
-description: Example projects using MCP servers in E2B sandboxes
----
-
-<CardGroup cols={3}>
-  <Card title="Claude Code" icon="terminal" href="https://github.com/e2b-dev/e2b-cookbook/tree/main/examples/mcp-claude-code-js">
-    Claude Code with MCP integration
-  </Card>
-  <Card title="Browserbase" icon="browser" href="https://github.com/e2b-dev/e2b-cookbook/tree/main/examples/mcp-browserbase-js">
-    Web automation agent with Browserbase
-  </Card>
-  <Card title="Groq + Exa" icon="sparkles" href="https://github.com/e2b-dev/e2b-cookbook/tree/main/examples/mcp-groq-exa-js">
-    AI research using Groq and Exa
-  </Card>
-  <Card title="Research agent" icon="magnifying-glass" href="https://github.com/e2b-dev/e2b-cookbook/tree/main/examples/mcp-research-agent-js">
-    Research Agent using the OpenAI Agents framework
-  </Card>
-  <Card title="MCP client" icon="plug" href="https://github.com/e2b-dev/e2b-cookbook/tree/main/examples/mcp-client-js">
-    Basic MCP client connecting to an E2B Sandbox
-  </Card>
-  <Card title="Custom MCP server" icon="server" href="https://github.com/e2b-dev/e2b-cookbook/tree/main/examples/mcp-custom-server-js">
-    Use custom MCP servers installed from GitHub
-  </Card>
-  <Card title="Custom template" icon="box" href="https://github.com/e2b-dev/e2b-cookbook/tree/main/examples/mcp-custom-template-js">
-    Create a custom E2B Sandbox with pre-installed MCP servers
-  </Card>
-</CardGroup>
diff --git a/docs/mcp/quickstart.mdx b/docs/mcp/quickstart.mdx
deleted file mode 100644
index 5cb03677..00000000
--- a/docs/mcp/quickstart.mdx
+++ /dev/null
@@ -1,222 +0,0 @@
----
-title: Quickstart
-description: Get started with MCP integration
----
-
-You can connect to the MCPs running inside the sandbox both from outside and inside the sandbox.
-
-## From outside the sandbox
-
-To connect to the MCPs running inside the sandbox, use the `sandbox.getMcpUrl()` in JavaScript and `sandbox.get_mcp_url()` in Python.
-<CodeGroup>
-```typescript TypeScript
-import Sandbox from 'e2b'
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
-
-const sandbox = await Sandbox.create({
-    mcp: {
-        browserbase: {
-            apiKey: process.env.BROWSERBASE_API_KEY!,
-            geminiApiKey: process.env.GEMINI_API_KEY!,
-            projectId: process.env.BROWSERBASE_PROJECT_ID!,
-        },
-        exa: {
-            apiKey: process.env.EXA_API_KEY!,
-        },
-        notion: {
-            internalIntegrationToken: process.env.NOTION_API_KEY!,
-        },
-    },
-});
-
-const client = new Client({
-    name: 'e2b-mcp-client',
-    version: '1.0.0'
-});
-
-const transport = new StreamableHTTPClientTransport(
-    new URL(sandbox.getMcpUrl()), 
-    {
-        requestInit: {
-            headers: {
-                'Authorization': `Bearer ${await sandbox.getMcpToken()}`
-            }
-        }
-    }
-);
-
-await client.connect(transport);
-
-const tools = await client.listTools();
-console.log('Available tools:', tools.tools.map(t => t.name));
-
-await client.close();
-await sandbox.kill();
-```
-
-```python Python
-import os
-import dotenv
-dotenv.load_dotenv()
-from e2b import AsyncSandbox
-import asyncio
-from datetime import timedelta
-from mcp.client.session import ClientSession
-from mcp.client.streamable_http import streamablehttp_client
-
-async def main():
-    sandbox = await AsyncSandbox.create(
-        mcp={            
-            "browserbase": {
-                "apiKey": os.environ["BROWSERBASE_API_KEY"],
-                "geminiApiKey": os.environ["GEMINI_API_KEY"],
-                "projectId": os.environ["BROWSERBASE_PROJECT_ID"],
-            },
-            "exa": {
-                "apiKey": os.environ["EXA_API_KEY"],
-            },
-            "notion": {
-                "internalIntegrationToken": os.environ["NOTION_API_KEY"],
-            },
-        }
-    )
-
-    async with streamablehttp_client(
-        url=sandbox.get_mcp_url(),
-        headers={"Authorization": f"Bearer {await sandbox.get_mcp_token()}"},
-        timeout=timedelta(seconds=600)
-    ) as (read_stream, write_stream, _):
-        async with ClientSession(read_stream, write_stream) as session:
-            await session.initialize()
-            tools = await session.list_tools()
-            print(f"Available tools: {[tool.name for tool in tools.tools]}")
-    await sandbox.kill()
-
-if __name__ == "__main__":
-    asyncio.run(main())
-```
-</CodeGroup>
-
-## From inside the sandbox
-
-If you need to access the MCP gateway from within the sandbox itself, it's available at:
-```
-http://localhost:50005/mcp
-```
-
-You'll need to include the Authorization header with the MCP token when making requests from inside the sandbox. How that is added depends on the MCP client you use:
-
-## Claude
-
-```
-claude mcp add --transport http e2b-mcp-gateway <url goes here> --header "Authorization: Bearer <token goes here>"
-```
-
-## OpenAI Agents
-
-<CodeGroup>
-```typescript TypeScript
-import { MCPServerStreamableHttp } from '@openai/agents';
-
-const mcp = new MCPServerStreamableHttp({
-    url: mcpUrl,
-    name: 'E2B MCP Gateway',
-    requestInit: {
-        headers: {
-            'Authorization': `Bearer ${await sandbox.getMcpToken()}`
-        }
-    },
-});
-```
-
-```python Python
-import asyncio
-import os
-from e2b import AsyncSandbox
-from agents.mcp import MCPServerStreamableHttp
-
-async def main():
-    async with MCPServerStreamableHttp(
-        name="e2b-mcp-client",
-        params={
-            "url": sandbox.get_mcp_url(),
-            "headers": {"Authorization": f"Bearer {await sandbox.get_mcp_token()}"},
-        },
-    ) as server:
-        tools = await server.list_tools()
-        print("Available tools:", [t.name for t in tools])
-
-    # Clean up
-    await sandbox.kill()
-
-asyncio.run(main())
-```
-</CodeGroup>
-
-## Official MCP client
-
-<CodeGroup>
-```typescript Typescript
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
-
-const client = new Client({
-    name: 'e2b-mcp-client',
-    version: '1.0.0'
-});
-
-const transport = new StreamableHTTPClientTransport(
-    new URL(sandbox.getMcpUrl()), 
-    {
-        requestInit: {
-            headers: {
-                'Authorization': `Bearer ${await sandbox.getMcpToken()}`
-            }
-        }
-    }
-);
-await client.connect(transport);
-```
-```python Python
-import asyncio
-from datetime import timedelta
-from mcp.client.session import ClientSession
-from mcp.client.streamable_http import streamablehttp_client
-
-async def main():
-    async with streamablehttp_client(
-        url=sandbox.get_mcp_url(),
-        headers={"Authorization": f"Bearer {await sandbox.get_mcp_token()}"},
-        timeout=timedelta(seconds=600)
-    ) as (read_stream, write_stream, _):
-        async with ClientSession(read_stream, write_stream) as session:
-            await session.initialize()
-            
-            tools = await session.list_tools()
-            print(f"Available tools: {[tool.name for tool in tools.tools]}")
-    await sandbox.kill()
-
-if __name__ == "__main__":
-    asyncio.run(main())
-
-```
-
-</CodeGroup>
-
-This list is not exhaustive. You can find more examples in the [E2B Cookbook](https://github.com/e2b-dev/e2b-cookbook).
-
-
-## Debugging with MCP Inspector
-
-The [MCP Inspector](https://github.com/modelcontextprotocol/inspector) is a useful tool for debugging and testing your MCP server setup. Get the command to run:
-
-```bash
-npx @modelcontextprotocol/inspector --transport http --url <your-mcp-url> --header "Authorization: Bearer ${mcpToken}"
-```
-
-Run the command in your terminal. This will open a web interface where you can:
-- Browse available tools
-- Test tool calls with different parameters
-- Inspect request/response payloads
-- Debug connection issues
diff --git a/docs/migration/v2.mdx b/docs/migration/v2.mdx
index 5d06336b..3560c644 100644
--- a/docs/migration/v2.mdx
+++ b/docs/migration/v2.mdx
@@ -63,7 +63,7 @@ sandbox = Sandbox.create(secure=False)  # Explicitly disable
 ```
 </CodeGroup>
 
-Check more details in the [secured access documentation](/docs/sandbox/secured-access).
+Check more details in the [secured access documentation](/docs/sandbox/security#secured-access).
 
 ### 3. File writing in Python SDK
 
diff --git a/docs/sandbox.mdx b/docs/sandbox.mdx
index 6c37ccd3..7bdb23d4 100644
--- a/docs/sandbox.mdx
+++ b/docs/sandbox.mdx
@@ -1,136 +1,120 @@
 ---
-title: "Sandbox lifecycle"
-sidebarTitle: Lifecycle
+title: "Sandbox"
+sidebarTitle: Overview
+icon: "cube"
+description: "E2B sandboxes are persistent, secure cloud environments for AI agents — with pause/resume, snapshots, and auto-resume built in."
 ---
 
-Sandboxes stay running as long as you need them. When their timeout expires, they can automatically pause to save resources — preserving their full state so you can resume at any time. You can also configure an explicit timeout or shut down a sandbox manually.
+An E2B sandbox is a persistent, secure cloud environment where your AI agents execute code, run commands, manage files, and access the internet. Every sandbox supports **pause and resume** — when a sandbox times out, it can automatically pause and preserve its full state (filesystem and memory), then resume exactly where it left off when activity arrives.
 
-<Note>
-Sandboxes can run continuously for up to 24 hours (Pro) or 1 hour (Base). For longer workloads, use [pause and resume](/docs/sandbox/persistence) — pausing resets the runtime window, and your sandbox's full state is preserved indefinitely.
-</Note>
-
-<CodeGroup>
-```js JavaScript & TypeScript highlight={6}
-import { Sandbox } from '@e2b/code-interpreter'
-
-// Create sandbox with and keep it running for 60 seconds.
-// 🚨 Note: The units are milliseconds.
-const sandbox = await Sandbox.create({
-  timeoutMs: 60_000,
-})
-```
-```python Python highlight={6}
-from e2b_code_interpreter import Sandbox
-
-# Create sandbox with and keep it running for 60 seconds.
-# 🚨 Note: The units are seconds.
-sandbox = Sandbox.create(
-  timeout=60,
-)
-```
-</CodeGroup>
+```mermaid actions={false}
+flowchart TD
+    start(( )) -->|Sandbox.create| Running
 
+    Running["<b>Running</b><br/>• Active execution<br/>• Consumes resources"]
+    Paused["<b>Paused</b><br/>• Preserves memory and files<br/>• Cannot execute code"]
+    Snapshotting["<b>Snapshotting</b><br/>• Creates persistent snapshot<br/>• Briefly pauses execution"]
+    Killed["<b>Killed</b><br/>• Resources released<br/>• Cannot be resumed"]
 
-## Change sandbox timeout during runtime
-
-You can change the sandbox timeout when it's running by calling the `setTimeout` method in JavaScript or `set_timeout` method in Python.
-
-When you call the set timeout method, the sandbox timeout will be reset to the new value that you specified.
-
-This can be useful if you want to extend the sandbox lifetime when it's already running.
-You can for example start with a sandbox with 1 minute timeout and then periodically call set timeout every time user interacts with it in your app.
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Sandbox } from '@e2b/code-interpreter'
-
-// Create sandbox with and keep it running for 60 seconds.
-const sandbox = await Sandbox.create({ timeoutMs: 60_000 })
-
-// Change the sandbox timeout to 30 seconds.
-// 🚨 The new timeout will be 30 seconds from now.
-await sandbox.setTimeout(30_000)
+    Running -->|pause| Paused
+    Running -->|createSnapshot| Snapshotting
+    Paused -->|connect| Running
+    Snapshotting -->|snapshot complete| Running
+    Running -->|kill| Killed
+    Paused -->|kill| Killed
 ```
-```python Python
-from e2b_code_interpreter import Sandbox
 
-# Create sandbox with and keep it running for 60 seconds.
-sandbox = Sandbox.create(timeout=60)
-
-# Change the sandbox timeout to 30 seconds.
-# 🚨 The new timeout will be 30 seconds from now.
-sandbox.set_timeout(30)
-```
-</CodeGroup>
+## Key characteristics
 
-## Retrieve sandbox information
+- **Persistent by default** — configure `onTimeout: 'pause'` and sandboxes preserve their full state (filesystem + memory) indefinitely. Resume at any time.
+- **Auto-resume** — when [enabled](/docs/sandbox/persistence#auto-pause-and-auto-resume), paused sandboxes wake automatically when SDK calls or HTTP traffic arrive. No manual state management needed.
+- **Snapshots** — capture a running sandbox's state and spawn multiple new sandboxes from it. Useful for checkpointing, forking, and rollback.
+- **Configurable timeouts** — sandboxes run for up to 24 hours (Pro) or 1 hour (Base) continuously. Pausing resets the runtime window.
+- **Isolated and secure** — each sandbox runs in its own microVM with network controls, access tokens, and rate limits.
 
-You can retrieve sandbox information like sandbox ID, template, metadata, started at/end at date by calling the `getInfo` method in JavaScript or `get_info` method in Python.
+## Quick setup: persistent sandbox
 
 <CodeGroup>
 ```js JavaScript & TypeScript
-import { Sandbox } from '@e2b/code-interpreter'
-
-// Create sandbox with and keep it running for 60 seconds.
-const sandbox = await Sandbox.create({ timeoutMs: 60_000 })
-
-// Retrieve sandbox information.
-const info = await sandbox.getInfo()
+import { Sandbox } from 'e2b'
 
-console.log(info)
+const sandbox = await Sandbox.create({
+  timeoutMs: 5 * 60 * 1000,
+  lifecycle: {
+    onTimeout: 'pause',     // pause instead of kill on timeout
+    autoResume: true,        // wake on activity
+  },
+})
 
-// {
-//   "sandboxId": "iiny0783cype8gmoawzmx-ce30bc46",
-//   "templateId": "rki5dems9wqfm4r03t7g",
-//   "name": "base",
-//   "metadata": {},
-//   "startedAt": "2025-03-24T15:37:58.076Z",
-//   "endAt": "2025-03-24T15:42:58.076Z"
-// }
+// Use the sandbox — it auto-pauses when idle, auto-resumes when needed
+const result = await sandbox.commands.run('echo "Hello from a persistent sandbox"')
+console.log(result.stdout)
 ```
-
 ```python Python
-from e2b_code_interpreter import Sandbox
+from e2b import Sandbox
 
-# Create sandbox with and keep it running for 60 seconds.
-sandbox = Sandbox.create(timeout=60)
-
-# Retrieve sandbox information.
-info = sandbox.get_info()
-
-print(info)
+sandbox = Sandbox.create(
+    timeout=5 * 60,
+    lifecycle={
+        "on_timeout": "pause",   # pause instead of kill on timeout
+        "auto_resume": True,     # wake on activity
+    },
+)
 
-# SandboxInfo(sandbox_id='ig6f1yt6idvxkxl562scj-419ff533',
-#   template_id='u7nqkmpn3jjf1tvftlsu',
-#   name='base',
-#   metadata={},
-#   started_at=datetime.datetime(2025, 3, 24, 15, 42, 59, 255612, tzinfo=tzutc()),
-#   end_at=datetime.datetime(2025, 3, 24, 15, 47, 59, 255612, tzinfo=tzutc())
-# )
+# Use the sandbox — it auto-pauses when idle, auto-resumes when needed
+result = sandbox.commands.run('echo "Hello from a persistent sandbox"')
+print(result.stdout)
 ```
 </CodeGroup>
 
-## Shutdown sandbox
-
-You can shutdown the sandbox any time even before the timeout is up by calling the `kill` method.
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Sandbox } from '@e2b/code-interpreter'
-
-// Create sandbox with and keep it running for 60 seconds.
-const sandbox = await Sandbox.create({ timeoutMs: 60_000 })
-
-// Shutdown the sandbox immediately.
-await sandbox.kill()
-```
-```python Python
-from e2b_code_interpreter import Sandbox
-
-# Create sandbox with and keep it running for 60 seconds.
-sandbox = Sandbox.create(timeout=60)
-
-# Shutdown the sandbox immediately.
-sandbox.kill()
-```
-</CodeGroup>
+## Core
+
+<CardGroup cols={2}>
+  <Card title="Managing sandboxes" icon="list-check" href="/docs/sandbox/lifecycle">
+    Timeouts, sandbox info, metadata, listing, filtering, and shutdown.
+  </Card>
+  <Card title="Pause, resume & snapshots" icon="pause" href="/docs/sandbox/persistence">
+    Pause/resume, auto-pause, auto-resume, snapshots, and state transitions.
+  </Card>
+  <Card title="Commands" icon="terminal" href="/docs/sandbox/commands">
+    Run commands, stream output, interactive terminal (PTY), and SSH access.
+  </Card>
+  <Card title="Filesystem" icon="folder" href="/docs/sandbox/filesystem">
+    Read, write, upload, download files and watch for changes.
+  </Card>
+  <Card title="Volumes" icon="hard-drive" href="/docs/sandbox/volumes">
+    Persistent storage that survives sandbox lifecycle.
+  </Card>
+  <Card title="MCP gateway" icon="plug" href="/docs/sandbox/mcp">
+    Connect to 200+ tools through the Model Context Protocol.
+  </Card>
+  <Card title="Environment variables" icon="key" href="/docs/sandbox/environment-variables">
+    Default metadata, global variables, and per-command overrides.
+  </Card>
+  <Card title="Connect storage bucket" icon="bucket" href="/docs/sandbox/connect-bucket">
+    Mount GCS, S3, or R2 buckets inside sandboxes.
+  </Card>
+  <Card title="Security" icon="shield" href="/docs/sandbox/security">
+    Secured access, network controls, and rate limits.
+  </Card>
+  <Card title="Observability" icon="chart-line" href="/docs/sandbox/observability">
+    Metrics, lifecycle events API, and webhooks.
+  </Card>
+</CardGroup>
+
+## Guides
+
+<CardGroup cols={3}>
+  <Card title="Runtime customization" icon="sliders" href="/docs/sandbox/runtime-customization">
+    Install packages, upload files, and configure sandboxes dynamically.
+  </Card>
+  <Card title="Git integration" icon="code-branch" href="/docs/sandbox/git-integration">
+    Clone repos, manage branches, push changes.
+  </Card>
+  <Card title="Proxy tunneling" icon="network-wired" href="/docs/sandbox/proxy-tunneling">
+    Route sandbox traffic through a proxy server.
+  </Card>
+  <Card title="Custom domain" icon="globe" href="/docs/sandbox/custom-domain">
+    Set up a custom domain for sandbox access.
+  </Card>
+</CardGroup>
diff --git a/docs/sandbox/auto-resume.mdx b/docs/sandbox/auto-resume.mdx
deleted file mode 100644
index b2d28a95..00000000
--- a/docs/sandbox/auto-resume.mdx
+++ /dev/null
@@ -1,328 +0,0 @@
----
-title: "AutoResume"
-sidebarTitle: AutoResume
----
-
-Many workloads don't need a sandbox running all the time, but when they do need it, it should just work, whether it was paused or not.
-
-`AutoResume` handles this automatically: a paused sandbox wakes up when activity arrives, so your code does not have to check or manage sandbox state.
-Configure it through the `lifecycle` object when creating a sandbox.
-
-## Configure lifecycle on create
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Sandbox } from 'e2b'
-
-const sandbox = await Sandbox.create({
-  timeoutMs: 10 * 60 * 1000,
-  lifecycle: {
-    onTimeout: 'pause',
-    autoResume: true, // resume when activity arrives
-  },
-})
-```
-```python Python
-from e2b import Sandbox
-
-sandbox = Sandbox.create(
-    timeout=10 * 60,
-    lifecycle={
-        "on_timeout": "pause",
-        "auto_resume": True,  # resume when activity arrives
-    },
-)
-```
-</CodeGroup>
-
-## Lifecycle options
-
-- `onTimeout` / `on_timeout`
-  - `kill` (default): sandbox is terminated when timeout is reached
-  - `pause`: sandbox is paused when timeout is reached
-- `autoResume` / `auto_resume`
-  - `false` (default): paused sandboxes do not auto-resume
-  - `true`: paused sandboxes auto-resume on activity
-  - `true` is valid only when `onTimeout`/`on_timeout` is `pause`
-
-## Behavior summary
-
-- Default behavior is equivalent to `onTimeout: "kill"` with `autoResume: false`.
-- `onTimeout: "pause"` with `autoResume: false` gives auto-pause without auto-resume.
-- `onTimeout: "pause"` with `autoResume: true` gives auto-pause with auto-resume.
-- [`Sandbox.connect()`](/docs/sandbox/connect) can still be used to resume a paused sandbox manually.
-
-If you use `autoResume: false`, resume explicitly with [`Sandbox.connect()`](/docs/sandbox/connect).
-
-## Timeout after auto-resume
-
-When a sandbox auto-resumes, it restarts with a **5-minute minimum timeout**. If you originally created the sandbox with a longer timeout, that value carries over.
-The countdown begins from the moment the sandbox resumes, not from when it was first created.
-
-For example, if you create a sandbox with a 2-minute timeout:
-
-1. The sandbox runs for 2 minutes, then pauses.
-2. Activity arrives and the sandbox auto-resumes.
-3. A 5-minute timeout starts (the 5-minute minimum applies because the original timeout was shorter).
-4. If no further activity resets the timeout, the sandbox pauses again after 5 minutes.
-
-If you create a sandbox with a 1-hour timeout, the auto-resume timeout will also be 1 hour, since it exceeds the 5-minute minimum.
-
-This cycle repeats every time the sandbox auto-resumes — the lifecycle configuration (`onTimeout: "pause"` + `autoResume: true`) is persistent across pause/resume cycles.
-
-<Note>
-You can change the timeout after the sandbox resumes by calling `setTimeout`/`set_timeout`. See [Change sandbox timeout during runtime](/docs/sandbox#change-sandbox-timeout-during-runtime).
-</Note>
-
-## What counts as activity
-
-Auto-resume is triggered by the sandbox activity - that's both HTTP traffic and controlling the sandbox from the SDK.
-
-That includes SDK operations like:
-- `sandbox.commands.run(...)`
-- `sandbox.files.read(...)`
-- `sandbox.files.write(...)`
-- opening a tunneled app URL or sending requests to a service running inside the sandbox
-
-If a sandbox is paused and `autoResume` is enabled, the next supported operation resumes it automatically. You do not need to call [`Sandbox.connect()`](/docs/sandbox/connect) first.
-
-### SDK example: pause, then read a file
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Sandbox } from 'e2b'
-
-const sandbox = await Sandbox.create({
-  timeoutMs: 10 * 60 * 1000,
-  lifecycle: {
-    onTimeout: 'pause',
-    autoResume: true,
-  },
-})
-
-await sandbox.files.write('/home/user/hello.txt', 'hello from a paused sandbox')
-await sandbox.pause()
-
-const content = await sandbox.files.read('/home/user/hello.txt')
-console.log(content)
-console.log(`State after read: ${(await sandbox.getInfo()).state}`)
-```
-```python Python
-from e2b import Sandbox
-
-sandbox = Sandbox.create(
-    timeout=10 * 60,
-    lifecycle={
-        "on_timeout": "pause",
-        "auto_resume": True,
-    },
-)
-
-sandbox.files.write("/home/user/hello.txt", "hello from a paused sandbox")
-sandbox.pause()
-
-content = sandbox.files.read("/home/user/hello.txt")
-print(content)
-print(f"State after read: {sandbox.get_info().state}")
-```
-</CodeGroup>
-
-## Use cases
-
-### Web and dev/preview servers
-
-Use `onTimeout: "pause"` + `autoResume: true` so inbound traffic can wake a paused sandbox automatically.
-This works for both:
-- Basic web/API servers
-- Dev or preview servers you open occasionally
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Sandbox } from 'e2b'
-
-const sandbox = await Sandbox.create({
-  timeoutMs: 10 * 60 * 1000,
-  lifecycle: {
-    onTimeout: 'pause',
-    autoResume: true,
-  },
-})
-
-await sandbox.commands.run(
-  `python3 -m pip -q install 'flask>=2.2'`
-)
-
-await sandbox.files.write(
-  '/home/user/app.py',
-  [
-    'from flask import Flask',
-    'app = Flask(__name__)',
-    '@app.route("/")',
-    'def hello():',
-    '    return "Hello, World!"',
-    'app.run(host="0.0.0.0", port=3000)',
-    '',
-  ].join('\n')
-)
-
-await sandbox.commands.run(
-  'python3 -u /home/user/app.py > /home/user/flask.log 2>&1',
-  { background: true }
-)
-
-await new Promise((resolve) => setTimeout(resolve, 1000))
-
-const previewHost = sandbox.getHost(3000)
-console.log(`Preview URL: https://${previewHost}`)
-
-console.log(`Status before pause: ${(await sandbox.getInfo()).state}`)
-await sandbox.pause()
-console.log(`Status after pause: ${(await sandbox.getInfo()).state}`)
-```
-```python Python
-import time
-
-from e2b import Sandbox
-
-sandbox = Sandbox.create(
-    timeout=10 * 60,
-    lifecycle={
-        "on_timeout": "pause",
-        "auto_resume": True,
-    },
-)
-
-sandbox.commands.run("python3 -m pip -q install 'flask>=2.2'")
-
-sandbox.files.write(
-    "/home/user/app.py",
-    'from flask import Flask\n'
-    'app = Flask(__name__)\n'
-    '@app.route("/")\n'
-    'def hello():\n'
-    '    return "Hello, World!"\n'
-    'app.run(host="0.0.0.0", port=3000)\n'
-)
-
-sandbox.commands.run(
-    "python3 -u /home/user/app.py > /home/user/flask.log 2>&1",
-    background=True,
-)
-
-time.sleep(1)
-
-preview_host = sandbox.get_host(3000)
-print(f"Preview URL: https://{preview_host}")
-
-print(f"Status before pause: {sandbox.get_info().state}")
-sandbox.pause()
-print(f"Status after pause: {sandbox.get_info().state}")
-```
-</CodeGroup>
-
-### Agent/tool execution
-
-For queued tasks or tool calls, create once and keep using the same sandbox handle. If it is paused, it will auto-resume when you run the next command.
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Sandbox } from 'e2b'
-
-// One-time setup
-const sandbox = await Sandbox.create({
-  timeoutMs: 5 * 60 * 1000,
-  lifecycle: {
-    onTimeout: 'pause',
-    autoResume: true,
-  },
-})
-
-// Later: called for each agent/tool task
-async function runToolTask(command) {
-  const result = await sandbox.commands.run(command)
-  return result.stdout
-}
-
-console.log(await runToolTask('python -c "print(2 + 2)"'))
-```
-```python Python
-from e2b import Sandbox
-
-# One-time setup
-sandbox = Sandbox.create(
-    timeout=5 * 60,
-    lifecycle={
-        "on_timeout": "pause",
-        "auto_resume": True,
-    },
-)
-
-# Later: called for each agent/tool task
-def run_tool_task(command: str) -> str:
-    result = sandbox.commands.run(command)
-    return result.stdout
-
-print(run_tool_task('python -c "print(2 + 2)"'))
-```
-</CodeGroup>
-
-### Per-user sandboxes
-
-For multi-tenant apps, keep a map of sandbox IDs by user. On each request, connect to the user's existing sandbox (which auto-resumes if paused) or create a new one.
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Sandbox } from 'e2b'
-
-const userSandboxes = new Map() // userId → Sandbox
-
-async function getSandbox(userId) {
-  let sandbox = userSandboxes.get(userId)
-
-  if (!sandbox) {
-    sandbox = await Sandbox.create({
-      timeoutMs: 5 * 60 * 1000,
-      lifecycle: {
-        onTimeout: 'pause',
-        autoResume: true,
-      },
-    })
-    userSandboxes.set(userId, sandbox)
-  }
-
-  return sandbox
-}
-
-// On each user request (auto-resumes if paused)
-const sandbox = await getSandbox('user-123')
-const result = await sandbox.commands.run('echo "Hello from your sandbox"')
-console.log(result.stdout)
-```
-```python Python
-from e2b import Sandbox
-
-user_sandboxes: dict[str, Sandbox] = {}  # user_id → Sandbox
-
-def get_sandbox(user_id: str) -> Sandbox:
-    if user_id not in user_sandboxes:
-        user_sandboxes[user_id] = Sandbox.create(
-            timeout=5 * 60,
-            lifecycle={
-                "on_timeout": "pause",
-                "auto_resume": True,
-            },
-        )
-
-    return user_sandboxes[user_id]
-
-# On each user request (auto-resumes if paused)
-sandbox = get_sandbox("user-123")
-result = sandbox.commands.run('echo "Hello from your sandbox"')
-print(result.stdout)
-```
-</CodeGroup>
-
-## Cleanup
-Auto-resume is persistent, meaning if your sandbox resumes and later times out again, it will pause again.
-Each time the sandbox resumes, it gets a fresh timeout (at least 5 minutes, or longer if the original creation timeout exceeds that) — so the sandbox keeps cycling between running and paused as long as activity arrives.
-If you call `.kill()`, the sandbox is permanently deleted and cannot be resumed.
diff --git a/docs/sandbox/cli.mdx b/docs/sandbox/cli.mdx
new file mode 100644
index 00000000..4c5180e5
--- /dev/null
+++ b/docs/sandbox/cli.mdx
@@ -0,0 +1,192 @@
+---
+title: "CLI"
+sidebarTitle: "CLI"
+icon: "rectangle-terminal"
+description: "Use the E2B CLI to create, connect, manage, and debug sandboxes from your terminal."
+---
+
+The E2B CLI lets you create, connect to, and manage sandboxes directly from your terminal. It's also used to manage [templates](/docs/template/quickstart).
+
+## Installation
+
+**Using Homebrew (on macOS)**
+
+```bash
+brew install e2b
+```
+
+**Using NPM**
+
+```bash
+npm i -g @e2b/cli
+```
+
+## Authentication
+
+There are two ways to authenticate with the E2B CLI:
+
+### Browser authentication
+
+<Warning>
+This option requires an interactive browser environment.
+</Warning>
+
+Run the following command to sign in through your browser:
+
+```bash
+e2b auth login
+```
+
+This will open your default browser and prompt you to authenticate with your E2B account.
+
+### Environment variables
+
+Set your environment variables:
+
+```bash
+export E2B_API_KEY=your_api_key_here
+export E2B_ACCESS_TOKEN=your_access_token_here
+```
+
+<Info>
+Learn more about obtaining and managing your API key and access token on the [API Key page](/docs/api-key).
+</Info>
+
+## Create a sandbox
+
+Create a sandbox and connect an interactive terminal to it.
+
+```bash
+e2b sandbox create <template>
+```
+
+For example, to create a sandbox from the `base` template:
+
+```bash
+e2b sandbox create base
+```
+
+This will:
+1. Create a new sandbox from the specified template
+2. Connect your terminal to the sandbox
+3. Keep the sandbox alive while you're connected
+4. Automatically kill the sandbox when you exit the terminal
+
+Once connected, you can inspect the sandbox filesystem and processes to debug or experiment, or use it as a dedicated environment for running agents instead of your local computer.
+
+## Connect to a sandbox
+
+Connect an interactive terminal to an already running sandbox.
+
+```bash
+e2b sandbox connect <sandbox-id>
+```
+
+Unlike the `create` command, `connect` does not kill the sandbox when you disconnect. When you exit the terminal, only your terminal session is closed — the sandbox continues running.
+
+## Execute commands
+
+Execute commands in a running sandbox.
+
+```bash
+e2b sandbox exec <sandbox-id> <command>
+```
+
+### Pipe from stdin
+
+```bash
+echo "foo" | e2b sandbox exec <sandbox-id> <command>
+```
+
+### Run in background
+
+Use the `--background` flag to run a command in the background and return immediately. The command will print the process ID (PID) to stderr:
+
+```bash
+e2b sandbox exec --background <sandbox-id> "sleep 60 && echo done"
+```
+
+### Set working directory
+
+```bash
+e2b sandbox exec --cwd /home/user <sandbox-id> ls
+```
+
+### Run as specific user
+
+```bash
+e2b sandbox exec --user root <sandbox-id> apt-get update
+```
+
+### Set environment variables
+
+Use the `--env` flag to set environment variables. This flag can be repeated for multiple variables:
+
+```bash
+e2b sandbox exec --env NODE_ENV=production --env DEBUG=true <sandbox-id> node app.js
+```
+
+## List sandboxes
+
+List all sandboxes:
+
+```bash
+e2b sandbox list
+```
+
+This returns running sandboxes by default. Use `--state` to filter by state.
+
+### Filter by state
+
+```bash
+e2b sandbox list --state running,paused
+```
+
+### Filter by metadata
+
+```bash
+e2b sandbox list --metadata key1=value1,key2=value2
+```
+
+### Limit results
+
+```bash
+e2b sandbox list --limit 10
+```
+
+### Output format
+
+```bash
+# Pretty print (default)
+e2b sandbox list --format pretty
+
+# JSON
+e2b sandbox list --format json
+```
+
+## Shutdown sandboxes
+
+### Shutdown specific sandboxes
+
+```bash
+e2b sandbox kill <sandbox-id1> <sandbox-id2> <sandbox-id3>
+```
+
+### Shutdown all sandboxes
+
+```bash
+e2b sandbox kill --all
+```
+
+You can filter which sandboxes to shut down by state, metadata, or both:
+
+```bash
+# By state
+e2b sandbox kill --all --state=running,paused
+
+# By metadata
+e2b sandbox kill --all --metadata=key=value
+
+# Both
+e2b sandbox kill --all --state=running,paused --metadata=key=value
+```
diff --git a/docs/sandbox/commands.mdx b/docs/sandbox/commands.mdx
new file mode 100644
index 00000000..ba8ed25e
--- /dev/null
+++ b/docs/sandbox/commands.mdx
@@ -0,0 +1,636 @@
+---
+title: "Commands & terminal"
+sidebarTitle: Commands
+icon: "terminal"
+description: "Run commands, use interactive terminals, and connect via SSH in E2B sandboxes."
+---
+
+E2B sandboxes provide multiple ways to run commands and interact with the terminal: `commands.run()` for executing commands, the PTY module for interactive terminal sessions, and SSH access for remote connectivity.
+
+## Running commands
+
+Use `commands.run()` to execute terminal commands inside the sandbox.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create()
+const result = await sandbox.commands.run('ls -l')
+console.log(result)
+```
+```python Python
+from e2b import Sandbox
+
+sandbox = Sandbox.create()
+result = sandbox.commands.run('ls -l')
+print(result)
+```
+</CodeGroup>
+
+### Streaming output
+
+To stream command output as it is being executed, pass `onStdout`/`onStderr` callbacks (JavaScript) or `on_stdout`/`on_stderr` callbacks (Python).
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create()
+
+const result = await sandbox.commands.run('echo hello; sleep 1; echo world', {
+  onStdout: (data) => {
+    console.log(data)
+  },
+  onStderr: (data) => {
+    console.log(data)
+  },
+})
+console.log(result)
+```
+```python Python
+from e2b import Sandbox
+
+sandbox = Sandbox.create()
+
+result = sandbox.commands.run('echo hello; sleep 1; echo world', on_stdout=lambda data: print(data), on_stderr=lambda data: print(data))
+print(result)
+```
+</CodeGroup>
+
+### Running commands in background
+
+To run commands in background, pass the `background` option. This returns immediately and the command continues running in the sandbox. You can later kill the command using `commands.kill()`.
+
+<CodeGroup>
+```js JavaScript & TypeScript highlight={7}
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create()
+
+// Start the command in the background
+const command = await sandbox.commands.run('echo hello; sleep 10; echo world', {
+  background: true,
+  onStdout: (data) => {
+    console.log(data)
+  },
+})
+
+// Kill the command
+await command.kill()
+```
+```python Python highlight={6}
+from e2b import Sandbox
+
+sandbox = Sandbox.create()
+
+# Start the command in the background
+command = sandbox.commands.run('echo hello; sleep 10; echo world', background=True)
+
+# Get stdout and stderr from the command running in the background.
+# You can run this code in a separate thread or use command.wait() to wait for the command to finish.
+for stdout, stderr, _ in command:
+    if stdout:
+        print(stdout)
+    if stderr:
+        print(stderr)
+
+# Kill the command
+command.kill()
+```
+</CodeGroup>
+
+### Listing running processes
+
+Use `commands.list()` to get all running processes in the sandbox, including background commands and PTY sessions.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create()
+
+// Start a background process
+const cmd = await sandbox.commands.run('sleep 300', { background: true })
+
+// List all running processes
+const processes = await sandbox.commands.list()
+for (const proc of processes) {
+  console.log(`PID: ${proc.pid}, Command: ${proc.cmd}`)
+}
+
+// Kill a process by PID
+await sandbox.commands.kill(processes[0].pid)
+```
+```python Python
+from e2b import Sandbox
+
+sandbox = Sandbox.create()
+
+# Start a background process
+cmd = sandbox.commands.run("sleep 300", background=True)
+
+# List all running processes
+processes = sandbox.commands.list()
+for proc in processes:
+    print(f"PID: {proc.pid}, Command: {proc.cmd}")
+
+# Kill a process by PID
+sandbox.commands.kill(processes[0].pid)
+```
+</CodeGroup>
+
+<Note>
+Background commands started with `commands.run()` appear as `/bin/bash` in the `cmd` field, not the inner command string. Only currently running processes are returned — exited or killed processes are not included.
+</Note>
+
+## Interactive terminal (PTY)
+
+The PTY (pseudo-terminal) module allows you to create interactive terminal sessions in the sandbox with real-time, bidirectional communication.
+
+Unlike `commands.run()` which executes a command and returns output after completion, PTY provides:
+- **Real-time streaming** - Output is streamed as it happens via callbacks
+- **Bidirectional input** - Send input while the terminal is running
+- **Interactive shell** - Full terminal support with ANSI colors and escape sequences
+- **Session persistence** - Disconnect and reconnect to running sessions
+
+### Create a PTY session
+
+Use `sandbox.pty.create()` to start an interactive bash shell.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create()
+
+const terminal = await sandbox.pty.create({
+  cols: 80,              // Terminal width in characters
+  rows: 24,              // Terminal height in characters
+  onData: (data) => {
+    // Called whenever terminal outputs data
+    process.stdout.write(data)
+  },
+  envs: { MY_VAR: 'hello' },  // Optional environment variables
+  cwd: '/home/user',          // Optional working directory
+  user: 'root',               // Optional user to run as
+})
+
+// terminal.pid contains the process ID
+console.log('Terminal PID:', terminal.pid)
+```
+
+```python Python
+from e2b import Sandbox
+
+sandbox = Sandbox()
+
+terminal = sandbox.pty.create(
+    cols=80,              # Terminal width in characters
+    rows=24,              # Terminal height in characters
+    on_data=lambda data: print(data.decode(), end=''),  # end='' prevents print from adding extra newline
+    envs={'MY_VAR': 'hello'},  # Optional environment variables
+    cwd='/home/user',          # Optional working directory
+    user='root',               # Optional user to run as
+)
+
+# terminal.pid contains the process ID
+print('Terminal PID:', terminal.pid)
+```
+</CodeGroup>
+
+<Note>
+The PTY runs an interactive bash shell with `TERM=xterm-256color`, which supports ANSI colors and escape sequences.
+</Note>
+
+### Timeout
+
+PTY sessions have a configurable timeout that controls the session duration. The default is 60 seconds. For interactive or long-running sessions, set `timeoutMs: 0` (JavaScript) or `timeout=0` (Python) to keep the session open indefinitely.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create()
+
+const terminal = await sandbox.pty.create({
+  cols: 80,
+  rows: 24,
+  onData: (data) => process.stdout.write(data),
+  timeoutMs: 0,  // Keep the session open indefinitely
+})
+```
+
+```python Python
+from e2b import Sandbox
+
+sandbox = Sandbox()
+
+# end='' prevents print() from adding an extra newline
+# (PTY output already contains newlines)
+terminal = sandbox.pty.create(
+    cols=80,
+    rows=24,
+    on_data=lambda data: print(data.decode(), end=''),
+    timeout=0,  # Keep the session open indefinitely
+)
+```
+</CodeGroup>
+
+### Send input to PTY
+
+Use `sendInput()` in JavaScript or `send_stdin()` in Python to send data to the terminal. These methods return a Promise (JavaScript) or complete synchronously (Python) - the actual output will be delivered to your `onData` callback.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create()
+
+const terminal = await sandbox.pty.create({
+  cols: 80,
+  rows: 24,
+  onData: (data) => process.stdout.write(data),
+})
+
+// Send a command (don't forget the newline!)
+await sandbox.pty.sendInput(
+  terminal.pid,
+  new TextEncoder().encode('echo "Hello from PTY"\n')
+)
+```
+
+```python Python
+from e2b import Sandbox
+
+sandbox = Sandbox()
+
+terminal = sandbox.pty.create(
+    cols=80,
+    rows=24,
+    on_data=lambda data: print(data.decode(), end=''),  # end='' prevents extra newline
+)
+
+# Send a command as bytes (b'...' is Python's byte string syntax)
+# Don't forget the newline!
+sandbox.pty.send_stdin(terminal.pid, b'echo "Hello from PTY"\n')
+```
+</CodeGroup>
+
+### Resize the terminal
+
+When the user's terminal window changes size, notify the PTY with `resize()`. The `cols` and `rows` parameters are measured in characters, not pixels.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create()
+
+const terminal = await sandbox.pty.create({
+  cols: 80,
+  rows: 24,
+  onData: (data) => process.stdout.write(data),
+})
+
+// Resize to new dimensions (in characters)
+await sandbox.pty.resize(terminal.pid, {
+  cols: 120,
+  rows: 40,
+})
+```
+
+```python Python
+from e2b import Sandbox
+
+sandbox = Sandbox()
+
+terminal = sandbox.pty.create(
+    cols=80,
+    rows=24,
+    on_data=lambda data: print(data.decode(), end=''),  # end='' prevents extra newline
+)
+
+# Resize to new dimensions (in characters)
+sandbox.pty.resize(terminal.pid, cols=120, rows=40)
+```
+</CodeGroup>
+
+### Disconnect and reconnect
+
+You can disconnect from a PTY session while keeping it running, then reconnect later with a new data handler. This is useful for resuming terminal sessions after network interruptions, sharing terminal access between multiple clients, or implementing terminal session persistence.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create()
+
+// Create a PTY session
+const terminal = await sandbox.pty.create({
+  cols: 80,
+  rows: 24,
+  onData: (data) => console.log('Handler 1:', new TextDecoder().decode(data)),
+})
+
+const pid = terminal.pid
+
+// Send a command
+await sandbox.pty.sendInput(pid, new TextEncoder().encode('echo hello\n'))
+
+// Disconnect - PTY keeps running in the background
+await terminal.disconnect()
+
+// Later: reconnect with a new data handler
+const reconnected = await sandbox.pty.connect(pid, {
+  onData: (data) => console.log('Handler 2:', new TextDecoder().decode(data)),
+})
+
+// Continue using the session
+await sandbox.pty.sendInput(pid, new TextEncoder().encode('echo world\n'))
+
+// Wait for the terminal to exit
+await reconnected.wait()
+```
+
+```python Python
+import time
+from e2b import Sandbox
+
+sandbox = Sandbox()
+
+# Create a PTY session
+terminal = sandbox.pty.create(
+    cols=80,
+    rows=24,
+    on_data=lambda data: print('Handler 1:', data.decode()),
+)
+
+pid = terminal.pid
+
+# Send a command
+sandbox.pty.send_stdin(pid, b'echo hello\n')
+time.sleep(0.5)
+
+# Disconnect - PTY keeps running in the background
+terminal.disconnect()
+
+# Later: reconnect with a new data handler
+reconnected = sandbox.pty.connect(
+    pid,
+    on_data=lambda data: print('Handler 2:', data.decode()),
+)
+
+# Continue using the session
+sandbox.pty.send_stdin(pid, b'echo world\n')
+
+# Wait for the terminal to exit
+reconnected.wait()
+```
+</CodeGroup>
+
+### Kill the PTY
+
+Terminate the PTY session with `kill()`.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create()
+
+const terminal = await sandbox.pty.create({
+  cols: 80,
+  rows: 24,
+  onData: (data) => process.stdout.write(data),
+})
+
+// Kill the PTY
+const killed = await sandbox.pty.kill(terminal.pid)
+console.log('Killed:', killed)  // true if successful
+
+// Or use the handle method
+// await terminal.kill()
+```
+
+```python Python
+from e2b import Sandbox
+
+sandbox = Sandbox()
+
+terminal = sandbox.pty.create(
+    cols=80,
+    rows=24,
+    on_data=lambda data: print(data.decode(), end=''),  # end='' prevents extra newline
+)
+
+# Kill the PTY
+killed = sandbox.pty.kill(terminal.pid)
+print('Killed:', killed)  # True if successful
+
+# Or use the handle method
+# terminal.kill()
+```
+</CodeGroup>
+
+### Wait for PTY to exit
+
+Use `wait()` to wait for the terminal session to end (e.g., when the user types `exit`).
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create()
+
+const terminal = await sandbox.pty.create({
+  cols: 80,
+  rows: 24,
+  onData: (data) => process.stdout.write(data),
+})
+
+// Send exit command
+await sandbox.pty.sendInput(terminal.pid, new TextEncoder().encode('exit\n'))
+
+// Wait for the terminal to exit
+const result = await terminal.wait()
+console.log('Exit code:', result.exitCode)
+```
+
+```python Python
+from e2b import Sandbox
+
+sandbox = Sandbox()
+
+terminal = sandbox.pty.create(
+    cols=80,
+    rows=24,
+    on_data=lambda data: print(data.decode(), end=''),  # end='' prevents extra newline
+)
+
+# Send exit command
+sandbox.pty.send_stdin(terminal.pid, b'exit\n')
+
+# Wait for the terminal to exit
+result = terminal.wait()
+print('Exit code:', result.exit_code)
+```
+</CodeGroup>
+
+### Interactive terminal (SSH-like)
+
+Building a fully interactive terminal (like SSH) requires handling raw mode, stdin forwarding, and terminal resize events. For a production implementation, see the [E2B CLI source code](https://github.com/e2b-dev/E2B/blob/main/packages/cli/src/terminal.ts) which uses the same `sandbox.pty` API documented above.
+
+## SSH access
+
+SSH access enables remote terminal sessions, SCP/SFTP file transfers, and integration with tools that expect SSH connectivity.
+
+### Quickstart
+
+<Steps>
+<Step title="Build the SSH template">
+
+Define a template with OpenSSH server and [websocat](https://github.com/vi/websocat):
+
+<CodeGroup>
+
+```typescript JavaScript & TypeScript
+// template.ts
+import { Template, waitForPort } from 'e2b'
+
+export const template = Template()
+  .fromUbuntuImage('25.04')
+  .aptInstall(['openssh-server'])
+  .runCmd([
+    'curl -fsSL -o /usr/local/bin/websocat https://github.com/vi/websocat/releases/latest/download/websocat.x86_64-unknown-linux-musl',
+    'chmod a+x /usr/local/bin/websocat',
+  ], { user: 'root' })
+  .setStartCmd('sudo websocat -b --exit-on-eof ws-l:0.0.0.0:8081 tcp:127.0.0.1:22', waitForPort(8081))
+```
+
+```python Python
+# template.py
+from e2b import Template, wait_for_port
+
+template = (
+    Template()
+    .from_ubuntu_image("25.04")
+    .apt_install(["openssh-server"])
+    .run_cmd([
+        "curl -fsSL -o /usr/local/bin/websocat https://github.com/vi/websocat/releases/latest/download/websocat.x86_64-unknown-linux-musl",
+        "chmod a+x /usr/local/bin/websocat",
+    ], user="root")
+    .set_start_cmd("sudo websocat -b --exit-on-eof ws-l:0.0.0.0:8081 tcp:127.0.0.1:22", wait_for_port(8081))
+)
+```
+
+</CodeGroup>
+
+Build the template:
+
+<CodeGroup>
+
+```typescript JavaScript & TypeScript
+// build.ts
+import { Template, defaultBuildLogger } from 'e2b'
+import { template as sshTemplate } from './template'
+
+await Template.build(sshTemplate, 'ssh-ready', {
+  cpuCount: 2,
+  memoryMB: 2048,
+  onBuildLogs: defaultBuildLogger(),
+})
+```
+
+```python Python
+# build.py
+from e2b import Template, default_build_logger
+from template import template as ssh_template
+
+Template.build(ssh_template, "ssh-ready",
+    cpu_count=2,
+    memory_mb=2048,
+    on_build_logs=default_build_logger(),
+)
+```
+
+</CodeGroup>
+
+</Step>
+<Step title="Create a sandbox from the template">
+
+<CodeGroup>
+
+```typescript JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+const sbx = await Sandbox.create('ssh-ready')
+console.log(sbx.sandboxId)
+```
+
+```python Python
+from e2b import Sandbox
+
+sbx = Sandbox.create("ssh-ready")
+print(sbx.sandbox_id)
+```
+
+</CodeGroup>
+
+</Step>
+<Step title="Connect from your machine">
+
+<CodeGroup>
+
+```bash macOS
+# Install websocat
+brew install websocat
+
+# Connect to your sandbox
+ssh -o 'ProxyCommand=websocat --binary -B 65536 - wss://8081-%h.e2b.app' user@<sandbox-id>
+```
+
+```bash Linux
+# Install websocat
+sudo curl -fsSL -o /usr/local/bin/websocat https://github.com/vi/websocat/releases/latest/download/websocat.x86_64-unknown-linux-musl
+sudo chmod a+x /usr/local/bin/websocat
+
+# Connect to your sandbox
+ssh -o 'ProxyCommand=websocat --binary -B 65536 - wss://8081-%h.e2b.app' user@<sandbox-id>
+```
+
+</CodeGroup>
+
+</Step>
+</Steps>
+
+---
+
+### How it works
+
+This method uses [websocat](https://github.com/vi/websocat) to proxy SSH connections over WebSocket through the sandbox's exposed ports.
+
+```
+┌───────────────────────────────────────────────────────────┐
+│  Your Machine                                             │
+│  ┌──────────┐    ProxyCommand    ┌──────────────────┐     │
+│  │   SSH    │ ────────────────── │    websocat      │     │
+│  │  Client  │                    │   (WebSocket)    │     │
+│  └──────────┘                    └─────────┬────────┘     │
+└────────────────────────────────────────────┼──────────────┘
+                                             │
+                         wss://8081-<sandbox-id>.e2b.app
+                                             │
+┌────────────────────────────────────────────┼──────────────┐
+│  E2B Sandbox                               ▼              │
+│                                  ┌──────────────────┐     │
+│                                  │    websocat      │     │
+│                                  │  (WS → TCP:22)   │     │
+│                                  └─────────┬────────┘     │
+│                                            │              │
+│                                  ┌─────────▼────────┐     │
+│                                  │   SSH Server     │     │
+│                                  │   (OpenSSH)      │     │
+│                                  └──────────────────┘     │
+└───────────────────────────────────────────────────────────┘
+```
diff --git a/docs/sandbox/connect-bucket.mdx b/docs/sandbox/connect-bucket.mdx
index 4b13b601..6f0fb53f 100644
--- a/docs/sandbox/connect-bucket.mdx
+++ b/docs/sandbox/connect-bucket.mdx
@@ -1,201 +1,204 @@
----
-title: "Connecting storage bucket to the sandbox"
-sidebarTitle: Connecting storage bucket
----
-
-To connect a bucket for storing data from the sandbox, we will use the FUSE file system to mount the bucket to the sandbox.
-
-You will need to create a custom sandbox template with the FUSE file system installed. The guide for building a custom sandbox template can be found [here](/docs/template/quickstart).
-
-## Google Cloud Storage
-### Prerequisites
-
-To use Google Cloud Storage, you'll need a bucket and a service account. You can create a service account [here](https://console.cloud.google.com/iam-admin/serviceaccounts) and a bucket [here](https://console.cloud.google.com/storage).
-
-If you want to write to the bucket, make sure the service account has the `Storage Object User` role for this bucket.
-
-You can find a guide on creating a service account key [here](https://cloud.google.com/iam/docs/keys-create-delete#iam-service-account-keys-create-console).
-
-### Mounting the bucket
-
-To use the Google Cloud Storage we need to install the `gcsfuse` package. There's simple [template](/docs/template/quickstart) that can be used to create a container with the `gcsfuse` installed.
-
-<CodeGroup>
-
-```ts JavaScript & TypeScript
-const template = Template()
-  .fromTemplate("code-interpreter-v1")
-  .aptInstall(["gnupg", "lsb-release"])
-  .runCmd("lsb_release -c -s > /tmp/lsb_release")
-  .runCmd(
-    'GCSFUSE_REPO=$(cat /tmp/lsb_release) && echo "deb [signed-by=/usr/share/keyrings/cloud.google.asc] https://packages.cloud.google.com/apt gcsfuse-$GCSFUSE_REPO main" | sudo tee /etc/apt/sources.list.d/gcsfuse.list',
-  )
-  .runCmd(
-    "curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo tee /usr/share/keyrings/cloud.google.asc",
-  )
-  .aptInstall(["gcsfuse"])
-```
-
-
-```python Python
-template = (
-    Template()
-    .from_template("code-interpreter-v1")
-    .apt_install(["gnupg", "lsb-release"])
-    .run_cmd("lsb_release -c -s > /tmp/lsb_release")
-    .run_cmd(
-        'GCSFUSE_REPO=$(cat /tmp/lsb_release) && echo "deb [signed-by=/usr/share/keyrings/cloud.google.asc] https://packages.cloud.google.com/apt gcsfuse-$GCSFUSE_REPO main" | sudo tee /etc/apt/sources.list.d/gcsfuse.list'
-    )
-    .run_cmd(
-        "curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo tee /usr/share/keyrings/cloud.google.asc"
-    )
-    .apt_install(["gcsfuse"])
-)
-```
-
-</CodeGroup>
-
-The bucket is mounted during the sandbox runtime using the `gcsfuse` command.
-
-<CodeGroup isRunnable={false}>
-```js JavaScript & TypeScript
-import { Sandbox } from 'e2b'
-
-const sandbox = await Sandbox.create('<your template id>')
-await sandbox.files.makeDir('/home/user/bucket')
-await sandbox.files.write('key.json', '<your service account key>')
-
-await sandbox.commands.run('sudo gcsfuse <flags> --key-file /home/user/key.json <bucket-name> /home/user/bucket')
-```
-
-```python Python
-from e2b import Sandbox
-
-sandbox = Sandbox.create("<your template id>")
-sandbox.files.make_dir("/home/user/bucket")
-sandbox.files.write("key.json", "<your key file content>")
-
-output = sandbox.commands.run(
-    "sudo gcsfuse <flags> --key-file /home/user/key.json <bucket-name> /home/user/bucket"
-)
-```
-</CodeGroup>
-
-### Flags
-
-The complete list of flags is available [here](https://cloud.google.com/storage/docs/gcsfuse-cli#options).
-
-### Allow the default user to access the files
-
-To allow the default user to access the files, we can use the following flags:
-
-```
--o allow_other -file-mode=777 -dir-mode=777
-```
-
-## Amazon S3
-
-To use Amazon S3, we can use the `s3fs` package. The [template](/docs/template/quickstart) setup is similar to that of Google Cloud Storage.
-
-<CodeGroup>
-
-```ts JavaScript & TypeScript
-const template = Template()
-  .fromImage("ubuntu:latest")
-  .aptInstall(["s3fs"])
-```
-
-
-```python Python
-template = (
-    Template()
-    .from_image("ubuntu:latest")
-    .apt_install(["s3fs"])
-)
-```
-
-</CodeGroup>
-
-Similar to Google Cloud Storage, the bucket is mounted during the runtime of the sandbox. The `s3fs` command is used to mount the bucket to the sandbox.
-
-<CodeGroup isRunnable={false}>
-```js JavaScript & TypeScript
-import { Sandbox } from 'e2b'
-
-const sandbox = await Sandbox.create('<your template id>')
-await sandbox.files.makeDir('/home/user/bucket')
-
-// Create a file with the credentials
-// If you use another path for the credentials you need to add the path in the command s3fs command
-await sandbox.files.write('/root/.passwd-s3fs', '<AWS_ACCESS_KEY_ID>:<AWS_SECRET_ACCESS_KEY>')
-await sandbox.commands.run('sudo chmod 600 /root/.passwd-s3fs')
-
-await sandbox.commands.run('sudo s3fs <flags> <bucket-name> /home/user/bucket')
-```
-
-```python Python
-from e2b import Sandbox
-
-sandbox = Sandbox.create("<your template id>")
-sandbox.files.make_dir("/home/user/bucket")
-
-# Create a file with the credentials
-# If you use another path for the credentials you need to add the path in the command s3fs command
-sandbox.files.write("/root/.passwd-s3fs", "<AWS_ACCESS_KEY_ID>:<AWS_SECRET_ACCESS_KEY>")
-sandbox.commands.run("sudo chmod 600 /root/.passwd-s3fs")
-
-sandbox.commands.run("sudo s3fs <flags> <bucket-name> /home/user/bucket")
-```
-</CodeGroup>
-
-### Flags
-
-The complete list of flags is available [here](https://manpages.ubuntu.com/manpages/xenial/man1/s3fs.1.html).
-
-### Allow the default user to access the files
-
-To allow the default user to access the files, add the following flag:
-
-```
--o allow_other
-```
-
-## Cloudflare R2
-
-For Cloudflare R2, we can use a setup very similar to S3. The template remains the same as for S3. However, the mounting differs slightly; we need to specify the endpoint for R2.
-
-<CodeGroup isRunnable={false}>
-```js JavaScript & TypeScript
-import { Sandbox } from 'e2b'
-
-const sandbox = await Sandbox.create({ template: '<your template id>' })
-await sandbox.files.makeDir('/home/user/bucket')
-
-// Create a file with the R2 credentials
-// If you use another path for the credentials you need to add the path in the command s3fs command
-await sandbox.files.write('/root/.passwd-s3fs', '<R2_ACCESS_KEY_ID>:<R2_SECRET_ACCESS_KEY>')
-await sandbox.commands.run('sudo chmod 600 /root/.passwd-s3fs')
-
-await sandbox.commands.run('sudo s3fs -o url=https://<ACCOUNT ID>.r2.cloudflarestorage.com <flags> <bucket-name> /home/user/bucket')
-```
-
-```python Python
-from e2b import Sandbox
-
-sandbox = Sandbox.create("<your template id>")
-sandbox.files.make_dir("/home/user/bucket")
-
-# Create a file with the R2 credentials
-# If you use another path for the credentials you need to add the path in the command s3fs command
-sandbox.files.write("/root/.passwd-s3fs", "<R2_ACCESS_KEY_ID>:<R2_SECRET_ACCESS_KEY>")
-sandbox.commands.run("sudo chmod 600 /root/.passwd-s3fs")
-
-sandbox.commands.run(
-    "sudo s3fs -o url=https://<ACCOUNT ID>.r2.cloudflarestorage.com <flags> <bucket-name> /home/user/bucket"
-)
-```
-</CodeGroup>
-
-### Flags
-
-It's the same as for S3.
+---
+title: "Connect storage bucket"
+sidebarTitle: "Connect storage bucket"
+icon: "bucket"
+description: "Mount Google Cloud Storage, Amazon S3, or Cloudflare R2 buckets inside E2B sandboxes using FUSE."
+---
+
+You can mount external cloud storage buckets inside a sandbox using FUSE file systems. This lets sandboxes read and write to your existing cloud storage.
+
+You will need to create a custom sandbox template with the FUSE file system installed. The guide for building a custom sandbox template can be found [here](/docs/template/quickstart).
+
+## Google Cloud Storage
+
+### Prerequisites
+
+To use Google Cloud Storage, you'll need a bucket and a service account. You can create a service account [here](https://console.cloud.google.com/iam-admin/serviceaccounts) and a bucket [here](https://console.cloud.google.com/storage).
+
+If you want to write to the bucket, make sure the service account has the `Storage Object User` role for this bucket.
+
+You can find a guide on creating a service account key [here](https://cloud.google.com/iam/docs/keys-create-delete#iam-service-account-keys-create-console).
+
+### Mounting the bucket
+
+To use the Google Cloud Storage we need to install the `gcsfuse` package. There's simple [template](/docs/template/quickstart) that can be used to create a container with the `gcsfuse` installed.
+
+<CodeGroup>
+
+```ts JavaScript & TypeScript
+const template = Template()
+  .fromTemplate("code-interpreter-v1")
+  .aptInstall(["gnupg", "lsb-release"])
+  .runCmd("lsb_release -c -s > /tmp/lsb_release")
+  .runCmd(
+    'GCSFUSE_REPO=$(cat /tmp/lsb_release) && echo "deb [signed-by=/usr/share/keyrings/cloud.google.asc] https://packages.cloud.google.com/apt gcsfuse-$GCSFUSE_REPO main" | sudo tee /etc/apt/sources.list.d/gcsfuse.list',
+  )
+  .runCmd(
+    "curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo tee /usr/share/keyrings/cloud.google.asc",
+  )
+  .aptInstall(["gcsfuse"])
+```
+
+
+```python Python
+template = (
+    Template()
+    .from_template("code-interpreter-v1")
+    .apt_install(["gnupg", "lsb-release"])
+    .run_cmd("lsb_release -c -s > /tmp/lsb_release")
+    .run_cmd(
+        'GCSFUSE_REPO=$(cat /tmp/lsb_release) && echo "deb [signed-by=/usr/share/keyrings/cloud.google.asc] https://packages.cloud.google.com/apt gcsfuse-$GCSFUSE_REPO main" | sudo tee /etc/apt/sources.list.d/gcsfuse.list'
+    )
+    .run_cmd(
+        "curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo tee /usr/share/keyrings/cloud.google.asc"
+    )
+    .apt_install(["gcsfuse"])
+)
+```
+
+</CodeGroup>
+
+The bucket is mounted during the sandbox runtime using the `gcsfuse` command.
+
+<CodeGroup isRunnable={false}>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create('<your template id>')
+await sandbox.files.makeDir('/home/user/bucket')
+await sandbox.files.write('key.json', '<your service account key>')
+
+await sandbox.commands.run('sudo gcsfuse <flags> --key-file /home/user/key.json <bucket-name> /home/user/bucket')
+```
+
+```python Python
+from e2b import Sandbox
+
+sandbox = Sandbox.create("<your template id>")
+sandbox.files.make_dir("/home/user/bucket")
+sandbox.files.write("key.json", "<your key file content>")
+
+output = sandbox.commands.run(
+    "sudo gcsfuse <flags> --key-file /home/user/key.json <bucket-name> /home/user/bucket"
+)
+```
+</CodeGroup>
+
+### Flags
+
+The complete list of flags is available [here](https://cloud.google.com/storage/docs/gcsfuse-cli#options).
+
+### Allow the default user to access the files
+
+To allow the default user to access the files, we can use the following flags:
+
+```
+-o allow_other -file-mode=777 -dir-mode=777
+```
+
+## Amazon S3
+
+To use Amazon S3, we can use the `s3fs` package. The [template](/docs/template/quickstart) setup is similar to that of Google Cloud Storage.
+
+<CodeGroup>
+
+```ts JavaScript & TypeScript
+const template = Template()
+  .fromImage("ubuntu:latest")
+  .aptInstall(["s3fs"])
+```
+
+
+```python Python
+template = (
+    Template()
+    .from_image("ubuntu:latest")
+    .apt_install(["s3fs"])
+)
+```
+
+</CodeGroup>
+
+Similar to Google Cloud Storage, the bucket is mounted during the runtime of the sandbox. The `s3fs` command is used to mount the bucket to the sandbox.
+
+<CodeGroup isRunnable={false}>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create('<your template id>')
+await sandbox.files.makeDir('/home/user/bucket')
+
+// Create a file with the credentials
+// If you use another path for the credentials you need to add the path in the command s3fs command
+await sandbox.files.write('/root/.passwd-s3fs', '<AWS_ACCESS_KEY_ID>:<AWS_SECRET_ACCESS_KEY>')
+await sandbox.commands.run('sudo chmod 600 /root/.passwd-s3fs')
+
+await sandbox.commands.run('sudo s3fs <flags> <bucket-name> /home/user/bucket')
+```
+
+```python Python
+from e2b import Sandbox
+
+sandbox = Sandbox.create("<your template id>")
+sandbox.files.make_dir("/home/user/bucket")
+
+# Create a file with the credentials
+# If you use another path for the credentials you need to add the path in the command s3fs command
+sandbox.files.write("/root/.passwd-s3fs", "<AWS_ACCESS_KEY_ID>:<AWS_SECRET_ACCESS_KEY>")
+sandbox.commands.run("sudo chmod 600 /root/.passwd-s3fs")
+
+sandbox.commands.run("sudo s3fs <flags> <bucket-name> /home/user/bucket")
+```
+</CodeGroup>
+
+### Flags
+
+The complete list of flags is available [here](https://manpages.ubuntu.com/manpages/xenial/man1/s3fs.1.html).
+
+### Allow the default user to access the files
+
+To allow the default user to access the files, add the following flag:
+
+```
+-o allow_other
+```
+
+## Cloudflare R2
+
+For Cloudflare R2, we can use a setup very similar to S3. The template remains the same as for S3. However, the mounting differs slightly; we need to specify the endpoint for R2.
+
+<CodeGroup isRunnable={false}>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create({ template: '<your template id>' })
+await sandbox.files.makeDir('/home/user/bucket')
+
+// Create a file with the R2 credentials
+// If you use another path for the credentials you need to add the path in the command s3fs command
+await sandbox.files.write('/root/.passwd-s3fs', '<R2_ACCESS_KEY_ID>:<R2_SECRET_ACCESS_KEY>')
+await sandbox.commands.run('sudo chmod 600 /root/.passwd-s3fs')
+
+await sandbox.commands.run('sudo s3fs -o url=https://<ACCOUNT ID>.r2.cloudflarestorage.com <flags> <bucket-name> /home/user/bucket')
+```
+
+```python Python
+from e2b import Sandbox
+
+sandbox = Sandbox.create("<your template id>")
+sandbox.files.make_dir("/home/user/bucket")
+
+# Create a file with the R2 credentials
+# If you use another path for the credentials you need to add the path in the command s3fs command
+sandbox.files.write("/root/.passwd-s3fs", "<R2_ACCESS_KEY_ID>:<R2_SECRET_ACCESS_KEY>")
+sandbox.commands.run("sudo chmod 600 /root/.passwd-s3fs")
+
+sandbox.commands.run(
+    "sudo s3fs -o url=https://<ACCOUNT ID>.r2.cloudflarestorage.com <flags> <bucket-name> /home/user/bucket"
+)
+```
+</CodeGroup>
+
+### Flags
+
+It's the same as for S3.
diff --git a/docs/sandbox/connect.mdx b/docs/sandbox/connect.mdx
deleted file mode 100644
index e62977e4..00000000
--- a/docs/sandbox/connect.mdx
+++ /dev/null
@@ -1,76 +0,0 @@
----
-title: "Connect to running sandbox"
----
-
-If you have a running sandbox, you can connect to it using the `Sandbox.connect()` method and then start controlling it with our SDK.
-
-This is useful if you want to, for example, reuse the same sandbox instance for the same user after a short period of inactivity.
-
-## 1. Get the sandbox ID
-To connect to a running sandbox, you first need to retrieve its ID. You can do this by calling the `Sandbox.list()` method.
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Sandbox } from '@e2b/code-interpreter'
-
-const sbx = await Sandbox.create()
-
-// Get all running sandboxes
-const paginator = await Sandbox.list({
-  query: { state: ['running'] },
-})
-
-const runningSandboxes = await paginator.nextItems()
-if (runningSandboxes.length === 0) {
-  throw new Error('No running sandboxes found')
-}
-
-// Get the ID of the sandbox you want to connect to
-const sandboxId = runningSandboxes[0].sandboxId
-```
-
-```python Python
-from e2b_code_interpreter import Sandbox
-
-sbx = Sandbox.create()
-
-# Get all running sandboxes
-paginator = Sandbox.list()
-
-# Get the ID of the sandbox you want to connect to
-running_sandboxes = paginator.next_items()
-if len(running_sandboxes) == 0:
-    raise Exception("No running sandboxes found")
-
-# Get the ID of the sandbox you want to connect to
-sandbox_id = running_sandboxes[0].sandbox_id
-```
-</CodeGroup>
-
-## 2. Connect to the sandbox
-
-Now that you have the sandbox ID, you can connect to the sandbox using the `Sandbox.connect()` method.
-
-<CodeGroup>
-```js JavaScript & TypeScript highlight={3}
-import { Sandbox } from '@e2b/code-interpreter'
-
-const sandbox = await Sandbox.connect(sandboxId)
-
-// Now you can use the sandbox as usual
-// ...
-const result = await sandbox.commands.run("whoami")
-console.log(`Running in sandbox ${sandbox.sandboxId} as "${result.stdout.trim()}"`)
-```
-
-```python Python highlight={3}
-from e2b_code_interpreter import Sandbox
-
-sandbox = Sandbox.connect(sandbox_id)
-
-# Now you can use the sandbox as usual
-# ...
-r = sandbox.commands.run("whoami")
-print(f"Running in sandbox {sandbox.sandbox_id} as \"{r.stdout.strip()}\"")
-```
-</CodeGroup>
diff --git a/docs/sandbox/custom-domain.mdx b/docs/sandbox/custom-domain.mdx
index 1fa46272..9f3cd453 100644
--- a/docs/sandbox/custom-domain.mdx
+++ b/docs/sandbox/custom-domain.mdx
@@ -1,5 +1,7 @@
 ---
 title: "Custom domain"
+icon: "globe"
+description: "Set up a custom domain to proxy requests to E2B sandboxes using Caddy and Cloudflare DNS."
 ---
 
 How to set up a custom domain for Sandboxes hosted on E2B.
@@ -183,7 +185,7 @@ Log into the Cloudflare dashboard and create a new A wildcard DNS record pointin
 
 We will create a new Sandbox on E2B and install a simple HTTP server in it.
 
-1. Create a new Sandbox using [E2B CLI](/docs/cli):
+1. Create a new Sandbox using [E2B CLI](/docs/sandbox/cli):
 
     ```bash
     e2b sandbox create base
diff --git a/docs/sandbox/environment-variables.mdx b/docs/sandbox/environment-variables.mdx
index 0f893e30..fd52f08d 100644
--- a/docs/sandbox/environment-variables.mdx
+++ b/docs/sandbox/environment-variables.mdx
@@ -1,52 +1,60 @@
 ---
 title: "Environment variables"
+sidebarTitle: "Environment variables"
+icon: "key"
+description: "Set and use environment variables in E2B sandboxes — default metadata, global variables, and per-command overrides."
 ---
 
-This page covers how to set and use environment variables in a sandbox, and default environment variables inside the sandbox.
+E2B sandboxes support environment variables at multiple levels: default metadata variables set automatically, global variables set at sandbox creation, and per-command overrides.
 
 ## Default environment variables
-### Knowing if you are inside a sandbox
 
-Sometimes it's useful to know if the code is running inside a sandbox. Upon creating a sandbox, useful sandbox metadata is set as environment variables for commands: 
+Upon creating a sandbox, useful sandbox metadata is set as environment variables for commands:
 - `E2B_SANDBOX` is set to `true` for processes to know if they are inside our VM.
 - `E2B_SANDBOX_ID` to know the ID of the sandbox.
-- `E2B_TEAM_ID` to know the team ID that created the sandbox. 
+- `E2B_TEAM_ID` to know the team ID that created the sandbox.
 - `E2B_TEMPLATE_ID` to know what template was used for the current sandbox.
 
 You can try it out by running the following code in the sandbox:
 
 <CodeGroup>
 ```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
 const sandbox = await Sandbox.create()
 const result = await sandbox.commands.run('echo $E2B_SANDBOX_ID')
 ```
 ```python Python
+from e2b import Sandbox
+
 sandbox = Sandbox.create()
 result = sandbox.commands.run("echo $E2B_SANDBOX_ID")
 ```
 </CodeGroup>
 
 <Note>
-These default environment variables are only accessible via the SDK, when using the CLI you can find them in the form of dot files in the `/run/e2b/` dir: 
+These default environment variables are only accessible via the SDK, when using the CLI you can find them in the form of dot files in the `/run/e2b/` dir:
 ```sh
 user@e2b:~$ ls -a /run/e2b/
 .E2B_SANDBOX  .E2B_SANDBOX_ID  .E2B_TEAM_ID  .E2B_TEMPLATE_ID
 ```
 </Note>
 
----
-
 ## Setting environment variables
+
 There are 3 ways to set environment variables in a sandbox:
-1. [Global environment variables when creating the sandbox](/docs/sandbox/environment-variables#1-global-environment-variables).
-2. [When running code in the sandbox](/docs/sandbox/environment-variables#2-setting-environment-variables-when-running-code).
-3. [When running commands in the sandbox](/docs/sandbox/environment-variables#3-setting-environment-variables-when-running-commands).
+1. [Global environment variables when creating the sandbox](/docs/sandbox/environment-variables#global-environment-variables).
+2. [When running code in the sandbox](/docs/sandbox/environment-variables#per-code-execution).
+3. [When running commands in the sandbox](/docs/sandbox/environment-variables#per-command).
+
+### Global environment variables
 
-### 1. Global environment variables
 You can set global environment variables when creating a sandbox.
 
 <CodeGroup>
 ```js JavaScript & TypeScript highlight={2-4}
+import { Sandbox } from 'e2b'
+
 const sandbox = await Sandbox.create({
   envs: {
     MY_VAR: 'my_value',
@@ -54,6 +62,8 @@ const sandbox = await Sandbox.create({
 })
 ```
 ```python Python highlight={2-4}
+from e2b import Sandbox
+
 sandbox = Sandbox.create(
   envs={
     'MY_VAR': 'my_value',
@@ -62,16 +72,19 @@ sandbox = Sandbox.create(
 ```
 </CodeGroup>
 
-### 2. Setting environment variables when running code
-You can set environment variables for specific code execution call in the sandbox. 
+### Per code execution
+
+You can set environment variables for a specific code execution call in the sandbox.
 
 <Note>
-- These environment variables are scoped to the command but are not private in the OS. 
+- These environment variables are scoped to the command but are not private in the OS.
 - If you had a global environment variable with the same name, it will be overridden only for the command.
 </Note>
 
 <CodeGroup>
 ```js JavaScript & TypeScript highlight={3-5}
+import { Sandbox } from '@e2b/code-interpreter'
+
 const sandbox = await Sandbox.create()
 const result = await sandbox.runCode('import os; print(os.environ.get("MY_VAR"))', {
   envs: {
@@ -80,6 +93,8 @@ const result = await sandbox.runCode('import os; print(os.environ.get("MY_VAR"))
 })
 ```
 ```python Python highlight={4-6}
+from e2b_code_interpreter import Sandbox
+
 sandbox = Sandbox.create()
 result = sandbox.run_code(
     'import os; print(os.environ.get("MY_VAR"))',
@@ -90,16 +105,19 @@ result = sandbox.run_code(
 ```
 </CodeGroup>
 
-### 3. Setting environment variables when running commands
-You can set environment variables for specific command execution in the sandbox.
+### Per command
+
+You can set environment variables for a specific command execution in the sandbox.
 
 <Note>
-- These environment variables are scoped to the command but are not private in the OS. 
+- These environment variables are scoped to the command but are not private in the OS.
 - If you had a global environment variable with the same name, it will be overridden only for the command.
 </Note>
 
 <CodeGroup>
 ```js JavaScript & TypeScript highlight={3-5}
+import { Sandbox } from 'e2b'
+
 const sandbox = await Sandbox.create()
 sandbox.commands.run('echo $MY_VAR', {
   envs: {
@@ -108,6 +126,8 @@ sandbox.commands.run('echo $MY_VAR', {
 })
 ```
 ```python Python highlight={4-6}
+from e2b import Sandbox
+
 sandbox = Sandbox.create()
 sandbox.commands.run(
     'echo $MY_VAR',
diff --git a/docs/sandbox/filesystem.mdx b/docs/sandbox/filesystem.mdx
new file mode 100644
index 00000000..d540f13e
--- /dev/null
+++ b/docs/sandbox/filesystem.mdx
@@ -0,0 +1,517 @@
+---
+title: "Filesystem"
+sidebarTitle: Filesystem
+icon: "folder"
+description: "Read, write, upload, and download files in E2B sandboxes. Each sandbox has an isolated filesystem with up to 20 GB of storage."
+---
+
+Each E2B Sandbox has its own isolated filesystem. The [Hobby tier](https://e2b.dev/pricing) sandboxes come with 10 GB of the free disk space and [Pro tier](https://e2b.dev/pricing) sandboxes come with 20 GB.
+
+With E2B SDK you can read and write files, get file and directory metadata, watch directories for changes, upload data to the sandbox, and download data from the sandbox.
+
+## Read and write files
+
+### Reading files
+
+You can read files from the sandbox filesystem using the `files.read()` method.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create()
+const fileContent = await sandbox.files.read('/path/to/file')
+```
+```python Python
+from e2b import Sandbox
+
+sandbox = Sandbox.create()
+file_content = sandbox.files.read('/path/to/file')
+```
+</CodeGroup>
+
+### Writing single files
+
+You can write single files to the sandbox filesystem using the `files.write()` method.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create()
+
+await sandbox.files.write('/path/to/file', 'file content')
+```
+```python Python
+from e2b import Sandbox
+
+sandbox = Sandbox.create()
+
+sandbox.files.write('/path/to/file', 'file content')
+```
+</CodeGroup>
+
+### Writing multiple files
+
+You can also write multiple files to the sandbox.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create()
+
+await sandbox.files.write([
+    { path: '/path/to/a', data: 'file content' },
+    { path: '/another/path/to/b', data: 'file content' }
+])
+```
+```python Python
+from e2b import Sandbox
+
+sandbox = Sandbox.create()
+
+sandbox.files.write_files([
+    { "path": "/path/to/a", "data": "file content" },
+    { "path": "another/path/to/b", "data": "file content" }
+])
+```
+</CodeGroup>
+
+## File and directory metadata
+
+You can get information about a file or directory using the `files.getInfo()` / `files.get_info()` methods. Information such as file name, type, and path is returned.
+
+### File metadata
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create()
+
+// Create a new file
+await sandbox.files.write('test_file.txt', 'Hello, world!')
+
+// Get information about the file
+const info = await sandbox.files.getInfo('test_file.txt')
+
+console.log(info)
+// {
+//   name: 'test_file.txt',
+//   type: 'file',
+//   path: '/home/user/test_file.txt',
+//   size: 13,
+//   mode: 0o644,
+//   permissions: '-rw-r--r--',
+//   owner: 'user',
+//   group: 'user',
+//   modifiedTime: '2025-05-26T12:00:00.000Z',
+//   symlinkTarget: null
+// }
+```
+```python Python
+from e2b import Sandbox
+
+sandbox = Sandbox.create()
+
+# Create a new file
+sandbox.files.write('test_file', 'Hello, world!')
+
+# Get information about the file
+info = sandbox.files.get_info('test_file')
+
+print(info)
+# EntryInfo(
+#   name='test_file.txt',
+#   type=<FileType.FILE: 'file'>,
+#   path='/home/user/test_file.txt',
+#   size=13,
+#   mode=0o644,
+#   permissions='-rw-r--r--',
+#   owner='user',
+#   group='user',
+#   modified_time='2025-05-26T12:00:00.000Z',
+#   symlink_target=None
+# )
+```
+</CodeGroup>
+
+### Directory metadata
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create()
+
+// Create a new directory
+await sandbox.files.makeDir('test_dir')
+
+// Get information about the directory
+const info = await sandbox.files.getInfo('test_dir')
+
+console.log(info)
+// {
+//   name: 'test_dir',
+//   type: 'dir',
+//   path: '/home/user/test_dir',
+//   size: 0,
+//   mode: 0o755,
+//   permissions: 'drwxr-xr-x',
+//   owner: 'user',
+//   group: 'user',
+//   modifiedTime: '2025-05-26T12:00:00.000Z',
+//   symlinkTarget: null
+// }
+```
+```python Python
+from e2b import Sandbox
+
+sandbox = Sandbox.create()
+
+# Create a new directory
+sandbox.files.make_dir('test_dir')
+
+# Get information about the directory
+info = sandbox.files.get_info('test_dir')
+
+print(info)
+# EntryInfo(
+#   name='test_dir',
+#   type=<FileType.DIR: 'dir'>,
+#   path='/home/user/test_dir',
+#   size=0,
+#   mode=0o755,
+#   permissions='drwxr-xr-x',
+#   owner='user',
+#   group='user',
+#   modified_time='2025-05-26T12:00:00.000Z',
+#   symlink_target=None
+# )
+```
+</CodeGroup>
+
+## Watch directory for changes
+
+You can watch a directory for changes using the `files.watchDir()` method in JavaScript and `files.watch_dir()` method in Python.
+
+<Note>
+Since events are tracked asynchronously, their delivery may be delayed.
+It's recommended not to collect or close watcher immediately after making a change.
+</Note>
+
+<CodeGroup>
+```js JavaScript & TypeScript highlight={7-12}
+import { Sandbox, FilesystemEventType } from 'e2b'
+
+const sandbox = await Sandbox.create()
+const dirname = '/home/user'
+
+// Start watching directory for changes
+const handle = await sandbox.files.watchDir(dirname, async (event) => {
+  console.log(event)
+  if (event.type === FilesystemEventType.WRITE) {
+    console.log(`wrote to file ${event.name}`)
+  }
+})
+
+// Trigger file write event
+await sandbox.files.write(`${dirname}/my-file`, 'hello')
+```
+```python Python highlight={7,12-16}
+from e2b import Sandbox, FilesystemEventType
+
+sandbox = Sandbox.create()
+dirname = '/home/user'
+
+# Watch directory for changes
+handle = sandbox.files.watch_dir(dirname)
+# Trigger file write event
+sandbox.files.write(f"{dirname}/my-file", "hello")
+
+# Retrieve the latest new events since the last `get_new_events()` call
+events = handle.get_new_events()
+for event in events:
+  print(event)
+  if event.type == FilesystemEventType.WRITE:
+    print(f"wrote to file {event.name}")
+```
+</CodeGroup>
+
+### Recursive watching
+
+You can enable recursive watching using the parameter `recursive`.
+
+<Note>
+When rapidly creating new folders (e.g., deeply nested path of folders), events other than `CREATE` might not be emitted. To avoid this behavior, create the required folder structure in advance.
+</Note>
+
+<CodeGroup>
+```js JavaScript & TypeScript highlight={13,17}
+import { Sandbox, FilesystemEventType } from 'e2b'
+
+const sandbox = await Sandbox.create()
+const dirname = '/home/user'
+
+// Start watching directory for changes
+const handle = await sandbox.files.watchDir(dirname, async (event) => {
+  console.log(event)
+  if (event.type === FilesystemEventType.WRITE) {
+    console.log(`wrote to file ${event.name}`)
+  }
+}, {
+  recursive: true
+})
+
+// Trigger file write event
+await sandbox.files.write(`${dirname}/my-folder/my-file`, 'hello')
+```
+```python Python highlight={7,9}
+from e2b import Sandbox, FilesystemEventType
+
+sandbox = Sandbox.create()
+dirname = '/home/user'
+
+# Watch directory for changes
+handle = sandbox.files.watch_dir(dirname, recursive=True)
+# Trigger file write event
+sandbox.files.write(f"{dirname}/my-folder/my-file", "hello")
+
+# Retrieve the latest new events since the last `get_new_events()` call
+events = handle.get_new_events()
+for event in events:
+  print(event)
+  if event.type == FilesystemEventType.WRITE:
+    print(f"wrote to file {event.name}")
+```
+</CodeGroup>
+
+## Upload data
+
+You can upload data to the sandbox using the `files.write()` method.
+
+### Upload single file
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import fs from 'fs'
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create()
+
+// Read file from local filesystem
+const content = fs.readFileSync('/local/path')
+// Upload file to sandbox
+await sandbox.files.write('/path/in/sandbox', content)
+```
+```python Python
+from e2b import Sandbox
+
+sandbox = Sandbox.create()
+
+# Read file from local filesystem
+with open("path/to/local/file", "rb") as file:
+  # Upload file to sandbox
+  sandbox.files.write("/path/in/sandbox", file)
+```
+</CodeGroup>
+
+### Upload with pre-signed URL
+
+Sometimes, you may want to let users from unauthorized environments, like a browser, upload files to the sandbox.
+For this use case, you can use pre-signed URLs to let users upload files securely.
+
+All you need to do is create a sandbox with the `secure: true` option. An upload URL will then be generated with a signature that allows only authorized users to upload files.
+You can optionally set an expiration time for the URL so that it will be valid only for a limited time.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+// Start a secured sandbox (all operations must be authorized by default)
+const sandbox = await Sandbox.create(template, { secure: true })
+
+// Create a pre-signed URL for file upload with a 10 second expiration
+const publicUploadUrl = await sandbox.uploadUrl(
+  'demo.txt', {
+    useSignatureExpiration: 10_000, // optional
+  },
+)
+
+// Upload a file with a pre-signed URL (this can be used in any environment, such as a browser)
+const form = new FormData()
+form.append('file', 'file content')
+
+await fetch(publicUploadUrl, { method: 'POST', body: form })
+
+// File is now available in the sandbox and you can read it
+const content = sandbox.files.read('/path/in/sandbox')
+```
+```python Python
+from e2b import Sandbox
+import requests
+
+# Start a secured sandbox (all operations must be authorized by default)
+sandbox = Sandbox.create(timeout=12_000, secure=True)
+
+# Create a pre-signed URL for file upload with a 10 second expiration
+signed_url = sandbox.upload_url(path="demo.txt", user="user", use_signature_expiration=10_000)
+
+form_data = {"file":"file content"}
+requests.post(signed_url, data=form_data)
+
+# File is now available in the sandbox and you can read it
+content = sandbox.files.read('/path/in/sandbox')
+```
+</CodeGroup>
+
+### Upload directory / multiple files
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create()
+
+// Read all files in the directory and store their paths and contents in an array
+const readDirectoryFiles = (directoryPath) => {
+  // Read all files in the local directory
+  const files = fs.readdirSync(directoryPath);
+
+  // Map files to objects with path and data
+  const filesArray = files
+    .filter(file => {
+      const fullPath = path.join(directoryPath, file);
+      // Skip if it's a directory
+      return fs.statSync(fullPath).isFile();
+    })
+    .map(file => {
+      const filePath = path.join(directoryPath, file);
+
+      // Read the content of each file
+      return {
+        path: filePath,
+        data: fs.readFileSync(filePath, 'utf8')
+      };
+    });
+
+  return filesArray;
+};
+
+// Usage example
+const files = readDirectoryFiles('/local/dir');
+console.log(files);
+// [
+//   { path: '/local/dir/file1.txt', data: 'File 1 contents...' },
+//   { path: '/local/dir/file2.txt', data: 'File 2 contents...' },
+//   ...
+// ]
+
+await sandbox.files.write(files)
+```
+```python Python
+import os
+from e2b import Sandbox
+
+sandbox = Sandbox.create()
+
+def read_directory_files(directory_path):
+    files = []
+
+    # Iterate through all files in the directory
+    for filename in os.listdir(directory_path):
+        file_path = os.path.join(directory_path, filename)
+
+        # Skip if it's a directory
+        if os.path.isfile(file_path):
+            # Read file contents in binary mode
+            with open(file_path, "rb") as file:
+                files.append({
+                    'path': file_path,
+                    'data': file.read()
+                })
+
+    return files
+
+files = read_directory_files("/local/dir")
+print(files)
+# [
+#  {"path": "/local/dir/file1.txt", "data": "File 1 contents..." },
+#   { "path": "/local/dir/file2.txt", "data": "File 2 contents..." },
+#   ...
+# ]
+
+sandbox.files.write_files(files)
+```
+</CodeGroup>
+
+## Download data
+
+You can download data from the sandbox using the `files.read()` method.
+
+### Download single file
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import fs from 'fs'
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create()
+
+// Read file from sandbox
+const content = await sandbox.files.read('/path/in/sandbox')
+// Write file to local filesystem
+fs.writeFileSync('/local/path', content)
+```
+```python Python
+from e2b import Sandbox
+
+sandbox = Sandbox.create()
+
+# Read file from sandbox
+content = sandbox.files.read('/path/in/sandbox')
+# Write file to local filesystem
+with open('/local/path', 'w') as file:
+  file.write(content)
+```
+</CodeGroup>
+
+### Download with pre-signed URL
+
+Sometimes, you may want to let users from unauthorized environments, like a browser, download files from the sandbox.
+For this use case, you can use pre-signed URLs to let users download files securely.
+
+All you need to do is create a sandbox with the `secure: true` option. A download URL will then be generated with a signature that allows only authorized users to access files.
+You can optionally set an expiration time for the URL so that it will be valid only for a limited time.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import fs from 'fs'
+import { Sandbox } from 'e2b'
+
+// Start a secured sandbox (all operations must be authorized by default)
+const sandbox = await Sandbox.create(template, { secure: true })
+
+// Create a pre-signed URL for file download with a 10 second expiration
+const publicUrl = await sandbox.downloadUrl(
+  'demo.txt', {
+    useSignatureExpiration: 10_000, // optional
+  },
+)
+
+// Download a file with a pre-signed URL (this can be used in any environment, such as a browser)
+const res = await fetch(publicUrl)
+const content = await res.text()
+```
+```python Python
+from e2b import Sandbox
+
+# Start a secured sandbox (all operations must be authorized by default)
+sandbox = Sandbox.create(timeout=12_000, secure=True)
+
+# Create a pre-signed URL for file download with a 10 second expiration
+# The user only has to visit the URL to download the file, this also works in a browser.
+signed_url = sbx.download_url(path="demo.txt", user="user", use_signature_expiration=10_000)
+```
+</CodeGroup>
diff --git a/docs/sandbox/git-integration.mdx b/docs/sandbox/git-integration.mdx
index f4618fe7..ac5ea593 100644
--- a/docs/sandbox/git-integration.mdx
+++ b/docs/sandbox/git-integration.mdx
@@ -1,5 +1,6 @@
 ---
 title: "Git integration"
+icon: "code-branch"
 description: "Clone repositories, manage branches, and push changes using the sandbox.git methods."
 ---
 
diff --git a/docs/sandbox/lifecycle-events-api.mdx b/docs/sandbox/lifecycle-events-api.mdx
deleted file mode 100644
index 219bbc18..00000000
--- a/docs/sandbox/lifecycle-events-api.mdx
+++ /dev/null
@@ -1,156 +0,0 @@
----
-title: "Monitor sandbox lifecycle events"
-sidebarTitle: Lifecycle events API
----
-
-The lifecycle API provides RESTful endpoints to request the latest sandbox lifecycle events. This allows you to track when sandboxes are created, paused, resumed, updated, snapshotted, or killed, along with metadata.
-All requests require authentication using your team [API key](/docs/api-key#where-to-find-api-key).
-
-Query Parameters:
-- `offset` (optional): Number of events to skip (default: 0, min: 0)
-- `limit` (optional): Number of events to return (default: 10, min: 1, max: 100)
-- `orderAsc` (optional): Sort order - true for ascending, false for descending (default: false)
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Sandbox } from '@e2b/code-interpreter'
-
-const sbx = await Sandbox.create()
-
-// Get the latest events for a specific sandbox
-const resp1 = await fetch(
-  `https://api.e2b.app/events/sandboxes/${sbx.id}`,
-  {
-    method: 'GET',
-    headers: {
-      'X-API-Key': E2B_API_KEY,
-    },
-  }
-)
-const sandboxEvents = await resp1.json()
-
-// Get the latest 10 events for all sandboxes associated with the team
-const resp2 = await fetch(
-  'https://api.e2b.app/events/sandboxes?limit=10',
-  {
-    method: 'GET',
-    headers: {
-      'X-API-Key': E2B_API_KEY,
-    },
-  }
-)
-const teamSandboxEvents = await resp2.json()
-
-console.log(teamSandboxEvents)
-
-// [
-//   {
-//     "version": "v1",
-//     "id": "f5911677-cb60-498f-afed-f68143b3cc59",
-//     "type": "sandbox.lifecycle.killed",
-//     "eventData": null,
-//     "sandboxBuildId": "a979a14b-bdcc-49e6-bc04-1189fc9fe7c2",
-//     "sandboxExecutionId": "1dae9e1c-9957-4ce7-a236-a99d5779aadf",
-//     "sandboxId": "${SANDBOX_ID}",
-//     "sandboxTeamId": "460355b3-4f64-48f9-9a16-4442817f79f5",
-//     "sandboxTemplateId": "rki5dems9wqfm4r03t7g",
-//     "timestamp": "2025-08-06T20:59:36Z"
-//   },
-//   {
-//     "version": "v1",
-//     "id": "30b09e11-9ba2-42db-9cf6-d21f0f43a234",
-//     "type": "sandbox.lifecycle.updated",
-//     "eventData": {
-//       "set_timeout": "2025-08-06T20:59:59Z"
-//     },
-//     "sandboxBuildId": "a979a14b-bdcc-49e6-bc04-1189fc9fe7c2",
-//     "sandboxExecutionId": "1dae9e1c-9957-4ce7-a236-a99d5779aadf",
-//     "sandboxId": "${SANDBOX_ID}",
-//     "sandboxTeamId": "460355b3-4f64-48f9-9a16-4442817f79f5",
-//     "sandboxTemplateId": "rki5dems9wqfm4r03t7g",
-//     "timestamp": "2025-08-06T20:59:29Z"
-//   },
-//   [...]
-//   {
-//     "version": "v1",
-//     "id": "0568572b-a2ac-4e5f-85fa-fae90905f556",
-//     "type": "sandbox.lifecycle.created",
-//     "eventData": null,
-//     "sandboxBuildId": "a979a14b-bdcc-49e6-bc04-1189fc9fe7c2",
-//     "sandboxExecutionId": "1dae9e1c-9957-4ce7-a236-a99d5779aadf",
-//     "sandboxId": "${SANDBOX_ID}",
-//     "sandboxTeamId": "460355b3-4f64-48f9-9a16-4442817f79f5",
-//     "sandboxTemplateId": "rki5dems9wqfm4r03t7g",
-//     "timestamp": "2025-08-06T20:59:24Z"
-//   }
-// ]
-```
-```python Python
-import requests
-from e2b_code_interpreter import Sandbox
-
-sbx = Sandbox.create()
-
-# Get the latest events for a specific sandbox
-resp1 = requests.get(
-    f"https://api.e2b.app/events/sandboxes/{sbx.sandbox_id}",
-    headers={
-        "X-API-Key": E2B_API_KEY,
-    }
-)
-sandbox_events = resp1.json()
-
-# Get the latest 10 events for all sandboxes associated with the team
-resp2 = requests.get(
-    "https://api.e2b.app/events/sandboxes?limit=10",
-    headers={
-        "X-API-Key": E2B_API_KEY,
-    }
-)
-team_sandbox_events = resp2.json()
-
-print(team_sandbox_events)
-
-# [
-#   {
-#     "version": "v1",
-#     "id": "0568572b-a2ac-4e5f-85fa-fae90905f556",
-#     "type": "sandbox.lifecycle.killed",
-#     "eventData": null,
-#     "sandboxBuildId": "a979a14b-bdcc-49e6-bc04-1189fc9fe7c2",
-#     "sandboxExecutionId": "1dae9e1c-9957-4ce7-a236-a99d5779aadf",
-#     "sandboxId": "${SANDBOX_ID}",
-#     "sandboxTeamId": "460355b3-4f64-48f9-9a16-4442817f79f5",
-#     "sandboxTemplateId": "rki5dems9wqfm4r03t7g",
-#     "timestamp": "2025-08-06T20:59:36Z"
-#   },
-#   {
-#     "version": "v1",
-#     "id": "e7013704-2c51-4dd2-9f6c-388c91460149",
-#     "type": "sandbox.lifecycle.updated",
-#     "eventData": {
-#       "set_timeout": "2025-08-06T20:59:59Z"
-#     },
-#     "sandboxBuildId": "a979a14b-bdcc-49e6-bc04-1189fc9fe7c2",
-#     "sandboxExecutionId": "1dae9e1c-9957-4ce7-a236-a99d5779aadf",
-#     "sandboxId": "${SANDBOX_ID}",
-#     "sandboxTeamId": "460355b3-4f64-48f9-9a16-4442817f79f5",
-#     "sandboxTemplateId": "rki5dems9wqfm4r03t7g",
-#     "timestamp": "2025-08-06T20:59:29Z"
-#   },
-#   [...]
-#   {
-#     "version": "v1",
-#     "id": "f29ef778-2743-4c97-a802-7ba67f84ce24",
-#     "type": "sandbox.lifecycle.created",
-#     "eventData": null,
-#     "sandboxBuildId": "a979a14b-bdcc-49e6-bc04-1189fc9fe7c2",
-#     "sandboxExecutionId": "1dae9e1c-9957-4ce7-a236-a99d5779aadf",
-#     "sandboxId": "${SANDBOX_ID}",
-#     "sandboxTeamId": "460355b3-4f64-48f9-9a16-4442817f79f5",
-#     "sandboxTemplateId": "rki5dems9wqfm4r03t7g",
-#     "timestamp": "2025-08-06T20:59:24Z"
-#   }
-# ]
-```
-</CodeGroup>
diff --git a/docs/sandbox/lifecycle-events-webhooks.mdx b/docs/sandbox/lifecycle-events-webhooks.mdx
deleted file mode 100644
index a3ff0e58..00000000
--- a/docs/sandbox/lifecycle-events-webhooks.mdx
+++ /dev/null
@@ -1,363 +0,0 @@
----
-title: "Sandbox lifecycle webhooks"
-sidebarTitle: Lifecycle events webhooks
----
-
-Webhooks provide a way for notifications to be delivered to an external web server whenever certain sandbox lifecycle events occur. 
-This allows you to receive real-time updates about sandbox creation, updates, and termination without having to poll the API.
-All webhook requests require authentication using your team [API key](/docs/api-key#where-to-find-api-key).
-
-## Webhook management
-
-### Register webhook
-
-Register a new webhook to receive sandbox lifecycle events.
-The webhook will be registered for the team ID associated with your API key.
-All events specified during webhook creation will be sent to URL provided during registration with [following payload](#webhook-payload).
-
-<CodeGroup>
-```js JavaScript & TypeScript
-// Register a new webhook
-const resp = await fetch(
-  'https://api.e2b.app/events/webhooks',
-  {
-    method: 'POST',
-    headers: {
-      'X-API-Key': E2B_API_KEY,
-      'Content-Type': 'application/json',
-    },
-    body: JSON.stringify({
-      name: 'My Sandbox Webhook',
-      url: 'https://your-webhook-endpoint.com/webhook',
-      enabled: true,
-      events: ['sandbox.lifecycle.created', 'sandbox.lifecycle.updated', 'sandbox.lifecycle.killed'],
-      signatureSecret: 'secret-for-event-signature-verification'
-    }),
-  }
-)
-
-if (resp.status === 201) {
-  console.log('Webhook registered successfully')
-}
-```
-```python Python
-import requests
-
-# Register a new webhook
-resp = requests.post(
-    "https://api.e2b.app/events/webhooks",
-    headers={
-        "X-API-Key": E2B_API_KEY,
-        "Content-Type": "application/json",
-    },
-    json={
-        "name": "My Sandbox Webhook",
-        "url": "https://your-webhook-endpoint.com/webhook",
-        "enabled": true,
-        "events": ["sandbox.lifecycle.created", "sandbox.lifecycle.updated", "sandbox.lifecycle.killed"],
-        "signatureSecret": "secret-for-event-signature-verification"
-    }
-)
-
-if resp.status_code == 201:
-    print("Webhook registered successfully")
-```
-</CodeGroup>
-
-### List webhooks
-
-List all registered webhooks for your team.
-
-<CodeGroup>
-```js JavaScript & TypeScript
-// List webhooks
-const resp = await fetch(
-  'https://api.e2b.app/events/webhooks',
-  {
-    method: 'GET',
-    headers: {
-      'X-API-Key': E2B_API_KEY
-    },
-  },
-)
-
-if (resp.status === 200) {
-  console.log('Webhooks listed successfully')
-  console.log(await resp.json())
-}
-```
-```python Python
-import requests
-
-# List webhooks
-resp = requests.get(
-    "https://api.e2b.app/events/webhooks",
-    headers={
-        "X-API-Key": E2B_API_KEY
-    },
-)
-
-if resp.status_code == 200:
-    print("Webhooks listed successfully")
-    print(response.json())
-```
-</CodeGroup>
-
-
-### Get webhook configuration
-
-Retrieve the current webhook configuration for your team.
-
-<CodeGroup>
-```js JavaScript & TypeScript
-// Get webhook configuration
-const resp = await fetch(
-  `https://api.e2b.app/events/webhooks/${webhookID}`,
-  {
-    method: 'GET',
-    headers: {
-      'X-API-Key': E2B_API_KEY,
-    },
-  }
-)
-const webhookConfig = await resp.json()
-console.log(webhookConfig)
-// {
-//   "id": "<webhook-id>",
-//   "teamID": "<your-team-id>",
-//   "name": "My Sandbox Webhook",
-//   "createdAt": "2025-08-06T21:00:00Z",
-//   "enabled": true,
-//   "url": "https://your-webhook-endpoint.com/webhook",
-//   "events": ["sandbox.lifecycle.created", "sandbox.lifecycle.killed"]
-// }
-
-```
-```python Python
-import requests
-
-# Get webhook configuration
-resp = requests.get(
-    "https://api.e2b.app/events/webhooks/{webhookID}",
-    headers={
-        "X-API-Key": E2B_API_KEY,
-    }
-)
-
-webhook_config = resp.json()
-print(webhook_config)
-# {
-#   "id": "<webhook-id>",
-#   "teamID": "<your-team-id>",
-#   "name": "My Sandbox Webhook",
-#   "createdAt": "2025-08-06T21:00:00Z",
-#   "enabled": true,
-#   "url": "https://your-webhook-endpoint.com/webhook",
-#   "events": ["sandbox.lifecycle.created", "sandbox.lifecycle.killed"]
-# }
-```
-</CodeGroup>
-
-### Update webhook configuration
-
-Update an existing webhook configuration. The update will replace the previous configuration fields with provided fields.
-
-<CodeGroup>
-```js JavaScript & TypeScript
-// Update webhook configuration
-const resp = await fetch(
-  `https://api.e2b.app/events/webhooks/${webhookID}`,
-  {
-    method: 'PATCH',
-    headers: {
-      'X-API-Key': E2B_API_KEY,
-      'Content-Type': 'application/json',
-    },
-    body: JSON.stringify({
-      url: 'https://your-updated-webhook-endpoint.com/webhook',
-      enabled: false,
-      events: ['sandbox.lifecycle.created']
-    }),
-  }
-)
-
-if (resp.status === 200) {
-  console.log('Webhook updated successfully')
-}
-```
-```python Python
-import requests
-
-# Update webhook configuration
-resp = requests.patch(
-    "https://api.e2b.app/events/webhooks/{webhookID}",
-    headers={
-        "X-API-Key": E2B_API_KEY,
-        "Content-Type": "application/json",
-    },
-    json={
-        "url": "https://your-updated-webhook-endpoint.com/webhook",
-        "enabled": False,
-        "events": ["sandbox.lifecycle.created"]
-    }
-)
-
-if resp.status_code == 200:
-    print("Webhook updated successfully")
-```
-</CodeGroup>
-
-### Delete webhook
-
-Unregister the webhook.
-
-<CodeGroup>
-```js JavaScript & TypeScript
-// Delete webhook configuration
-const resp = await fetch(
-  `https://api.e2b.app/events/webhooks/${webhookID}`,
-  {
-    method: 'DELETE',
-    headers: {
-      'X-API-Key': E2B_API_KEY,
-    },
-  }
-)
-
-if (resp.status === 200) {
-  console.log('Webhook deleted successfully')
-}
-```
-```python Python
-import requests
-
-# Delete webhook configuration
-resp = requests.delete(
-    "https://api.e2b.app/events/webhooks/{webhookID}",
-    headers={
-        "X-API-Key": E2B_API_KEY,
-    }
-)
-
-if resp.status_code == 200:
-    print("Webhook deleted successfully")
-```
-</CodeGroup>
-
-## Webhook payload
-
-When a webhook is triggered, your endpoint will receive a POST request with a JSON payload containing the sandbox event data.
-The payload structure matches the event format from the API:
-
-```json
-{
-  "version": "v2",
-  "id": "<event-id>",
-  "type": "<sandbox-event-type>",
-  "eventData": {
-    "sandbox_metadata": {
-      "<custom-key>": "<custom-value>"
-    },
-    "execution": {
-      "started_at": "2025-08-06T20:58:24Z",
-      "vcpu_count": 2,
-      "memory_mb": 512,
-      "execution_time": 1000,
-    }
-  },
-  "sandboxBuildId": "<template-build-id>",
-  "sandboxExecutionId": "<sandbox-unique-execution-id>",
-  "sandboxId": "<your-sandbox-id>",
-  "sandboxTeamId": "<your-team-id>",
-  "sandboxTemplateId": "<your-template-id>",
-  "timestamp": "2025-08-06T20:59:24Z"
-}
-```
-
-`eventData.execution` contains sandbox execution details and is included on `sandbox.lifecycle.killed` and `sandbox.lifecycle.paused` events:
-
-- `started_at` - UTC RFC3339 timestamp when the current sandbox execution started
-- `vcpu_count` - Number of vCPUs assigned to the sandbox
-- `memory_mb` - Memory assigned to the sandbox in MB
-- `execution_time` - Sandbox runtime in milliseconds
-
-# Webhook verification
-To ensure the authenticity of webhook requests, each request includes a signature in the `e2b-signature` header.
-You can verify the signature using the signature secret you provided when registering the webhook.
-This confirms that the request originated from E2B and has not been tampered with.
-
-<CodeGroup>
-```js JavaScript & TypeScript
-function verifyWebhookSignature(secret : string, payload : string, payloadSignature : string) {
-    const expectedSignatureRaw = crypto.createHash('sha256').update(secret + payload).digest('base64');
-    const expectedSignature = expectedSignatureRaw.replace(/=+$/, '');
-    return  expectedSignature == payloadSignature
-}
-
-const payloadValid = verifyWebhookSignature(secret, webhookBodyRaw, webhookSignatureHeader)
-if (payloadValid) {
-    console.log("Payload signature is valid")
-} else {
-    console.log("Payload signature is INVALID")
-}
-```
-```python Python
-import hashlib
-import base64
-
-def verify_webhook_signature(secret: str, payload: str, payload_signature: str) -> bool:
-    hash_bytes = hashlib.sha256((secret + payload).encode('utf-8')).digest()
-    expected_signature = base64.b64encode(hash_bytes).decode('utf-8')
-    expected_signature = expected_signature.rstrip('=')
-
-    return expected_signature == payload_signature
-
-if verify_webhook_signature(secret, webhook_body_raw, webhook_signature_header):
-    print("Payload signature is valid")
-else:
-    print("Payload signature is INVALID")
-```
-```go Golang
-import (
-    "crypto/sha256"
-    "encoding/base64"
-    "fmt"
-    "strings"
-)
-
-func verifyWebhookSignature(secret, payload, payloadSignature string) bool {
-    hash := sha256.Sum256([]byte(secret + payload))
-    expectedSignature := base64.StdEncoding.EncodeToString(hash[:])
-
-    expectedSignature = strings.TrimRight(expectedSignature, "=")
-
-    return expectedSignature == payloadSignature
-}
-
-if verifyWebhookSignature(secret, webhookBodyString, webhookSignatureHeaderString) {
-    fmt.Println("Payload signature is valid")
-} else {
-    fmt.Println("Payload signature is INVALID")
-}
-```
-</CodeGroup>
-
-## Webhook request headers
-When webhooks is send, we are adding headers to help you verify the authenticity of the request and make debugging easier.
-
-- `e2b-webhook-id` - Webhook ID that triggered the event
-- `e2b-delivery-id` - Unique ID for the delivery attempt
-- `e2b-signature-version` - Currently always `v1`, reserved for future use
-- `e2b-signature` - Signature for verifying the request authenticity`
-
-## Available event types
-
-The following event types can be subscribed to via webhooks, they are used as the `type` field in the [payload](#webhook-payload).
-
-- `sandbox.lifecycle.created` - Sandbox creation
-- `sandbox.lifecycle.killed` - Sandbox termination
-- `sandbox.lifecycle.updated` - Sandbox configuration updates
-- `sandbox.lifecycle.paused` - Sandbox pausing
-- `sandbox.lifecycle.resumed` - Sandbox resuming
-- `sandbox.lifecycle.checkpointed` - Sandbox [snapshot](/docs/sandbox/snapshots) created
-
diff --git a/docs/sandbox/lifecycle.mdx b/docs/sandbox/lifecycle.mdx
new file mode 100644
index 00000000..04c0728a
--- /dev/null
+++ b/docs/sandbox/lifecycle.mdx
@@ -0,0 +1,481 @@
+---
+title: "Managing sandboxes"
+sidebarTitle: Managing sandboxes
+icon: "list-check"
+description: "Manage E2B sandboxes — timeouts, metadata, listing, filtering, connecting, and shutdown. Sandboxes are persistent cloud environments for AI agents."
+---
+
+Sandboxes stay running as long as you need them. When their timeout expires, they can automatically [pause to save resources](/docs/sandbox/persistence) — preserving their full state so you can resume at any time. You can also configure an explicit timeout or shut down a sandbox manually.
+
+<Note>
+Sandboxes can run continuously for up to 24 hours (Pro) or 1 hour (Base). For longer workloads, use [pause and resume](/docs/sandbox/persistence) — pausing resets the runtime window, and your sandbox's full state is preserved indefinitely.
+</Note>
+
+## Timeouts
+
+Every sandbox has a configurable timeout that determines how long it stays running. You set it at creation time in milliseconds (JavaScript) or seconds (Python).
+
+<CodeGroup>
+```js JavaScript & TypeScript highlight={6}
+import { Sandbox } from 'e2b'
+
+// Create a sandbox and keep it running for 60 seconds.
+// 🚨 Note: The units are milliseconds.
+const sandbox = await Sandbox.create({
+  timeoutMs: 60_000,
+})
+```
+```python Python highlight={6}
+from e2b import Sandbox
+
+# Create a sandbox and keep it running for 60 seconds.
+# 🚨 Note: The units are seconds.
+sandbox = Sandbox.create(
+  timeout=60,
+)
+```
+</CodeGroup>
+
+### Change timeout at runtime
+
+You can change the sandbox timeout when it's running by calling the `setTimeout` method in JavaScript or `set_timeout` method in Python.
+
+When you call the set timeout method, the sandbox timeout will be reset to the new value that you specified.
+
+This can be useful if you want to extend the sandbox lifetime when it's already running.
+You can for example start with a sandbox with 1 minute timeout and then periodically call set timeout every time user interacts with it in your app.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+// Create a sandbox and keep it running for 60 seconds.
+const sandbox = await Sandbox.create({ timeoutMs: 60_000 })
+
+// Change the sandbox timeout to 30 seconds.
+// 🚨 The new timeout will be 30 seconds from now.
+await sandbox.setTimeout(30_000)
+```
+```python Python
+from e2b import Sandbox
+
+# Create a sandbox and keep it running for 60 seconds.
+sandbox = Sandbox.create(timeout=60)
+
+# Change the sandbox timeout to 30 seconds.
+# 🚨 The new timeout will be 30 seconds from now.
+sandbox.set_timeout(30)
+```
+</CodeGroup>
+
+## Retrieve sandbox information
+
+You can retrieve sandbox information like sandbox ID, template, metadata, started at/end at date by calling the `getInfo` method in JavaScript or `get_info` method in Python.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+// Create a sandbox and keep it running for 60 seconds.
+const sandbox = await Sandbox.create({ timeoutMs: 60_000 })
+
+// Retrieve sandbox information.
+const info = await sandbox.getInfo()
+
+console.log(info)
+
+// {
+//   "sandboxId": "iiny0783cype8gmoawzmx-ce30bc46",
+//   "templateId": "rki5dems9wqfm4r03t7g",
+//   "name": "base",
+//   "metadata": {},
+//   "startedAt": "2025-03-24T15:37:58.076Z",
+//   "endAt": "2025-03-24T15:42:58.076Z"
+// }
+```
+
+```python Python
+from e2b import Sandbox
+
+# Create a sandbox and keep it running for 60 seconds.
+sandbox = Sandbox.create(timeout=60)
+
+# Retrieve sandbox information.
+info = sandbox.get_info()
+
+print(info)
+
+# SandboxInfo(sandbox_id='ig6f1yt6idvxkxl562scj-419ff533',
+#   template_id='u7nqkmpn3jjf1tvftlsu',
+#   name='base',
+#   metadata={},
+#   started_at=datetime.datetime(2025, 3, 24, 15, 42, 59, 255612, tzinfo=tzutc()),
+#   end_at=datetime.datetime(2025, 3, 24, 15, 47, 59, 255612, tzinfo=tzutc())
+# )
+```
+</CodeGroup>
+
+## Metadata
+
+Metadata lets you attach arbitrary key-value pairs to a sandbox. This is useful for associating sandboxes with user sessions, storing custom data, or looking up sandboxes later via `Sandbox.list()`.
+
+You specify metadata when creating a sandbox and can access it later through [listing sandboxes](/docs/sandbox/lifecycle#list-sandboxes).
+
+<CodeGroup>
+```js JavaScript & TypeScript highlight={6}
+import { Sandbox } from 'e2b'
+
+// Create sandbox with metadata.
+const sandbox = await Sandbox.create({
+  metadata: {
+    userId: '123',
+  },
+})
+
+// List running sandboxes and access metadata.
+const paginator = await Sandbox.list()
+const runningSandboxes = await paginator.nextItems()
+// Will print:
+// {
+//   'userId': '123',
+// }
+console.log(runningSandboxes[0].metadata)
+```
+```python Python highlight={6}
+from e2b import Sandbox
+
+# Create sandbox with metadata.
+sandbox = Sandbox.create(
+  metadata={
+    'userId': '123',
+  },
+)
+
+# List running sandboxes and access metadata.
+paginator = Sandbox.list()
+running_sandboxes = paginator.next_items()
+# Will print:
+# {
+#   'userId': '123',
+# }
+print(running_sandboxes[0].metadata)
+```
+</CodeGroup>
+
+You can also [filter sandboxes by metadata](/docs/sandbox/lifecycle#filter-sandboxes).
+
+## List sandboxes
+
+You can list sandboxes using the `Sandbox.list()` method. The method supports pagination and returns both running and paused sandboxes.
+
+<Note>
+    Once you have information about a running sandbox, you can [connect](/docs/sandbox/lifecycle#connect-to-a-sandbox) to it using the `Sandbox.connect()` method.
+</Note>
+
+<CodeGroup>
+    ```js JavaScript & TypeScript highlight={6,11,14,24}
+    import { Sandbox, SandboxInfo } from 'e2b'
+
+    const sandbox = await Sandbox.create(
+      {
+        metadata: {
+          name: 'My Sandbox',
+        },
+      },
+    )
+
+    const paginator = Sandbox.list()
+
+    // Get the first page of sandboxes (running and paused)
+    const firstPage = await paginator.nextItems()
+
+    const runningSandbox = firstPage[0]
+
+    console.log('Running sandbox metadata:', runningSandbox.metadata)
+    console.log('Running sandbox id:', runningSandbox.sandboxId)
+    console.log('Running sandbox started at:', runningSandbox.startedAt)
+    console.log('Running sandbox template id:', runningSandbox.templateId)
+
+    // Get the next page of sandboxes
+    const nextPage = await paginator.nextItems()
+    ```
+    ```python Python highlight={5,9,12,22}
+    from e2b import Sandbox, SandboxInfo
+
+    sandbox = Sandbox.create(
+        metadata={
+            "name": "My Sandbox",
+        },
+    )
+
+    paginator = Sandbox.list()
+
+    # Get the first page of sandboxes (running and paused)
+    firstPage = paginator.next_items()
+
+    running_sandbox = firstPage[0]
+
+    print('Running sandbox metadata:', running_sandbox.metadata)
+    print('Running sandbox id:', running_sandbox.sandbox_id)
+    print('Running sandbox started at:', running_sandbox.started_at)
+    print('Running sandbox template id:', running_sandbox.template_id)
+
+    # Get the next page of sandboxes
+    nextPage = paginator.next_items()
+    ```
+</CodeGroup>
+
+### Filter sandboxes
+
+Filter sandboxes by their current state. The state parameter can contain either "**running**" for running sandboxes or "**paused**" for paused sandboxes, or both.
+
+<CodeGroup>
+    ```js JavaScript & TypeScript highlight={9,13}
+    import { Sandbox } from 'e2b'
+
+    // Create a sandbox.
+    const sandbox = await Sandbox.create()
+
+    // List sandboxes that are running or paused.
+    const paginator = Sandbox.list({
+      query: {
+        state: ['running', 'paused'],
+      },
+    })
+
+    const sandboxes = await paginator.nextItems()
+    ```
+    ```python Python highlight={9,14}
+    from e2b import Sandbox, SandboxQuery, SandboxState
+
+    # Create a sandbox with metadata.
+    sandbox = Sandbox.create()
+
+    # List sandboxes that are running or paused.
+    paginator = Sandbox.list(
+        query=SandboxQuery(
+            state=[SandboxState.RUNNING, SandboxState.PAUSED],
+        ),
+    )
+
+    # Get the first page of sandboxes (running and paused)
+    sandboxes = paginator.next_items()
+    ```
+</CodeGroup>
+
+You can also filter sandboxes by metadata key-value pairs specified during creation.
+
+<CodeGroup>
+    ```js JavaScript & TypeScript highlight={6-8,15,18}
+    import { Sandbox } from 'e2b'
+
+    // Create sandbox with metadata.
+    const sandbox = await Sandbox.create({
+      metadata: {
+        env: 'dev',
+        app: 'my-app',
+        userId: '123',
+      },
+    })
+
+    // List all sandboxes that has `userId` key with value `123` and `env` key with value `dev`.
+    const paginator = Sandbox.list({
+      query: {
+        metadata: { userId: '123', env: 'dev' },
+      },
+    })
+
+    const sandboxes = await paginator.nextItems()
+    ```
+    ```python Python highlight={6-8,16-17}
+    from e2b import Sandbox, SandboxQuery, SandboxState
+
+    # Create sandbox with metadata.
+    sandbox = Sandbox.create(
+        metadata={
+            "env": "dev",
+            "app": "my-app",
+            "user_id": "123",
+        },
+    )
+
+    # List running sandboxes that has `userId` key with value `123` and `env` key with value `dev`.
+    paginator = Sandbox.list(
+        query=SandboxQuery(
+            metadata={
+                "userId": "123",
+                "env": "dev",
+            }
+        ),
+    )
+
+    # Get the first page of sandboxes (running and paused)
+    sandboxes = paginator.next_items()
+    ```
+</CodeGroup>
+
+### Advanced pagination
+
+For more granular pagination, you can set custom per-page item limit (default and maximum is **100**) and specify an offset parameter (`nextToken` or `next_token`) to start paginating from.
+
+<CodeGroup>
+    ```js JavaScript & TypeScript highlight={4-5,16}
+    import { Sandbox } from 'e2b'
+
+    const paginator = Sandbox.list({
+      limit: 100,
+      nextToken: '<base64-encoded-token>',
+    })
+
+    // Additional paginator properties
+    // Whether there is a next page
+    paginator.hasNext
+
+    // Next page token
+    paginator.nextToken
+
+    // Fetch the next page
+    await paginator.nextItems()
+    ```
+    ```python Python  highlight={5-6,13}
+    from e2b import Sandbox
+
+    paginator = Sandbox.list(
+        limit=100,
+        next_token="<base64-encoded-token>",
+    )
+
+    paginator.has_next  # Whether there is a next page
+    paginator.next_token  # Next page token
+
+    # Fetch the next page
+    paginator.next_items()
+    ```
+</CodeGroup>
+
+You can fetch all pages by looping through the paginator while checking if there is a next page (using `hasNext` or `has_next` property) and fetching until there are no more pages left to fetch:
+
+<CodeGroup>
+    ```js JavaScript & TypeScript  highlight={7}
+    import { Sandbox } from 'e2b'
+
+    const paginator = Sandbox.list()
+
+    // Loop through all pages
+    const sandboxes: SandboxInfo[] = []
+    while (paginator.hasNext) {
+      const items = await paginator.nextItems()
+      sandboxes.push(...items)
+    }
+    ```
+    ```python Python highlight={7}
+    from e2b import Sandbox, SandboxQuery
+
+    paginator = Sandbox.list()
+
+    # Loop through all pages
+    sandboxes: list[SandboxInfo] = []
+    while paginator.has_next:
+        items = paginator.next_items()
+        sandboxes.extend(items)
+    ```
+</CodeGroup>
+
+## Connect to a sandbox
+
+If you have a running sandbox, you can connect to it using the `Sandbox.connect()` method and start controlling it with the SDK. This is useful for reusing the same sandbox instance after a period of inactivity, or for resuming a paused sandbox.
+
+### 1. Get the sandbox ID
+
+To connect to a running sandbox, you first need to retrieve its ID. You can do this by calling the `Sandbox.list()` method.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+const sbx = await Sandbox.create()
+
+// Get all running sandboxes
+const paginator = await Sandbox.list({
+  query: { state: ['running'] },
+})
+
+const runningSandboxes = await paginator.nextItems()
+if (runningSandboxes.length === 0) {
+  throw new Error('No running sandboxes found')
+}
+
+// Get the ID of the sandbox you want to connect to
+const sandboxId = runningSandboxes[0].sandboxId
+```
+
+```python Python
+from e2b import Sandbox
+
+sbx = Sandbox.create()
+
+# Get all running sandboxes
+paginator = Sandbox.list()
+
+# Get the ID of the sandbox you want to connect to
+running_sandboxes = paginator.next_items()
+if len(running_sandboxes) == 0:
+    raise Exception("No running sandboxes found")
+
+# Get the ID of the sandbox you want to connect to
+sandbox_id = running_sandboxes[0].sandbox_id
+```
+</CodeGroup>
+
+### 2. Connect to the sandbox
+
+Now that you have the sandbox ID, you can connect to the sandbox using the `Sandbox.connect()` method.
+
+<CodeGroup>
+```js JavaScript & TypeScript highlight={3}
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.connect(sandboxId)
+
+// Now you can use the sandbox as usual
+// ...
+const result = await sandbox.commands.run("whoami")
+console.log(`Running in sandbox ${sandbox.sandboxId} as "${result.stdout.trim()}"`)
+```
+
+```python Python highlight={3}
+from e2b import Sandbox
+
+sandbox = Sandbox.connect(sandbox_id)
+
+# Now you can use the sandbox as usual
+# ...
+r = sandbox.commands.run("whoami")
+print(f"Running in sandbox {sandbox.sandbox_id} as \"{r.stdout.strip()}\"")
+```
+</CodeGroup>
+
+## Shutdown sandbox
+
+You can shutdown the sandbox any time even before the timeout is up by calling the `kill` method.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+// Create a sandbox and keep it running for 60 seconds.
+const sandbox = await Sandbox.create({ timeoutMs: 60_000 })
+
+// Shutdown the sandbox immediately.
+await sandbox.kill()
+```
+```python Python
+from e2b import Sandbox
+
+# Create a sandbox and keep it running for 60 seconds.
+sandbox = Sandbox.create(timeout=60)
+
+# Shutdown the sandbox immediately.
+sandbox.kill()
+```
+</CodeGroup>
diff --git a/docs/sandbox/list.mdx b/docs/sandbox/list.mdx
deleted file mode 100644
index 4d836e8f..00000000
--- a/docs/sandbox/list.mdx
+++ /dev/null
@@ -1,339 +0,0 @@
----
-title: "List sandboxes"
----
-
-You can list sandboxes using the `Sandbox.list()` method.
-
-<Note>
-    Once you have information about running sandbox, you can [connect](/docs/sandbox/connect) to it using the `Sandbox.connect()` method.
-</Note>
-
-### Listing sandboxes
-
-The `Sandbox.list()` method supports pagination. In the [advanced pagination](/docs/sandbox/list#advanced-pagination) section, you can find more information about pagination techniques using the updated method.
-
-<CodeGroup>
-    ```js JavaScript & TypeScript highlight={6,11,14,24}
-    import { Sandbox, SandboxInfo } from '@e2b/code-interpreter'
-
-    const sandbox = await Sandbox.create(
-      {
-        metadata: {
-          name: 'My Sandbox',
-        },
-      },
-    )
-
-    const paginator = Sandbox.list()
-
-    // Get the first page of sandboxes (running and paused)
-    const firstPage = await paginator.nextItems()
-
-    const runningSandbox = firstPage[0]
-
-    console.log('Running sandbox metadata:', runningSandbox.metadata)
-    console.log('Running sandbox id:', runningSandbox.sandboxId)
-    console.log('Running sandbox started at:', runningSandbox.startedAt)
-    console.log('Running sandbox template id:', runningSandbox.templateId)
-
-    // Get the next page of sandboxes
-    const nextPage = await paginator.nextItems()
-    ```
-    ```python Python highlight={5,9,12,22}
-    from e2b_code_interpreter import Sandbox, SandboxInfo
-
-    sandbox = Sandbox.create(
-        metadata={
-            "name": "My Sandbox",
-        },
-    )
-
-    paginator = Sandbox.list()
-
-    # Get the first page of sandboxes (running and paused)
-    firstPage = paginator.next_items()
-
-    running_sandbox = firstPage[0]
-
-    print('Running sandbox metadata:', running_sandbox.metadata)
-    print('Running sandbox id:', running_sandbox.sandbox_id)
-    print('Running sandbox started at:', running_sandbox.started_at)
-    print('Running sandbox template id:', running_sandbox.template_id)
-
-    # Get the next page of sandboxes
-    nextPage = paginator.next_items()
-    ```
-</CodeGroup>
-The code above will output something like this:
-<CodeGroup>
-    ```bash JavaScript & TypeScript
-    Running sandbox metadata: {name: "My Sandbox"}
-    Running sandbox id: ixjj3iankaishgcge4jwn-b0b684e9
-    Running sandbox started at: 2024-10-15T21:13:07.311Z
-    Running sandbox template id: 3e4rngfa34txe0gxc1zf
-    ```
-    ```bash Python
-    Running sandbox metadata: {'name': 'My Sandbox'}
-    Running sandbox id: ixjj3iankaishgcge4jwn-b0b684e9
-    Running sandbox started at: 2024-10-15 21:13:07.311861+00:00
-    Running sandbox template id: 3e4rngfa34txe0gxc1zf
-    ```
-</CodeGroup>
-
-
-### Filtering sandboxes
-
-Filter sandboxes by their current state. The state parameter can contain either "**running**" for running sandboxes or "**paused**" for paused sandboxes, or both.
-
-<CodeGroup>
-    ```js JavaScript & TypeScript highlight={9,13}
-    import { Sandbox } from '@e2b/code-interpreter'
-
-    // Create a sandbox.
-    const sandbox = await Sandbox.create()
-
-    // List sandboxes that are running or paused.
-    const paginator = Sandbox.list({
-      query: {
-        state: ['running', 'paused'],
-      },
-    })
-
-    const sandboxes = await paginator.nextItems()
-    ```
-    ```python Python highlight={9,14}
-    from e2b_code_interpreter import Sandbox, SandboxQuery, SandboxState
-
-    # Create a sandbox with metadata.
-    sandbox = Sandbox.create()
-
-    # List sandboxes that are running or paused.
-    paginator = Sandbox.list(
-        query=SandboxQuery(
-            state=[SandboxState.RUNNING, SandboxState.PAUSED],
-        ),
-    )
-
-    # Get the first page of sandboxes (running and paused)
-    sandboxes = paginator.next_items()
-    ```
-</CodeGroup>
-
-Filter sandboxes by the metadata key value pairs specified during Sandbox creation.
-
-<CodeGroup>
-    ```js JavaScript & TypeScript highlight={6-8,15,18}
-    import { Sandbox } from '@e2b/code-interpreter'
-
-    // Create sandbox with metadata.
-    const sandbox = await Sandbox.create({
-      metadata: {
-        env: 'dev',
-        app: 'my-app',
-        userId: '123',
-      },
-    })
-
-    // List all sandboxes that has `userId` key with value `123` and `env` key with value `dev`.
-    const paginator = Sandbox.list({
-      query: {
-        metadata: { userId: '123', env: 'dev' },
-      },
-    })
-
-    const sandboxes = await paginator.nextItems()
-    ```
-    ```python Python highlight={6-8,16-17}
-    from e2b_code_interpreter import Sandbox, SandboxQuery, SandboxState
-
-    # Create sandbox with metadata.
-    sandbox = Sandbox.create(
-        metadata={
-            "env": "dev",
-            "app": "my-app",
-            "user_id": "123",
-        },
-    )
-
-    # List running sandboxes that has `userId` key with value `123` and `env` key with value `dev`.
-    paginator = Sandbox.list(
-        query=SandboxQuery(
-            metadata={
-                "userId": "123",
-                "env": "dev",
-            }
-        ),
-    )
-
-    # Get the first page of sandboxes (running and paused)
-    sandboxes = paginator.next_items()
-    ```
-</CodeGroup>
-
-### Advanced pagination
-
-For more granular pagination, you can set custom per-page item limit (default and maximum is **100**) and specify an offset parameter (`nextToken` or `next_token`) to start paginating from.
-
-<CodeGroup>
-    ```js JavaScript & TypeScript highlight={4-5,16}
-    import { Sandbox } from '@e2b/code-interpreter'
-
-    const paginator = Sandbox.list({
-      limit: 100,
-      nextToken: '<base64-encoded-token>',
-    })
-
-    // Additional paginator properties
-    // Whether there is a next page
-    paginator.hasNext
-
-    // Next page token
-    paginator.nextToken
-
-    // Fetch the next page
-    await paginator.nextItems()
-    ```
-    ```python Python  highlight={5-6,13}
-    from e2b_code_interpreter import Sandbox
-
-    # List running sandboxes that has `userId` key with value `123` and `env` key with value `dev`.
-    paginator = Sandbox.list(
-        limit=100,
-        next_token="<base64-encoded-token>",
-    )
-
-    paginator.has_next  # Whether there is a next page
-    paginator.next_token  # Next page token
-
-    # Fetch the next page
-    paginator.next_items()
-    ```
-</CodeGroup>
-
-You can fetch all pages by looping through the paginator while checking if there is a next page (using `hasNext` or `has_next` property) and fetching until there are no more pages left to fetch:
-
-<CodeGroup>
-    ```js JavaScript & TypeScript  highlight={7}
-    import { Sandbox } from '@e2b/code-interpreter'
-
-    const paginator = Sandbox.list()
-
-    // Loop through all pages
-    const sandboxes: SandboxInfo[] = []
-    while (paginator.hasNext) {
-      const items = await paginator.nextItems()
-      sandboxes.push(...items)
-    }
-    ```
-    ```python Python highlight={7}
-    from e2b_code_interpreter import Sandbox, SandboxQuery
-
-    paginator = Sandbox.list()
-
-    # Loop through all pages
-    sandboxes: list[SandboxInfo] = []
-    while paginator.has_next:
-        items = paginator.next_items()
-        sandboxes.extend(items)
-    ```
-</CodeGroup>
-
-## Old SDK (v1.x.y)
-
-<Note>
-    If you're using SDK with version lower than `2.0.0`, the `Sandbox.list()` method behaves differently.
-</Note>
-
-
-<CodeGroup>
-    ```js JavaScript & TypeScript highlight={11}
-    import { Sandbox } from '@e2b/code-interpreter'
-
-    // Create a sandbox.
-    const sandbox = await Sandbox.create({
-      metadata: {
-        name: 'My Sandbox',
-      },
-    })
-
-    // List all running sandboxes.
-    const runningSandboxes = await Sandbox.list()
-    const runningSandbox = runningSandboxes[0]
-
-    console.log('Running sandbox metadata:', runningSandbox.metadata)
-    console.log('Running sandbox id:', runningSandbox.sandboxId)
-    console.log('Running sandbox started at:', runningSandbox.startedAt)
-    console.log('Running sandbox template id:', runningSandbox.templateId)
-    ```
-    ```python Python highlight={11}
-    from e2b_code_interpreter import Sandbox
-
-    # Create a sandbox.
-    sandbox = Sandbox.create(
-      metadata: {
-        name: 'My Sandbox',
-      },
-    )
-
-    # List all running sandboxes.
-    running_sandboxes = Sandbox.list() 
-    running_sandbox = running_sandboxes[0]
-
-    print('Running sandbox metadata:', running_sandbox.metadata)
-    print('Running sandbox id:', running_sandbox.sandbox_id)
-    print('Running sandbox started at:', running_sandbox.started_at)
-    print('Running sandbox template id:', running_sandbox.template_id)
-    ```
-</CodeGroup>
-
-## Filtering sandboxes
-
-You can filter sandboxes by specifying [Metadata](/docs/sandbox/metadata) key value pairs.
-Specifying multiple key value pairs will return sandboxes that match all of them.
-
-This can be useful when you have a large number of sandboxes and want to find only specific ones. The filtering is performed on the server.
-
-<CodeGroup>
-    ```js JavaScript & TypeScript highlight={6-8,15}
-    import { Sandbox } from '@e2b/code-interpreter'
-
-    // Create sandbox with metadata.
-    const sandbox = await Sandbox.create({
-      metadata: {
-        env: 'dev',
-        app: 'my-app',
-        userId: '123',
-      },
-    })
-
-    // List running sandboxes that has `userId` key with value `123` and `env` key with value `dev`.
-    const runningSandboxes = await Sandbox.list({
-      query: {
-        metadata: { userId: '123', env: 'dev' },
-      },
-    })
-    ```
-    ```python Python highlight={7-9,17-18}
-    from e2b_code_interpreter import Sandbox
-    from e2b.sandbox.sandbox_api import SandboxQuery
-
-    # Create sandbox with metadata.
-    sandbox = Sandbox.create(
-        metadata={
-            "env": "dev",
-            "app": "my-app",
-            "user_id": "123",
-        },
-    )
-
-    # List running sandboxes that has `userId` key with value `123` and `env` key with value `dev`.
-    running_sandboxes = Sandbox.list(
-        query=SandboxQuery(
-            metadata={
-                "userId": "123",
-                "env": "dev",
-            }
-        ),
-    )
-    ```
-</CodeGroup>
diff --git a/docs/sandbox/mcp.mdx b/docs/sandbox/mcp.mdx
new file mode 100644
index 00000000..d87a1c70
--- /dev/null
+++ b/docs/sandbox/mcp.mdx
@@ -0,0 +1,514 @@
+---
+title: "MCP gateway"
+sidebarTitle: MCP gateway
+icon: "plug"
+description: "Connect E2B sandboxes to 200+ MCP tools — Browserbase, Exa, Notion, Stripe, GitHub, and more — through a built-in MCP gateway."
+---
+
+E2B provides a batteries-included MCP gateway that runs inside sandboxes, giving you type-safe access to 200+ MCP tools from the [Docker MCP Catalog](https://hub.docker.com/mcp) or [custom MCP servers](#custom-mcp-servers) through a unified interface. This integration gives developers instant access to tools like [Browserbase](https://www.browserbase.com/), [Exa](https://exa.ai/), [Notion](https://www.notion.so/), [Stripe](https://stripe.com/), or [GitHub](https://github.com/).
+
+The [Model Context Protocol (MCP)](https://modelcontextprotocol.io/docs/getting-started/intro) is an open standard for connecting AI models to external tools and data sources. E2B sandboxes provide an ideal environment for running MCP tools, giving AI full access to an internet-connected Linux machine where it can safely install packages, write files, run terminal commands, and AI-generated code.
+
+<Frame>
+    <img src="/images/mcp-overview.png" />
+</Frame>
+
+## Quickstart
+
+Create a sandbox with MCP servers configured and connect it to an AI agent. This example sets up Browserbase, Exa, and Airtable MCP servers and uses Claude to orchestrate them.
+
+<CodeGroup>
+
+```typescript TypeScript
+import Sandbox from 'e2b'
+
+const sbx = await Sandbox.create({
+    mcp: {
+        browserbase: {
+            apiKey: process.env.BROWSERBASE_API_KEY!,
+            geminiApiKey: process.env.GEMINI_API_KEY!,
+            projectId: process.env.BROWSERBASE_PROJECT_ID!,
+        },
+        exa: {
+            apiKey: process.env.EXA_API_KEY!,
+        },
+        airtable: {
+            airtableApiKey: process.env.AIRTABLE_API_KEY!,
+        },
+    },
+});
+
+const mcpUrl = sbx.getMcpUrl();
+const mcpToken = await sbx.getMcpToken();
+
+// You can now connect the gateway to any MCP client, for example claude:
+// This also works for your local claude!
+await sbx.commands.run(`claude mcp add --transport http e2b-mcp-gateway ${mcpUrl} --header "Authorization: Bearer ${mcpToken}"`, { timeoutMs: 0, onStdout: console.log, onStderr: console.log });
+
+await sbx.commands.run(
+    `echo 'Use browserbase and exa to research open positions at e2b.dev. Collect your findings in Airtable.' | claude -p --dangerously-skip-permissions`,
+    { timeoutMs: 0, onStdout: console.log, onStderr: console.log }
+)
+
+```
+
+```python Python
+import asyncio
+from e2b import AsyncSandbox
+import os
+import dotenv
+
+dotenv.load_dotenv()
+
+async def main():
+    sbx = await AsyncSandbox.create(mcp={
+        "browserbase": {
+            "apiKey": os.getenv("BROWSERBASE_API_KEY"),
+            "geminiApiKey": os.getenv("GEMINI_API_KEY"),
+            "projectId": os.getenv("BROWSERBASE_PROJECT_ID"),
+        },
+        "exa": {
+            "apiKey": os.getenv("EXA_API_KEY"),
+        },
+        "airtable": {
+            "airtableApiKey": os.getenv("AIRTABLE_API_KEY"),
+        },
+    })
+
+    mcp_url = sbx.get_mcp_url()
+    mcp_token = await sbx.get_mcp_token()
+
+    # You can now connect the gateway to any MCP client, for example claude:
+    # This also works for your local claude!
+    await sbx.commands.run(f'claude mcp add --transport http e2b-mcp-gateway {mcp_url} --header "Authorization: Bearer {mcp_token}"', timeout=0, on_stdout=print, on_stderr=print)
+
+    await sbx.commands.run(
+        "echo 'Use browserbase and exa to research open positions at e2b.dev. Collect your findings in Airtable.' | claude -p --dangerously-skip-permissions",
+        timeout=0, on_stdout=print, on_stderr=print
+    )
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+</CodeGroup>
+
+## Connecting to the MCP gateway
+
+You can connect to the MCPs running inside the sandbox both from outside and inside the sandbox.
+
+### From outside the sandbox
+
+To connect to the MCPs running inside the sandbox, use the `sandbox.getMcpUrl()` in JavaScript and `sandbox.get_mcp_url()` in Python.
+
+<CodeGroup>
+```typescript TypeScript
+import Sandbox from 'e2b'
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+
+const sandbox = await Sandbox.create({
+    mcp: {
+        browserbase: {
+            apiKey: process.env.BROWSERBASE_API_KEY!,
+            geminiApiKey: process.env.GEMINI_API_KEY!,
+            projectId: process.env.BROWSERBASE_PROJECT_ID!,
+        },
+        exa: {
+            apiKey: process.env.EXA_API_KEY!,
+        },
+        notion: {
+            internalIntegrationToken: process.env.NOTION_API_KEY!,
+        },
+    },
+});
+
+const client = new Client({
+    name: 'e2b-mcp-client',
+    version: '1.0.0'
+});
+
+const transport = new StreamableHTTPClientTransport(
+    new URL(sandbox.getMcpUrl()),
+    {
+        requestInit: {
+            headers: {
+                'Authorization': `Bearer ${await sandbox.getMcpToken()}`
+            }
+        }
+    }
+);
+
+await client.connect(transport);
+
+const tools = await client.listTools();
+console.log('Available tools:', tools.tools.map(t => t.name));
+
+await client.close();
+await sandbox.kill();
+```
+
+```python Python
+import os
+import dotenv
+dotenv.load_dotenv()
+from e2b import AsyncSandbox
+import asyncio
+from datetime import timedelta
+from mcp.client.session import ClientSession
+from mcp.client.streamable_http import streamablehttp_client
+
+async def main():
+    sandbox = await AsyncSandbox.create(
+        mcp={
+            "browserbase": {
+                "apiKey": os.environ["BROWSERBASE_API_KEY"],
+                "geminiApiKey": os.environ["GEMINI_API_KEY"],
+                "projectId": os.environ["BROWSERBASE_PROJECT_ID"],
+            },
+            "exa": {
+                "apiKey": os.environ["EXA_API_KEY"],
+            },
+            "notion": {
+                "internalIntegrationToken": os.environ["NOTION_API_KEY"],
+            },
+        }
+    )
+
+    async with streamablehttp_client(
+        url=sandbox.get_mcp_url(),
+        headers={"Authorization": f"Bearer {await sandbox.get_mcp_token()}"},
+        timeout=timedelta(seconds=600)
+    ) as (read_stream, write_stream, _):
+        async with ClientSession(read_stream, write_stream) as session:
+            await session.initialize()
+            tools = await session.list_tools()
+            print(f"Available tools: {[tool.name for tool in tools.tools]}")
+    await sandbox.kill()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+</CodeGroup>
+
+### From inside the sandbox
+
+If you need to access the MCP gateway from within the sandbox itself, it's available at:
+```
+http://localhost:50005/mcp
+```
+
+You'll need to include the Authorization header with the MCP token when making requests from inside the sandbox. How that is added depends on the MCP client you use.
+
+## MCP client integrations
+
+### Claude
+
+```
+claude mcp add --transport http e2b-mcp-gateway <url goes here> --header "Authorization: Bearer <token goes here>"
+```
+
+### OpenAI Agents
+
+<CodeGroup>
+```typescript TypeScript
+import { MCPServerStreamableHttp } from '@openai/agents';
+
+const mcp = new MCPServerStreamableHttp({
+    url: mcpUrl,
+    name: 'E2B MCP Gateway',
+    requestInit: {
+        headers: {
+            'Authorization': `Bearer ${await sandbox.getMcpToken()}`
+        }
+    },
+});
+```
+
+```python Python
+import asyncio
+import os
+from e2b import AsyncSandbox
+from agents.mcp import MCPServerStreamableHttp
+
+async def main():
+    async with MCPServerStreamableHttp(
+        name="e2b-mcp-client",
+        params={
+            "url": sandbox.get_mcp_url(),
+            "headers": {"Authorization": f"Bearer {await sandbox.get_mcp_token()}"},
+        },
+    ) as server:
+        tools = await server.list_tools()
+        print("Available tools:", [t.name for t in tools])
+
+    # Clean up
+    await sandbox.kill()
+
+asyncio.run(main())
+```
+</CodeGroup>
+
+### Official MCP client
+
+<CodeGroup>
+```typescript TypeScript
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+
+const client = new Client({
+    name: 'e2b-mcp-client',
+    version: '1.0.0'
+});
+
+const transport = new StreamableHTTPClientTransport(
+    new URL(sandbox.getMcpUrl()),
+    {
+        requestInit: {
+            headers: {
+                'Authorization': `Bearer ${await sandbox.getMcpToken()}`
+            }
+        }
+    }
+);
+await client.connect(transport);
+```
+```python Python
+import asyncio
+from datetime import timedelta
+from mcp.client.session import ClientSession
+from mcp.client.streamable_http import streamablehttp_client
+
+async def main():
+    async with streamablehttp_client(
+        url=sandbox.get_mcp_url(),
+        headers={"Authorization": f"Bearer {await sandbox.get_mcp_token()}"},
+        timeout=timedelta(seconds=600)
+    ) as (read_stream, write_stream, _):
+        async with ClientSession(read_stream, write_stream) as session:
+            await session.initialize()
+
+            tools = await session.list_tools()
+            print(f"Available tools: {[tool.name for tool in tools.tools]}")
+    await sandbox.kill()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+
+```
+
+</CodeGroup>
+
+This list is not exhaustive. You can find more examples in the [E2B Cookbook](https://github.com/e2b-dev/e2b-cookbook).
+
+## Custom templates
+
+You can prepull MCP server Docker images during template build time to significantly improve runtime performance.
+
+When you build a template with prepulled MCP servers, the Docker images for those servers are downloaded and cached during the build process. This means when you create a sandbox from that template, the MCP servers are ready to use immediately without waiting for image downloads.
+
+<Info>
+You must use the MCP gateway enabled template (`mcp-gateway`) as your base template to use this feature.
+</Info>
+
+### Building a template with MCP servers
+
+Use the `addMcpServer()` method (TypeScript) or `add_mcp_server()` method (Python) to prepull MCP server images during template build. You can pass a single server or an array of servers.
+
+The server names (like `"browserbase"` and `"exa"`) correspond to the keys defined in the [Available Servers](/docs/sandbox/mcp/available-servers) documentation.
+
+<CodeGroup>
+
+```typescript JavaScript & TypeScript
+import "dotenv/config";
+import { Template, defaultBuildLogger } from 'e2b';
+
+export const template = Template()
+  .fromTemplate("mcp-gateway")
+  .addMcpServer(["browserbase", "exa"]);
+
+await Template.build(template, 'my-mcp-gateway', {
+  cpuCount: 8,
+  memoryMB: 8192,
+  onBuildLogs: defaultBuildLogger(),
+});
+```
+
+```python Python
+from dotenv import load_dotenv
+from e2b import Template, default_build_logger
+
+load_dotenv()
+
+template = (
+    Template()
+    .from_template("mcp-gateway")
+    .add_mcp_server(["browserbase", "exa"])
+)
+
+Template.build(
+    template,
+    'my-mcp-gateway',
+    cpu_count=8,
+    memory_mb=8192,
+    on_build_logs=default_build_logger(),
+)
+```
+
+</CodeGroup>
+
+### Using the template
+
+Once built, create sandboxes from your template. You still need to provide the configuration for each MCP server.
+
+<CodeGroup>
+
+```typescript JavaScript & TypeScript
+import { Sandbox } from 'e2b';
+
+const sandbox = await Sandbox.create({
+    template: "my-mcp-gateway",
+    mcp: {
+        browserbase: {
+            apiKey: process.env.BROWSERBASE_API_KEY!,
+            geminiApiKey: process.env.GEMINI_API_KEY!,
+            projectId: process.env.BROWSERBASE_PROJECT_ID!,
+        },
+        exa: {
+            apiKey: process.env.EXA_API_KEY!,
+        },
+    },
+});
+
+```
+
+```python Python
+from e2b import Sandbox
+import os
+
+sbx = Sandbox.create(
+    template="my-mcp-gateway",
+    mcp={
+        "browserbase": {
+            "apiKey": os.getenv("BROWSERBASE_API_KEY"),
+            "geminiApiKey": os.getenv("GEMINI_API_KEY"),
+            "projectId": os.getenv("BROWSERBASE_PROJECT_ID"),
+        },
+        "exa": {
+            "apiKey": os.getenv("EXA_API_KEY"),
+        },
+    }
+)
+```
+
+</CodeGroup>
+
+For more information about working with templates, see:
+- [Template Quickstart](/docs/template/quickstart) - Get started with custom templates
+- [Defining Templates](/docs/template/defining-template) - Learn all template configuration options
+- [Template Build](/docs/template/build) - Understand the build process
+
+## Custom MCP servers
+
+In addition to the 200+ pre-built MCP servers from the [Docker MCP Catalog](https://hub.docker.com/mcp), you can run custom MCP servers directly from public GitHub repositories.
+
+When you specify a GitHub repository, E2B will:
+1. Clone the repository into the sandbox
+2. Run the `installCmd` (optional) to install dependencies
+3. Run the `runCmd` to start the MCP server with stdio transport
+
+The `runCmd` must start an MCP server that follows the [MCP specification](https://modelcontextprotocol.io/specification/2025-06-18) and communicates via stdio (standard input/output).
+
+<CodeGroup>
+
+```typescript TypeScript
+import Sandbox from 'e2b'
+
+const sandbox = await Sandbox.create({
+    mcp: {
+        'github/modelcontextprotocol/servers': {
+            installCmd: 'npm install',
+            runCmd: 'sudo npx -y @modelcontextprotocol/server-filesystem /root',
+        },
+    },
+});
+```
+
+```python Python
+from e2b import Sandbox
+import os
+
+sbx = Sandbox.create(
+    mcp={
+        "github/modelcontextprotocol/servers": {
+                "install_cmd": "npm install",
+                "run_cmd": "sudo npx -y @modelcontextprotocol/server-filesystem /root",
+        },
+    }
+)
+```
+
+</CodeGroup>
+
+### Configuration
+
+<ParamField path="installCmd" type="string">
+  Optional command to run before starting the MCP server. Use this to install dependencies (e.g., `npm install`, `pip install -r requirements.txt`).
+</ParamField>
+
+<ParamField path="runCmd" type="string" required>
+  Command to start the MCP server. Must launch a stdio-enabled MCP server.
+</ParamField>
+
+<Note>
+**Important for npx-based servers:** Always include `installCmd: 'npm install'` (or equivalent) when using `npx` in your `runCmd`. Without installing dependencies first, npx will try to use the local repository and fail.
+</Note>
+
+### Troubleshooting
+
+If your custom MCP server doesn't work as expected:
+
+1. Explore the sandbox either via the [dashboard](https://e2b.dev/dashboard) or by connecting to it via `e2b connect <sandbox-id>`
+2. Check the gateway log file with `sudo cat /var/log/mcp-gateway/gateway.log`.
+
+## Debugging with MCP Inspector
+
+The [MCP Inspector](https://github.com/modelcontextprotocol/inspector) is a useful tool for debugging and testing your MCP server setup. Get the command to run:
+
+```bash
+npx @modelcontextprotocol/inspector --transport http --url <your-mcp-url> --header "Authorization: Bearer ${mcpToken}"
+```
+
+Run the command in your terminal. This will open a web interface where you can:
+- Browse available tools
+- Test tool calls with different parameters
+- Inspect request/response payloads
+- Debug connection issues
+
+## Examples
+
+<CardGroup cols={3}>
+  <Card title="Claude Code" icon="terminal" href="https://github.com/e2b-dev/e2b-cookbook/tree/main/examples/mcp-claude-code-js">
+    Claude Code with MCP integration
+  </Card>
+  <Card title="Browserbase" icon="browser" href="https://github.com/e2b-dev/e2b-cookbook/tree/main/examples/mcp-browserbase-js">
+    Web automation agent with Browserbase
+  </Card>
+  <Card title="Groq + Exa" icon="sparkles" href="https://github.com/e2b-dev/e2b-cookbook/tree/main/examples/mcp-groq-exa-js">
+    AI research using Groq and Exa
+  </Card>
+  <Card title="Research agent" icon="magnifying-glass" href="https://github.com/e2b-dev/e2b-cookbook/tree/main/examples/mcp-research-agent-js">
+    Research Agent using the OpenAI Agents framework
+  </Card>
+  <Card title="MCP client" icon="plug" href="https://github.com/e2b-dev/e2b-cookbook/tree/main/examples/mcp-client-js">
+    Basic MCP client connecting to an E2B Sandbox
+  </Card>
+  <Card title="Custom MCP server" icon="server" href="https://github.com/e2b-dev/e2b-cookbook/tree/main/examples/mcp-custom-server-js">
+    Use custom MCP servers installed from GitHub
+  </Card>
+  <Card title="Custom template" icon="box" href="https://github.com/e2b-dev/e2b-cookbook/tree/main/examples/mcp-custom-template-js">
+    Create a custom E2B Sandbox with pre-installed MCP servers
+  </Card>
+</CardGroup>
+
+For the full list of available MCP servers, see [Available servers](/docs/sandbox/mcp/available-servers).
diff --git a/docs/mcp/available-servers.mdx b/docs/sandbox/mcp/available-servers.mdx
similarity index 99%
rename from docs/mcp/available-servers.mdx
rename to docs/sandbox/mcp/available-servers.mdx
index 7cf25ad5..34e36d5f 100644
--- a/docs/mcp/available-servers.mdx
+++ b/docs/sandbox/mcp/available-servers.mdx
@@ -3,7 +3,7 @@ title: Available servers
 description: Browse available MCP servers
 ---
 
-E2B provides access to 200+ MCP servers from [Docker's catalog](https://hub.docker.com/mcp). You can also run [custom MCP servers](/docs/mcp/custom-servers) inside the sandbox.
+E2B provides access to 200+ MCP servers from [Docker's catalog](https://hub.docker.com/mcp). You can also run [custom MCP servers](/docs/sandbox/mcp#custom-mcp-servers) inside the sandbox.
 
 
 ## Airtable
diff --git a/docs/sandbox/metadata.mdx b/docs/sandbox/metadata.mdx
deleted file mode 100644
index 026c4362..00000000
--- a/docs/sandbox/metadata.mdx
+++ /dev/null
@@ -1,57 +0,0 @@
----
-title: "Sandbox metadata"
-sidebarTitle: Metadata
----
-
-Metadata is a way to attach arbitrary key-value pairs for a sandbox.
-
-This is useful in various scenarios, for example:
-- Associate a sandbox with a user session.
-- Store custom user data for a sandbox like API keys.
-- Associate a sandbox with a user ID and [connect to it later](/docs/sandbox/connect).
-
-You specify metadata when creating a sandbox and can access it later through listing running sandboxes with `Sandbox.list()` method.
-
-<CodeGroup>
-```js JavaScript & TypeScript highlight={6}
-import { Sandbox } from '@e2b/code-interpreter'
-
-// Create sandbox with metadata.
-const sandbox = await Sandbox.create({
-  metadata: {
-    userId: '123',
-  },
-})
-
-// List running sandboxes and access metadata.
-const paginator = await Sandbox.list()
-const runningSandboxes = await paginator.nextItems()
-// Will print:
-// {
-//   'userId': '123',
-// }
-console.log(runningSandboxes[0].metadata)
-```
-```python Python highlight={6}
-from e2b_code_interpreter import Sandbox
-
-# Create sandbox with metadata.
-sandbox = Sandbox.create(
-  metadata={
-    'userId': '123',
-  },
-)
-
-# List running sandboxes and access metadata.
-paginator = Sandbox.list()
-running_sandboxes = paginator.next_items()
-# Will print:
-# {
-#   'userId': '123',
-# }
-print(running_sandboxes[0].metadata)
-```
-</CodeGroup>
-
-## Filtering sandboxes by metadata
-You can also filter sandboxes by metadata, you can find more about it [here](/docs/sandbox/list#filtering-sandboxes).
\ No newline at end of file
diff --git a/docs/sandbox/metrics.mdx b/docs/sandbox/metrics.mdx
deleted file mode 100644
index 99769f47..00000000
--- a/docs/sandbox/metrics.mdx
+++ /dev/null
@@ -1,110 +0,0 @@
----
-title: "Sandbox metrics"
-sidebarTitle: Metrics
----
-
-The sandbox metrics allows you to get information about the sandbox's CPU, memory and disk usage.
-
-## Getting sandbox metrics
-Getting the metrics of a sandbox returns an array of timestamped metrics containing CPU, memory and disk usage information.
-The metrics are collected every 5 seconds.
-
-### Getting sandbox metrics using the SDKs
-
-<CodeGroup>
-```js JavaScript & TypeScript highlight={9}
-import { Sandbox } from '@e2b/code-interpreter'
-
-const sbx = await Sandbox.create()
-console.log('Sandbox created', sbx.sandboxId)
-
-// Wait for a few seconds to collect some metrics
-await new Promise((resolve) => setTimeout(resolve, 10_000))
-
-const metrics = await sbx.getMetrics()
-
-// You can also get the metrics by sandbox ID:
-// const metrics = await Sandbox.getMetrics(sbx.sandboxId)
-
-console.log('Sandbox metrics:', metrics)
-
-// Sandbox metrics:
-// [
-//   {
-//     timestamp: 2025-07-28T08:04:05.000Z,
-//     cpuUsedPct: 20.33,
-//     cpuCount: 2,
-//     memUsed: 32681984,  // in bytes
-//     memTotal: 507592704,  // in bytes
-//     diskUsed: 1514856448,  // in bytes
-//     diskTotal: 2573185024  // in bytes
-//   },
-//   {
-//     timestamp: 2025-07-28T08:04:10.000Z,
-//     cpuUsedPct: 0.2,
-//     cpuCount: 2,
-//     memUsed: 33316864,  // in bytes
-//     memTotal: 507592704, // in bytes
-//     diskUsed: 1514856448,  // in bytes
-//     diskTotal: 2573185024  // in bytes
-//   }
-// ]
-```
-```python Python highlight={10}
-from time import sleep
-from e2b_code_interpreter import Sandbox
-
-sbx = Sandbox.create()
-print('Sandbox created', sbx.sandbox_id)
-
-# Wait for a few seconds to collect some metrics
-sleep(10)
-
-metrics = sbx.get_metrics()
-
-# You can also get the metrics by sandbox ID:
-# metrics = Sandbox.get_metrics(sbx.sandbox_id)
-
-print('Sandbox metrics', metrics) 
-
-# Sandbox metrics
-# [
-#     SandboxMetric(
-#         cpu_count=2,
-#         cpu_used_pct=13.97,
-#         disk_total=2573185024,  # in bytes
-#         disk_used=1514856448,  # in bytes
-#         mem_total=507592704,  # in bytes
-#         mem_used=30588928,  # in bytes
-#         timestamp=datetime.datetime(2025, 7, 28, 8, 8, 15, tzinfo=tzutc()),
-#     ),
-#     SandboxMetric(
-#         cpu_count=2,
-#         cpu_used_pct=0.1,
-#         disk_total=2573185024,  # in bytes
-#         disk_used=1514856448,  # in bytes
-#         mem_total=507592704,  # in bytes
-#         mem_used=31084544,  # in bytes
-#         timestamp=datetime.datetime(2025, 7, 28, 8, 8, 20, tzinfo=tzutc()),
-#     ),
-# ]
-```
-</CodeGroup>
-
-### Getting sandbox metrics using the CLI
-<CodeGroup>
-```bash Terminal highlight={1}
-e2b sandbox metrics <sandbox_id> 
-
-# Metrics for sandbox <sandbox_id>
-# 
-# [2025-07-25 14:05:55Z]  CPU:  8.27% /  2 Cores | Memory:    31 / 484   MiB | Disk:  1445 / 2453  MiB
-# [2025-07-25 14:06:00Z]  CPU:   0.5% /  2 Cores | Memory:    32 / 484   MiB | Disk:  1445 / 2453  MiB
-# [2025-07-25 14:06:05Z]  CPU:   0.1% /  2 Cores | Memory:    32 / 484   MiB | Disk:  1445 / 2453  MiB
-# [2025-07-25 14:06:10Z]  CPU:   0.3% /  2 Cores | Memory:    32 / 484   MiB | Disk:  1445 / 2453  MiB
-```
-</CodeGroup>
-
-<Note>
-   It may take a second or more to get the first metrics after the sandbox is created. Until the first metrics are collected from the sandbox, you will get an empty array.
-</Note>
diff --git a/docs/sandbox/observability.mdx b/docs/sandbox/observability.mdx
new file mode 100644
index 00000000..1b6bb168
--- /dev/null
+++ b/docs/sandbox/observability.mdx
@@ -0,0 +1,625 @@
+---
+title: "Observability"
+sidebarTitle: Observability
+icon: "chart-line"
+description: "Monitor E2B sandboxes with resource metrics, lifecycle event history, and real-time webhooks."
+---
+
+E2B provides several ways to monitor and track your sandboxes: resource metrics via the SDK and CLI, a REST API for lifecycle event history, and webhooks for real-time notifications.
+
+## Metrics
+
+Sandbox metrics let you monitor CPU, memory, and disk usage of running sandboxes. Metrics are collected every 5 seconds.
+
+### Getting metrics using the SDKs
+
+<CodeGroup>
+```js JavaScript & TypeScript highlight={9}
+import { Sandbox } from 'e2b'
+
+const sbx = await Sandbox.create()
+console.log('Sandbox created', sbx.sandboxId)
+
+// Wait for a few seconds to collect some metrics
+await new Promise((resolve) => setTimeout(resolve, 10_000))
+
+const metrics = await sbx.getMetrics()
+
+// You can also get the metrics by sandbox ID:
+// const metrics = await Sandbox.getMetrics(sbx.sandboxId)
+
+console.log('Sandbox metrics:', metrics)
+
+// Sandbox metrics:
+// [
+//   {
+//     timestamp: 2025-07-28T08:04:05.000Z,
+//     cpuUsedPct: 20.33,
+//     cpuCount: 2,
+//     memUsed: 32681984,  // in bytes
+//     memTotal: 507592704,  // in bytes
+//     diskUsed: 1514856448,  // in bytes
+//     diskTotal: 2573185024  // in bytes
+//   },
+//   {
+//     timestamp: 2025-07-28T08:04:10.000Z,
+//     cpuUsedPct: 0.2,
+//     cpuCount: 2,
+//     memUsed: 33316864,  // in bytes
+//     memTotal: 507592704, // in bytes
+//     diskUsed: 1514856448,  // in bytes
+//     diskTotal: 2573185024  // in bytes
+//   }
+// ]
+```
+```python Python highlight={10}
+from time import sleep
+from e2b import Sandbox
+
+sbx = Sandbox.create()
+print('Sandbox created', sbx.sandbox_id)
+
+# Wait for a few seconds to collect some metrics
+sleep(10)
+
+metrics = sbx.get_metrics()
+
+# You can also get the metrics by sandbox ID:
+# metrics = Sandbox.get_metrics(sbx.sandbox_id)
+
+print('Sandbox metrics', metrics)
+
+# Sandbox metrics
+# [
+#     SandboxMetric(
+#         cpu_count=2,
+#         cpu_used_pct=13.97,
+#         disk_total=2573185024,  # in bytes
+#         disk_used=1514856448,  # in bytes
+#         mem_total=507592704,  # in bytes
+#         mem_used=30588928,  # in bytes
+#         timestamp=datetime.datetime(2025, 7, 28, 8, 8, 15, tzinfo=tzutc()),
+#     ),
+#     SandboxMetric(
+#         cpu_count=2,
+#         cpu_used_pct=0.1,
+#         disk_total=2573185024,  # in bytes
+#         disk_used=1514856448,  # in bytes
+#         mem_total=507592704,  # in bytes
+#         mem_used=31084544,  # in bytes
+#         timestamp=datetime.datetime(2025, 7, 28, 8, 8, 20, tzinfo=tzutc()),
+#     ),
+# ]
+```
+</CodeGroup>
+
+### Getting metrics using the CLI
+
+<CodeGroup>
+```bash Terminal highlight={1}
+e2b sandbox metrics <sandbox_id>
+
+# Metrics for sandbox <sandbox_id>
+#
+# [2025-07-25 14:05:55Z]  CPU:  8.27% /  2 Cores | Memory:    31 / 484   MiB | Disk:  1445 / 2453  MiB
+# [2025-07-25 14:06:00Z]  CPU:   0.5% /  2 Cores | Memory:    32 / 484   MiB | Disk:  1445 / 2453  MiB
+# [2025-07-25 14:06:05Z]  CPU:   0.1% /  2 Cores | Memory:    32 / 484   MiB | Disk:  1445 / 2453  MiB
+# [2025-07-25 14:06:10Z]  CPU:   0.3% /  2 Cores | Memory:    32 / 484   MiB | Disk:  1445 / 2453  MiB
+```
+</CodeGroup>
+
+<Note>
+   It may take a second or more to get the first metrics after the sandbox is created. Until the first metrics are collected from the sandbox, you will get an empty array.
+</Note>
+
+## Lifecycle events API
+
+The lifecycle API provides RESTful endpoints to request the latest sandbox lifecycle events. This allows you to track when sandboxes are created, paused, resumed, updated, snapshotted, or killed, along with metadata.
+All requests require authentication using your team [API key](/docs/api-key#where-to-find-api-key).
+
+Query Parameters:
+- `offset` (optional): Number of events to skip (default: 0, min: 0)
+- `limit` (optional): Number of events to return (default: 10, min: 1, max: 100)
+- `orderAsc` (optional): Sort order - true for ascending, false for descending (default: false)
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+const sbx = await Sandbox.create()
+
+// Get the latest events for a specific sandbox
+const resp1 = await fetch(
+  `https://api.e2b.app/events/sandboxes/${sbx.id}`,
+  {
+    method: 'GET',
+    headers: {
+      'X-API-Key': E2B_API_KEY,
+    },
+  }
+)
+const sandboxEvents = await resp1.json()
+
+// Get the latest 10 events for all sandboxes associated with the team
+const resp2 = await fetch(
+  'https://api.e2b.app/events/sandboxes?limit=10',
+  {
+    method: 'GET',
+    headers: {
+      'X-API-Key': E2B_API_KEY,
+    },
+  }
+)
+const teamSandboxEvents = await resp2.json()
+
+console.log(teamSandboxEvents)
+
+// [
+//   {
+//     "version": "v1",
+//     "id": "f5911677-cb60-498f-afed-f68143b3cc59",
+//     "type": "sandbox.lifecycle.killed",
+//     "eventData": null,
+//     "sandboxBuildId": "a979a14b-bdcc-49e6-bc04-1189fc9fe7c2",
+//     "sandboxExecutionId": "1dae9e1c-9957-4ce7-a236-a99d5779aadf",
+//     "sandboxId": "${SANDBOX_ID}",
+//     "sandboxTeamId": "460355b3-4f64-48f9-9a16-4442817f79f5",
+//     "sandboxTemplateId": "rki5dems9wqfm4r03t7g",
+//     "timestamp": "2025-08-06T20:59:36Z"
+//   },
+//   {
+//     "version": "v1",
+//     "id": "30b09e11-9ba2-42db-9cf6-d21f0f43a234",
+//     "type": "sandbox.lifecycle.updated",
+//     "eventData": {
+//       "set_timeout": "2025-08-06T20:59:59Z"
+//     },
+//     "sandboxBuildId": "a979a14b-bdcc-49e6-bc04-1189fc9fe7c2",
+//     "sandboxExecutionId": "1dae9e1c-9957-4ce7-a236-a99d5779aadf",
+//     "sandboxId": "${SANDBOX_ID}",
+//     "sandboxTeamId": "460355b3-4f64-48f9-9a16-4442817f79f5",
+//     "sandboxTemplateId": "rki5dems9wqfm4r03t7g",
+//     "timestamp": "2025-08-06T20:59:29Z"
+//   },
+//   [...]
+//   {
+//     "version": "v1",
+//     "id": "0568572b-a2ac-4e5f-85fa-fae90905f556",
+//     "type": "sandbox.lifecycle.created",
+//     "eventData": null,
+//     "sandboxBuildId": "a979a14b-bdcc-49e6-bc04-1189fc9fe7c2",
+//     "sandboxExecutionId": "1dae9e1c-9957-4ce7-a236-a99d5779aadf",
+//     "sandboxId": "${SANDBOX_ID}",
+//     "sandboxTeamId": "460355b3-4f64-48f9-9a16-4442817f79f5",
+//     "sandboxTemplateId": "rki5dems9wqfm4r03t7g",
+//     "timestamp": "2025-08-06T20:59:24Z"
+//   }
+// ]
+```
+```python Python
+import requests
+from e2b import Sandbox
+
+sbx = Sandbox.create()
+
+# Get the latest events for a specific sandbox
+resp1 = requests.get(
+    f"https://api.e2b.app/events/sandboxes/{sbx.sandbox_id}",
+    headers={
+        "X-API-Key": E2B_API_KEY,
+    }
+)
+sandbox_events = resp1.json()
+
+# Get the latest 10 events for all sandboxes associated with the team
+resp2 = requests.get(
+    "https://api.e2b.app/events/sandboxes?limit=10",
+    headers={
+        "X-API-Key": E2B_API_KEY,
+    }
+)
+team_sandbox_events = resp2.json()
+
+print(team_sandbox_events)
+
+# [
+#   {
+#     "version": "v1",
+#     "id": "0568572b-a2ac-4e5f-85fa-fae90905f556",
+#     "type": "sandbox.lifecycle.killed",
+#     "eventData": null,
+#     "sandboxBuildId": "a979a14b-bdcc-49e6-bc04-1189fc9fe7c2",
+#     "sandboxExecutionId": "1dae9e1c-9957-4ce7-a236-a99d5779aadf",
+#     "sandboxId": "${SANDBOX_ID}",
+#     "sandboxTeamId": "460355b3-4f64-48f9-9a16-4442817f79f5",
+#     "sandboxTemplateId": "rki5dems9wqfm4r03t7g",
+#     "timestamp": "2025-08-06T20:59:36Z"
+#   },
+#   {
+#     "version": "v1",
+#     "id": "e7013704-2c51-4dd2-9f6c-388c91460149",
+#     "type": "sandbox.lifecycle.updated",
+#     "eventData": {
+#       "set_timeout": "2025-08-06T20:59:59Z"
+#     },
+#     "sandboxBuildId": "a979a14b-bdcc-49e6-bc04-1189fc9fe7c2",
+#     "sandboxExecutionId": "1dae9e1c-9957-4ce7-a236-a99d5779aadf",
+#     "sandboxId": "${SANDBOX_ID}",
+#     "sandboxTeamId": "460355b3-4f64-48f9-9a16-4442817f79f5",
+#     "sandboxTemplateId": "rki5dems9wqfm4r03t7g",
+#     "timestamp": "2025-08-06T20:59:29Z"
+#   },
+#   [...]
+#   {
+#     "version": "v1",
+#     "id": "f29ef778-2743-4c97-a802-7ba67f84ce24",
+#     "type": "sandbox.lifecycle.created",
+#     "eventData": null,
+#     "sandboxBuildId": "a979a14b-bdcc-49e6-bc04-1189fc9fe7c2",
+#     "sandboxExecutionId": "1dae9e1c-9957-4ce7-a236-a99d5779aadf",
+#     "sandboxId": "${SANDBOX_ID}",
+#     "sandboxTeamId": "460355b3-4f64-48f9-9a16-4442817f79f5",
+#     "sandboxTemplateId": "rki5dems9wqfm4r03t7g",
+#     "timestamp": "2025-08-06T20:59:24Z"
+#   }
+# ]
+```
+</CodeGroup>
+
+## Lifecycle webhooks
+
+Webhooks provide a way for notifications to be delivered to an external web server whenever certain sandbox lifecycle events occur.
+This allows you to receive real-time updates about sandbox creation, updates, and termination without having to poll the API.
+All webhook requests require authentication using your team [API key](/docs/api-key#where-to-find-api-key).
+
+### Register webhook
+
+Register a new webhook to receive sandbox lifecycle events. The webhook will be registered for the team ID associated with your API key. All events specified during webhook creation will be sent to URL provided during registration with the [webhook payload](#webhook-payload).
+
+<CodeGroup>
+```js JavaScript & TypeScript
+// Register a new webhook
+const resp = await fetch(
+  'https://api.e2b.app/events/webhooks',
+  {
+    method: 'POST',
+    headers: {
+      'X-API-Key': E2B_API_KEY,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      name: 'My Sandbox Webhook',
+      url: 'https://your-webhook-endpoint.com/webhook',
+      enabled: true,
+      events: ['sandbox.lifecycle.created', 'sandbox.lifecycle.updated', 'sandbox.lifecycle.killed'],
+      signatureSecret: 'secret-for-event-signature-verification'
+    }),
+  }
+)
+
+if (resp.status === 201) {
+  console.log('Webhook registered successfully')
+}
+```
+```python Python
+import requests
+
+# Register a new webhook
+resp = requests.post(
+    "https://api.e2b.app/events/webhooks",
+    headers={
+        "X-API-Key": E2B_API_KEY,
+        "Content-Type": "application/json",
+    },
+    json={
+        "name": "My Sandbox Webhook",
+        "url": "https://your-webhook-endpoint.com/webhook",
+        "enabled": true,
+        "events": ["sandbox.lifecycle.created", "sandbox.lifecycle.updated", "sandbox.lifecycle.killed"],
+        "signatureSecret": "secret-for-event-signature-verification"
+    }
+)
+
+if resp.status_code == 201:
+    print("Webhook registered successfully")
+```
+</CodeGroup>
+
+### List webhooks
+
+List all registered webhooks for your team.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+// List webhooks
+const resp = await fetch(
+  'https://api.e2b.app/events/webhooks',
+  {
+    method: 'GET',
+    headers: {
+      'X-API-Key': E2B_API_KEY
+    },
+  },
+)
+
+if (resp.status === 200) {
+  console.log('Webhooks listed successfully')
+  console.log(await resp.json())
+}
+```
+```python Python
+import requests
+
+# List webhooks
+resp = requests.get(
+    "https://api.e2b.app/events/webhooks",
+    headers={
+        "X-API-Key": E2B_API_KEY
+    },
+)
+
+if resp.status_code == 200:
+    print("Webhooks listed successfully")
+    print(resp.json())
+```
+</CodeGroup>
+
+
+### Get webhook configuration
+
+Retrieve the current webhook configuration for your team.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+// Get webhook configuration
+const resp = await fetch(
+  `https://api.e2b.app/events/webhooks/${webhookID}`,
+  {
+    method: 'GET',
+    headers: {
+      'X-API-Key': E2B_API_KEY,
+    },
+  }
+)
+const webhookConfig = await resp.json()
+console.log(webhookConfig)
+// {
+//   "id": "<webhook-id>",
+//   "teamID": "<your-team-id>",
+//   "name": "My Sandbox Webhook",
+//   "createdAt": "2025-08-06T21:00:00Z",
+//   "enabled": true,
+//   "url": "https://your-webhook-endpoint.com/webhook",
+//   "events": ["sandbox.lifecycle.created", "sandbox.lifecycle.killed"]
+// }
+
+```
+```python Python
+import requests
+
+# Get webhook configuration
+resp = requests.get(
+    "https://api.e2b.app/events/webhooks/{webhookID}",
+    headers={
+        "X-API-Key": E2B_API_KEY,
+    }
+)
+
+webhook_config = resp.json()
+print(webhook_config)
+# {
+#   "id": "<webhook-id>",
+#   "teamID": "<your-team-id>",
+#   "name": "My Sandbox Webhook",
+#   "createdAt": "2025-08-06T21:00:00Z",
+#   "enabled": true,
+#   "url": "https://your-webhook-endpoint.com/webhook",
+#   "events": ["sandbox.lifecycle.created", "sandbox.lifecycle.killed"]
+# }
+```
+</CodeGroup>
+
+### Update webhook configuration
+
+Update an existing webhook configuration. The update will replace the previous configuration fields with provided fields.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+// Update webhook configuration
+const resp = await fetch(
+  `https://api.e2b.app/events/webhooks/${webhookID}`,
+  {
+    method: 'PATCH',
+    headers: {
+      'X-API-Key': E2B_API_KEY,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      url: 'https://your-updated-webhook-endpoint.com/webhook',
+      enabled: false,
+      events: ['sandbox.lifecycle.created']
+    }),
+  }
+)
+
+if (resp.status === 200) {
+  console.log('Webhook updated successfully')
+}
+```
+```python Python
+import requests
+
+# Update webhook configuration
+resp = requests.patch(
+    "https://api.e2b.app/events/webhooks/{webhookID}",
+    headers={
+        "X-API-Key": E2B_API_KEY,
+        "Content-Type": "application/json",
+    },
+    json={
+        "url": "https://your-updated-webhook-endpoint.com/webhook",
+        "enabled": False,
+        "events": ["sandbox.lifecycle.created"]
+    }
+)
+
+if resp.status_code == 200:
+    print("Webhook updated successfully")
+```
+</CodeGroup>
+
+### Delete webhook
+
+Unregister the webhook.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+// Delete webhook configuration
+const resp = await fetch(
+  `https://api.e2b.app/events/webhooks/${webhookID}`,
+  {
+    method: 'DELETE',
+    headers: {
+      'X-API-Key': E2B_API_KEY,
+    },
+  }
+)
+
+if (resp.status === 200) {
+  console.log('Webhook deleted successfully')
+}
+```
+```python Python
+import requests
+
+# Delete webhook configuration
+resp = requests.delete(
+    "https://api.e2b.app/events/webhooks/{webhookID}",
+    headers={
+        "X-API-Key": E2B_API_KEY,
+    }
+)
+
+if resp.status_code == 200:
+    print("Webhook deleted successfully")
+```
+</CodeGroup>
+
+### Webhook payload
+
+When a webhook is triggered, your endpoint will receive a POST request with a JSON payload containing the sandbox event data.
+The payload structure matches the event format from the API:
+
+```json
+{
+  "version": "v2",
+  "id": "<event-id>",
+  "type": "<sandbox-event-type>",
+  "eventData": {
+    "sandbox_metadata": {
+      "<custom-key>": "<custom-value>"
+    },
+    "execution": {
+      "started_at": "2025-08-06T20:58:24Z",
+      "vcpu_count": 2,
+      "memory_mb": 512,
+      "execution_time": 1000,
+    }
+  },
+  "sandboxBuildId": "<template-build-id>",
+  "sandboxExecutionId": "<sandbox-unique-execution-id>",
+  "sandboxId": "<your-sandbox-id>",
+  "sandboxTeamId": "<your-team-id>",
+  "sandboxTemplateId": "<your-template-id>",
+  "timestamp": "2025-08-06T20:59:24Z"
+}
+```
+
+`eventData.execution` contains sandbox execution details and is included on `sandbox.lifecycle.killed` and `sandbox.lifecycle.paused` events:
+
+- `started_at` - UTC RFC3339 timestamp when the current sandbox execution started
+- `vcpu_count` - Number of vCPUs assigned to the sandbox
+- `memory_mb` - Memory assigned to the sandbox in MB
+- `execution_time` - Sandbox runtime in milliseconds
+
+### Webhook verification
+
+To ensure the authenticity of webhook requests, each request includes a signature in the `e2b-signature` header.
+You can verify the signature using the signature secret you provided when registering the webhook.
+This confirms that the request originated from E2B and has not been tampered with.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+function verifyWebhookSignature(secret : string, payload : string, payloadSignature : string) {
+    const expectedSignatureRaw = crypto.createHash('sha256').update(secret + payload).digest('base64');
+    const expectedSignature = expectedSignatureRaw.replace(/=+$/, '');
+    return  expectedSignature == payloadSignature
+}
+
+const payloadValid = verifyWebhookSignature(secret, webhookBodyRaw, webhookSignatureHeader)
+if (payloadValid) {
+    console.log("Payload signature is valid")
+} else {
+    console.log("Payload signature is INVALID")
+}
+```
+```python Python
+import hashlib
+import base64
+
+def verify_webhook_signature(secret: str, payload: str, payload_signature: str) -> bool:
+    hash_bytes = hashlib.sha256((secret + payload).encode('utf-8')).digest()
+    expected_signature = base64.b64encode(hash_bytes).decode('utf-8')
+    expected_signature = expected_signature.rstrip('=')
+
+    return expected_signature == payload_signature
+
+if verify_webhook_signature(secret, webhook_body_raw, webhook_signature_header):
+    print("Payload signature is valid")
+else:
+    print("Payload signature is INVALID")
+```
+```go Golang
+import (
+    "crypto/sha256"
+    "encoding/base64"
+    "fmt"
+    "strings"
+)
+
+func verifyWebhookSignature(secret, payload, payloadSignature string) bool {
+    hash := sha256.Sum256([]byte(secret + payload))
+    expectedSignature := base64.StdEncoding.EncodeToString(hash[:])
+
+    expectedSignature = strings.TrimRight(expectedSignature, "=")
+
+    return expectedSignature == payloadSignature
+}
+
+if verifyWebhookSignature(secret, webhookBodyString, webhookSignatureHeaderString) {
+    fmt.Println("Payload signature is valid")
+} else {
+    fmt.Println("Payload signature is INVALID")
+}
+```
+</CodeGroup>
+
+### Webhook request headers
+
+When a webhook is sent, E2B adds headers to help you verify authenticity and debug delivery:
+
+- `e2b-webhook-id` - Webhook ID that triggered the event
+- `e2b-delivery-id` - Unique ID for the delivery attempt
+- `e2b-signature-version` - Currently always `v1`, reserved for future use
+- `e2b-signature` - Signature for verifying the request authenticity
+
+### Available event types
+
+The following event types can be subscribed to via webhooks, they are used as the `type` field in the [payload](#webhook-payload).
+
+- `sandbox.lifecycle.created` - Sandbox creation
+- `sandbox.lifecycle.killed` - Sandbox termination
+- `sandbox.lifecycle.updated` - Sandbox configuration updates
+- `sandbox.lifecycle.paused` - Sandbox pausing
+- `sandbox.lifecycle.resumed` - Sandbox resuming
+- `sandbox.lifecycle.checkpointed` - Sandbox [snapshot](/docs/sandbox/persistence#snapshots) created
diff --git a/docs/sandbox/persistence.mdx b/docs/sandbox/persistence.mdx
index e6555a9f..fb2fb5b7 100644
--- a/docs/sandbox/persistence.mdx
+++ b/docs/sandbox/persistence.mdx
@@ -1,282 +1,767 @@
----
-title: "Sandbox persistence"
-sidebarTitle: 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:
-
-```mermaid actions={false}
-flowchart TD
-    start(( )) -->|Sandbox.create| Running
-
-    Running["<b>Running</b><br/>• Active execution<br/>• Consumes resources"]
-    Paused["<b>Paused</b><br/>• Preserves memory and files<br/>• Cannot execute code"]
-    Snapshotting["<b>Snapshotting</b><br/>• Creates persistent snapshot<br/>• Briefly pauses execution"]
-    Killed["<b>Killed</b><br/>• Resources released<br/>• Cannot be resumed"]
-
-    Running -->|pause| Paused
-    Running -->|createSnapshot| Snapshotting
-    Paused -->|connect| Running
-    Snapshotting -->|snapshot complete| Running
-    Running -->|kill| Killed
-    Paused -->|kill| Killed
-```
-
-### 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.
-- **Snapshotting**: The sandbox is briefly paused while a persistent snapshot is being created. It automatically returns to Running. See [Snapshots](/docs/sandbox/snapshots).
-- **Killed**: The sandbox is terminated and all resources are released. This is a terminal state.
-
-### Changing sandbox's state
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Sandbox } from '@e2b/code-interpreter'
-
-const sandbox = await Sandbox.create() // Starts in Running state
-
-// Pause the sandbox
-await sandbox.pause() // 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.pause()  # Running → Paused
-
-# Resume the sandbox
-sandbox.connect()  # Running/Paused → Running
-
-# Kill the sandbox (from any state)
-sandbox.kill()  # Running/Paused → Killed
-```
-</CodeGroup>
-
-## 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.
-
-<CodeGroup>
-```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.pause()
-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.pause()
-print('Sandbox paused', sbx.sandbox_id) 
-```
-</CodeGroup>
-
-
-## 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.
-
-<CodeGroup>
-```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.pause()
-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.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)
-```
-</CodeGroup>
-
-## 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).
-
-<CodeGroup>
-```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)
-```
-</CodeGroup>
-
-## Removing paused sandboxes
-
-You can remove paused sandboxes by calling the `kill` method on the Sandbox instance.
-
-<CodeGroup>
-```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.pause()
-
-// 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.pause()
-
-# Remove the sandbox
-sbx.kill()
-
-# Remove sandbox by id
-Sandbox.kill(sbx.sandbox_id)
-```
-</CodeGroup>
-
-## Sandbox's timeout
-When you connect to a sandbox, the timeout resets. The default is 5 minutes, but you can pass a custom timeout to the `Sandbox.connect()` method:
-
-<CodeGroup>
-```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
-```
-</CodeGroup>
-
-
-### Auto-pause
-
-Auto-pause is configured in the sandbox lifecycle on create. Set `onTimeout`/`on_timeout` to `pause`.
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Sandbox } from 'e2b'
-
-const sandbox = await Sandbox.create({
-  timeoutMs: 10 * 60 * 1000, // Optional: change default timeout (10 minutes)
-  lifecycle: {
-    onTimeout: 'pause',
-    autoResume: false, // Optional (default is false)
-  },
-})
-```
-```python Python
-from e2b import Sandbox
-
-sandbox = Sandbox.create(
-    timeout=10 * 60,  # Optional: change default timeout (10 minutes)
-    lifecycle={
-        "on_timeout": "pause", # Auto-pause after the sandbox times out
-        "auto_resume": False,  # Optional (default is False)
-    },
-)
-```
-</CodeGroup>
-
-Auto-pause is persistent, meaning if your sandbox resumes and later times out again, it will pause again.
-
-If you call `.kill()`, the sandbox is permanently deleted and cannot be resumed.
-
-For auto-resume behavior, see [AutoResume](/docs/sandbox/auto-resume).
-
-## 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
-
-### Pause and resume performance
-- Pausing a sandbox takes approximately **4 seconds per 1 GiB of RAM**
-- Resuming a sandbox takes approximately **1 second**
-
-### Paused sandbox retention
-- Paused sandboxes are kept **indefinitely** — there is no automatic deletion or time-to-live limit
-- You can resume a paused sandbox at any time
-
-### 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**
+---
+title: "Pause, resume & snapshots"
+sidebarTitle: "Pause, resume & snapshots"
+icon: "pause"
+description: "E2B sandboxes are persistent — pause and resume preserves filesystem and memory state. Use snapshots to checkpoint and fork sandbox state."
+---
+
+E2B sandboxes are persistent environments. When you pause a sandbox, its full state — filesystem and memory, including all running processes and loaded variables — is preserved indefinitely. Resume it at any time and pick up exactly where you left off. Snapshots let you capture that state and spawn multiple new sandboxes from it.
+
+## Sandbox state transitions
+
+Understanding how sandboxes transition between states:
+
+```mermaid actions={false}
+flowchart TD
+    start(( )) -->|Sandbox.create| Running
+
+    Running["<b>Running</b><br/>• Active execution<br/>• Consumes resources"]
+    Paused["<b>Paused</b><br/>• Preserves memory and files<br/>• Cannot execute code"]
+    Snapshotting["<b>Snapshotting</b><br/>• Creates persistent snapshot<br/>• Briefly pauses execution"]
+    Killed["<b>Killed</b><br/>• Resources released<br/>• Cannot be resumed"]
+
+    Running -->|pause| Paused
+    Running -->|createSnapshot| Snapshotting
+    Paused -->|connect| Running
+    Snapshotting -->|snapshot complete| Running
+    Running -->|kill| Killed
+    Paused -->|kill| Killed
+```
+
+### 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.
+- **Snapshotting**: The sandbox is briefly paused while a persistent snapshot is being created. It automatically returns to Running. See [Snapshots](/docs/sandbox/persistence#snapshots).
+- **Killed**: The sandbox is terminated and all resources are released. This is a terminal state.
+
+### Changing sandbox state
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create() // Starts in Running state
+
+// Pause the sandbox
+await sandbox.pause() // 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 import Sandbox
+
+sandbox = Sandbox.create()  # Starts in Running state
+
+# Pause the sandbox
+sandbox.pause()  # Running → Paused
+
+# Resume the sandbox
+sandbox.connect()  # Running/Paused → Running
+
+# Kill the sandbox (from any state)
+sandbox.kill()  # Running/Paused → Killed
+```
+</CodeGroup>
+
+## Pause and resume
+
+### Pausing a 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.
+
+<CodeGroup>
+```js JavaScript & TypeScript highlight={8-9}
+import { Sandbox } from 'e2b'
+
+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.pause()
+console.log('Sandbox paused', sbx.sandboxId)
+```
+```python Python highlight={8-9}
+from e2b 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.pause()
+print('Sandbox paused', sbx.sandbox_id)
+```
+</CodeGroup>
+
+### Resuming a 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.
+
+<CodeGroup>
+```js JavaScript & TypeScript highlight={12-13}
+import { Sandbox } from 'e2b'
+
+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.pause()
+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 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.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)
+```
+</CodeGroup>
+
+### Listing paused sandboxes
+
+You can list all paused sandboxes by calling the `Sandbox.list` method and supplying the `state` query parameter.
+
+<CodeGroup>
+```js JavaScript & TypeScript highlight={4,7}
+import { Sandbox, SandboxInfo } from 'e2b'
+
+// 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 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)
+```
+</CodeGroup>
+
+### Removing paused sandboxes
+
+You can remove paused sandboxes by calling the `kill` method on the Sandbox instance.
+
+<CodeGroup>
+```js JavaScript & TypeScript highlight={11,14}
+import { Sandbox } from 'e2b'
+
+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.pause()
+
+// Remove the sandbox
+await sbx.kill()
+
+// Remove sandbox by id
+await Sandbox.kill(sbx.sandboxId)
+```
+```python Python highlight={9,12}
+from e2b import Sandbox
+
+sbx = Sandbox.create()
+
+# Pause the sandbox
+sbx.pause()
+
+# Remove the sandbox
+sbx.kill()
+
+# Remove sandbox by id
+Sandbox.kill(sbx.sandbox_id)
+```
+</CodeGroup>
+
+### Timeout on connect
+
+When you connect to a sandbox, the inactivity timeout resets. The default is 5 minutes, but you can pass a custom timeout to the `Sandbox.connect()` method:
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+const sbx = await Sandbox.connect(sandboxId, { timeoutMs: 60 * 1000 }) // 60 seconds
+```
+```python Python
+from e2b import Sandbox
+
+sbx = Sandbox.connect(sandbox_id, timeout=60) # 60 seconds
+```
+</CodeGroup>
+
+### Network behavior during pause
+
+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
+
+#### Pause and resume performance
+- Pausing a sandbox takes approximately **4 seconds per 1 GiB of RAM**
+- Resuming a sandbox takes approximately **1 second**
+
+#### Paused sandbox retention
+- Paused sandboxes are kept **indefinitely** — there is no automatic deletion or time-to-live limit
+- You can resume a paused sandbox at any time
+
+#### 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**
+
+## Auto-pause and auto-resume
+
+Auto-pause and auto-resume are configured together through the `lifecycle` object when creating a sandbox. Auto-pause suspends a sandbox when its timeout expires. Auto-resume wakes it back up when activity arrives.
+
+### Configure lifecycle on create
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create({
+  timeoutMs: 10 * 60 * 1000,
+  lifecycle: {
+    onTimeout: 'pause',    // auto-pause when timeout expires
+    autoResume: true,       // auto-resume when activity arrives
+  },
+})
+```
+```python Python
+from e2b import Sandbox
+
+sandbox = Sandbox.create(
+    timeout=10 * 60,
+    lifecycle={
+        "on_timeout": "pause",    # auto-pause when timeout expires
+        "auto_resume": True,      # auto-resume when activity arrives
+    },
+)
+```
+</CodeGroup>
+
+Auto-pause is persistent — if your sandbox resumes and later times out again, it will pause again.
+
+If you call `.kill()`, the sandbox is permanently deleted and cannot be resumed.
+
+### Lifecycle options
+
+- `onTimeout` / `on_timeout`
+  - `kill` (default): sandbox is terminated when timeout is reached
+  - `pause`: sandbox is paused when timeout is reached
+- `autoResume` / `auto_resume`
+  - `false` (default): paused sandboxes do not auto-resume
+  - `true`: paused sandboxes auto-resume on activity
+  - `true` is valid only when `onTimeout`/`on_timeout` is `pause`
+
+### Behavior summary
+
+- Default behavior is equivalent to `onTimeout: "kill"` with `autoResume: false`.
+- `onTimeout: "pause"` with `autoResume: false` gives auto-pause without auto-resume.
+- `onTimeout: "pause"` with `autoResume: true` gives auto-pause with auto-resume.
+- `Sandbox.connect()` can still be used to resume a paused sandbox manually.
+
+If you use `autoResume: false`, resume explicitly with `Sandbox.connect()`.
+
+### Timeout after auto-resume
+
+When a sandbox auto-resumes, it restarts with a **5-minute minimum timeout**. If you originally created the sandbox with a longer timeout, that value carries over.
+The countdown begins from the moment the sandbox resumes, not from when it was first created.
+
+For example, if you create a sandbox with a 2-minute timeout:
+
+1. The sandbox runs for 2 minutes, then pauses.
+2. Activity arrives and the sandbox auto-resumes.
+3. A 5-minute timeout starts (the 5-minute minimum applies because the original timeout was shorter).
+4. If no further activity resets the timeout, the sandbox pauses again after 5 minutes.
+
+If you create a sandbox with a 1-hour timeout, the auto-resume timeout will also be 1 hour, since it exceeds the 5-minute minimum.
+
+This cycle repeats every time the sandbox auto-resumes — the lifecycle configuration (`onTimeout: "pause"` + `autoResume: true`) is persistent across pause/resume cycles.
+
+<Note>
+You can change the timeout after the sandbox resumes by calling `setTimeout`/`set_timeout`. See [Change sandbox timeout during runtime](/docs/sandbox/lifecycle#change-sandbox-timeout-during-runtime).
+</Note>
+
+### What counts as activity
+
+Auto-resume is triggered by the sandbox activity - that's both HTTP traffic and controlling the sandbox from the SDK.
+
+That includes SDK operations like:
+- `sandbox.commands.run(...)`
+- `sandbox.files.read(...)`
+- `sandbox.files.write(...)`
+- opening a tunneled app URL or sending requests to a service running inside the sandbox
+
+If a sandbox is paused and `autoResume` is enabled, the next supported operation resumes it automatically. You do not need to call `Sandbox.connect()` first.
+
+#### SDK example: pause, then read a file
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create({
+  timeoutMs: 10 * 60 * 1000,
+  lifecycle: {
+    onTimeout: 'pause',
+    autoResume: true,
+  },
+})
+
+await sandbox.files.write('/home/user/hello.txt', 'hello from a paused sandbox')
+await sandbox.pause()
+
+const content = await sandbox.files.read('/home/user/hello.txt')
+console.log(content)
+console.log(`State after read: ${(await sandbox.getInfo()).state}`)
+```
+```python Python
+from e2b import Sandbox
+
+sandbox = Sandbox.create(
+    timeout=10 * 60,
+    lifecycle={
+        "on_timeout": "pause",
+        "auto_resume": True,
+    },
+)
+
+sandbox.files.write("/home/user/hello.txt", "hello from a paused sandbox")
+sandbox.pause()
+
+content = sandbox.files.read("/home/user/hello.txt")
+print(content)
+print(f"State after read: {sandbox.get_info().state}")
+```
+</CodeGroup>
+
+### Use cases
+
+#### Web and dev/preview servers
+
+Use `onTimeout: "pause"` + `autoResume: true` so inbound traffic can wake a paused sandbox automatically.
+This works for both basic web/API servers and dev or preview servers you open occasionally.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create({
+  timeoutMs: 10 * 60 * 1000,
+  lifecycle: {
+    onTimeout: 'pause',
+    autoResume: true,
+  },
+})
+
+await sandbox.commands.run(
+  `python3 -m pip -q install 'flask>=2.2'`
+)
+
+await sandbox.files.write(
+  '/home/user/app.py',
+  [
+    'from flask import Flask',
+    'app = Flask(__name__)',
+    '@app.route("/")',
+    'def hello():',
+    '    return "Hello, World!"',
+    'app.run(host="0.0.0.0", port=3000)',
+    '',
+  ].join('\n')
+)
+
+await sandbox.commands.run(
+  'python3 -u /home/user/app.py > /home/user/flask.log 2>&1',
+  { background: true }
+)
+
+await new Promise((resolve) => setTimeout(resolve, 1000))
+
+const previewHost = sandbox.getHost(3000)
+console.log(`Preview URL: https://${previewHost}`)
+
+console.log(`Status before pause: ${(await sandbox.getInfo()).state}`)
+await sandbox.pause()
+console.log(`Status after pause: ${(await sandbox.getInfo()).state}`)
+```
+```python Python
+import time
+
+from e2b import Sandbox
+
+sandbox = Sandbox.create(
+    timeout=10 * 60,
+    lifecycle={
+        "on_timeout": "pause",
+        "auto_resume": True,
+    },
+)
+
+sandbox.commands.run("python3 -m pip -q install 'flask>=2.2'")
+
+sandbox.files.write(
+    "/home/user/app.py",
+    'from flask import Flask\n'
+    'app = Flask(__name__)\n'
+    '@app.route("/")\n'
+    'def hello():\n'
+    '    return "Hello, World!"\n'
+    'app.run(host="0.0.0.0", port=3000)\n'
+)
+
+sandbox.commands.run(
+    "python3 -u /home/user/app.py > /home/user/flask.log 2>&1",
+    background=True,
+)
+
+time.sleep(1)
+
+preview_host = sandbox.get_host(3000)
+print(f"Preview URL: https://{preview_host}")
+
+print(f"Status before pause: {sandbox.get_info().state}")
+sandbox.pause()
+print(f"Status after pause: {sandbox.get_info().state}")
+```
+</CodeGroup>
+
+#### Agent/tool execution
+
+For queued tasks or tool calls, create once and keep using the same sandbox handle. If it is paused, it will auto-resume when you run the next command.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+// One-time setup
+const sandbox = await Sandbox.create({
+  timeoutMs: 5 * 60 * 1000,
+  lifecycle: {
+    onTimeout: 'pause',
+    autoResume: true,
+  },
+})
+
+// Later: called for each agent/tool task
+async function runToolTask(command) {
+  const result = await sandbox.commands.run(command)
+  return result.stdout
+}
+
+console.log(await runToolTask('python -c "print(2 + 2)"'))
+```
+```python Python
+from e2b import Sandbox
+
+# One-time setup
+sandbox = Sandbox.create(
+    timeout=5 * 60,
+    lifecycle={
+        "on_timeout": "pause",
+        "auto_resume": True,
+    },
+)
+
+# Later: called for each agent/tool task
+def run_tool_task(command: str) -> str:
+    result = sandbox.commands.run(command)
+    return result.stdout
+
+print(run_tool_task('python -c "print(2 + 2)"'))
+```
+</CodeGroup>
+
+#### Per-user sandboxes
+
+For multi-tenant apps, keep a map of sandbox IDs by user. On each request, connect to the user's existing sandbox (which auto-resumes if paused) or create a new one.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+const userSandboxes = new Map() // userId → Sandbox
+
+async function getSandbox(userId) {
+  let sandbox = userSandboxes.get(userId)
+
+  if (!sandbox) {
+    sandbox = await Sandbox.create({
+      timeoutMs: 5 * 60 * 1000,
+      lifecycle: {
+        onTimeout: 'pause',
+        autoResume: true,
+      },
+    })
+    userSandboxes.set(userId, sandbox)
+  }
+
+  return sandbox
+}
+
+// On each user request (auto-resumes if paused)
+const sandbox = await getSandbox('user-123')
+const result = await sandbox.commands.run('echo "Hello from your sandbox"')
+console.log(result.stdout)
+```
+```python Python
+from e2b import Sandbox
+
+user_sandboxes: dict[str, Sandbox] = {}  # user_id → Sandbox
+
+def get_sandbox(user_id: str) -> Sandbox:
+    if user_id not in user_sandboxes:
+        user_sandboxes[user_id] = Sandbox.create(
+            timeout=5 * 60,
+            lifecycle={
+                "on_timeout": "pause",
+                "auto_resume": True,
+            },
+        )
+
+    return user_sandboxes[user_id]
+
+# On each user request (auto-resumes if paused)
+sandbox = get_sandbox("user-123")
+result = sandbox.commands.run('echo "Hello from your sandbox"')
+print(result.stdout)
+```
+</CodeGroup>
+
+### Cleanup
+
+Auto-resume is persistent, meaning if your sandbox resumes and later times out again, it will pause again.
+Each time the sandbox resumes, it gets a fresh timeout (at least 5 minutes, or longer if the original creation timeout exceeds that) — so the sandbox keeps cycling between running and paused as long as activity arrives.
+
+If you call `.kill()`, the sandbox is permanently deleted and cannot be resumed.
+
+## Snapshots
+
+Snapshots let you create a persistent point-in-time capture of a running sandbox, including both its filesystem and memory state.
+You can then use a snapshot to spawn new sandboxes that start from the exact same state.
+
+The original sandbox continues running after the snapshot is created, and a single snapshot can be used to create many new sandboxes.
+
+### Prerequisites
+
+Snapshots require templates with envd version `v0.5.0` or above. If you are using a custom template created before envd `v0.5.0`, you need to rebuild it.
+
+You can check the template envd version using the `e2b template list` command or by viewing the templates list on the dashboard.
+
+### Snapshots vs. Pause/Resume
+
+| | Pause/Resume | Snapshots |
+|---|---|---|
+| Effect on original sandbox | Pauses (stops) the sandbox | Sandbox briefly pauses, then continues running |
+| Relationship | One-to-one — resume restores the same sandbox | One-to-many — snapshot can spawn many new sandboxes |
+| Use case | Suspend and resume a single sandbox | Create a reusable checkpoint |
+
+### Snapshot flow
+
+```mermaid actions={false}
+graph LR
+    A[Running Sandbox] -->|createSnapshot| B[Snapshotting]
+    B --> C[Snapshot Created]
+    B --> A
+    C -->|Sandbox.create| D[New Sandbox 1]
+    C -->|Sandbox.create| E[New Sandbox 2]
+    C -->|Sandbox.create| F[New Sandbox N]
+```
+
+The sandbox is briefly paused during the snapshot process but automatically returns to running state. The sandbox ID stays the same after the snapshot completes.
+
+<Warning>
+During the snapshot, the sandbox is temporarily paused and resumed. This causes all active connections (e.g. WebSocket, PTY, command streams) to be dropped. Make sure your client handles reconnection properly.
+</Warning>
+
+### Create a snapshot
+
+You can create a snapshot from a running sandbox instance.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create()
+
+// Create a snapshot from a running sandbox
+const snapshot = await sandbox.createSnapshot()
+console.log('Snapshot ID:', snapshot.snapshotId)
+```
+```python Python
+from e2b import Sandbox
+
+sandbox = Sandbox.create()
+
+# Create a snapshot from a running sandbox
+snapshot = sandbox.create_snapshot()
+print('Snapshot ID:', snapshot.snapshot_id)
+```
+</CodeGroup>
+
+You can also create a snapshot by sandbox ID using the static method.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+// Create a snapshot by sandbox ID
+const snapshot = await Sandbox.createSnapshot(sandboxId)
+console.log('Snapshot ID:', snapshot.snapshotId)
+```
+```python Python
+from e2b import Sandbox
+
+# Create a snapshot by sandbox ID
+snapshot = Sandbox.create_snapshot(sandbox_id)
+print('Snapshot ID:', snapshot.snapshot_id)
+```
+</CodeGroup>
+
+### Create a sandbox from a snapshot
+
+The snapshot ID can be used directly with `Sandbox.create()` to spawn a new sandbox from the snapshot. The new sandbox starts with the exact filesystem and memory state captured in the snapshot.
+
+<CodeGroup>
+```js JavaScript & TypeScript highlight={5}
+import { Sandbox } from 'e2b'
+
+const snapshot = await sandbox.createSnapshot()
+
+// Create a new sandbox from the snapshot
+const newSandbox = await Sandbox.create(snapshot.snapshotId)
+```
+```python Python highlight={5}
+from e2b import Sandbox
+
+snapshot = sandbox.create_snapshot()
+
+# Create a new sandbox from the snapshot
+new_sandbox = Sandbox.create(snapshot.snapshot_id)
+```
+</CodeGroup>
+
+### List snapshots
+
+You can list all snapshots. The method returns a paginator for iterating through results.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+const paginator = Sandbox.listSnapshots()
+
+const snapshots = []
+while (paginator.hasNext) {
+  const items = await paginator.nextItems()
+  snapshots.push(...items)
+}
+```
+```python Python
+from e2b import Sandbox
+
+paginator = Sandbox.list_snapshots()
+
+snapshots = []
+while paginator.has_next:
+    items = paginator.next_items()
+    snapshots.extend(items)
+```
+</CodeGroup>
+
+#### Filter by sandbox
+
+You can filter snapshots created from a specific sandbox.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+const paginator = Sandbox.listSnapshots({ sandboxId: 'your-sandbox-id' })
+const snapshots = await paginator.nextItems()
+```
+```python Python
+from e2b import Sandbox
+
+paginator = Sandbox.list_snapshots(sandbox_id="your-sandbox-id")
+snapshots = paginator.next_items()
+```
+</CodeGroup>
+
+### Delete a snapshot
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+// Returns true if deleted, false if the snapshot was not found
+const deleted = await Sandbox.deleteSnapshot(snapshot.snapshotId)
+```
+```python Python
+from e2b import Sandbox
+
+Sandbox.delete_snapshot(snapshot.snapshot_id)
+```
+</CodeGroup>
+
+### Snapshots vs. Templates
+
+Both snapshots and [templates](/docs/template/quickstart) create reusable starting points for sandboxes, but they solve different problems.
+
+| | Templates | Snapshots |
+|---|---|---|
+| Defined by | Declarative code (Template builder) | Capturing a running sandbox |
+| Reproducibility | Same definition produces the same sandbox every time | Captures whatever state exists at that moment |
+| Best for | Repeatable base environments | Checkpointing, rollback, forking runtime state |
+
+Use templates when every sandbox should start from an identical, known state — pre-installed tools, fixed configurations, consistent environments.
+Use snapshots when you need to capture or fork live runtime state that depends on what happened during execution.
+
+### Snapshot use cases
+
+- **Checkpointing agent work** — an AI agent has loaded data and produced partial results in memory. Snapshot it so you can resume or fork from that point later.
+- **Rollback points** — snapshot before a risky or expensive operation (running untrusted code, applying a migration, refactoring a web app). If it fails, rollback - spawn a fresh sandbox from the snapshot before the operation happened.
+- **Forking workflows** — spawn multiple sandboxes from the same snapshot to explore different approaches in parallel.
+- **Cached sandboxes** — avoid repeating expensive setup by snapshotting a sandbox that has already loaded a large dataset or started a long-running process.
+- **Sharing state** — one user or agent configures an environment interactively, snapshots it, and others start from that exact state.
diff --git a/docs/sandbox/ip-tunneling.mdx b/docs/sandbox/proxy-tunneling.mdx
similarity index 99%
rename from docs/sandbox/ip-tunneling.mdx
rename to docs/sandbox/proxy-tunneling.mdx
index 82927194..21cb18ca 100644
--- a/docs/sandbox/ip-tunneling.mdx
+++ b/docs/sandbox/proxy-tunneling.mdx
@@ -1,5 +1,6 @@
 ---
 title: "Proxy tunneling"
+icon: "route"
 description: "How to tunnel Sandbox network traffic through a proxy server"
 ---
 
diff --git a/docs/sandbox/pty.mdx b/docs/sandbox/pty.mdx
deleted file mode 100644
index 2c5db488..00000000
--- a/docs/sandbox/pty.mdx
+++ /dev/null
@@ -1,342 +0,0 @@
----
-title: "Interactive terminal (PTY)"
-sidebarTitle: Interactive terminal
----
-
-The PTY (pseudo-terminal) module allows you to create interactive terminal sessions in the sandbox with real-time, bidirectional communication.
-
-Unlike `commands.run()` which executes a command and returns output after completion, PTY provides:
-- **Real-time streaming** - Output is streamed as it happens via callbacks
-- **Bidirectional input** - Send input while the terminal is running
-- **Interactive shell** - Full terminal support with ANSI colors and escape sequences
-- **Session persistence** - Disconnect and reconnect to running sessions
-
-## Create a PTY session
-
-Use `sandbox.pty.create()` to start an interactive bash shell.
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Sandbox } from '@e2b/code-interpreter'
-
-const sandbox = await Sandbox.create()
-
-const terminal = await sandbox.pty.create({
-  cols: 80,              // Terminal width in characters
-  rows: 24,              // Terminal height in characters
-  onData: (data) => {
-    // Called whenever terminal outputs data
-    process.stdout.write(data)
-  },
-  envs: { MY_VAR: 'hello' },  // Optional environment variables
-  cwd: '/home/user',          // Optional working directory
-  user: 'root',               // Optional user to run as
-})
-
-// terminal.pid contains the process ID
-console.log('Terminal PID:', terminal.pid)
-```
-
-```python Python
-from e2b_code_interpreter import Sandbox
-
-sandbox = Sandbox()
-
-terminal = sandbox.pty.create(
-    cols=80,              # Terminal width in characters
-    rows=24,              # Terminal height in characters
-    on_data=lambda data: print(data.decode(), end=''),  # end='' prevents print from adding extra newline
-    envs={'MY_VAR': 'hello'},  # Optional environment variables
-    cwd='/home/user',          # Optional working directory
-    user='root',               # Optional user to run as
-)
-
-# terminal.pid contains the process ID
-print('Terminal PID:', terminal.pid)
-```
-</CodeGroup>
-
-<Note>
-The PTY runs an interactive bash shell with `TERM=xterm-256color`, which supports ANSI colors and escape sequences.
-</Note>
-
-## Timeout
-
-PTY sessions have a configurable timeout that controls the session duration. The default is 60 seconds. For interactive or long-running sessions, set `timeoutMs: 0` (JavaScript) or `timeout=0` (Python) to keep the session open indefinitely.
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Sandbox } from '@e2b/code-interpreter'
-
-const sandbox = await Sandbox.create()
-
-const terminal = await sandbox.pty.create({
-  cols: 80,
-  rows: 24,
-  onData: (data) => process.stdout.write(data),
-  timeoutMs: 0,  // Keep the session open indefinitely
-})
-```
-
-```python Python
-from e2b_code_interpreter import Sandbox
-
-sandbox = Sandbox()
-
-# end='' prevents print() from adding an extra newline
-# (PTY output already contains newlines)
-terminal = sandbox.pty.create(
-    cols=80,
-    rows=24,
-    on_data=lambda data: print(data.decode(), end=''),
-    timeout=0,  # Keep the session open indefinitely
-)
-```
-</CodeGroup>
-
-## Send input to PTY
-
-Use `sendInput()` in JavaScript or `send_stdin()` in Python to send data to the terminal. These methods return a Promise (JavaScript) or complete synchronously (Python) - the actual output will be delivered to your `onData` callback.
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Sandbox } from '@e2b/code-interpreter'
-
-const sandbox = await Sandbox.create()
-
-const terminal = await sandbox.pty.create({
-  cols: 80,
-  rows: 24,
-  onData: (data) => process.stdout.write(data),
-})
-
-// Send a command (don't forget the newline!)
-await sandbox.pty.sendInput(
-  terminal.pid,
-  new TextEncoder().encode('echo "Hello from PTY"\n')
-)
-```
-
-```python Python
-from e2b_code_interpreter import Sandbox
-
-sandbox = Sandbox()
-
-terminal = sandbox.pty.create(
-    cols=80,
-    rows=24,
-    on_data=lambda data: print(data.decode(), end=''),  # end='' prevents extra newline
-)
-
-# Send a command as bytes (b'...' is Python's byte string syntax)
-# Don't forget the newline!
-sandbox.pty.send_stdin(terminal.pid, b'echo "Hello from PTY"\n')
-```
-</CodeGroup>
-
-## Resize the terminal
-
-When the user's terminal window changes size, notify the PTY with `resize()`. The `cols` and `rows` parameters are measured in characters, not pixels.
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Sandbox } from '@e2b/code-interpreter'
-
-const sandbox = await Sandbox.create()
-
-const terminal = await sandbox.pty.create({
-  cols: 80,
-  rows: 24,
-  onData: (data) => process.stdout.write(data),
-})
-
-// Resize to new dimensions (in characters)
-await sandbox.pty.resize(terminal.pid, {
-  cols: 120,
-  rows: 40,
-})
-```
-
-```python Python
-from e2b_code_interpreter import Sandbox
-
-sandbox = Sandbox()
-
-terminal = sandbox.pty.create(
-    cols=80,
-    rows=24,
-    on_data=lambda data: print(data.decode(), end=''),  # end='' prevents extra newline
-)
-
-# Resize to new dimensions (in characters)
-sandbox.pty.resize(terminal.pid, cols=120, rows=40)
-```
-</CodeGroup>
-
-## Disconnect and reconnect
-
-You can disconnect from a PTY session while keeping it running, then reconnect later with a new data handler. This is useful for:
-- Resuming terminal sessions after network interruptions
-- Sharing terminal access between multiple clients
-- Implementing terminal session persistence
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Sandbox } from '@e2b/code-interpreter'
-
-const sandbox = await Sandbox.create()
-
-// Create a PTY session
-const terminal = await sandbox.pty.create({
-  cols: 80,
-  rows: 24,
-  onData: (data) => console.log('Handler 1:', new TextDecoder().decode(data)),
-})
-
-const pid = terminal.pid
-
-// Send a command
-await sandbox.pty.sendInput(pid, new TextEncoder().encode('echo hello\n'))
-
-// Disconnect - PTY keeps running in the background
-await terminal.disconnect()
-
-// Later: reconnect with a new data handler
-const reconnected = await sandbox.pty.connect(pid, {
-  onData: (data) => console.log('Handler 2:', new TextDecoder().decode(data)),
-})
-
-// Continue using the session
-await sandbox.pty.sendInput(pid, new TextEncoder().encode('echo world\n'))
-
-// Wait for the terminal to exit
-await reconnected.wait()
-```
-
-```python Python
-import time
-from e2b_code_interpreter import Sandbox
-
-sandbox = Sandbox()
-
-# Create a PTY session
-terminal = sandbox.pty.create(
-    cols=80,
-    rows=24,
-    on_data=lambda data: print('Handler 1:', data.decode()),
-)
-
-pid = terminal.pid
-
-# Send a command
-sandbox.pty.send_stdin(pid, b'echo hello\n')
-time.sleep(0.5)
-
-# Disconnect - PTY keeps running in the background
-terminal.disconnect()
-
-# Later: reconnect with a new data handler
-reconnected = sandbox.pty.connect(
-    pid,
-    on_data=lambda data: print('Handler 2:', data.decode()),
-)
-
-# Continue using the session
-sandbox.pty.send_stdin(pid, b'echo world\n')
-
-# Wait for the terminal to exit
-reconnected.wait()
-```
-</CodeGroup>
-
-## Kill the PTY
-
-Terminate the PTY session with `kill()`.
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Sandbox } from '@e2b/code-interpreter'
-
-const sandbox = await Sandbox.create()
-
-const terminal = await sandbox.pty.create({
-  cols: 80,
-  rows: 24,
-  onData: (data) => process.stdout.write(data),
-})
-
-// Kill the PTY
-const killed = await sandbox.pty.kill(terminal.pid)
-console.log('Killed:', killed)  // true if successful
-
-// Or use the handle method
-// await terminal.kill()
-```
-
-```python Python
-from e2b_code_interpreter import Sandbox
-
-sandbox = Sandbox()
-
-terminal = sandbox.pty.create(
-    cols=80,
-    rows=24,
-    on_data=lambda data: print(data.decode(), end=''),  # end='' prevents extra newline
-)
-
-# Kill the PTY
-killed = sandbox.pty.kill(terminal.pid)
-print('Killed:', killed)  # True if successful
-
-# Or use the handle method
-# terminal.kill()
-```
-</CodeGroup>
-
-## Wait for PTY to exit
-
-Use `wait()` to wait for the terminal session to end (e.g., when the user types `exit`).
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Sandbox } from '@e2b/code-interpreter'
-
-const sandbox = await Sandbox.create()
-
-const terminal = await sandbox.pty.create({
-  cols: 80,
-  rows: 24,
-  onData: (data) => process.stdout.write(data),
-})
-
-// Send exit command
-await sandbox.pty.sendInput(terminal.pid, new TextEncoder().encode('exit\n'))
-
-// Wait for the terminal to exit
-const result = await terminal.wait()
-console.log('Exit code:', result.exitCode)
-```
-
-```python Python
-from e2b_code_interpreter import Sandbox
-
-sandbox = Sandbox()
-
-terminal = sandbox.pty.create(
-    cols=80,
-    rows=24,
-    on_data=lambda data: print(data.decode(), end=''),  # end='' prevents extra newline
-)
-
-# Send exit command
-sandbox.pty.send_stdin(terminal.pid, b'exit\n')
-
-# Wait for the terminal to exit
-result = terminal.wait()
-print('Exit code:', result.exit_code)
-```
-</CodeGroup>
-
-## Interactive terminal (SSH-like)
-
-Building a fully interactive terminal (like SSH) requires handling raw mode, stdin forwarding, and terminal resize events. For a production implementation, see the [E2B CLI source code](https://github.com/e2b-dev/E2B/blob/main/packages/cli/src/terminal.ts) which uses the same `sandbox.pty` API documented above.
diff --git a/docs/sandbox/rate-limits.mdx b/docs/sandbox/rate-limits.mdx
deleted file mode 100644
index 2a1618f0..00000000
--- a/docs/sandbox/rate-limits.mdx
+++ /dev/null
@@ -1,143 +0,0 @@
----
-title: "Rate limits"
-sidebarTitle: "Rate limits"
----
-
-This page describes API and sandbox rate limits of the E2B platform.
-
-## Table of Contents
-
-- [Sandbox lifecycle and management API](#sandbox-lifecycle-and-management-api)
-- [Sandbox operations and requests to sandboxes](#sandbox-operations-and-requests-to-sandboxes)
-- [Concurrent Sandboxes](#concurrent-sandboxes)
-- [Sandbox creation rate](#sandbox-creation-rate)
-- [Egress connections](#egress-connections)
-- [Reaching limits](#reaching-limits)
-- [Increasing and avoiding rate limits](#increasing-and-avoiding-rate-limits)
-
-Here's a limits breakdown table based on the plan:
-
-<table style={{ display: 'inline-table', margin: '0 auto', borderCollapse: 'collapse' }}>
-  <thead>
-    <tr style={{ background: '#000', color: 'white' }}>
-      <th style={{ textAlign: 'left', padding: '8px', color: 'white' }}>Plan</th>
-      <th style={{ textAlign: 'center', padding: '8px', color: 'white' }}>Hobby</th>
-      <th style={{ textAlign: 'center', padding: '8px', color: 'white' }}>Pro</th>
-      <th style={{ textAlign: 'center', padding: '8px', color: 'white' }}>Enterprise</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td style={{ fontWeight: 'bold', padding: '8px' }}>Sandbox lifecycle &amp; management API</td>
-      <td style={{ textAlign: 'center', padding: '8px' }}>20,000 / 30s</td>
-      <td style={{ textAlign: 'center', padding: '8px' }}>20,000 / 30s</td>
-      <td style={{ textAlign: 'center', padding: '8px' }}>Custom</td>
-    </tr>
-    <tr>
-      <td style={{ fontWeight: 'bold', padding: '8px' }}>Sandbox operations</td>
-      <td style={{ textAlign: 'center', padding: '8px' }}>40,000 / 60s per IP</td>
-      <td style={{ textAlign: 'center', padding: '8px' }}>40,000 / 60s per IP</td>
-      <td style={{ textAlign: 'center', padding: '8px' }}>Custom</td>
-    </tr>
-    <tr>
-      <td style={{ fontWeight: 'bold', padding: '8px' }}>Concurrent sandboxes</td>
-      <td style={{ textAlign: 'center', padding: '8px' }}>20</td>
-      <td style={{ textAlign: 'center', padding: '8px' }}>100 - 1,100<b><sup>*</sup></b></td>
-      <td style={{ textAlign: 'center', padding: '8px' }}>Custom</td>
-    </tr>
-    <tr>
-      <td style={{ fontWeight: 'bold', padding: '8px' }}>Sandbox creation rate</td>
-      <td style={{ textAlign: 'center', padding: '8px' }}>1 / sec</td>
-      <td style={{ textAlign: 'center', padding: '8px' }}>5 / sec</td>
-      <td style={{ textAlign: 'center', padding: '8px' }}>Custom</td>
-    </tr>
-    <tr>
-      <td style={{ fontWeight: 'bold', padding: '8px' }}>Egress connections per sandbox</td>
-      <td style={{ textAlign: 'center', padding: '8px' }}>2,500</td>
-      <td style={{ textAlign: 'center', padding: '8px' }}>2,500</td>
-      <td style={{ textAlign: 'center', padding: '8px' }}>Custom</td>
-    </tr>
-  </tbody>
-</table>
-
-<Note>
-  <b><sup>*</sup></b>Pro plan default is 100 concurrent sandboxes. Higher concurrency of up to 1,100 is available as a separate purchasable add-on.
-</Note>
-
----
-
-## Sandbox lifecycle and management API
-
-**20,000 requests per 30 seconds**
-
-This rate limit applies to lifecycle and management operations such as sandbox create, kill, update, list, and other.
-
----
-
-## Sandbox operations and requests to sandboxes
-
-**40,000 requests per 60 seconds**
-
-This rate limits applies to operations to/within running sandboxes such as running code, listing files, running commands, etc.
-This also includes requests made to custom ports in the sandbox.
-
-<br/> This limit is enforced globally across all sandbox operations from a single IP address.
-
----
-
-## Concurrent sandboxes
-
-Number of concurrent sandboxes differs based on the pricing tier.
-
-### Hobby tier
-**Up to 20 concurrent sandboxes**
-
-### Pro tier
-**Starts at 100 concurrent sandboxes**
-
-<Note>
-    Can go up to 1,100 with additional [add-ons available for purchase](https://e2b.dev/dashboard/?tab=billing).
-</Note>
-
-
-### Enterprise tier
-**Custom limit - 1,100+ concurrent sandboxes**
-
----
-
-## Sandbox creation rate
-
-This limit controls how quickly you can create new sandboxes.
-
-### Hobby tier
-**1 sandbox per second**
-
-
-### Pro tier
-**5 sandboxes per second**
-
-### Enterprise tier
-**Custom limit - 5+ sandboxes per second**
-
----
-
-## Egress connections
-
-**2,500 connections per sandbox**
-
-This limit controls the maximum number of outbound (egress) network connections that can be established from a single sandbox.
-
-## Reaching limits
-
-When you reach the limits of your plan, subsequent requests/function calls will be effectively dropped and return the following:
--  the `429 Too Many Requests` HTTP status code (when calling API/sandbox ports directly)
-- `RateLimitError` in the JS/TS SDK
-- `RateLimitException` in the Python SDK
-
-For example, if you're on the Pro tier (without any concurrency add-ons), you can create up to 100 sandboxes running concurrently.
-If the 100 sandboxes are still running, requests for creating new sandboxes from the SDKs (`Sandbox.create()` in JS/TS or `Sandbox.create()` in Python) will fail and return `RateLimitError` or `RateLimitException` respectively.
-Once the number of running sandboxes drops below 100, or you purchase a concurrency add-on, you’ll be able to create new sandboxes again.
-
-## Increasing and avoiding rate limits
-
-You can avoid rate limits by [upgrading your plan](https://e2b.dev/dashboard/?tab=billing) or contacting our sales team to discuss your specific requirements and we can provide tailored limits to meet your needs at [enterprise@e2b.dev](mailto:enterprise@e2b.dev).
diff --git a/docs/sandbox/runtime-customization.mdx b/docs/sandbox/runtime-customization.mdx
new file mode 100644
index 00000000..dc031739
--- /dev/null
+++ b/docs/sandbox/runtime-customization.mdx
@@ -0,0 +1,234 @@
+---
+title: "Customizing sandboxes"
+sidebarTitle: "Customizing sandboxes"
+icon: "wrench"
+description: "Install packages, upload files, and configure E2B sandboxes dynamically when you can't bake everything into a template."
+---
+
+Templates define a sandbox's base environment, but many workloads need dynamic configuration — different packages per user, files uploaded at request time, or settings that change between runs. This page covers patterns for customizing sandboxes after creation.
+
+## When to use templates vs. runtime setup
+
+| Use case | Template | Runtime |
+|---|---|---|
+| Same packages for every sandbox | Yes | |
+| Packages vary per user or request | | Yes |
+| Static config files, shared across sandboxes | Yes | |
+| User-uploaded files or per-request data | | Yes |
+| Secrets that change per request | | Yes |
+
+When in doubt: if every sandbox needs it, put it in a [template](/docs/template/quickstart). If it varies per user or request, handle it at runtime.
+
+## Install packages
+
+Use `sandbox.commands.run()` to install packages after the sandbox starts. This is useful when different users or requests need different dependencies.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create()
+
+// Install Python packages
+await sandbox.commands.run('pip install pandas numpy matplotlib')
+
+// Install system packages
+await sandbox.commands.run('sudo apt-get update && sudo apt-get install -y ffmpeg')
+
+// Install Node.js packages
+await sandbox.commands.run('npm install express')
+```
+```python Python
+from e2b import Sandbox
+
+sandbox = Sandbox.create()
+
+# Install Python packages
+sandbox.commands.run("pip install pandas numpy matplotlib")
+
+# Install system packages
+sandbox.commands.run("sudo apt-get update && sudo apt-get install -y ffmpeg")
+
+# Install Node.js packages
+sandbox.commands.run("npm install express")
+```
+</CodeGroup>
+
+<Tip>
+For packages you install in every sandbox, add them to a [template](/docs/template/quickstart) instead. Template-based installs are faster because they're baked into the sandbox image.
+</Tip>
+
+### Speed up repeated installs with snapshots
+
+If multiple sandboxes need the same runtime setup, install once and [snapshot](/docs/sandbox/persistence#snapshots) the result. New sandboxes start from the snapshot with everything already installed.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+// First time: install and snapshot
+const sandbox = await Sandbox.create()
+await sandbox.commands.run('pip install pandas numpy scikit-learn')
+
+const snapshot = await sandbox.createSnapshot()
+console.log('Snapshot ID:', snapshot.snapshotId)
+
+// Later: start from snapshot — packages are already installed
+const fast = await Sandbox.create(snapshot.snapshotId)
+```
+```python Python
+from e2b import Sandbox
+
+# First time: install and snapshot
+sandbox = Sandbox.create()
+sandbox.commands.run("pip install pandas numpy scikit-learn")
+
+snapshot = sandbox.create_snapshot()
+print("Snapshot ID:", snapshot.snapshot_id)
+
+# Later: start from snapshot — packages are already installed
+fast = Sandbox.create(snapshot.snapshot_id)
+```
+</CodeGroup>
+
+## Upload files
+
+Use `sandbox.files.write()` to upload configuration files, scripts, or user data into the sandbox. See the [Filesystem](/docs/sandbox/filesystem) page for the full file operations API.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create()
+
+// Upload a configuration file
+await sandbox.files.write('/home/user/config.json', JSON.stringify({
+  apiEndpoint: 'https://api.example.com',
+  maxRetries: 3,
+}))
+
+// Upload a script
+await sandbox.files.write('/home/user/analyze.py', `
+import json
+with open('config.json') as f:
+    config = json.load(f)
+print(f"Connecting to {config['apiEndpoint']}")
+`)
+
+// Run the uploaded script
+const result = await sandbox.commands.run('cd /home/user && python analyze.py')
+console.log(result.stdout)
+```
+```python Python
+import json
+from e2b import Sandbox
+
+sandbox = Sandbox.create()
+
+# Upload a configuration file
+sandbox.files.write("/home/user/config.json", json.dumps({
+    "apiEndpoint": "https://api.example.com",
+    "maxRetries": 3,
+}))
+
+# Upload a script
+sandbox.files.write("/home/user/analyze.py", """
+import json
+with open('config.json') as f:
+    config = json.load(f)
+print(f"Connecting to {config['apiEndpoint']}")
+""")
+
+# Run the uploaded script
+result = sandbox.commands.run("cd /home/user && python analyze.py")
+print(result.stdout)
+```
+</CodeGroup>
+
+## Use `start_cmd` for initialization
+
+If your [template](/docs/template/quickstart) supports a [start command](/docs/template/start-ready-command), you can override it at runtime to customize sandbox initialization.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create('my-template', {
+  startCmd: 'python /home/user/setup.py && nginx -g "daemon off;"',
+})
+```
+```python Python
+from e2b import Sandbox
+
+sandbox = Sandbox.create("my-template", start_cmd="python /home/user/setup.py && nginx -g 'daemon off;'")
+```
+</CodeGroup>
+
+## Combine patterns
+
+For complex setups, combine multiple approaches. Here's an example setting up a data analysis sandbox per user:
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+async function createAnalysisSandbox(userId, dataUrl, packages) {
+  const sandbox = await Sandbox.create({
+    timeoutMs: 10 * 60 * 1000,
+    lifecycle: {
+      onTimeout: 'pause',
+      autoResume: true,
+    },
+    envs: {
+      USER_ID: userId,
+      DATA_URL: dataUrl,
+    },
+  })
+
+  // Install user-specific packages
+  if (packages.length > 0) {
+    await sandbox.commands.run(`pip install ${packages.join(' ')}`)
+  }
+
+  // Upload analysis script
+  await sandbox.files.write('/home/user/run.py', `
+import os, urllib.request
+urllib.request.urlretrieve(os.environ['DATA_URL'], '/home/user/data.csv')
+print(f"Data downloaded for user {os.environ['USER_ID']}")
+  `)
+
+  await sandbox.commands.run('python /home/user/run.py')
+  return sandbox
+}
+```
+```python Python
+from e2b import Sandbox
+
+def create_analysis_sandbox(user_id: str, data_url: str, packages: list[str]):
+    sandbox = Sandbox.create(
+        timeout=10 * 60,
+        lifecycle={
+            "on_timeout": "pause",
+            "auto_resume": True,
+        },
+        envs={
+            "USER_ID": user_id,
+            "DATA_URL": data_url,
+        },
+    )
+
+    # Install user-specific packages
+    if packages:
+        sandbox.commands.run(f"pip install {' '.join(packages)}")
+
+    # Upload analysis script
+    sandbox.files.write("/home/user/run.py", """
+import os, urllib.request
+urllib.request.urlretrieve(os.environ['DATA_URL'], '/home/user/data.csv')
+print(f"Data downloaded for user {os.environ['USER_ID']}")
+    """)
+
+    sandbox.commands.run("python /home/user/run.py")
+    return sandbox
+```
+</CodeGroup>
diff --git a/docs/sandbox/secured-access.mdx b/docs/sandbox/secured-access.mdx
deleted file mode 100644
index d01ce3db..00000000
--- a/docs/sandbox/secured-access.mdx
+++ /dev/null
@@ -1,54 +0,0 @@
----
-title: "Secured access"
-sidebarTitle: Secured access
----
-
-Secure access authenticates communication between SDK and sandbox controller.
-
-Sandbox controller runs in sandbox itself and exposes APIs for work with file system, run commands, and generally control the sandbox via our SDK.
-Without secure access, anyone with a sandbox ID can access the controller APIs and control the sandbox from inside.
-
-<Note>
-    SDKs version `v2.0.0` and above are using secure access by default when creating sandbox. This may not be compatible with older custom templates and you may need to rebuild them.
-</Note>
-
-## Migration path
-
-When using custom templates created before envd `v0.2.0`, you need to rebuild the templates to enable secure access.
-Temporarily, you can disable secure access by setting `secure` to `false` during sandbox creation, but this is not recommended for production use because it increases security risks.
-
-You can check the template envd version using the `e2b template list` command or by viewing the templates list on the dashboard.
-
-## Supported versions
-
-All sandboxes based on templates with envd version at least `v0.2.0` already support secure access without any additional changes.
-
-The secure access flag was introduced in `1.5.0` for JavaScript and Python SDKs to be used optionally.
-Starting with SDK version `v2.0.0`, sandboxes are created with secure access enabled by default.
-
-## Access sandbox API directly
-
-In some cases, you might want to access sandbox controller APIs directly through its URL, such as when you are not using SDKs.
-When secure access is enabled, you must provide an authentication token that was returned during sandbox creation.
-
-Each call to the sandbox controller must include an additional header `X-Access-Token` with the access token value returned during sandbox creation.
-
-For sandbox [upload](/docs/filesystem/upload#upload-with-pre-signed-url) and [download](/docs/filesystem/download#download-with-pre-signed-url) URLs, you need to generate pre-signed URLs. We are advising to use SDK for generating presigned URLs.
-
-## Disable secure access
-
-Disabling secured access is discouraged because it creates security vulnerabilities.
-
-<CodeGroup>
-    ```js JavaScript & TypeScript
-    import { Sandbox } from '@e2b/code-interpreter'
-
-    const sandbox = await Sandbox.create({ secure: false }) // Explicitly disable
-    ```
-
-    ```python Python
-    from e2b_code_interpreter import Sandbox
-
-    sandbox = Sandbox.create(secure=False)  # Explicitly disable
-    ```
-</CodeGroup>
diff --git a/docs/sandbox/internet-access.mdx b/docs/sandbox/security.mdx
similarity index 51%
rename from docs/sandbox/internet-access.mdx
rename to docs/sandbox/security.mdx
index ae9f2b93..627d4d07 100644
--- a/docs/sandbox/internet-access.mdx
+++ b/docs/sandbox/security.mdx
@@ -1,464 +1,611 @@
----
-title: "Internet access"
----
-
-Every sandbox has access to the internet and can be reached by a public URL.
-
-## Controlling internet access
-
-You can control whether a sandbox has access to the internet by using the `allowInternetAccess` parameter when creating a sandbox. By default, internet access is enabled (`true`), but you can disable it for security-sensitive workloads.
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Sandbox } from '@e2b/code-interpreter'
-
-// Create sandbox with internet access enabled (default)
-const sandbox = await Sandbox.create({ allowInternetAccess: true })
-
-// Create sandbox without internet access
-const isolatedSandbox = await Sandbox.create({ allowInternetAccess: false })
-```
-```python Python
-from e2b_code_interpreter import Sandbox
-
-# Create sandbox with internet access enabled (default)
-sandbox = Sandbox.create(allow_internet_access=True)
-
-# Create sandbox without internet access
-isolated_sandbox = Sandbox.create(allow_internet_access=False)
-```
-</CodeGroup>
-
-When internet access is disabled, the sandbox cannot make outbound network connections, which provides an additional layer of security for sensitive code execution.
-
-<Note>
-Setting `allowInternetAccess` to `false` is equivalent to setting `network.denyOut` to `['0.0.0.0/0']` (denying all traffic).
-</Note>
-
-## Fine-grained network control
-
-For more granular control over network access, you can use the `network` configuration option to specify allow and deny lists for outbound traffic.
-
-### Allow and deny lists
-
-You can specify IP addresses, CIDR blocks, or domain names that the sandbox is allowed to use:
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Sandbox, ALL_TRAFFIC } from '@e2b/code-interpreter'
-
-// Deny all traffic except specific IPs
-const sandbox = await Sandbox.create({
-  network: {
-    denyOut: [ALL_TRAFFIC],
-    allowOut: ['1.1.1.1', '8.8.8.0/24']
-  }
-})
-
-// Deny specific IPs only
-const restrictedSandbox = await Sandbox.create({
-  network: {
-    denyOut: ['8.8.8.8']
-  }
-})
-```
-```python Python
-from e2b_code_interpreter import Sandbox, ALL_TRAFFIC
-
-# Deny all traffic except specific IPs
-sandbox = Sandbox.create(
-    network={
-        "deny_out": [ALL_TRAFFIC],
-        "allow_out": ["1.1.1.1", "8.8.8.0/24"]
-    }
-)
-
-# Deny specific IPs only
-restricted_sandbox = Sandbox.create(
-    network={
-        "deny_out": ["8.8.8.8"]
-    }
-)
-```
-</CodeGroup>
-
-### Domain-based filtering
-
-You can allow traffic to specific domains by specifying hostnames in `allow out`. When using domain-based filtering, you must include `ALL_TRAFFIC` in `deny out` to block all other traffic. Domains are not supported in the `deny out` list.
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Sandbox, ALL_TRAFFIC } from '@e2b/code-interpreter'
-
-// Allow only traffic to google.com
-const sandbox = await Sandbox.create({
-  network: {
-    allowOut: ['google.com'],
-    denyOut: [ALL_TRAFFIC]
-  }
-})
-```
-```python Python
-from e2b_code_interpreter import Sandbox, ALL_TRAFFIC
-
-# Allow only traffic to google.com
-sandbox = Sandbox.create(
-    network={
-        "allow_out": ["google.com"],
-        "deny_out": [ALL_TRAFFIC]
-    }
-)
-```
-</CodeGroup>
-
-<Note>
-When any domain is used, the default nameserver `8.8.8.8` is automatically allowed to ensure proper DNS resolution.
-</Note>
-
-You can also use wildcards to allow all subdomains of a domain:
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Sandbox, ALL_TRAFFIC } from '@e2b/code-interpreter'
-
-// Allow traffic to any subdomain of mydomain.com
-const sandbox = await Sandbox.create({
-  network: {
-    allowOut: ['*.mydomain.com'],
-    denyOut: [ALL_TRAFFIC]
-  }
-})
-```
-```python Python
-from e2b_code_interpreter import Sandbox, ALL_TRAFFIC
-
-# Allow traffic to any subdomain of mydomain.com
-sandbox = Sandbox.create(
-    network={
-        "allow_out": ["*.mydomain.com"],
-        "deny_out": [ALL_TRAFFIC]
-    }
-)
-```
-</CodeGroup>
-
-You can combine domain names with IP addresses and CIDR blocks:
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Sandbox, ALL_TRAFFIC } from '@e2b/code-interpreter'
-
-// Allow traffic to specific domains and IPs
-const sandbox = await Sandbox.create({
-  network: {
-    allowOut: ['api.example.com', '*.github.com', '8.8.8.8'],
-    denyOut: [ALL_TRAFFIC]
-  }
-})
-```
-```python Python
-from e2b_code_interpreter import Sandbox, ALL_TRAFFIC
-
-# Allow traffic to specific domains and IPs
-sandbox = Sandbox.create(
-    network={
-        "allow_out": ["api.example.com", "*.github.com", "8.8.8.8"],
-        "deny_out": [ALL_TRAFFIC]
-    }
-)
-```
-</CodeGroup>
-
-<Note>
-Domain-based filtering only works for HTTP traffic on port 80 (via Host header inspection) and TLS traffic on port 443 (via SNI inspection). Traffic on other ports uses CIDR-based filtering only. UDP-based protocols like QUIC/HTTP3 are not supported for domain filtering.
-</Note>
-
-### Priority rules
-
-When both `allow out` and `deny out` are specified, **allow rules always take precedence** over deny rules. This means if an IP address is in both lists, it will be allowed.
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Sandbox, ALL_TRAFFIC } from '@e2b/code-interpreter'
-
-// Even though ALL_TRAFFIC is denied, 1.1.1.1 and 8.8.8.8 are explicitly allowed
-const sandbox = await Sandbox.create({
-  network: {
-    denyOut: [ALL_TRAFFIC],
-    allowOut: ['1.1.1.1', '8.8.8.8']
-  }
-})
-```
-```python Python
-from e2b_code_interpreter import Sandbox, ALL_TRAFFIC
-
-# Even though ALL_TRAFFIC is denied, 1.1.1.1 and 8.8.8.8 are explicitly allowed
-sandbox = Sandbox.create(
-    network={
-        "deny_out": [ALL_TRAFFIC],
-        "allow_out": ["1.1.1.1", "8.8.8.8"]
-    }
-)
-```
-</CodeGroup>
-
-### ALL_TRAFFIC helper
-
-The `ALL_TRAFFIC` constant represents the CIDR range `0.0.0.0/0`, which matches all IP addresses. Use it to easily deny or allow all network traffic:
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Sandbox, ALL_TRAFFIC } from '@e2b/code-interpreter'
-
-// Deny all outbound traffic
-const sandbox = await Sandbox.create({
-  network: {
-    denyOut: [ALL_TRAFFIC]
-  }
-})
-```
-```python Python
-from e2b_code_interpreter import Sandbox, ALL_TRAFFIC
-
-# Deny all outbound traffic
-sandbox = Sandbox.create(
-    network={
-        "deny_out": [ALL_TRAFFIC]
-    }
-)
-```
-</CodeGroup>
-
-## Sandbox public URL
-Every sandbox has a public URL that can be used to access running services inside the sandbox.
-
-<CodeGroup>
-```js JavaScript & TypeScript highlight={6}
-import { Sandbox } from '@e2b/code-interpreter'
-
-const sandbox = await Sandbox.create()
-
-// You need to always pass a port number to get the host
-const host = sandbox.getHost(3000)
-console.log(`https://${host}`)
-```
-```python Python highlight={6}
-from e2b_code_interpreter import Sandbox
-
-sandbox = Sandbox.create()
-
-# You need to always pass a port number to get the host
-host = sandbox.get_host(3000)
-print(f'https://{host}')
-```
-</CodeGroup>
-
-The code above will print something like this:
-
-<CodeGroup>
-```bash JavaScript & TypeScript
-https://3000-i62mff4ahtrdfdkyn2esc.e2b.app
-```
-```bash Python
-https://3000-i62mff4ahtrdfdkyn2esc.e2b.app
-```
-</CodeGroup>
-
-The first leftmost part of the host is the port number we passed to the method.
-
-## Restricting public access to sandbox URLs
-
-By default, sandbox URLs are publicly accessible. You can restrict access to require authentication using the `allowPublicTraffic` option:
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Sandbox } from '@e2b/code-interpreter'
-
-// Create sandbox with restricted public access
-const sandbox = await Sandbox.create({
-  network: {
-    allowPublicTraffic: false
-  }
-})
-
-// The sandbox has a traffic access token
-console.log(sandbox.trafficAccessToken)
-
-// Start a server inside the sandbox
-await sandbox.commands.run('python -m http.server 8080', { background: true })
-
-const host = sandbox.getHost(8080)
-const url = `https://${host}`
-
-// Request without token will fail with 403
-const response1 = await fetch(url)
-console.log(response1.status) // 403
-
-// Request with token will succeed
-const response2 = await fetch(url, {
-  headers: {
-    'e2b-traffic-access-token': sandbox.trafficAccessToken
-  }
-})
-console.log(response2.status) // 200
-```
-```python Python
-import requests
-from e2b_code_interpreter import Sandbox
-
-# Create sandbox with restricted public access
-sandbox = Sandbox.create(
-    network={
-        "allow_public_traffic": False
-    }
-)
-
-# The sandbox has a traffic access token
-print(sandbox.traffic_access_token)
-
-# Start a server inside the sandbox
-sandbox.commands.run("python -m http.server 8080", background=True)
-
-host = sandbox.get_host(8080)
-url = f"https://{host}"
-
-# Request without token will fail with 403
-response1 = requests.get(url)
-print(response1.status_code)  # 403
-
-# Request with token will succeed
-response2 = requests.get(url, headers={
-    'e2b-traffic-access-token': sandbox.traffic_access_token
-})
-print(response2.status_code)  # 200
-```
-</CodeGroup>
-
-When `allowPublicTraffic` is set to `false`, all requests to the sandbox's public URLs must include the `e2b-traffic-access-token` header with the value from `sandbox.trafficAccessToken`.
-
-## Connecting to a server running inside the sandbox
-You can start a server inside the sandbox and connect to it using the approach above.
-
-In this example we will start a simple HTTP server that listens on port 3000 and responds with the content of the directory where the server is started.
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Sandbox } from '@e2b/code-interpreter'
-
-const sandbox = await Sandbox.create()
-
-// Start a simple HTTP server inside the sandbox.
-const process = await sandbox.commands.run('python -m http.server 3000', { background: true })
-const host = sandbox.getHost(3000)
-const url = `https://${host}`
-console.log('Server started at:', url)
-
-// Fetch data from the server inside the sandbox.
-const response = await fetch(url);
-const data = await response.text();
-console.log('Response from server inside sandbox:', data);
-
-// Kill the server process inside the sandbox.
-await process.kill()
-```
-```python Python
-import requests
-from e2b_code_interpreter import Sandbox
-
-sandbox = Sandbox.create()
-
-# Start a simple HTTP server inside the sandbox.
-process = sandbox.commands.run("python -m http.server 3000", background=True)
-host = sandbox.get_host(3000)
-url = f"https://{host}"
-print('Server started at:', url)
-
-# Fetch data from the server inside the sandbox.
-response = requests.get(url)
-data = response.text
-print('Response from server inside sandbox:', data)
-
-# Kill the server process inside the sandbox.
-process.kill()
-```
-</CodeGroup>
-
-This output will look like this:
-<CodeGroup>
-```bash JavaScript & TypeScript
-Server started at: https://3000-ip3nfrvajtqu5ktoxugc7.e2b.app
-Response from server inside sandbox: <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
-<title>Directory listing for /</title>
-</head>
-<body>
-<h1>Directory listing for /</h1>
-<hr>
-<ul>
-<li><a href=".bash_logout">.bash_logout</a></li>
-<li><a href=".bashrc">.bashrc</a></li>
-<li><a href=".profile">.profile</a></li>
-</ul>
-<hr>
-</body>
-</html>
-```
-```bash Python
-Server started at: https://3000-ip3nfrvajtqu5ktoxugc7.e2b.app
-Response from server inside sandbox: <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
-<title>Directory listing for /</title>
-</head>
-<body>
-<h1>Directory listing for /</h1>
-<hr>
-<ul>
-<li><a href=".bash_logout">.bash_logout</a></li>
-<li><a href=".bashrc">.bashrc</a></li>
-<li><a href=".profile">.profile</a></li>
-</ul>
-<hr>
-</body>
-</html>
-```
-</CodeGroup>
-
-
-## Masking request host headers
-
-You can customize the `Host` header that gets sent to services running inside the sandbox using the `maskRequestHost` option. This is useful when your application expects a specific host format.
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Sandbox } from '@e2b/code-interpreter'
-
-// Create sandbox with custom host masking
-const sandbox = await Sandbox.create({
-  network: {
-    maskRequestHost: 'localhost:${PORT}'
-  }
-})
-
-// The ${PORT} variable will be replaced with the actual port number
-// Requests to the sandbox will have Host header set to for example: localhost:8080
-```
-```python Python
-from e2b_code_interpreter import Sandbox
-
-# Create sandbox with custom host masking
-sandbox = Sandbox.create(
-    network={
-        "mask_request_host": "localhost:${PORT}"
-    }
-)
-
-# The ${PORT} variable will be replaced with the actual port number
-# Requests to the sandbox will have Host header set to for example: localhost:8080
-```
-</CodeGroup>
-
-The `${PORT}` variable in the mask will be automatically replaced with the actual port number of the requested service.
+---
+title: "Security"
+sidebarTitle: Security
+icon: "shield"
+description: "Learn about E2B sandbox security including authenticated access, network controls, and rate limits."
+---
+
+E2B sandboxes provide multiple layers of security: authenticated access to the sandbox controller, fine-grained network controls, and rate limits to protect your infrastructure.
+
+## Secured access
+
+Secure access authenticates communication between SDK and sandbox controller.
+
+Sandbox controller runs in sandbox itself and exposes APIs for work with file system, run commands, and generally control the sandbox via our SDK.
+Without secure access, anyone with a sandbox ID can access the controller APIs and control the sandbox from inside.
+
+<Note>
+    SDKs version `v2.0.0` and above are using secure access by default when creating sandbox. This may not be compatible with older custom templates and you may need to rebuild them.
+</Note>
+
+### Migration path
+
+When using custom templates created before envd `v0.2.0`, you need to rebuild the templates to enable secure access.
+Temporarily, you can disable secure access by setting `secure` to `false` during sandbox creation, but this is not recommended for production use because it increases security risks.
+
+You can check the template envd version using the `e2b template list` command or by viewing the templates list on the dashboard.
+
+### Supported versions
+
+All sandboxes based on templates with envd version at least `v0.2.0` already support secure access without any additional changes.
+
+The secure access flag was introduced in `1.5.0` for JavaScript and Python SDKs to be used optionally.
+Starting with SDK version `v2.0.0`, sandboxes are created with secure access enabled by default.
+
+### Access sandbox API directly
+
+In some cases, you might want to access sandbox controller APIs directly through its URL, such as when you are not using SDKs.
+When secure access is enabled, you must provide an authentication token that was returned during sandbox creation.
+
+Each call to the sandbox controller must include an additional header `X-Access-Token` with the access token value returned during sandbox creation.
+
+For sandbox [upload](/docs/sandbox/filesystem#upload-with-pre-signed-url) and [download](/docs/sandbox/filesystem#download-with-pre-signed-url) URLs, you need to generate pre-signed URLs. We are advising to use SDK for generating presigned URLs.
+
+### Disable secure access
+
+Disabling secured access is discouraged because it creates security vulnerabilities.
+
+<CodeGroup>
+    ```js JavaScript & TypeScript
+    import { Sandbox } from 'e2b'
+
+    const sandbox = await Sandbox.create({ secure: false }) // Explicitly disable
+    ```
+
+    ```python Python
+    from e2b import Sandbox
+
+    sandbox = Sandbox.create(secure=False)  # Explicitly disable
+    ```
+</CodeGroup>
+
+## Internet access
+
+Every sandbox has access to the internet and can be reached by a public URL.
+
+### Controlling internet access
+
+You can control whether a sandbox has access to the internet by using the `allowInternetAccess` parameter when creating a sandbox. By default, internet access is enabled (`true`), but you can disable it for security-sensitive workloads.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+// Create sandbox with internet access enabled (default)
+const sandbox = await Sandbox.create({ allowInternetAccess: true })
+
+// Create sandbox without internet access
+const isolatedSandbox = await Sandbox.create({ allowInternetAccess: false })
+```
+```python Python
+from e2b import Sandbox
+
+# Create sandbox with internet access enabled (default)
+sandbox = Sandbox.create(allow_internet_access=True)
+
+# Create sandbox without internet access
+isolated_sandbox = Sandbox.create(allow_internet_access=False)
+```
+</CodeGroup>
+
+When internet access is disabled, the sandbox cannot make outbound network connections, which provides an additional layer of security for sensitive code execution.
+
+<Note>
+Setting `allowInternetAccess` to `false` is equivalent to setting `network.denyOut` to `['0.0.0.0/0']` (denying all traffic).
+</Note>
+
+### Fine-grained network control
+
+For more granular control over network access, you can use the `network` configuration option to specify allow and deny lists for outbound traffic.
+
+#### Allow and deny lists
+
+You can specify IP addresses, CIDR blocks, or domain names that the sandbox is allowed to use:
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox, ALL_TRAFFIC } from 'e2b'
+
+// Deny all traffic except specific IPs
+const sandbox = await Sandbox.create({
+  network: {
+    denyOut: [ALL_TRAFFIC],
+    allowOut: ['1.1.1.1', '8.8.8.0/24']
+  }
+})
+
+// Deny specific IPs only
+const restrictedSandbox = await Sandbox.create({
+  network: {
+    denyOut: ['8.8.8.8']
+  }
+})
+```
+```python Python
+from e2b import Sandbox, ALL_TRAFFIC
+
+# Deny all traffic except specific IPs
+sandbox = Sandbox.create(
+    network={
+        "deny_out": [ALL_TRAFFIC],
+        "allow_out": ["1.1.1.1", "8.8.8.0/24"]
+    }
+)
+
+# Deny specific IPs only
+restricted_sandbox = Sandbox.create(
+    network={
+        "deny_out": ["8.8.8.8"]
+    }
+)
+```
+</CodeGroup>
+
+#### Domain-based filtering
+
+You can allow traffic to specific domains by specifying hostnames in `allow out`. When using domain-based filtering, you must include `ALL_TRAFFIC` in `deny out` to block all other traffic. Domains are not supported in the `deny out` list.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox, ALL_TRAFFIC } from 'e2b'
+
+// Allow only traffic to google.com
+const sandbox = await Sandbox.create({
+  network: {
+    allowOut: ['google.com'],
+    denyOut: [ALL_TRAFFIC]
+  }
+})
+```
+```python Python
+from e2b import Sandbox, ALL_TRAFFIC
+
+# Allow only traffic to google.com
+sandbox = Sandbox.create(
+    network={
+        "allow_out": ["google.com"],
+        "deny_out": [ALL_TRAFFIC]
+    }
+)
+```
+</CodeGroup>
+
+<Note>
+When any domain is used, the default nameserver `8.8.8.8` is automatically allowed to ensure proper DNS resolution.
+</Note>
+
+You can also use wildcards to allow all subdomains of a domain:
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox, ALL_TRAFFIC } from 'e2b'
+
+// Allow traffic to any subdomain of mydomain.com
+const sandbox = await Sandbox.create({
+  network: {
+    allowOut: ['*.mydomain.com'],
+    denyOut: [ALL_TRAFFIC]
+  }
+})
+```
+```python Python
+from e2b import Sandbox, ALL_TRAFFIC
+
+# Allow traffic to any subdomain of mydomain.com
+sandbox = Sandbox.create(
+    network={
+        "allow_out": ["*.mydomain.com"],
+        "deny_out": [ALL_TRAFFIC]
+    }
+)
+```
+</CodeGroup>
+
+You can combine domain names with IP addresses and CIDR blocks:
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox, ALL_TRAFFIC } from 'e2b'
+
+// Allow traffic to specific domains and IPs
+const sandbox = await Sandbox.create({
+  network: {
+    allowOut: ['api.example.com', '*.github.com', '8.8.8.8'],
+    denyOut: [ALL_TRAFFIC]
+  }
+})
+```
+```python Python
+from e2b import Sandbox, ALL_TRAFFIC
+
+# Allow traffic to specific domains and IPs
+sandbox = Sandbox.create(
+    network={
+        "allow_out": ["api.example.com", "*.github.com", "8.8.8.8"],
+        "deny_out": [ALL_TRAFFIC]
+    }
+)
+```
+</CodeGroup>
+
+<Note>
+Domain-based filtering only works for HTTP traffic on port 80 (via Host header inspection) and TLS traffic on port 443 (via SNI inspection). Traffic on other ports uses CIDR-based filtering only. UDP-based protocols like QUIC/HTTP3 are not supported for domain filtering.
+</Note>
+
+#### Priority rules
+
+When both `allow out` and `deny out` are specified, **allow rules always take precedence** over deny rules. This means if an IP address is in both lists, it will be allowed.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox, ALL_TRAFFIC } from 'e2b'
+
+// Even though ALL_TRAFFIC is denied, 1.1.1.1 and 8.8.8.8 are explicitly allowed
+const sandbox = await Sandbox.create({
+  network: {
+    denyOut: [ALL_TRAFFIC],
+    allowOut: ['1.1.1.1', '8.8.8.8']
+  }
+})
+```
+```python Python
+from e2b import Sandbox, ALL_TRAFFIC
+
+# Even though ALL_TRAFFIC is denied, 1.1.1.1 and 8.8.8.8 are explicitly allowed
+sandbox = Sandbox.create(
+    network={
+        "deny_out": [ALL_TRAFFIC],
+        "allow_out": ["1.1.1.1", "8.8.8.8"]
+    }
+)
+```
+</CodeGroup>
+
+#### ALL_TRAFFIC helper
+
+The `ALL_TRAFFIC` constant represents the CIDR range `0.0.0.0/0`, which matches all IP addresses. Use it to easily deny or allow all network traffic:
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox, ALL_TRAFFIC } from 'e2b'
+
+// Deny all outbound traffic
+const sandbox = await Sandbox.create({
+  network: {
+    denyOut: [ALL_TRAFFIC]
+  }
+})
+```
+```python Python
+from e2b import Sandbox, ALL_TRAFFIC
+
+# Deny all outbound traffic
+sandbox = Sandbox.create(
+    network={
+        "deny_out": [ALL_TRAFFIC]
+    }
+)
+```
+</CodeGroup>
+
+### Sandbox public URL
+
+Every sandbox has a public URL that can be used to access running services inside the sandbox.
+
+<CodeGroup>
+```js JavaScript & TypeScript highlight={6}
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create()
+
+// You need to always pass a port number to get the host
+const host = sandbox.getHost(3000)
+console.log(`https://${host}`)
+```
+```python Python highlight={6}
+from e2b import Sandbox
+
+sandbox = Sandbox.create()
+
+# You need to always pass a port number to get the host
+host = sandbox.get_host(3000)
+print(f'https://{host}')
+```
+</CodeGroup>
+
+The code above will print something like this:
+
+<CodeGroup>
+```bash JavaScript & TypeScript
+https://3000-i62mff4ahtrdfdkyn2esc.e2b.app
+```
+```bash Python
+https://3000-i62mff4ahtrdfdkyn2esc.e2b.app
+```
+</CodeGroup>
+
+The first leftmost part of the host is the port number we passed to the method.
+
+### Restricting public access to sandbox URLs
+
+By default, sandbox URLs are publicly accessible. You can restrict access to require authentication using the `allowPublicTraffic` option:
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+// Create sandbox with restricted public access
+const sandbox = await Sandbox.create({
+  network: {
+    allowPublicTraffic: false
+  }
+})
+
+// The sandbox has a traffic access token
+console.log(sandbox.trafficAccessToken)
+
+// Start a server inside the sandbox
+await sandbox.commands.run('python -m http.server 8080', { background: true })
+
+const host = sandbox.getHost(8080)
+const url = `https://${host}`
+
+// Request without token will fail with 403
+const response1 = await fetch(url)
+console.log(response1.status) // 403
+
+// Request with token will succeed
+const response2 = await fetch(url, {
+  headers: {
+    'e2b-traffic-access-token': sandbox.trafficAccessToken
+  }
+})
+console.log(response2.status) // 200
+```
+```python Python
+import requests
+from e2b import Sandbox
+
+# Create sandbox with restricted public access
+sandbox = Sandbox.create(
+    network={
+        "allow_public_traffic": False
+    }
+)
+
+# The sandbox has a traffic access token
+print(sandbox.traffic_access_token)
+
+# Start a server inside the sandbox
+sandbox.commands.run("python -m http.server 8080", background=True)
+
+host = sandbox.get_host(8080)
+url = f"https://{host}"
+
+# Request without token will fail with 403
+response1 = requests.get(url)
+print(response1.status_code)  # 403
+
+# Request with token will succeed
+response2 = requests.get(url, headers={
+    'e2b-traffic-access-token': sandbox.traffic_access_token
+})
+print(response2.status_code)  # 200
+```
+</CodeGroup>
+
+When `allowPublicTraffic` is set to `false`, all requests to the sandbox's public URLs must include the `e2b-traffic-access-token` header with the value from `sandbox.trafficAccessToken`.
+
+### Connecting to a server running inside the sandbox
+
+You can start a server inside the sandbox and connect to it using the public URL approach described above.
+
+In this example we will start a simple HTTP server that listens on port 3000 and responds with the content of the directory where the server is started.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create()
+
+// Start a simple HTTP server inside the sandbox.
+const process = await sandbox.commands.run('python -m http.server 3000', { background: true })
+const host = sandbox.getHost(3000)
+const url = `https://${host}`
+console.log('Server started at:', url)
+
+// Fetch data from the server inside the sandbox.
+const response = await fetch(url);
+const data = await response.text();
+console.log('Response from server inside sandbox:', data);
+
+// Kill the server process inside the sandbox.
+await process.kill()
+```
+```python Python
+import requests
+from e2b import Sandbox
+
+sandbox = Sandbox.create()
+
+# Start a simple HTTP server inside the sandbox.
+process = sandbox.commands.run("python -m http.server 3000", background=True)
+host = sandbox.get_host(3000)
+url = f"https://{host}"
+print('Server started at:', url)
+
+# Fetch data from the server inside the sandbox.
+response = requests.get(url)
+data = response.text
+print('Response from server inside sandbox:', data)
+
+# Kill the server process inside the sandbox.
+process.kill()
+```
+</CodeGroup>
+
+### Masking request host headers
+
+You can customize the `Host` header that gets sent to services running inside the sandbox using the `maskRequestHost` option. This is useful when your application expects a specific host format.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+// Create sandbox with custom host masking
+const sandbox = await Sandbox.create({
+  network: {
+    maskRequestHost: 'localhost:${PORT}'
+  }
+})
+
+// The ${PORT} variable will be replaced with the actual port number
+// Requests to the sandbox will have Host header set to for example: localhost:8080
+```
+```python Python
+from e2b import Sandbox
+
+# Create sandbox with custom host masking
+sandbox = Sandbox.create(
+    network={
+        "mask_request_host": "localhost:${PORT}"
+    }
+)
+
+# The ${PORT} variable will be replaced with the actual port number
+# Requests to the sandbox will have Host header set to for example: localhost:8080
+```
+</CodeGroup>
+
+The `${PORT}` variable in the mask will be automatically replaced with the actual port number of the requested service.
+
+## Rate limits
+
+This section describes API and sandbox rate limits of the E2B platform.
+
+Here's a limits breakdown table based on the plan:
+
+<table style={{ display: 'inline-table', margin: '0 auto', borderCollapse: 'collapse' }}>
+  <thead>
+    <tr style={{ background: '#000', color: 'white' }}>
+      <th style={{ textAlign: 'left', padding: '8px', color: 'white' }}>Plan</th>
+      <th style={{ textAlign: 'center', padding: '8px', color: 'white' }}>Hobby</th>
+      <th style={{ textAlign: 'center', padding: '8px', color: 'white' }}>Pro</th>
+      <th style={{ textAlign: 'center', padding: '8px', color: 'white' }}>Enterprise</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td style={{ fontWeight: 'bold', padding: '8px' }}>Sandbox lifecycle &amp; management API</td>
+      <td style={{ textAlign: 'center', padding: '8px' }}>20,000 / 30s</td>
+      <td style={{ textAlign: 'center', padding: '8px' }}>20,000 / 30s</td>
+      <td style={{ textAlign: 'center', padding: '8px' }}>Custom</td>
+    </tr>
+    <tr>
+      <td style={{ fontWeight: 'bold', padding: '8px' }}>Sandbox operations</td>
+      <td style={{ textAlign: 'center', padding: '8px' }}>40,000 / 60s per IP</td>
+      <td style={{ textAlign: 'center', padding: '8px' }}>40,000 / 60s per IP</td>
+      <td style={{ textAlign: 'center', padding: '8px' }}>Custom</td>
+    </tr>
+    <tr>
+      <td style={{ fontWeight: 'bold', padding: '8px' }}>Concurrent sandboxes</td>
+      <td style={{ textAlign: 'center', padding: '8px' }}>20</td>
+      <td style={{ textAlign: 'center', padding: '8px' }}>100 - 1,100<b><sup>*</sup></b></td>
+      <td style={{ textAlign: 'center', padding: '8px' }}>Custom</td>
+    </tr>
+    <tr>
+      <td style={{ fontWeight: 'bold', padding: '8px' }}>Sandbox creation rate</td>
+      <td style={{ textAlign: 'center', padding: '8px' }}>1 / sec</td>
+      <td style={{ textAlign: 'center', padding: '8px' }}>5 / sec</td>
+      <td style={{ textAlign: 'center', padding: '8px' }}>Custom</td>
+    </tr>
+    <tr>
+      <td style={{ fontWeight: 'bold', padding: '8px' }}>Egress connections per sandbox</td>
+      <td style={{ textAlign: 'center', padding: '8px' }}>2,500</td>
+      <td style={{ textAlign: 'center', padding: '8px' }}>2,500</td>
+      <td style={{ textAlign: 'center', padding: '8px' }}>Custom</td>
+    </tr>
+  </tbody>
+</table>
+
+<Note>
+  <b><sup>*</sup></b>Pro plan default is 100 concurrent sandboxes. Higher concurrency of up to 1,100 is available as a separate purchasable add-on.
+</Note>
+
+---
+
+### Sandbox lifecycle and management API
+
+**20,000 requests per 30 seconds**
+
+This rate limit applies to lifecycle and management operations such as sandbox create, kill, update, list, and other.
+
+---
+
+### Sandbox operations and requests to sandboxes
+
+**40,000 requests per 60 seconds**
+
+This rate limits applies to operations to/within running sandboxes such as running code, listing files, running commands, etc.
+This also includes requests made to custom ports in the sandbox.
+
+<br/> This limit is enforced globally across all sandbox operations from a single IP address.
+
+---
+
+### Concurrent sandboxes
+
+Number of concurrent sandboxes differs based on the pricing tier.
+
+#### Hobby tier
+**Up to 20 concurrent sandboxes**
+
+#### Pro tier
+**Starts at 100 concurrent sandboxes**
+
+<Note>
+    Can go up to 1,100 with additional [add-ons available for purchase](https://e2b.dev/dashboard/?tab=billing).
+</Note>
+
+
+#### Enterprise tier
+**Custom limit - 1,100+ concurrent sandboxes**
+
+---
+
+### Sandbox creation rate
+
+This limit controls how quickly you can create new sandboxes.
+
+#### Hobby tier
+**1 sandbox per second**
+
+
+#### Pro tier
+**5 sandboxes per second**
+
+#### Enterprise tier
+**Custom limit - 5+ sandboxes per second**
+
+---
+
+### Egress connections
+
+**2,500 connections per sandbox**
+
+This limit controls the maximum number of outbound (egress) network connections that can be established from a single sandbox.
+
+### Reaching limits
+
+When you reach the limits of your plan, subsequent requests/function calls will be effectively dropped and return the following:
+-  the `429 Too Many Requests` HTTP status code (when calling API/sandbox ports directly)
+- `RateLimitError` in the JS/TS SDK
+- `RateLimitException` in the Python SDK
+
+For example, if you're on the Pro tier (without any concurrency add-ons), you can create up to 100 sandboxes running concurrently.
+If the 100 sandboxes are still running, requests for creating new sandboxes from the SDKs (`Sandbox.create()` in JS/TS or `Sandbox.create()` in Python) will fail and return `RateLimitError` or `RateLimitException` respectively.
+Once the number of running sandboxes drops below 100, or you purchase a concurrency add-on, you'll be able to create new sandboxes again.
+
+### Increasing and avoiding rate limits
+
+You can avoid rate limits by [upgrading your plan](https://e2b.dev/dashboard/?tab=billing) or contacting our sales team to discuss your specific requirements and we can provide tailored limits to meet your needs at [enterprise@e2b.dev](mailto:enterprise@e2b.dev).
diff --git a/docs/sandbox/snapshots.mdx b/docs/sandbox/snapshots.mdx
deleted file mode 100644
index 8e28303d..00000000
--- a/docs/sandbox/snapshots.mdx
+++ /dev/null
@@ -1,194 +0,0 @@
----
-title: "Sandbox snapshots"
-sidebarTitle: Snapshots
----
-
-Snapshots let you create a persistent point-in-time capture of a running sandbox, including both its filesystem and memory state.
-You can then use a snapshot to spawn new sandboxes that start from the exact same state.
-
-The original sandbox continues running after the snapshot is created, and a single snapshot can be used to create many new sandboxes.
-
-## Prerequisites
-
-Snapshots require templates with envd version `v0.5.0` or above. If you are using a custom template created before envd `v0.5.0`, you need to rebuild it.
-
-You can check the template envd version using the `e2b template list` command or by viewing the templates list on the dashboard.
-
-## Snapshots vs. Pause/Resume
-
-| | Pause/Resume | Snapshots |
-|---|---|---|
-| Effect on original sandbox | Pauses (stops) the sandbox | Sandbox briefly pauses, then continues running |
-| Relationship | One-to-one — resume restores the same sandbox | One-to-many — snapshot can spawn many new sandboxes |
-| Use case | Suspend and resume a single sandbox | Create a reusable checkpoint |
-
-For pause/resume functionality, see [Persistence](/docs/sandbox/persistence).
-
-## Snapshot flow
-
-```mermaid actions={false}
-graph LR
-    A[Running Sandbox] -->|createSnapshot| B[Snapshotting]
-    B --> C[Snapshot Created]
-    B --> A
-    C -->|Sandbox.create| D[New Sandbox 1]
-    C -->|Sandbox.create| E[New Sandbox 2]
-    C -->|Sandbox.create| F[New Sandbox N]
-```
-
-The sandbox is briefly paused during the snapshot process but automatically returns to running state. The sandbox ID stays the same after the snapshot completes.
-
-<Warning>
-During the snapshot, the sandbox is temporarily paused and resumed. This causes all active connections (e.g. WebSocket, PTY, command streams) to be dropped. Make sure your client handles reconnection properly.
-</Warning>
-
-## Create a snapshot
-
-You can create a snapshot from a running sandbox instance.
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Sandbox } from 'e2b'
-
-const sandbox = await Sandbox.create()
-
-// Create a snapshot from a running sandbox
-const snapshot = await sandbox.createSnapshot()
-console.log('Snapshot ID:', snapshot.snapshotId)
-```
-```python Python
-from e2b import Sandbox
-
-sandbox = Sandbox.create()
-
-# Create a snapshot from a running sandbox
-snapshot = sandbox.create_snapshot()
-print('Snapshot ID:', snapshot.snapshot_id)
-```
-</CodeGroup>
-
-You can also create a snapshot by sandbox ID using the static method.
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Sandbox } from 'e2b'
-
-// Create a snapshot by sandbox ID
-const snapshot = await Sandbox.createSnapshot(sandboxId)
-console.log('Snapshot ID:', snapshot.snapshotId)
-```
-```python Python
-from e2b import Sandbox
-
-# Create a snapshot by sandbox ID
-snapshot = Sandbox.create_snapshot(sandbox_id)
-print('Snapshot ID:', snapshot.snapshot_id)
-```
-</CodeGroup>
-
-## Create a sandbox from a snapshot
-
-The snapshot ID can be used directly with `Sandbox.create()` to spawn a new sandbox from the snapshot. The new sandbox starts with the exact filesystem and memory state captured in the snapshot.
-
-<CodeGroup>
-```js JavaScript & TypeScript highlight={5}
-import { Sandbox } from 'e2b'
-
-const snapshot = await sandbox.createSnapshot()
-
-// Create a new sandbox from the snapshot
-const newSandbox = await Sandbox.create(snapshot.snapshotId)
-```
-```python Python highlight={5}
-from e2b import Sandbox
-
-snapshot = sandbox.create_snapshot()
-
-# Create a new sandbox from the snapshot
-new_sandbox = Sandbox.create(snapshot.snapshot_id)
-```
-</CodeGroup>
-
-## List snapshots
-
-You can list all snapshots. The method returns a paginator for iterating through results.
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Sandbox } from 'e2b'
-
-const paginator = Sandbox.listSnapshots()
-
-const snapshots = []
-while (paginator.hasNext) {
-  const items = await paginator.nextItems()
-  snapshots.push(...items)
-}
-```
-```python Python
-from e2b import Sandbox
-
-paginator = Sandbox.list_snapshots()
-
-snapshots = []
-while paginator.has_next:
-    items = paginator.next_items()
-    snapshots.extend(items)
-```
-</CodeGroup>
-
-### Filter by sandbox
-
-You can filter snapshots created from a specific sandbox.
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Sandbox } from 'e2b'
-
-const paginator = Sandbox.listSnapshots({ sandboxId: 'your-sandbox-id' })
-const snapshots = await paginator.nextItems()
-```
-```python Python
-from e2b import Sandbox
-
-paginator = Sandbox.list_snapshots(sandbox_id="your-sandbox-id")
-snapshots = paginator.next_items()
-```
-</CodeGroup>
-
-## Delete a snapshot
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Sandbox } from 'e2b'
-
-// Returns true if deleted, false if the snapshot was not found
-const deleted = await Sandbox.deleteSnapshot(snapshot.snapshotId)
-```
-```python Python
-from e2b import Sandbox
-
-Sandbox.delete_snapshot(snapshot.snapshot_id)
-```
-</CodeGroup>
-
-## Snapshots vs. Templates
-
-Both snapshots and [templates](/docs/template/quickstart) create reusable starting points for sandboxes, but they solve different problems.
-
-| | Templates | Snapshots |
-|---|---|---|
-| Defined by | Declarative code (Template builder) | Capturing a running sandbox |
-| Reproducibility | Same definition produces the same sandbox every time | Captures whatever state exists at that moment |
-| Best for | Repeatable base environments | Checkpointing, rollback, forking runtime state |
-
-Use templates when every sandbox should start from an identical, known state — pre-installed tools, fixed configurations, consistent environments.
-Use snapshots when you need to capture or fork live runtime state that depends on what happened during execution.
-
-## Use cases
-
-- **Checkpointing agent work** — an AI agent has loaded data and produced partial results in memory. Snapshot it so you can resume or fork from that point later.
-- **Rollback points** — snapshot before a risky or expensive operation (running untrusted code, applying a migration, refactoring a web app). If it fails, rollback - spawn a fresh sandbox from the snapshot before the operation happened.
-- **Forking workflows** — spawn multiple sandboxes from the same snapshot to explore different approaches in parallel.
-- **Cached sandboxes** — avoid repeating expensive setup by snapshotting a sandbox that has already loaded a large dataset or started a long-running process.
-- **Sharing state** — one user or agent configures an environment interactively, snapshots it, and others start from that exact state.
diff --git a/docs/sandbox/ssh-access.mdx b/docs/sandbox/ssh-access.mdx
deleted file mode 100644
index 40f8ded0..00000000
--- a/docs/sandbox/ssh-access.mdx
+++ /dev/null
@@ -1,156 +0,0 @@
----
-title: "SSH access"
-description: "Connect to your sandbox via SSH using a WebSocket proxy"
----
-
-SSH access enables remote terminal sessions, SCP/SFTP file transfers, and integration with tools that expect SSH connectivity.
-
-## Quickstart
-
-<Steps>
-<Step title="Build the SSH template">
-
-Define a template with OpenSSH server and [websocat](https://github.com/vi/websocat):
-
-<CodeGroup>
-
-```typescript JavaScript & TypeScript
-// template.ts
-import { Template, waitForPort } from 'e2b'
-
-export const template = Template()
-  .fromUbuntuImage('25.04')
-  .aptInstall(['openssh-server'])
-  .runCmd([
-    'curl -fsSL -o /usr/local/bin/websocat https://github.com/vi/websocat/releases/latest/download/websocat.x86_64-unknown-linux-musl',
-    'chmod a+x /usr/local/bin/websocat',
-  ], { user: 'root' })
-  .setStartCmd('sudo websocat -b --exit-on-eof ws-l:0.0.0.0:8081 tcp:127.0.0.1:22', waitForPort(8081))
-```
-
-```python Python
-# template.py
-from e2b import Template, wait_for_port
-
-template = (
-    Template()
-    .from_ubuntu_image("25.04")
-    .apt_install(["openssh-server"])
-    .run_cmd([
-        "curl -fsSL -o /usr/local/bin/websocat https://github.com/vi/websocat/releases/latest/download/websocat.x86_64-unknown-linux-musl",
-        "chmod a+x /usr/local/bin/websocat",
-    ], user="root")
-    .set_start_cmd("sudo websocat -b --exit-on-eof ws-l:0.0.0.0:8081 tcp:127.0.0.1:22", wait_for_port(8081))
-)
-```
-
-</CodeGroup>
-
-Build the template:
-
-<CodeGroup>
-
-```typescript JavaScript & TypeScript
-// build.ts
-import { Template, defaultBuildLogger } from 'e2b'
-import { template as sshTemplate } from './template'
-
-await Template.build(sshTemplate, 'ssh-ready', {
-  cpuCount: 2,
-  memoryMB: 2048,
-  onBuildLogs: defaultBuildLogger(),
-})
-```
-
-```python Python
-# build.py
-from e2b import Template, default_build_logger
-from template import template as ssh_template
-
-Template.build(ssh_template, "ssh-ready",
-    cpu_count=2,
-    memory_mb=2048,
-    on_build_logs=default_build_logger(),
-)
-```
-
-</CodeGroup>
-
-</Step>
-<Step title="Create a sandbox from the template">
-
-<CodeGroup>
-
-```typescript JavaScript & TypeScript
-import { Sandbox } from 'e2b'
-
-const sbx = await Sandbox.create('ssh-ready')
-console.log(sbx.sandboxId)
-```
-
-```python Python
-from e2b import Sandbox
-
-sbx = Sandbox.create("ssh-ready")
-print(sbx.sandbox_id)
-```
-
-</CodeGroup>
-
-</Step>
-<Step title="Connect from your machine">
-
-<CodeGroup>
-
-```bash macOS
-# Install websocat
-brew install websocat
-
-# Connect to your sandbox
-ssh -o 'ProxyCommand=websocat --binary -B 65536 - wss://8081-%h.e2b.app' user@<sandbox-id>
-```
-
-```bash Linux
-# Install websocat
-sudo curl -fsSL -o /usr/local/bin/websocat https://github.com/vi/websocat/releases/latest/download/websocat.x86_64-unknown-linux-musl
-sudo chmod a+x /usr/local/bin/websocat
-
-# Connect to your sandbox
-ssh -o 'ProxyCommand=websocat --binary -B 65536 - wss://8081-%h.e2b.app' user@<sandbox-id>
-```
-
-</CodeGroup>
-
-</Step>
-</Steps>
-
----
-
-## How it works
-
-This method uses [websocat](https://github.com/vi/websocat) to proxy SSH connections over WebSocket through the sandbox's exposed ports.
-
-```
-┌───────────────────────────────────────────────────────────┐
-│  Your Machine                                             │
-│  ┌──────────┐    ProxyCommand    ┌──────────────────┐     │
-│  │   SSH    │ ────────────────── │    websocat      │     │
-│  │  Client  │                    │   (WebSocket)    │     │
-│  └──────────┘                    └─────────┬────────┘     │
-└────────────────────────────────────────────┼──────────────┘
-                                             │
-                         wss://8081-<sandbox-id>.e2b.app
-                                             │
-┌────────────────────────────────────────────┼──────────────┐
-│  E2B Sandbox                               ▼              │
-│                                  ┌──────────────────┐     │
-│                                  │    websocat      │     │
-│                                  │  (WS → TCP:22)   │     │
-│                                  └─────────┬────────┘     │
-│                                            │              │
-│                                  ┌─────────▼────────┐     │
-│                                  │   SSH Server     │     │
-│                                  │   (OpenSSH)      │     │
-│                                  └──────────────────┘     │
-└───────────────────────────────────────────────────────────┘
-```
diff --git a/docs/sandbox/volumes.mdx b/docs/sandbox/volumes.mdx
new file mode 100644
index 00000000..9fddb313
--- /dev/null
+++ b/docs/sandbox/volumes.mdx
@@ -0,0 +1,617 @@
+---
+title: "Volumes"
+sidebarTitle: Volumes
+icon: "hard-drive"
+description: "Persistent storage volumes for E2B sandboxes — create, mount, read, write, and manage files that persist across sandbox sessions."
+---
+
+<Note>
+Volumes are currently in private beta.
+If you'd like access, please reach out to us at [support@e2b.dev](mailto:support@e2b.dev).
+</Note>
+
+<Note>
+**Most use cases don't need volumes.** Every sandbox already has its own persistent filesystem — when you [pause and resume](/docs/sandbox/persistence) a sandbox, all files are preserved automatically. Volumes are for when you need storage that is **shared across multiple sandboxes** or persists independently of any single sandbox.
+</Note>
+
+Volumes provide storage that exists independently of any single sandbox. Data written to a volume survives sandbox shutdowns and can be mounted to different sandboxes over time.
+
+**One volume shared across multiple sandboxes**
+
+```mermaid actions={false}
+graph LR
+  V1[Volume A] --- S1[Sandbox 1]
+  V1 --- S2[Sandbox 2]
+  V1 --- S3[Sandbox 3]
+```
+
+**Each sandbox with its own volume**
+
+```mermaid actions={false}
+graph LR
+  V2[Volume A] --- S4[Sandbox 1]
+  V3[Volume B] --- S5[Sandbox 2]
+```
+
+**Standalone usage via SDK**
+
+```mermaid actions={false}
+graph LR
+  SDK[SDK] --- V4[Volume A]
+  SDK --- V5[Volume B]
+```
+
+When a volume is mounted to a sandbox, files can be read and written directly at the mount path. The SDK methods below are meant to be used when the volume is not mounted to any sandbox.
+
+## Managing volumes
+
+### Create a volume
+
+<Note>
+Volume names can only contain letters, numbers, and hyphens.
+</Note>
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Volume } from 'e2b'
+
+const volume = await Volume.create('my-volume')
+console.log(volume.volumeId) // Volume ID
+console.log(volume.name)     // 'my-volume'
+```
+```python Python
+from e2b import Volume
+
+volume = Volume.create('my-volume')
+print(volume.volume_id)  # Volume ID
+print(volume.name)       # 'my-volume'
+```
+</CodeGroup>
+
+### Connect to an existing volume
+
+You can connect to an existing volume by its ID using the `connect()` method.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Volume } from 'e2b'
+
+const volume = await Volume.connect('volume-id')
+console.log(volume.volumeId) // Volume ID
+console.log(volume.name)     // Volume name
+```
+```python Python
+from e2b import Volume
+
+volume = Volume.connect('volume-id')
+print(volume.volume_id)  # Volume ID
+print(volume.name)       # Volume name
+```
+</CodeGroup>
+
+### List volumes
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Volume } from 'e2b'
+
+const volumes = await Volume.list()
+console.log(volumes)
+// [{ volumeId: '...', name: 'my-volume' }, ...]
+```
+```python Python
+from e2b import Volume
+
+volumes = Volume.list()
+print(volumes)
+# [VolumeInfo(volume_id='...', name='my-volume'), ...]
+```
+</CodeGroup>
+
+### Get volume info
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Volume } from 'e2b'
+
+const info = await Volume.getInfo('volume-id')
+console.log(info)
+// { volumeId: '...', name: 'my-volume' }
+```
+```python Python
+from e2b import Volume
+
+info = Volume.get_info('volume-id')
+print(info)
+# VolumeInfo(volume_id='...', name='my-volume')
+```
+</CodeGroup>
+
+### Destroy a volume
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Volume } from 'e2b'
+
+const success = await Volume.destroy('volume-id')
+console.log(success) // true
+```
+```python Python
+from e2b import Volume
+
+success = Volume.destroy('volume-id')
+print(success)  # True
+```
+</CodeGroup>
+
+## Mounting volumes
+
+You can mount one or more volumes to a sandbox when creating it. The keys of the `volumeMounts` / `volume_mounts` object are the mount paths inside the sandbox.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Volume, Sandbox } from 'e2b'
+
+const volume = await Volume.create('my-volume')
+
+// You can pass a Volume object
+const sandbox = await Sandbox.create({
+  volumeMounts: {
+    '/mnt/my-data': volume,
+  },
+})
+
+// Or pass the volume name directly
+const sandbox = await Sandbox.create({
+  volumeMounts: {
+    '/mnt/my-data': 'my-volume',
+  },
+})
+
+// Files written to /mnt/my-data inside the sandbox are persisted in the volume
+await sandbox.files.write('/mnt/my-data/hello.txt', 'Hello, world!')
+```
+```python Python
+from e2b import Volume, Sandbox
+
+volume = Volume.create('my-volume')
+
+# You can pass a Volume object
+sandbox = Sandbox.create(
+    volume_mounts={
+        '/mnt/my-data': volume,
+    },
+)
+
+# Or pass the volume name directly
+sandbox = Sandbox.create(
+    volume_mounts={
+        '/mnt/my-data': 'my-volume',
+    },
+)
+
+# Files written to /mnt/my-data inside the sandbox are persisted in the volume
+sandbox.files.write('/mnt/my-data/hello.txt', 'Hello, world!')
+```
+</CodeGroup>
+
+## Read and write files
+
+### Reading files
+
+You can read files from a volume using the `readFile()` / `read_file()` method.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Volume } from 'e2b'
+
+const volume = await Volume.create('my-volume')
+
+const content = await volume.readFile('/path/to/file')
+console.log(content)
+```
+```python Python
+from e2b import Volume
+
+volume = Volume.create('my-volume')
+
+content = volume.read_file('/path/to/file')
+print(content)
+```
+</CodeGroup>
+
+### Writing files
+
+You can write files to a volume using the `writeFile()` / `write_file()` method.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Volume } from 'e2b'
+
+const volume = await Volume.create('my-volume')
+
+await volume.writeFile('/path/to/file', 'file content')
+```
+```python Python
+from e2b import Volume
+
+volume = Volume.create('my-volume')
+
+volume.write_file('/path/to/file', 'file content')
+```
+</CodeGroup>
+
+### Creating directories
+
+You can create directories in a volume using the `makeDir()` / `make_dir()` method.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Volume } from 'e2b'
+
+const volume = await Volume.create('my-volume')
+
+await volume.makeDir('/path/to/dir')
+
+// Create nested directories with force option
+await volume.makeDir('/path/to/nested/dir', { force: true })
+```
+```python Python
+from e2b import Volume
+
+volume = Volume.create('my-volume')
+
+volume.make_dir('/path/to/dir')
+
+# Create nested directories with force option
+volume.make_dir('/path/to/nested/dir', force=True)
+```
+</CodeGroup>
+
+### Listing directory contents
+
+You can list the contents of a directory in a volume using the `list()` method.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Volume } from 'e2b'
+
+const volume = await Volume.create('my-volume')
+
+const entries = await volume.list('/path/to/dir')
+console.log(entries)
+// [
+//   { name: 'file.txt', type: 'file', path: '/path/to/dir/file.txt', size: 13, ... },
+//   { name: 'subdir', type: 'directory', path: '/path/to/dir/subdir', size: 0, ... },
+// ]
+```
+```python Python
+from e2b import Volume
+
+volume = Volume.create('my-volume')
+
+entries = volume.list('/path/to/dir')
+print(entries)
+# [
+#   VolumeEntryStat(name='file.txt', type_='file', path='/path/to/dir/file.txt', size=13, ...),
+#   VolumeEntryStat(name='subdir', type_='directory', path='/path/to/dir/subdir', size=0, ...),
+# ]
+```
+</CodeGroup>
+
+### Removing files or directories
+
+You can remove files or directories from a volume using the `remove()` method.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Volume } from 'e2b'
+
+const volume = await Volume.create('my-volume')
+
+// Remove a file
+await volume.remove('/path/to/file')
+
+// Remove a directory recursively
+await volume.remove('/path/to/dir', { recursive: true })
+```
+```python Python
+from e2b import Volume
+
+volume = Volume.create('my-volume')
+
+# Remove a file
+volume.remove('/path/to/file')
+
+# Remove a directory recursively
+volume.remove('/path/to/dir', recursive=True)
+```
+</CodeGroup>
+
+## File and directory metadata
+
+You can get information about a file or directory in a volume using the `getInfo()` / `get_info()` method.
+
+### File metadata
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Volume } from 'e2b'
+
+const volume = await Volume.create('my-volume')
+
+// Create a new file
+await volume.writeFile('/test_file.txt', 'Hello, world!')
+
+// Get information about the file
+const info = await volume.getInfo('/test_file.txt')
+
+console.log(info)
+// {
+//   name: 'test_file.txt',
+//   type: 'file',
+//   path: '/test_file.txt',
+//   size: 13,
+//   mode: 0o644,
+//   uid: 0,
+//   gid: 0,
+//   atime: 2025-05-26T12:00:00.000Z,
+//   mtime: 2025-05-26T12:00:00.000Z,
+//   ctime: 2025-05-26T12:00:00.000Z,
+// }
+```
+```python Python
+from e2b import Volume
+
+volume = Volume.create('my-volume')
+
+# Create a new file
+volume.write_file('/test_file.txt', 'Hello, world!')
+
+# Get information about the file
+info = volume.get_info('/test_file.txt')
+
+print(info)
+# VolumeEntryStat(
+#   name='test_file.txt',
+#   type_='file',
+#   path='/test_file.txt',
+#   size=13,
+#   mode=0o644,
+#   uid=0,
+#   gid=0,
+#   atime=datetime(2025, 5, 26, 12, 0, 0),
+#   mtime=datetime(2025, 5, 26, 12, 0, 0),
+#   ctime=datetime(2025, 5, 26, 12, 0, 0),
+# )
+```
+</CodeGroup>
+
+### Directory metadata
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Volume } from 'e2b'
+
+const volume = await Volume.create('my-volume')
+
+// Create a new directory
+await volume.makeDir('/test_dir')
+
+// Get information about the directory
+const info = await volume.getInfo('/test_dir')
+
+console.log(info)
+// {
+//   name: 'test_dir',
+//   type: 'directory',
+//   path: '/test_dir',
+//   size: 0,
+//   mode: 0o755,
+//   uid: 0,
+//   gid: 0,
+//   atime: 2025-05-26T12:00:00.000Z,
+//   mtime: 2025-05-26T12:00:00.000Z,
+//   ctime: 2025-05-26T12:00:00.000Z,
+// }
+```
+```python Python
+from e2b import Volume
+
+volume = Volume.create('my-volume')
+
+# Create a new directory
+volume.make_dir('/test_dir')
+
+# Get information about the directory
+info = volume.get_info('/test_dir')
+
+print(info)
+# VolumeEntryStat(
+#   name='test_dir',
+#   type_='directory',
+#   path='/test_dir',
+#   size=0,
+#   mode=0o755,
+#   uid=0,
+#   gid=0,
+#   atime=datetime(2025, 5, 26, 12, 0, 0),
+#   mtime=datetime(2025, 5, 26, 12, 0, 0),
+#   ctime=datetime(2025, 5, 26, 12, 0, 0),
+# )
+```
+</CodeGroup>
+
+### Checking if a path exists
+
+You can check whether a file or directory exists in a volume using the `exists()` method.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Volume } from 'e2b'
+
+const volume = await Volume.create('my-volume')
+
+const fileExists = await volume.exists('/test_file.txt')
+console.log(fileExists) // true or false
+```
+```python Python
+from e2b import Volume
+
+volume = Volume.create('my-volume')
+
+file_exists = volume.exists('/test_file.txt')
+print(file_exists)  # True or False
+```
+</CodeGroup>
+
+### Updating metadata
+
+You can update file or directory metadata such as user ID, group ID, and permissions mode using the `updateMetadata()` / `update_metadata()` method.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import { Volume } from 'e2b'
+
+const volume = await Volume.create('my-volume')
+
+await volume.writeFile('/test_file.txt', 'Hello, world!')
+
+const updated = await volume.updateMetadata('/test_file.txt', { uid: 1000, gid: 1000, mode: 0o600 })
+
+console.log(updated)
+// {
+//   name: 'test_file.txt',
+//   type: 'file',
+//   path: '/test_file.txt',
+//   size: 13,
+//   mode: 0o600,
+//   uid: 1000,
+//   gid: 1000,
+//   ...
+// }
+```
+```python Python
+from e2b import Volume
+
+volume = Volume.create('my-volume')
+
+volume.write_file('/test_file.txt', 'Hello, world!')
+
+updated = volume.update_metadata('/test_file.txt', uid=1000, gid=1000, mode=0o600)
+
+print(updated)
+# VolumeEntryStat(
+#   name='test_file.txt',
+#   type_='file',
+#   path='/test_file.txt',
+#   size=13,
+#   mode=0o600,
+#   uid=1000,
+#   gid=1000,
+#   ...
+# )
+```
+</CodeGroup>
+
+## Upload data
+
+You can upload data to a volume using the `writeFile()` / `write_file()` method.
+
+### Upload single file
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import fs from 'fs'
+import { Volume } from 'e2b'
+
+const volume = await Volume.create('my-volume')
+
+// Read file from local filesystem
+const content = fs.readFileSync('/local/path')
+// Upload file to volume
+await volume.writeFile('/path/in/volume', content)
+```
+```python Python
+from e2b import Volume
+
+volume = Volume.create('my-volume')
+
+# Read file from local filesystem
+with open('/local/path', 'rb') as file:
+    # Upload file to volume
+    volume.write_file('/path/in/volume', file)
+```
+</CodeGroup>
+
+### Upload directory / multiple files
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import fs from 'fs'
+import path from 'path'
+import { Volume } from 'e2b'
+
+const volume = await Volume.create('my-volume')
+
+const directoryPath = '/local/dir'
+const files = fs.readdirSync(directoryPath)
+
+for (const file of files) {
+  const fullPath = path.join(directoryPath, file)
+
+  // Skip directories
+  if (!fs.statSync(fullPath).isFile()) continue
+
+  const content = fs.readFileSync(fullPath)
+  await volume.writeFile(`/upload/${file}`, content)
+}
+```
+```python Python
+import os
+from e2b import Volume
+
+volume = Volume.create('my-volume')
+
+directory_path = '/local/dir'
+
+for filename in os.listdir(directory_path):
+    file_path = os.path.join(directory_path, filename)
+
+    # Skip directories
+    if not os.path.isfile(file_path):
+        continue
+
+    with open(file_path, 'rb') as file:
+        volume.write_file(f'/upload/{filename}', file)
+```
+</CodeGroup>
+
+## Download data
+
+You can download data from a volume using the `readFile()` / `read_file()` method.
+
+<CodeGroup>
+```js JavaScript & TypeScript
+import fs from 'fs'
+import { Volume } from 'e2b'
+
+const volume = await Volume.create('my-volume')
+
+// Read file from volume
+const content = await volume.readFile('/path/in/volume')
+// Write file to local filesystem
+fs.writeFileSync('/local/path', content)
+```
+```python Python
+from e2b import Volume
+
+volume = Volume.create('my-volume')
+
+# Read file from volume
+content = volume.read_file('/path/in/volume')
+# Write file to local filesystem
+with open('/local/path', 'w') as file:
+    file.write(content)
+```
+</CodeGroup>
diff --git a/docs/template/migration-v2.mdx b/docs/template/migration-v2.mdx
index bec6875c..6d17aa07 100644
--- a/docs/template/migration-v2.mdx
+++ b/docs/template/migration-v2.mdx
@@ -21,7 +21,7 @@ To migrate the existing template definition to the new format, follow these step
 
 <Steps>
     <Step title="Install E2B CLI">
-        Install the latest version of the [E2B CLI](https://e2b.dev/docs/cli)
+        Install the latest version of the [E2B CLI](/docs/sandbox/cli)
     </Step>
     <Step title="Navigate to your template folder">
         Navigate to the folder of your existing template definition (where you have `e2b.toml` and `e2b.Dockerfile` files).
diff --git a/docs/template/quickstart.mdx b/docs/template/quickstart.mdx
index b5a13079..33db3352 100644
--- a/docs/template/quickstart.mdx
+++ b/docs/template/quickstart.mdx
@@ -18,7 +18,7 @@ You can use the E2B CLI to create a new template.
 
 <Steps>
     <Step title="Install the E2B CLI">
-        Install the latest version of the [E2B CLI](https://e2b.dev/docs/cli)
+        Install the latest version of the [E2B CLI](/docs/sandbox/cli)
     </Step>
     <Step title="Initialize a new template">
     ```bash
diff --git a/docs/template/start-ready-command.mdx b/docs/template/start-ready-command.mdx
index 7920c4ec..498e929d 100644
--- a/docs/template/start-ready-command.mdx
+++ b/docs/template/start-ready-command.mdx
@@ -13,7 +13,7 @@ This is how you get servers, seeded databases, or any long-running process avail
 <Note title="The start command does not run on sandbox creation">
   The start command runs **once during template build** and is captured in a snapshot. It does not re-execute each time you create a sandbox. If you need to run a command every time a sandbox is created, use `sandbox.commands.run()` after creating the sandbox instead.
 
-  This also means that [environment variables passed to `Sandbox.create()`](/docs/sandbox/environment-variables#1-global-environment-variables) are **not available** to the start command process — it already ran during the build. If your start command needs environment variables, set them in the template definition using `setEnvs()` / `set_envs()`.
+  This also means that [environment variables passed to `Sandbox.create()`](/docs/sandbox/environment-variables) are **not available** to the start command process — it already ran during the build. If your start command needs environment variables, set them in the template definition using `setEnvs()` / `set_envs()`.
 </Note>
 
 You can see the full build process [here](/docs/template/how-it-works).
diff --git a/docs/volumes.mdx b/docs/volumes.mdx
deleted file mode 100644
index 8f98d378..00000000
--- a/docs/volumes.mdx
+++ /dev/null
@@ -1,73 +0,0 @@
----
-title: "Volumes"
-sidebarTitle: Overview
----
-
-<Note>
-Volumes are currently in private beta.
-If you'd like access, please reach out to us at [support@e2b.dev](mailto:support@e2b.dev).
-</Note>
-
-Volumes provide persistent storage that exists independently of sandbox lifecycles. Data written to a volume persists even after a sandbox is shut down, and volumes can be mounted to multiple sandboxes over time.
-
-**One volume shared across multiple sandboxes**
-
-```mermaid actions={false}
-graph LR
-  V1[Volume A] --- S1[Sandbox 1]
-  V1 --- S2[Sandbox 2]
-  V1 --- S3[Sandbox 3]
-```
-
-**Each sandbox with its own volume**
-
-```mermaid actions={false}
-graph LR
-  V2[Volume A] --- S4[Sandbox 1]
-  V3[Volume B] --- S5[Sandbox 2]
-```
-
-**Standalone usage via SDK**
-
-```mermaid actions={false}
-graph LR
-  SDK[SDK] --- V4[Volume A]
-  SDK --- V5[Volume B]
-```
-
-When a volume is mounted to a sandbox, files can be read and written directly at the mount path. The SDK methods are meant to be used when the volume is not mounted to any sandbox.
-
-With E2B SDK you can:
-- [Manage volumes.](/docs/volumes/manage)
-- [Mount volumes to sandboxes.](/docs/volumes/mount)
-- [Read and write files to a volume.](/docs/volumes/read-write)
-- [Get file and directory metadata.](/docs/volumes/info)
-- [Upload data to a volume.](/docs/volumes/upload)
-- [Download data from a volume.](/docs/volumes/download)
-
-## Example
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Volume, Sandbox } from 'e2b'
-
-const volume = await Volume.create('my-volume')
-
-const sandbox = await Sandbox.create({
-  volumeMounts: {
-    '/mnt/my-data': volume,
-  },
-})
-```
-```python Python
-from e2b import Volume, Sandbox
-
-volume = Volume.create('my-volume')
-
-sandbox = Sandbox.create(
-    volume_mounts={
-        '/mnt/my-data': volume,
-    },
-)
-```
-</CodeGroup>
diff --git a/docs/volumes/download.mdx b/docs/volumes/download.mdx
deleted file mode 100644
index e2f0ef2a..00000000
--- a/docs/volumes/download.mdx
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: "Download data from volume"
-sidebarTitle: Download data
----
-
-You can download data from a volume using the `readFile()` / `read_file()` method.
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import fs from 'fs'
-import { Volume } from 'e2b'
-
-const volume = await Volume.create('my-volume')
-
-// Read file from volume
-const content = await volume.readFile('/path/in/volume')
-// Write file to local filesystem
-fs.writeFileSync('/local/path', content)
-```
-```python Python
-from e2b import Volume
-
-volume = Volume.create('my-volume')
-
-# Read file from volume
-content = volume.read_file('/path/in/volume')
-# Write file to local filesystem
-with open('/local/path', 'w') as file:
-    file.write(content)
-```
-</CodeGroup>
diff --git a/docs/volumes/info.mdx b/docs/volumes/info.mdx
deleted file mode 100644
index 91c3c7ef..00000000
--- a/docs/volumes/info.mdx
+++ /dev/null
@@ -1,188 +0,0 @@
----
-title: "Get information about a file or directory"
-sidebarTitle: File & directory metadata
----
-
-You can get information about a file or directory in a volume using the `getInfo()` / `get_info()` method.
-
-### Getting information about a file
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Volume } from 'e2b'
-
-const volume = await Volume.create('my-volume')
-
-// Create a new file
-await volume.writeFile('/test_file.txt', 'Hello, world!')
-
-// Get information about the file
-const info = await volume.getInfo('/test_file.txt')
-
-console.log(info)
-// {
-//   name: 'test_file.txt',
-//   type: 'file',
-//   path: '/test_file.txt',
-//   size: 13,
-//   mode: 0o644,
-//   uid: 0,
-//   gid: 0,
-//   atime: 2025-05-26T12:00:00.000Z,
-//   mtime: 2025-05-26T12:00:00.000Z,
-//   ctime: 2025-05-26T12:00:00.000Z,
-// }
-```
-```python Python
-from e2b import Volume
-
-volume = Volume.create('my-volume')
-
-# Create a new file
-volume.write_file('/test_file.txt', 'Hello, world!')
-
-# Get information about the file
-info = volume.get_info('/test_file.txt')
-
-print(info)
-# VolumeEntryStat(
-#   name='test_file.txt',
-#   type_='file',
-#   path='/test_file.txt',
-#   size=13,
-#   mode=0o644,
-#   uid=0,
-#   gid=0,
-#   atime=datetime(2025, 5, 26, 12, 0, 0),
-#   mtime=datetime(2025, 5, 26, 12, 0, 0),
-#   ctime=datetime(2025, 5, 26, 12, 0, 0),
-# )
-```
-</CodeGroup>
-
-### Getting information about a directory
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Volume } from 'e2b'
-
-const volume = await Volume.create('my-volume')
-
-// Create a new directory
-await volume.makeDir('/test_dir')
-
-// Get information about the directory
-const info = await volume.getInfo('/test_dir')
-
-console.log(info)
-// {
-//   name: 'test_dir',
-//   type: 'directory',
-//   path: '/test_dir',
-//   size: 0,
-//   mode: 0o755,
-//   uid: 0,
-//   gid: 0,
-//   atime: 2025-05-26T12:00:00.000Z,
-//   mtime: 2025-05-26T12:00:00.000Z,
-//   ctime: 2025-05-26T12:00:00.000Z,
-// }
-```
-```python Python
-from e2b import Volume
-
-volume = Volume.create('my-volume')
-
-# Create a new directory
-volume.make_dir('/test_dir')
-
-# Get information about the directory
-info = volume.get_info('/test_dir')
-
-print(info)
-# VolumeEntryStat(
-#   name='test_dir',
-#   type_='directory',
-#   path='/test_dir',
-#   size=0,
-#   mode=0o755,
-#   uid=0,
-#   gid=0,
-#   atime=datetime(2025, 5, 26, 12, 0, 0),
-#   mtime=datetime(2025, 5, 26, 12, 0, 0),
-#   ctime=datetime(2025, 5, 26, 12, 0, 0),
-# )
-```
-</CodeGroup>
-
-### Checking if a path exists
-
-You can check whether a file or directory exists in a volume using the `exists()` method.
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Volume } from 'e2b'
-
-const volume = await Volume.create('my-volume')
-
-const fileExists = await volume.exists('/test_file.txt')
-console.log(fileExists) // true or false
-```
-```python Python
-from e2b import Volume
-
-volume = Volume.create('my-volume')
-
-file_exists = volume.exists('/test_file.txt')
-print(file_exists)  # True or False
-```
-</CodeGroup>
-
-### Updating metadata
-
-You can update file or directory metadata such as user ID, group ID, and permissions mode using the `updateMetadata()` / `update_metadata()` method.
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Volume } from 'e2b'
-
-const volume = await Volume.create('my-volume')
-
-await volume.writeFile('/test_file.txt', 'Hello, world!')
-
-const updated = await volume.updateMetadata('/test_file.txt', { uid: 1000, gid: 1000, mode: 0o600 })
-
-console.log(updated)
-// {
-//   name: 'test_file.txt',
-//   type: 'file',
-//   path: '/test_file.txt',
-//   size: 13,
-//   mode: 0o600,
-//   uid: 1000,
-//   gid: 1000,
-//   ...
-// }
-```
-```python Python
-from e2b import Volume
-
-volume = Volume.create('my-volume')
-
-volume.write_file('/test_file.txt', 'Hello, world!')
-
-updated = volume.update_metadata('/test_file.txt', uid=1000, gid=1000, mode=0o600)
-
-print(updated)
-# VolumeEntryStat(
-#   name='test_file.txt',
-#   type_='file',
-#   path='/test_file.txt',
-#   size=13,
-#   mode=0o600,
-#   uid=1000,
-#   gid=1000,
-#   ...
-# )
-```
-</CodeGroup>
diff --git a/docs/volumes/manage.mdx b/docs/volumes/manage.mdx
deleted file mode 100644
index 08bbd6c0..00000000
--- a/docs/volumes/manage.mdx
+++ /dev/null
@@ -1,102 +0,0 @@
----
-title: "Managing volumes"
----
-
-## Create a volume
-
-<Note>
-Volume names can only contain letters, numbers, and hyphens.
-</Note>
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Volume } from 'e2b'
-
-const volume = await Volume.create('my-volume')
-console.log(volume.volumeId) // Volume ID
-console.log(volume.name)     // 'my-volume'
-```
-```python Python
-from e2b import Volume
-
-volume = Volume.create('my-volume')
-print(volume.volume_id)  # Volume ID
-print(volume.name)       # 'my-volume'
-```
-</CodeGroup>
-
-## Connect to an existing volume
-
-You can connect to an existing volume by its ID using the `connect()` method.
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Volume } from 'e2b'
-
-const volume = await Volume.connect('volume-id')
-console.log(volume.volumeId) // Volume ID
-console.log(volume.name)     // Volume name
-```
-```python Python
-from e2b import Volume
-
-volume = Volume.connect('volume-id')
-print(volume.volume_id)  # Volume ID
-print(volume.name)       # Volume name
-```
-</CodeGroup>
-
-## List volumes
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Volume } from 'e2b'
-
-const volumes = await Volume.list()
-console.log(volumes)
-// [{ volumeId: '...', name: 'my-volume' }, ...]
-```
-```python Python
-from e2b import Volume
-
-volumes = Volume.list()
-print(volumes)
-# [VolumeInfo(volume_id='...', name='my-volume'), ...]
-```
-</CodeGroup>
-
-## Get volume info
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Volume } from 'e2b'
-
-const info = await Volume.getInfo('volume-id')
-console.log(info)
-// { volumeId: '...', name: 'my-volume' }
-```
-```python Python
-from e2b import Volume
-
-info = Volume.get_info('volume-id')
-print(info)
-# VolumeInfo(volume_id='...', name='my-volume')
-```
-</CodeGroup>
-
-## Destroy a volume
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Volume } from 'e2b'
-
-const success = await Volume.destroy('volume-id')
-console.log(success) // true
-```
-```python Python
-from e2b import Volume
-
-success = Volume.destroy('volume-id')
-print(success)  # True
-```
-</CodeGroup>
diff --git a/docs/volumes/mount.mdx b/docs/volumes/mount.mdx
deleted file mode 100644
index ab02a12d..00000000
--- a/docs/volumes/mount.mdx
+++ /dev/null
@@ -1,52 +0,0 @@
----
-title: "Mounting volumes"
----
-
-You can mount one or more volumes to a sandbox when creating it. The keys of the `volumeMounts` / `volume_mounts` object are the mount paths inside the sandbox.
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import { Volume, Sandbox } from 'e2b'
-
-const volume = await Volume.create('my-volume')
-
-// You can pass a Volume object
-const sandbox = await Sandbox.create({
-  volumeMounts: {
-    '/mnt/my-data': volume,
-  },
-})
-
-// Or pass the volume name directly
-const sandbox = await Sandbox.create({
-  volumeMounts: {
-    '/mnt/my-data': 'my-volume',
-  },
-})
-
-// Files written to /mnt/my-data inside the sandbox are persisted in the volume
-await sandbox.files.write('/mnt/my-data/hello.txt', 'Hello, world!')
-```
-```python Python
-from e2b import Volume, Sandbox
-
-volume = Volume.create('my-volume')
-
-# You can pass a Volume object
-sandbox = Sandbox.create(
-    volume_mounts={
-        '/mnt/my-data': volume,
-    },
-)
-
-# Or pass the volume name directly
-sandbox = Sandbox.create(
-    volume_mounts={
-        '/mnt/my-data': 'my-volume',
-    },
-)
-
-# Files written to /mnt/my-data inside the sandbox are persisted in the volume
-sandbox.files.write('/mnt/my-data/hello.txt', 'Hello, world!')
-```
-</CodeGroup>
diff --git a/docs/volumes/read-write.mdx b/docs/volumes/read-write.mdx
deleted file mode 100644
index 43838b6c..00000000
--- a/docs/volumes/read-write.mdx
+++ /dev/null
@@ -1,135 +0,0 @@
----
-title: "Read & write files"
-sidebarTitle: Read & write
----
-
-## Reading files
-
-You can read files from a volume using the `readFile()` / `read_file()` method.
-
-<CodeGroup>
-```js  JavaScript & TypeScript
-import { Volume } from 'e2b'
-
-const volume = await Volume.create('my-volume')
-
-const content = await volume.readFile('/path/to/file')
-console.log(content)
-```
-```python  Python
-from e2b import Volume
-
-volume = Volume.create('my-volume')
-
-content = volume.read_file('/path/to/file')
-print(content)
-```
-</CodeGroup>
-
-## Writing files
-
-You can write files to a volume using the `writeFile()` / `write_file()` method.
-
-<CodeGroup>
-```js  JavaScript & TypeScript
-import { Volume } from 'e2b'
-
-const volume = await Volume.create('my-volume')
-
-await volume.writeFile('/path/to/file', 'file content')
-```
-```python  Python
-from e2b import Volume
-
-volume = Volume.create('my-volume')
-
-volume.write_file('/path/to/file', 'file content')
-```
-</CodeGroup>
-
-## Creating directories
-
-You can create directories in a volume using the `makeDir()` / `make_dir()` method.
-
-<CodeGroup>
-```js  JavaScript & TypeScript
-import { Volume } from 'e2b'
-
-const volume = await Volume.create('my-volume')
-
-await volume.makeDir('/path/to/dir')
-
-// Create nested directories with force option
-await volume.makeDir('/path/to/nested/dir', { force: true })
-```
-```python  Python
-from e2b import Volume
-
-volume = Volume.create('my-volume')
-
-volume.make_dir('/path/to/dir')
-
-# Create nested directories with force option
-volume.make_dir('/path/to/nested/dir', force=True)
-```
-</CodeGroup>
-
-## Listing directory contents
-
-You can list the contents of a directory in a volume using the `list()` method.
-
-<CodeGroup>
-```js  JavaScript & TypeScript
-import { Volume } from 'e2b'
-
-const volume = await Volume.create('my-volume')
-
-const entries = await volume.list('/path/to/dir')
-console.log(entries)
-// [
-//   { name: 'file.txt', type: 'file', path: '/path/to/dir/file.txt', size: 13, ... },
-//   { name: 'subdir', type: 'directory', path: '/path/to/dir/subdir', size: 0, ... },
-// ]
-```
-```python  Python
-from e2b import Volume
-
-volume = Volume.create('my-volume')
-
-entries = volume.list('/path/to/dir')
-print(entries)
-# [
-#   VolumeEntryStat(name='file.txt', type_='file', path='/path/to/dir/file.txt', size=13, ...),
-#   VolumeEntryStat(name='subdir', type_='directory', path='/path/to/dir/subdir', size=0, ...),
-# ]
-```
-</CodeGroup>
-
-## Removing files or directories
-
-You can remove files or directories from a volume using the `remove()` method.
-
-<CodeGroup>
-```js  JavaScript & TypeScript
-import { Volume } from 'e2b'
-
-const volume = await Volume.create('my-volume')
-
-// Remove a file
-await volume.remove('/path/to/file')
-
-// Remove a directory recursively
-await volume.remove('/path/to/dir', { recursive: true })
-```
-```python  Python
-from e2b import Volume
-
-volume = Volume.create('my-volume')
-
-# Remove a file
-volume.remove('/path/to/file')
-
-# Remove a directory recursively
-volume.remove('/path/to/dir', recursive=True)
-```
-</CodeGroup>
diff --git a/docs/volumes/upload.mdx b/docs/volumes/upload.mdx
deleted file mode 100644
index dee64c68..00000000
--- a/docs/volumes/upload.mdx
+++ /dev/null
@@ -1,75 +0,0 @@
----
-title: "Upload data to volume"
-sidebarTitle: Upload data
----
-
-You can upload data to a volume using the `writeFile()` / `write_file()` method.
-
-## Upload single file
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import fs from 'fs'
-import { Volume } from 'e2b'
-
-const volume = await Volume.create('my-volume')
-
-// Read file from local filesystem
-const content = fs.readFileSync('/local/path')
-// Upload file to volume
-await volume.writeFile('/path/in/volume', content)
-```
-```python Python
-from e2b import Volume
-
-volume = Volume.create('my-volume')
-
-# Read file from local filesystem
-with open('/local/path', 'rb') as file:
-    # Upload file to volume
-    volume.write_file('/path/in/volume', file)
-```
-</CodeGroup>
-
-## Upload directory / multiple files
-
-<CodeGroup>
-```js JavaScript & TypeScript
-import fs from 'fs'
-import path from 'path'
-import { Volume } from 'e2b'
-
-const volume = await Volume.create('my-volume')
-
-const directoryPath = '/local/dir'
-const files = fs.readdirSync(directoryPath)
-
-for (const file of files) {
-  const fullPath = path.join(directoryPath, file)
-
-  // Skip directories
-  if (!fs.statSync(fullPath).isFile()) continue
-
-  const content = fs.readFileSync(fullPath)
-  await volume.writeFile(`/upload/${file}`, content)
-}
-```
-```python Python
-import os
-from e2b import Volume
-
-volume = Volume.create('my-volume')
-
-directory_path = '/local/dir'
-
-for filename in os.listdir(directory_path):
-    file_path = os.path.join(directory_path, filename)
-
-    # Skip directories
-    if not os.path.isfile(file_path):
-        continue
-
-    with open(file_path, 'rb') as file:
-        volume.write_file(f'/upload/{filename}', file)
-```
-</CodeGroup>