+
+
+### BYOC Cluster Components
+- **Orchestrator**: Represents a node that is responsible for managing sandboxes and their lifecycle. Optionally, it can also run the template builder component.
+- **Edge Controller**: Routes traffic to sandboxes, exposes API for cluster management, and gRPC proxy used by E2B control plane to communicate with orchestrators.
+- **Monitoring**: Collector that receives sandbox and build logs and system metrics from orchestrators and edge controllers. Only anonymized metrics are sent to the E2B Cloud for observability purposes.
+- **Storage**: Persistent storage for sandbox templates, snapshots, and runtime logs. Image container repository for template images.
+
+## Onboarding
+
+Customers can initiate the onboarding process by reaching out to us.
+Customers need to have a dedicated AWS account and know the region they will use.
+After that, we will receive the IAM role needed for managing account resources.
+For AWS account quota limits may need to be increased.
+
+Terraform configuration and machine images will be used for provisioning BYOC cluster.
+When provisioning is done and running, we will create a new team under your E2B account that can be used by SDK/CLI the same way as it is hosted on E2B Cloud.
+
+## FAQ
+
+
+
+
+### Full final code
+Check the full code in JavaScript and Python below:
+
+
\ No newline at end of file
diff --git a/apps/web/src/app/(docs)/mintlify-docs/code-interpreting/streaming/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/code-interpreting/streaming/index.mdx
new file mode 100644
index 0000000000..7120f9401f
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/code-interpreting/streaming/index.mdx
@@ -0,0 +1,141 @@
+---
+title: "Streaming"
+---
+
+Use E2B SDK allows you to stream the output, and results when executing code in the sandbox.
+
+
+## Stream `stdout` and `stderr`
+When using the `runCode()` method in JavaScript or `run_code()` in Python you can pass `onStdout`/`on_stdout` and `onStderr`/`on_stderr` callbacks to handle the output.
+
+'
+const execution = await sandbox.notebook.execCell(code)
+
+// There was an error during execution, return the error and its traceback
+if (execution.error) {
+ return `There was an error during execution: ${execution.error.name}: ${execution.error.value}.\n
+ ${execution.error.traceback}`
+}
+
+// The execution has some result, summarize to LLM, what are the results
+if (execution.results.length > 0) {
+ let message = 'These are results of the execution:\n'
+ let counter = 1
+ for (const result of execution.results) {
+ message += `Result ${counter++}:\n`
+ if (result.isMainResult) {
+ message += `[Main result]: ${result.text}\n`
+ } else {
+ message += `[Display data]: ${result.text}\n`
+ }
+ if (result.formats().length > 0) {
+ message += `It has following formats: ${result.formats()}\n`
+ }
+ }
+
+ return message
+}
+
+// There were no results, check if there was something is stdout/err
+if (
+ execution.logs.stdout.length > 0 ||
+ execution.logs.stderr.length > 0
+) {
+ let message = 'There was no result of the execution, but here are the logs:\n'
+ if (execution.logs.stdout.length > 0) {
+ message += `Stdout: ${execution.logs.stdout.join('\n')}\n`
+ }
+ if (execution.logs.stderr.length > 0) {
+ message += `Stderr: ${execution.logs.stderr.join('\n')}\n`
+ }
+
+ return message
+}
+
+return 'There was no output of the execution.'
+```
+
+```python Python
+code = ""
+execution = sandbox.notebook.exec_cell(code)
+
+# There was an error during execution, return the error and its traceback
+if execution.error:
+ return (
+ f"There was an error during execution: {execution.error.name}: {execution.error.value}.\n"
+ f"{execution.error.traceback}"
+ )
+
+# The execution has some result, summarize to LLM, what are the results
+if execution.results:
+ message = "These are results of the execution:\n"
+ for i, result in enumerate(execution.results):
+ message += f"Result {i + 1}:\n"
+ if result.is_main_result:
+ message += f"[Main result]: {result.text}\n"
+ else:
+ message += f"[Display data]: {result.text}\n"
+
+ if result.formats():
+ message += f"It has also following formats: {result.formats()}\n"
+
+ return message
+
+# There were no results, check if there was something is stdout/err
+if execution.logs.stdout or execution.logs.stderr:
+ message = "There was no result of the execution, but here are the logs:\n"
+ if execution.logs.stdout:
+ message += "Stdout: " + "\n".join(execution.logs.stdout) + "\n"
+
+ if execution.logs.stderr:
+ message += "Stderr: " + "\n".join(execution.logs.stderr) + "\n"
+
+ return message
+
+return "There was no output of the execution."
+```
+Core Sandbox SDK changes
+These changes affect both the `e2b` Core SDKs and Code Interpreter SDKs (`@e2b/code-interpreter`/`e2b-code-interpreter`) because the Code Interpreter uses the Core SDK. + +Code Interpreter SDK changes
+All the previously mentioned changes to the Core SDK also apply to the Code Interpreter SDK. +Apart from them, the changes to the Code Interpreter SDK are very minimal: + +## Executing code +When executing code via JS/TS Code Interpreter SDK you now pass the `timeoutMs` option to the `execCell` method instead of `timeout`. + +The default timeout for the code execution is now 300 seconds. + +Python Async
+Python Core SDK and Code Interpter SDK now support async. + +If you need to use async import `AsyncSandbox`/`AsyncCodeInterpreter` instead of `Sandbox`/`CodeInterpreter`. + +
+```
+
+We got our median in the logs (`stdout`, and `stderr`) but we also something intering in `firstResult`.
+```sh
+
+```
+
+## 6. Save generated chart
+
+This looks like a plot. Let's save it to a file. Update the `run()` function like this,
+and run the code again with `tsx index.ts` in your terminal.
+
+```ts index.ts
+async function run() {
+ const userMessage = 'Visualize a distribution of height of men based on the latest data you know. Also print the median value.'
+
+ const codeInterpreter = await CodeInterpreter.create()
+
+ const codeOutput = await chat(codeInterpreter, userMessage)
+ if (!codeOutput) {
+ console.log('No code output')
+ return
+ }
+
+ const logs = codeOutput.logs
+ console.log(logs)
+
+ if (codeOutput.results.length == 0) {
+ console.log('No results')
+ return
+ }
+
+ const firstResult = codeOutput.results[0]
+ // Print description of the first rich result
+ console.log(firstResult.text)
+
+ // If we received a chart in PNG form, we can visualize it
+ if (firstResult.png) {
+ // Decode the base64 encoded PNG data
+ const pngData = Buffer.from(firstResult.png, 'base64');
+
+ // Generate a unique filename for the PNG
+ const filename = 'chart.png';
+
+ // Save the decoded PNG data to a file
+ fs.writeFileSync(filename, pngData);
+
+ console.log(`Saved chart to ${filename}`);
+ }
+
+ await codeInterpreter.close()
+}
+
+run()
+```
+
+
+The chart got saved in the `chart.png` file and it should look similar to this:
+
+
+ 
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/legacy/hello-world/py/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/legacy/hello-world/py/index.mdx
new file mode 100644
index 0000000000..146c7c2e4e
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/legacy/hello-world/py/index.mdx
@@ -0,0 +1,256 @@
+---
+title: "Hello World.py"
+---
+
+You are reading a legacy (pre v1.0) document.
+
+
+This Python guide will show you the basics of E2B:
+- Connect the code interpreter to an LLM
+- Prompt the LLM to generate the Python code
+- Execute the AI-generated Python code in a secure E2B sandbox
+
+### Get full code
+Check out the [full code in our cookbook](https://github.com/e2b-dev/e2b-cookbook/tree/main/examples/hello-world-python).
+
+### Overview
+1. [Install Code Interpreter SDK](#1-install-code-interpreter-sdk)
+1. [Prepare prompt and tools for LLM](#2-prepare-prompt-and-tools-for-llm)
+1. [Prepare code interpreting](#3-prepare-code-interpreting)
+1. [Call LLM and parse response with tools](#4-call-llm-and-parse-response-with-tools)
+1. [Create code interpreter and run everything](##5-create-code-interpreter-and-run-everything)
+1. [Save generated chart](#6-save-generated-chart)
+
+
+## 1. Install Code Interpreter SDK
+
+The Code Interpreter SDK allows you to run AI-generated code in a secure small VM - **E2B sandbox** - made for AI code execution.
+Inside the sandbox is a Jupyter server running that you can control from our SDK through the `notebook.execCell()` method.
+
+Check out the [SDK's repository on GitHub](https://github.com/e2b-dev/code-interpreter).
+
+
+```bash Python
+pip install e2b_code_interpreter python-dotenv
+```
+
+
+Get your E2B API key [here](/legacy/getting-started/api-key) and save it to `.env` in your root directory.
+
+```bash .env
+E2B_API_KEY="e2b-api-key"
+```
+
+
+
+## 2. Prepare prompt and tools for LLM
+We'll be using Anthropic's [Claude 3 Opus](https://www.anthropic.com/news/claude-3-family) model but E2B works with any LLM so feel free to pick any you want!
+
+
+Usually, all you need from the model is just support for tool use. If the LLM doesn't support tool use, you can ask the LLM to respond with Markdown or XML and parse the LLM's output on your own. Then just pass the parsed code from code blocks to the code interpreter.
+
+
+Create the `model.py` file and paste the following code.
+
+```python Python
+# model.py
+MODEL_NAME = "claude-3-opus-20240229"
+
+SYSTEM_PROMPT = """
+## your job & context
+you are a python data scientist. you are given tasks to complete and you run python code to solve them.
+- the python code runs in jupyter notebook.
+- every time you call `execute_python` tool, the python code is executed in a separate cell. it's okay to multiple calls to `execute_python`.
+- display visualizations using matplotlib or any other visualization library directly in the notebook. don't worry about saving the visualizations to a file.
+- you have access to the internet and can make api requests.
+- you also have access to the filesystem and can read/write files.
+- you can install any pip package (if it exists) if you need to but the usual packages for data analysis are already preinstalled.
+- you can run any python code you want, everything is running in a secure sandbox environment.
+"""
+
+tools = [
+ {
+ "name": "execute_python",
+ "description": "Execute python code in a Jupyter notebook cell and returns any result, stdout, stderr, display_data, and error.",
+ "input_schema": {
+ "type": "object",
+ "properties": {
+ "code": {
+ "type": "string",
+ "description": "The python code to execute in a single cell."
+ }
+ },
+ "required": ["code"]
+ }
+ }
+]
+```
+
+
+This defines our system prompt and the `tools` dictionary with available tools for the LLM - namely the `"execute_python"` tool.
+A little bit later, we'll connect `"execute_python"` to the E2B's code interpreter.
+
+
+## 3. Prepare code interpreting
+We'll create a new function called `code_interpret()` in a separate file `code_interpreter.py`.
+
+
+```python Python
+# code_interpreter.py
+from e2b_code_interpreter import CodeInterpreter
+
+def code_interpret(code_interpreter: CodeInterpreter, code: str):
+ print(f"\n{'='*50}\n> Running following AI-generated code:\n{code}\n{'='*50}")
+ exec = code_interpreter.notebook.exec_cell(
+ code,
+ # You can stream logs from the code interpreter
+ # on_stderr=lambda stderr: print("\n[Code Interpreter stdout]", stderr),
+ # on_stdout=lambda stdout: print("\n[Code Interpreter stderr]", stdout),
+ #
+ # You can also stream additional results like charts, images, etc.
+ # on_result=...
+ )
+
+ if exec.error:
+ print("[Code Interpreter error]", exec.error) # Runtime error
+ else:
+ return exec.results, exec.logs
+```
+
+
+This function takes the `CodeInterpreter` object from our SDK and `code` as paramaters.
+The `code` parameter is the code generated by the LLM.
+
+Inside the function, we call the `code_interpreter.notebook.exec_cell()` method. The `exec_cell()` takes the `code` argument and executes this `code` inside E2B sandbox.
+
+## 4. Call LLM and parse response with tools
+We're using Claude 3 Opus. Get your [Anthropic API key](https://console.anthropic.com/), save it to `.env` file, and install the [Anthropic SDK](https://docs.anthropic.com/claude/reference/client-sdks).
+
+
+```bash .env
+ANTHROPIC_API_KEY="anthropic-api-key"
+```
+
+
+
+```bash bash
+pip install anthropic==0.35.0
+```
+
+
+Now we'll put everything together.
+Create the `main.py` file, import dependencies, and create the `chat()` function that will do the LLM calling and tool parsing.
+
+
+```python Python
+import base64
+from dotenv import load_dotenv
+from anthropic import Anthropic
+from typing import List, Tuple
+from e2b_code_interpreter import CodeInterpreter, Result
+from e2b_code_interpreter.models import Logs
+
+from e2b_hello_world.model import MODEL_NAME, SYSTEM_PROMPT, tools
+from e2b_hello_world.code_interpreter import code_interpret
+
+# Load the .env file
+load_dotenv()
+
+client = Anthropic()
+
+def chat(code_interpreter: CodeInterpreter, user_message: str) -> Tuple[List[Result], Logs]:
+ print(f"\n{'='*50}\nUser Message: {user_message}\n{'='*50}")
+
+ message = client.messages.create(
+ model=MODEL_NAME,
+ system=SYSTEM_PROMPT,
+ max_tokens=4096,
+ messages=[{"role": "user", "content": user_message}],
+ tools=tools,
+ )
+
+ print(f"\n{'='*50}\nModel response: {message.content}\n{'='*50}")
+
+ if message.stop_reason == "tool_use":
+ tool_use = next(block for block in message.content if block.type == "tool_use")
+ tool_name = tool_use.name
+ tool_input = tool_use.input
+
+ print(f"\n{'='*50}\nUsing tool: {tool_name}\n{'='*50}")
+
+ if tool_name == "execute_python":
+ return code_interpret(code_interpreter, tool_input["code"])
+ return []
+```
+
+
+
+## 5. Create code interpreter and run everything
+Now we are ready to run our program. At the end of `main.py` add the following code prompting the LLM to visualize a distribution of the height of men and print the median.
+
+
+```python Python
+# main.py
+def main():
+ user_message = "Visualize a distribution of height of men based on the latest data you know. Also, print the median value."
+
+ # Create the CodeInterpreter object and save it as code_interpreter
+ with CodeInterpreter() as code_interpreter:
+ code_interpreter_results, code_interpreter_logs = chat(
+ code_interpreter,
+ user_message,
+ )
+
+ print(code_interpreter_logs)
+
+ first_result= code_interpreter_results[0]
+ print(first_result)
+```
+
+
+After running your code with the following command
+
+```bash bash
+$ python main.py
+```
+
+
+you should see results similar to this:
+
+```sh
+stdout=['The median male height is 175.5 cm\n'] stderr=[]
+
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/legacy/hello-world/py/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/legacy/hello-world/py/index.mdx
new file mode 100644
index 0000000000..146c7c2e4e
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/legacy/hello-world/py/index.mdx
@@ -0,0 +1,256 @@
+---
+title: "Hello World.py"
+---
+
+
+```
+
+We got our median in the logs (`stdout`, and `stderr`) but we also something intering in `first_result`.
+```sh
+
+```
+
+## 6. Save generated chart
+
+This looks like a plot. Let's save it to a file. Add the following to the end of `main.py` and run the code again with `python main.py` in your terminal.
+
+```python Python
+# main.py
+ # If we received a chart in PNG form, we can visualize it
+ if first_result.png:
+ # Decode the base64 encoded PNG data
+ png_data = base64.b64decode(first_result.png)
+
+ # Generate a unique filename for the PNG
+ filename = f"chart.png"
+
+ # Save the decoded PNG data to a file
+ with open(filename, "wb") as f:
+ f.write(png_data)
+
+ print(f"Saved chart to {filename}")
+```
+
+
+The chart was saved in the `chart.png` file and it should look similar to this:
+
+
+
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/legacy/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/legacy/index.mdx
new file mode 100644
index 0000000000..9b1f174f18
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/legacy/index.mdx
@@ -0,0 +1,53 @@
+---
+title: "Code interpreting for your AI app"
+---
+
+You are reading a legacy (pre v1.0) document.
+
+E2B's [Code Interpreter SDK](https://github.com/e2b-dev/code-interpreter) allows you to add code interpreting capabilities to your AI apps.
+
+With code interpreting, you can build apps like:
+- AI code execution
+- Data analysis with AI
+- AI tutors
+- Reasoning modules for LLM
+
+## Quickstart
+
+### 1. Install SDK
+
+```bash JavaScript & TypeScript
+npm i @e2b/code-interpreter
+```
+```bash Python
+pip install e2b_code_interpreter
+```
+
+
+### 2. Execute code with code interpreter inside sandbox
+
+```ts JavaScript & TypeScript
+import { CodeInterpreter } from '@e2b/code-interpreter'
+
+const sandbox = await CodeInterpreter.create()
+await sandbox.notebook.execCell('x = 1')
+
+const execution = await sandbox.notebook.execCell('x+=1; x')
+console.log(execution.text) // outputs 2
+
+await sandbox.close()
+```
+
+```py Python
+from e2b_code_interpreter import CodeInterpreter
+
+with CodeInterpreter() as sandbox:
+ sandbox.notebook.exec_cell("x = 1")
+
+ execution = sandbox.notebook.exec_cell("x+=1; x")
+ print(execution.text) # outputs 2
+```
+
+
+### 3. Hello World guide
+Dive depeer and check out the [JavaScript](/legacy/hello-world/js) and [Python](/legacy/hello-world/py) Hello World guides to learn how to connect the code interpreter to LLMs.
diff --git a/apps/web/src/app/(docs)/mintlify-docs/legacy/open-source/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/legacy/open-source/index.mdx
new file mode 100644
index 0000000000..1b13cf322f
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/legacy/open-source/index.mdx
@@ -0,0 +1,15 @@
+---
+title: "Open source"
+---
+
+You are reading a legacy (pre v1.0) document.
+
+
+E2B is fully open source including the infrastructure layer.
+
+- [E2B monorepo containing the SDKs, CLI, and docs](https://github.com/e2b-dev/e2b)
+- [E2B infrastructure](https://github.com/e2b-dev/infra)
+- [Example code interpreter ChatGPT plugin](https://github.com/e2b-dev/llm-code-interpreter)
+- [List of awesome SDKs for AI agents](https://github.com/e2b-dev/awesome-sdks-for-ai-agents)
+- [List of awesome AI agents](https://github.com/e2b-dev/awesome-ai-agents)
+{/* - [E2B cookbook](https://github.com/e2b-dev/e2b-cookbook) */}
diff --git a/apps/web/src/app/(docs)/mintlify-docs/legacy/pricing/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/legacy/pricing/index.mdx
new file mode 100644
index 0000000000..011e50d43d
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/legacy/pricing/index.mdx
@@ -0,0 +1,70 @@
+---
+title: "Pricing"
+---
+
+You are reading a legacy (pre v1.0) document.
+
+
+import SandboxSpec from "/snippets/SandboxSpec.mdx";
+
+[Manage Billing](https://e2b.dev/dashboard?tab=billing)
+
+We charge you based on your real sandbox usage. All new users get one-time free $100 worth of usage in credits.
+
+---
+
+# Plans pricing
+Additionally to the usage costs, you can also select a tier that includes dedicated support, prioritized features, and higher sandbox limits.
+
+## Hobby tier
+**$0/month + usage costs**
+
+- One-time $100 of usage in credits
+- Community support
+- Up to 1 hour sandbox session length
+- Up to 20 concurrently running sandboxes
+
+## Pro tier
+**$150/month + usage costs**
+
+- One-time $100 of usage in credits
+- Dedicated Slack channel with live Pro support from our team
+- Prioritized features
+- Customize your [sandbox compute](/legacy/sandbox/compute)
+- Up to 24 hours sandbox session length
+- Up to 100 concurrently running sandboxes
+
+
+If you need any additional features or resources, please [reach out to us](/legacy/getting-help) with your use case.
+
+---
+
+# Compute pricing
+We charge per second of a running sandbox.
+- vCPU: $0.000014 per second (~$0.05 per hour)
+- GiB RAM: $0.0000045 per second (~$0.018 per hour)
+- GiB storage: Free
+
+
+1 GiB is equal to 1,024 MiB
+
+
+## Sandbox compute
+Pro customers can customize the sandbox with **any combination** of the CPU and RAM based on the following tables.
+
+
+By default your sandbox has 2 vCPU and 512 MiB RAM.
+
+To customize your sandbox compute, you need to build your custom sandbox template using the [E2B CLI](/legacy/cli/installation).
+Run [`e2b template build`](/legacy/cli/commands#template-build) and specify the `--cpu-count` and `--memory-mb` options.
+
+For example this custom build gives your sandbox 8 vCPU and 4GiB of RAM
+```sh
+e2b template build --cpu-count 8 --memory-mb 4096
+```
+
+
+
+[Let us know](/legacy/getting-help) if you need more powerful compute. diff --git a/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/api/cwd/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/api/cwd/index.mdx new file mode 100644 index 0000000000..b7bbdb1d33 --- /dev/null +++ b/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/api/cwd/index.mdx @@ -0,0 +1,136 @@ +--- +title: "Current Working Directory" +--- + +You are reading a legacy (pre v1.0) document.
+
+
+You can set a working directory either for the whole sandbox, a filesystem operation, or a new process.
+
+## Sandbox
+
+If the current working directory for the sandbox is not set, it will default to the home directory - `/home/user`.
+
+
+```js JavaScript & TypeScript highlight={5-9}
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create({
+ template: 'base',
+ cwd: '/code',
+})
+
+// You can also change the cwd of an existing sandbox
+sandbox.cwd = '/home'
+
+await sandbox.close()
+```
+```python Python highlight={5-9}
+from e2b import Sandbox
+
+sandbox = Sandbox(
+ template="base",
+ cwd="/code",
+)
+
+# You can also change the cwd of an existing sandbox
+sandbox.cwd = "/home"
+
+sandbox.close()
+```
+
+
+## Filesystem
+
+All filesystem operations with relative paths are relative to the current working directory.
+
+
+```js JavaScript & TypeScript highlight={5,8,16}
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create({
+ template: 'base',
+ cwd: '/home/user/code',
+})
+
+await sandbox.filesystem.write('hello.txt', 'Welcome to E2B!')
+const proc = await sandbox.process.start({
+ cmd: 'cat /home/user/code/hello.txt',
+})
+await proc.wait()
+console.log(proc.output.stdout)
+// output: "Welcome to E2B!"
+
+await sandbox.filesystem.write('../hello.txt', 'We hope you have a great day!')
+const proc2 = await sandbox.process.start({cmd: 'cat /home/user/hello.txt'})
+await proc2.wait()
+console.log(proc2.output.stdout)
+// output: "We hope you have a great day!"
+
+await sandbox.close()
+```
+```python Python highlight={5,7,13}
+from e2b import Sandbox
+
+sandbox = Sandbox(
+ template="base",
+ cwd="/home/user/code"
+)
+sandbox.filesystem.write("hello.txt", "Welcome to E2B!")
+proc = sandbox.process.start("cat /home/user/code/hello.txt")
+proc.wait()
+print(proc.output.stdout)
+# output: "Welcome to E2B!"
+
+sandbox.filesystem.write("../hello.txt", "We hope you have a great day!")
+proc2 = sandbox.process.start("cat /home/user/hello.txt")
+proc2.wait()
+print(proc2.output.stdout)
+# output: "We hope you have a great day!"
+
+sandbox.close()
+```
+
+
+## Process
+
+If you set a working directory for the sandbox, all processes will inherit it. You can override it for each process.
+
+
+```js JavaScript & TypeScript highlight={5,8,13}
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create({
+ template: 'base',
+ cwd: '/code',
+})
+
+const sandboxCwd = await sandbox.process.start({cmd: 'pwd'})
+await sandboxCwd.wait()
+console.log(sandboxCwd.output.stdout)
+// output: /code
+
+const processCwd = await sandbox.process.start({cmd: 'pwd', cwd: '/home'})
+await processCwd.wait()
+console.log(processCwd.output.stdout)
+// output: /home
+
+await sandbox.close()
+```
+```python Python highlight={3,4,9}
+from e2b import Sandbox
+
+sandbox = Sandbox(template="base", cwd="/code")
+sandbox_cwd = sandbox.process.start("pwd")
+sandbox_cwd.wait()
+print(sandbox_cwd.output.stdout)
+# output: "/code"
+
+process_cwd = sandbox.process.start("pwd", cwd="/home")
+process_cwd.wait()
+print(process_cwd.output.stdout)
+# output: "/home"
+
+sandbox.close()
+```
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/api/debugging/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/api/debugging/index.mdx
new file mode 100644
index 0000000000..d11a3212bd
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/api/debugging/index.mdx
@@ -0,0 +1,79 @@
+---
+title: "Logging"
+---
+
+You are reading a legacy (pre v1.0) document.
+
+
+export const sections = [
+ { title: 'Logging', id: 'logging' },
+]
+
+
+ ```text JavaScript & TypeScript
+ E2B package logs only warnings & errors to the console by default. Below is an example of how to fully customize the logging levels.\n\nFeel free to override the logger with your own implementation with debug, info, warn, and error methods.
+ ```
+ ```text Python
+ E2B package uses the standard Python logging module You can configure the logging level, handlers and format as you would with any other Python application. \n\nBelow is an example of how to configure the logging module to log to the console.
+ ```
+
+
+
+```js JavaScript & TypeScript highlight={14}
+import { Sandbox } from 'e2b'
+
+const logger = {
+ debug: console.debug, // log debug messages, in default logger this is noop
+ info: console.info, // log info messages, in default logger this is noop
+ // don't forget to also specify warn & error handlers, otherwise they won't be logged when overriding the logger
+ warn: console.warn,
+ error: console.error,
+}
+
+const sandbox = await Sandbox.create({
+ template: 'base',
+ apiKey: process.env.E2B_API_KEY,
+ logger,
+})
+```
+```python Python highlight={10,15,18,29}
+import logging
+from os import getenv
+
+from e2b import Sandbox
+
+E2B_API_KEY = getenv("E2B_API_KEY")
+
+# Global logging configuration
+logging.basicConfig(level=logging.INFO, format="GLOBAL - [%(asctime)s] - %(name)-32s - %(levelname)7s: %(message)s",
+ datefmt="%Y-%m-%d %H:%M:%S")
+
+# Or configure only e2b logger
+
+# Get e2b logger
+e2b_logger = logging.getLogger("e2b")
+
+# Set e2b logger level to INFO
+e2b_logger.setLevel(logging.INFO)
+
+# Setup formatter
+formatter = logging.Formatter("E2B - [%(asctime)s] - %(name)-32s - %(levelname)7s: %(message)s",
+ datefmt="%Y-%m-%d %H:%M:%S")
+
+# Setup handler
+handler = logging.StreamHandler()
+handler.setFormatter(formatter)
+
+# Add handler to e2b logger
+e2b_logger.addHandler(handler)
+
+
+def main():
+ sandbox = Sandbox(template="base", api_key=E2B_API_KEY)
+ sandbox.filesystem.write("test.txt", "Hello World")
+ sandbox.close()
+
+
+main()
+```
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/api/download/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/api/download/index.mdx
new file mode 100644
index 0000000000..2855834030
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/api/download/index.mdx
@@ -0,0 +1,40 @@
+---
+title: "Download files from the sandbox"
+---
+
+You are reading a legacy (pre v1.0) document.
+
+
+Any file inside the sandbox can be downloaded using the `downloadFile`/`download_file` method.
+
+## Use case for downloading files
+For example, the download file method is useful for downloading any files produced by LLM. You can let LLM generate and execute code inside the sandbox.
+This LLM-generated code might produce some files like charts, CSV files, or PDF files that you want to download to your machine.
+
+
+```js JavaScript & TypeScript highlight={6}
+import { Sandbox } from 'e2b'
+import fs from 'node:fs'
+
+const sandbox = await Sandbox.create({ template: 'base' })
+
+const buffer = await sandbox.downloadFile('path/to/remote/file/inside/sandbox', 'buffer')
+// Save file to local filesystem
+fs.writeFileSync('path/to/local/file', buffer)
+
+await sandbox.close()
+```
+```python Python highlight={5,7,8}
+from e2b import Sandbox
+
+sandbox = Sandbox(template="base")
+
+file_in_bytes = sandbox.download_file("path/to/remote/file/inside/sandbox")
+# Save file to local filesystem
+with open("path/to/local/file", "wb") as f:
+ f.write(file_in_bytes)
+
+sandbox.close()
+```
+
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/api/envs/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/api/envs/index.mdx
new file mode 100644
index 0000000000..f3b7fdf0b9
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/api/envs/index.mdx
@@ -0,0 +1,79 @@
+---
+title: "Setting environment variables"
+---
+
+You are reading a legacy (pre v1.0) document.
+
+
+## Global environment variables
+You can set the sandbox's global environment variables when initializing a new sandbox.
+
+```js JavaScript & TypeScript highlight={5}
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create({
+ template: 'base',
+ envVars: {FOO: 'Hello'},
+})
+
+await sandbox.close()
+```
+```python Python highlight={5}
+from e2b import Sandbox
+
+sandbox = Sandbox(
+ template="base",
+ env_vars={"FOO": "Hello"},
+)
+
+sandbox.close()
+```
+
+
+
+## Environment variables per process
+Alternatively, you can set environment variables when starting a new process. These environment variables are accessible only for this process.
+
+
+Environment variables set when starting a new process have precedence over the environment variables set when initializing the sandbox.
+
+
+
+```js JavaScript & TypeScript highlight={10}
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create({
+ template: 'base',
+ envVars: {FOO: 'Hello'},
+})
+
+const proc = await sandbox.process.start({
+ cmd: 'echo $FOO $BAR!',
+ envVars: {BAR: 'World'},
+})
+await proc.wait()
+console.log(proc.output.stdout)
+// output: Hello World!
+
+await sandbox.close()
+```
+```python Python highlight={10}
+from e2b import Sandbox
+
+sandbox = Sandbox(
+ template="base",
+ env_vars={"FOO": "Hello"}
+)
+
+proc = sandbox.process.start(
+ "echo $FOO $BAR!",
+ env_vars={"BAR": "World"},
+)
+proc.wait()
+
+print(proc.output.stdout)
+# output: Hello World!
+
+sandbox.close()
+```
+
\ No newline at end of file
diff --git a/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/api/filesystem/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/api/filesystem/index.mdx
new file mode 100644
index 0000000000..a972478a45
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/api/filesystem/index.mdx
@@ -0,0 +1,275 @@
+---
+title: List directory
+---
+
+You are reading a legacy (pre v1.0) document.
+
+
+
+```js JavaScript & TypeScript highlight={7}
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create({
+ template: 'base',
+})
+
+const dirContent = await sandbox.filesystem.list('/')
+dirContent.forEach((item) => {
+ console.log(item.name)
+})
+
+await sandbox.close()
+```
+```python Python highlight={6}
+from e2b import Sandbox
+
+sandbox = Sandbox(template="base")
+
+# List the root directory
+content = sandbox.filesystem.list("/")
+for item in content:
+ print(f"Is '{item.name}' directory?", item.is_dir)
+
+sandbox.close()
+```
+
+
+## Create directory
+
+Create directory and all parent directories.
+
+
+```js JavaScript & TypeScript highlight={6}
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create({ template: 'base' })
+
+// Create a new directory '/dir'
+await sandbox.filesystem.makeDir('/dir')
+
+await sandbox.close()
+```
+```python Python highlight={6}
+from e2b import Sandbox
+
+sandbox = Sandbox(template="base")
+
+# Create a new directory '/dir'
+sandbox.filesystem.make_dir("/dir")
+
+sandbox.close()
+```
+
+
+## Write to file
+
+When writing to a file that doesn't exist, the file will get created.
+
+When writing to a file that already exists, the file will get overwritten.
+
+When writing to a file that's in a directory that doesn't exist, you'll get an error.
+
+
+```js JavaScript & TypeScript highlight={11}
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create({ template: 'base' })
+
+// `filesystem.write()` will:
+// - create the file if it doesn't exist
+// - fail if any directory in the path doesn't exist
+// - overwrite the file if it exists
+
+// Write the content of the file '/hello.txt'
+await sandbox.filesystem.write('/hello.txt', 'Hello World!')
+
+// The following would fail because '/dir' doesn't exist
+// await sandbox.filesystem.write("/dir/hello.txt", "Hello World!")
+
+await sandbox.close()
+```
+```python Python highlight={11}
+from e2b import Sandbox
+
+sandbox = Sandbox(template="base")
+
+# `filesystem.write()` will:
+# - create the file if it doesn't exist
+# - fail if any directory in the path doesn't exist
+# - overwrite the file if it exists
+
+# Write the content of the file '/hello.txt'
+sandbox.filesystem.write("/hello.txt", "Hello World!")
+
+# The following would fail because '/dir' doesn't exist
+# sandbox.filesystem.write("/dir/hello.txt", "Hello World!")
+
+sandbox.close()
+```
+
+
+## Read from file
+
+
+```js JavaScript & TypeScript highlight={5}
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create({ template: 'base' })
+
+const fileContent = await sandbox.filesystem.read('/etc/hosts')
+console.log(fileContent)
+
+await sandbox.close()
+```
+```python Python highlight={6}
+from e2b import Sandbox
+
+sandbox = Sandbox(template="base")
+
+# Read the '/etc/hosts' file
+file_content = sandbox.filesystem.read("/etc/hosts")
+
+# Prints something like:
+# 127.0.0.1 localhost
+print(file_content)
+
+sandbox.close()
+```
+
+
+## Write bytes
+
+
+```js JavaScript & TypeScript highlight={10}
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create({ template: 'base' })
+
+// Let's convert string to bytes for testing purposes
+const encoder = new TextEncoder('utf-8')
+const contentInBytes = encoder.encode('Hello World!')
+
+// `writeBytes` accepts a Uint8Array and saves it to a file inside the playground
+await sandbox.filesystem.writeBytes('/file', contentInBytes)
+
+// We can read the file back to verify the content
+const fileContent = await sandbox.filesystem.read('/file')
+
+// This will print 'Hello World!'
+console.log(fileContent)
+
+await sandbox.close()
+```
+```python Python highlight={8}
+from e2b import Sandbox
+
+sandbox = Sandbox(template="base")
+
+content_in_bytes = bytearray(b"Hello world")
+
+# `write_bytes` will write bytearray to a file inside the playground.
+sandbox.filesystem.write_bytes("/file", content_in_bytes)
+
+# We can read the file back to verify the content
+file_content = sandbox.filesystem.read("/file")
+print(file_content)
+
+sandbox.close()
+```
+
+
+## Read bytes
+
+
+```js JavaScript & TypeScript highlight={8}
+import fs from 'fs'
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create({ template: 'base' })
+
+// File bytes will read file's content as bytes
+// `fileBytes` as a Uint8Array
+const fileBytes = await sandbox.filesystem.readBytes('/etc/hosts')
+
+// The output will look similar to this:
+//
+
+## Watch directory for changes
+
+
+```js JavaScript & TypeScript highlight={6-10}
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create({ template: 'base' })
+
+// Start filesystem watcher for the /home directory
+const watcher = sandbox.filesystem.watchDir('/home')
+watcher.addEventListener((event) => {
+ console.log('Filesystem event', event)
+})
+await watcher.start()
+
+// Create files in the /home directory inside the playground
+// We'll receive notifications for these events through the watcher we created above.
+for (let i = 0; i < 10; i++) {
+ console.log('Creating file', i)
+ // `filesystem.write()` will trigger two events:
+ // 1. 'Create' when the file is created
+ // 2. 'Write' when the file is written to
+ await sandbox.filesystem.write(`/home/${i}.txt`, `Hello World ${i}!`)
+}
+
+await sandbox.close()
+```
+```python Python highlight={7,19}
+import time
+
+from e2b import Sandbox
+
+sandbox = Sandbox.create()
+
+watcher = sandbox.files.watch_dir("/home")
+
+# Create files in the /home directory inside the playground
+# We'll receive notifications for these events through the watcher we created above.
+for i in range(10):
+ # `filesystem.write()` will trigger two events:
+ # 1. 'Create' when the file is created
+ # 2. 'Write' when the file is written to
+ sandbox.files.write(f"/home/file{i}.txt", f"Hello World {i}!")
+ time.sleep(1)
+
+for event in watcher.get():
+ print(f"Event: {event.type} {event.name}")
+
+watcher.stop()
+sandbox.kill()
+```
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/api/metadata/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/api/metadata/index.mdx
new file mode 100644
index 0000000000..96233b4433
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/api/metadata/index.mdx
@@ -0,0 +1,66 @@
+---
+title: Sandbox metadata
+---
+
+You are reading a legacy (pre v1.0) document.
+
+
+You can assign metadata to your sandbox. This metadata will be available if you call `Sandbox.list()`. This can be useful in a situation where each of your users have dedicated sandbox and the time between the steps of the integration is long. You can use the metadata to store the user id and reconnect to it later.
+
+
+```js JavaScript & TypeScript highlight={5}
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create({
+ template: 'base',
+ metadata: { userID: 'uniqueID' }
+})
+// Keep the sandbox alive for 60 seconds
+await sandbox.keepAlive(60_000)
+// You can even close the script
+
+// Later, can be even from another process
+// List all running sandboxes
+const paginator = Sandbox.list({ query: {state: ['running']}})
+const runningSandboxes = await paginator.nextItems()
+// Find the sandbox by metadata
+const found = runningSandboxes.find(s => s.metadata?.userID === 'uniqueID')
+if (found) {
+ // Sandbox found, we can reconnect to it
+ const sandbox = await Sandbox.reconnect(found.sandboxID)
+} else {
+ // Sandbox not found
+}
+
+await sandbox.close()
+```
+```python Python highlight={6}
+from e2b import Sandbox, SandboxState
+from e2b.sandbox.sandbox_api import SandboxQuery
+
+sandbox = Sandbox(
+ template="base",
+ metadata={"user_id": "uniqueID"},
+)
+
+# Keep the sandbox alive for 60 seconds
+sandbox.set_timeout(60)
+# You can even close the script
+
+# Later, can be even from another process
+# List all running sandboxes
+paginator = Sandbox.list(query=SandboxQuery(state=[SandboxState.RUNNING]))
+running_sandboxes = paginator.next_items()
+
+# Find the sandbox by metadata
+for running_sandbox in running_sandboxes:
+ if running_sandbox.metadata.get("user_id", "") == "uniqueID":
+ sandbox = Sandbox.connect(running_sandbox.sandbox_id)
+ break
+else:
+ # Sandbox not found
+ pass
+
+sandbox.close()
+```
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/api/process/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/api/process/index.mdx
new file mode 100644
index 0000000000..ce3c6bfe94
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/api/process/index.mdx
@@ -0,0 +1,269 @@
+---
+title: "Starting process inside a sandbox"
+---
+
+You are reading a legacy (pre v1.0) document.
+
+
+Here are the basic operations you can do with the process inside the sandbox:
+
+- [Start process](#start-process)
+- [Stop process](#stop-process)
+- [Stdout](#stream-stdout)
+- [Stdin](#send-stdin)
+- [Stderr](#stream-stderr)
+- [On exit](#on-process-exit)
+
+## Start process
+
+
+```js JavaScript & TypeScript highlight={6}
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create({ template: 'base' })
+
+const npmInit = await sandbox.process.start({
+ cmd: 'npm init -y',
+})
+await npmInit.wait()
+
+console.log(npmInit.output.stdout)
+
+await sandbox.close()
+```
+```python Python highlight={5}
+from e2b import Sandbox
+
+sandbox = Sandbox(template="base")
+
+npm_init = sandbox.process.start("npm init -y")
+npm_init.wait()
+print(npm_init.stdout)
+
+sandbox.close()
+```
+
+
+## Stop process
+
+
+```js JavaScript & TypeScript highlight={10}
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create({
+ template: 'base',
+})
+
+const npmInit = await sandbox.process.start({
+ cmd: 'npm init -y',
+})
+await npmInit.kill()
+// There will be no output because we immediately kill the `npm_init` process
+console.log(npmInit.output.stdout)
+
+await sandbox.close()
+```
+```python Python highlight={6}
+from e2b import Sandbox
+
+sandbox = Sandbox(template="base")
+
+npm_init = sandbox.process.start("npm init -y")
+npm_init.kill()
+
+# There will be no output because we immediately kill the `npm_init` process
+print(npm_init.stdout)
+
+sandbox.close()
+```
+
+
+## Stream stdout
+
+Set either stdout handler for the whole sandbox level or per process.
+
+
+```js JavaScript & TypeScript highlight={5,16}
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create({
+ template: 'base',
+ onStdout: (output) => console.log('sandbox', output.line),
+})
+
+const proc = await sandbox.process.start({
+ cmd: 'echo "Hello World!"',
+})
+await proc.wait()
+// output: sandbox Hello World!
+
+const procWithCustomHandler = await sandbox.process.start({
+ cmd: 'echo "Hello World!"',
+ onStdout: (data) => console.log('process', data.line),
+})
+await procWithCustomHandler.wait()
+// output: process Hello World!
+
+await sandbox.close()
+```
+```python Python highlight={5,14}
+from e2b import Sandbox
+
+sandbox = Sandbox(
+ template="base",
+ on_stdout=lambda output: print("sandbox", output.line),
+)
+
+proc = sandbox.process.start('echo "Hello World!"')
+proc.wait()
+# output: sandbox Hello World!
+
+proc_with_custom_handler = sandbox.process.start(
+ 'echo "Hello World!"',
+ on_stdout=lambda output: print("process", output.line),
+)
+proc_with_custom_handler.wait()
+# output: process Hello World!
+
+sandbox.close()
+```
+
+
+## Stream stderr
+
+Set either stderr handler for the whole sandbox level or per process.
+
+
+```js JavaScript & TypeScript highlight={10,17}
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create({
+ template: 'base',
+})
+
+// This command will fail and output to stderr because Golang isn't installed in the cloud playground
+const golangVersion = await sandbox.process.start({
+ cmd: 'go version',
+ onStderr: (output) => console.log('sandbox', output.line),
+})
+await golangVersion.wait()
+// output: [sandbox] /bin/bash: line 1: go: command not found
+
+const procWithCustomHandler = await sandbox.process.start({
+ cmd: 'go version',
+ onStderr: (data) => console.log('process', data.line),
+})
+await procWithCustomHandler.wait()
+// output: process /bin/bash: line 1: go: command not found
+
+await sandbox.close()
+```
+```python Python highlight={5,15}
+from e2b import Sandbox
+
+sandbox = Sandbox(
+ template="base",
+ on_stderr=lambda output: print("[sandbox]", output.line),
+)
+
+# This command will fail and output to stderr because Golang isn't installed in the cloud playground
+proc = sandbox.process.start("go version")
+proc.wait()
+# output: [sandbox] /bin/bash: line 1: go: command not found
+
+proc_with_custom_handler = sandbox.process.start(
+ "go version",
+ on_stderr=lambda output: print("[process]", output.line),
+)
+proc_with_custom_handler.wait()
+# output: [process] /bin/bash: line 1: go: command not found
+
+sandbox.close()
+```
+
+
+## On process exit
+
+Set either on exit handler for the whole sandbox level or per process.
+
+
+```js JavaScript & TypeScript highlight={5,14}
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create({
+ template: 'base',
+ onExit: () => console.log('[sandbox]', 'process ended'),
+})
+
+const proc = await sandbox.process.start({cmd: 'echo "Hello World!"'})
+await proc.wait()
+// output: [sandbox] process ended
+
+const procWithCustomHandler = await sandbox.process.start({
+ cmd: 'echo "Hello World!"',
+ onExit: () => console.log('[process]', 'process ended'),
+})
+await procWithCustomHandler.wait()
+// output: [process] process ended
+
+await sandbox.close()
+```
+```python Python highlight={5,14}
+from e2b import Sandbox
+
+sandbox = Sandbox(
+ template="base",
+ on_exit=lambda: print("[sandbox]", "process ended"),
+)
+
+proc = sandbox.process.start('echo "Hello World!"')
+proc.wait()
+# output: [sandbox] process ended
+
+proc_with_custom_handler = sandbox.process.start(
+ 'echo "Hello World!"',
+ on_exit=lambda: print("[process]", "process ended"),
+)
+proc_with_custom_handler.wait()
+# output: [process] process ended
+
+sandbox.close()
+```
+
+
+## Send stdin
+
+
+```js JavaScript & TypeScript highlight={11}
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create({ template: 'base' })
+
+// This example will print back the string we send to the process using `sendStdin()`
+
+const proc = await sandbox.process.start({
+ cmd: 'while IFS= read -r line; do echo "$line"; sleep 1; done',
+ onStdout: (output) => console.log(output),
+})
+await proc.sendStdin('AI Playground\n')
+await proc.kill()
+
+await sandbox.close()
+```
+```python Python highlight={11}
+from e2b import Sandbox
+
+sandbox = Sandbox(template="base")
+
+# This example will print back the string we send to the process using `send_stdin()`
+
+proc = sandbox.process.start(
+ 'while IFS= read -r line; do echo "$line"; sleep 1; done',
+ on_stdout=print,
+)
+proc.send_stdin("AI Playground\n")
+proc.kill()
+
+sandbox.close()
+```
+
\ No newline at end of file
diff --git a/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/api/reconnect/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/api/reconnect/index.mdx
new file mode 100644
index 0000000000..aab0ea6658
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/api/reconnect/index.mdx
@@ -0,0 +1,110 @@
+---
+title: "Connect to running sandbox"
+---
+
+You are reading a legacy (pre v1.0) document.
+
+
+Disconnect and reconnect later to the same sandbox while keeping it alive
+
+## Description
+
+The sandboxes are by default kept alive only when connected to them. When you disconnect from a sandbox, it will be destroyed.
+
+If you want to keep the sandbox alive even after disconnecting from it, you can explicitly say for how long you want to keep it alive. You can then disconnect from the sandbox and reconnect to it later. This can be useful for example in a **serverless environment** or **chatbot application**.
+
+The duration limit to keep the sandbox alive is 1 hour. If you need more, feel free to [reach out to us](/legacy/getting-help) with your use.
+
+## Keep sandbox alive
+
+The example below shows how to disconnect from a running sandbox and reconnect to it again while keeping the sandbox alive.
+
+
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+async function wait(ms) {
+ return new Promise(resolve => setTimeout(resolve, ms))
+}
+
+const sandbox = await Sandbox.create({ template: 'base' })
+```
+```python Python
+import time
+from e2b import Sandbox
+
+
+sandbox = Sandbox('base')
+```
+
+
+Call the `keep_alive`/`keepAlive` method on the sandbox instance to keep it alive. You can specify the preferred duration, as a multiple of a default time unit, which is
+- 1ms in JS
+- 1s in Python.
+
+You then disconnect from the sandbox.
+
+
+```js JavaScript & TypeScript highlight={8}
+// Do something in the sandbox
+await sandbox.filesystem.write('hello.txt', 'Hello World!')
+
+// Get the sandbox ID, we'll need it later
+const sandboxID = sandbox.id
+
+// Keep alive the sandbox for 2 minutes
+await sandbox.keepAlive(2 * 60 * 1000) // 2 minutes
+
+// Close the sandbox. Even if we close the sandbox, it will stay alive, because we explicitly called keepAlive().
+await sandbox.close()
+
+// Do something else...
+await wait(60 * 1000)
+```
+```python Python highlight={8}
+# Do something in the sandbox
+sandbox.filesystem.write('hello.txt', 'Hello World!')
+
+# Get the sandbox ID, we'll need it later
+sandboxID = sandbox.id
+
+# Keep the sandbox alive for 2 minutes
+sandbox.keep_alive(60 * 2)
+
+# Close the sandbox. Even if we close the sandbox, it will stay alive, because we explicitly called keep_alive().
+sandbox.close()
+
+# Do something else...
+time.sleep(60)
+```
+
+
+You can then reconnect to the sandbox from anywhere.
+
+
+```js JavaScript & TypeScript highlight={2}
+// Reconnect to the sandbox
+const sandbox2 = await Sandbox.reconnect(sandboxID)
+
+// Continue in using the sandbox
+const content = await sandbox2.filesystem.read('hello.txt')
+console.log(content)
+
+// Close the sandbox
+await sandbox2.close()
+```
+```python Python highlight={2}
+# Reconnect to the sandbox
+sandbox2 = Sandbox.reconnect(sandboxID)
+
+# Continue in using the sandbox
+content = sandbox2.filesystem.read('hello.txt')
+print(content)
+
+# Close the sandbox
+sandbox2.close()
+```
+
+
+## Use sandbox metadata
+Sandbox metadata can be very useful to store information about the sandbox. You can use it to store the user ID or any other information you need to keep track of and then use this info for reconnecting to the sandbox. You can read more about sandbox metadata [here](/legacy/sandbox/api/metadata).
\ No newline at end of file
diff --git a/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/api/timeouts/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/api/timeouts/index.mdx
new file mode 100644
index 0000000000..40e08d7a3c
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/api/timeouts/index.mdx
@@ -0,0 +1,100 @@
+---
+title: "Timeouts"
+---
+
+You are reading a legacy (pre v1.0) document.
+
+
+The SDK has a number of timeouts that can be configured to control how long the SDK will wait for a response from the E2B servers. **The default is 60 seconds.**
+
+## Timeout creating sandbox
+
+```js JavaScript & TypeScript highlight={6}
+import { Sandbox } from 'e2b'
+
+// Timeout 3s for the sandbox to open
+const sandbox = await Sandbox.create({
+ template: 'base',
+ timeout: 3000,
+})
+
+await sandbox.close()
+```
+```python Python highlight={4}
+from e2b import Sandbox
+
+# Timeout 3s for the sandbox to open
+sandbox = Sandbox(template="base", timeout=3)
+
+sandbox.close()
+```
+
+
+## Timeout process
+
+```js JavaScript & TypeScript highlight={8}
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create({ template: 'base' })
+
+// Timeout 3s for the process to start
+const npmInit = await sandbox.process.start({
+ cmd: 'npm init -y',
+ timeout: 3000,
+})
+await npmInit.wait()
+
+await sandbox.close()
+```
+```python Python highlight={6}
+from e2b import Sandbox
+
+sandbox = Sandbox(template="base")
+
+# Timeout 3s for the process to start
+npm_init = sandbox.process.start("npm init -y", timeout=3)
+npm_init.wait()
+
+sandbox.close()
+```
+
+
+## Timeout filesystem operations
+
+```js JavaScript & TypeScript highlight={6,9,13}
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create({ template: 'base' })
+
+// Timeout 3s for the write operation
+await sandbox.filesystem.write('hello.txt', 'Hello World!', {timeout: 3000})
+
+// Timeout 3s for the list operation
+const files = await sandbox.filesystem.list('.', {timeout: 3000})
+console.log(files)
+
+// Timeout 3s for the read operation
+const content = await sandbox.filesystem.read('hello.txt', {timeout: 3000})
+console.log(content)
+
+await sandbox.close()
+```
+```python Python highlight={6,9,13}
+from e2b import Sandbox
+
+sandbox = Sandbox(template="base")
+
+# Timeout 3s for the write operation
+sandbox.filesystem.write("test.txt", "Hello World", timeout=3)
+
+# Timeout 3s for the list operation
+dir_content = sandbox.filesystem.list(".", timeout=3)
+print(dir_content)
+
+# Timeout 3s for the read operation
+file_content = sandbox.filesystem.read("test.txt", timeout=3)
+print(file_content)
+
+sandbox.close()
+```
+
\ No newline at end of file
diff --git a/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/api/upload/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/api/upload/index.mdx
new file mode 100644
index 0000000000..517417c175
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/api/upload/index.mdx
@@ -0,0 +1,56 @@
+---
+title: "Upload files to sandbox"
+---
+
+You are reading a legacy (pre v1.0) document.
+
+
+You can upload any file to the sandbox. This is useful if you want to let the LLM work with your files or files of your users. The file will be uploaded to the user's home directory with the same name. If a file with the same name already exists, it will be overwritten.
+
+## Use case for uploading files
+A popular workflow is for example to upload a CSV data file and then let the LLM generate and execute Python code that operates with the uploaded CSV file inside the sandbox. This way, you can essentially create your own AI data analyst or code interpreter.
+
+
+We support uploading files up to 100MB at the moment. If you need to upload larger files, please [reach out to us](/legacy/getting-help).
+
+
+
+```js JavaScript & TypeScript highlight={7-9}
+import { Sandbox } from 'e2b'
+import fs from 'node:fs'
+
+const sandbox = await Sandbox.create({ template: 'base' })
+
+// If you're in the server environment
+const filename = 'data.csv'
+const fileBuffer = fs.readFileSync('path/to/local/file')
+const remotePath = await sandbox.uploadFile(fileBuffer, filename)
+
+// If you're in the browser environment, you can use the Blob API
+// const filename = 'data.csv'
+// const CSV = [
+// '"1","val1","val2","val3","val4"',
+// '"2","val1","val2","val3","val4"',
+// '"3","val1","val2","val3","val4"'
+// ].join('\n');
+// const fileBlob = new Blob([csv], { type: 'text/csv' })
+// const remotePath = await sandbox.uploadFile(fileBlob, 'data.csv')
+
+console.log(
+ `The file was uploaded to '${remotePath}' path inside the sandbox `,
+)
+
+await sandbox.close()
+```
+```python Python highlight={6}
+from e2b import Sandbox
+
+sandbox = Sandbox(template="base")
+
+with open("path/to/local/file", "rb") as f:
+ remote_path = sandbox.upload_file(f)
+
+sandbox.close()
+```
+
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/api/url/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/api/url/index.mdx
new file mode 100644
index 0000000000..423d3005b1
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/api/url/index.mdx
@@ -0,0 +1,60 @@
+---
+title: "Sandbox URL"
+---
+
+You are reading a legacy (pre v1.0) document.
+
+
+Each sandbox has its own URL that you can use to connect to any service running inside the sandbox.
+
+For example, you can start a server inside the sandbox and connect to it from your browser.
+
+
+```js JavaScript & TypeScript highlight={5}
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create({ template: 'base' })
+
+const url = sandbox.getHostname()
+console.log('https://' + url)
+
+await sandbox.close()
+```
+```python Python highlight={5}
+from e2b import Sandbox
+
+sandbox = Sandbox(template="base")
+
+url = sandbox.get_host()
+print("https://" + url)
+
+sandbox.close()
+```
+
+
+
+If you want to get an URL for a specific port inside the sandbox, pass the port number to the `getHostname()`/`get_hostname()` method.
+
+```js JavaScript & TypeScript highlight={6}
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create({ template: 'base' })
+
+const openPort = 3000
+const url = sandbox.getHostname(openPort)
+console.log('https://' + url)
+
+await sandbox.close()
+```
+```python Python highlight={6}
+from e2b import Sandbox
+
+sandbox = Sandbox(template="base")
+
+open_port = 3000
+url = sandbox.get_host(open_port)
+print("https://" + url)
+
+sandbox.close()
+```
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/compute/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/compute/index.mdx
new file mode 100644
index 0000000000..eec0fb8652
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/compute/index.mdx
@@ -0,0 +1,31 @@
+---
+title: "Sandbox compute"
+---
+
+You are reading a legacy (pre v1.0) document.
+
+
+import SandboxSpec from "/snippets/SandboxSpec.mdx";
+
+# Sandbox compute
+Pro customers can customize the sandbox with **any combination** of the CPU and RAM based on the following tables.
+
+Read a dedicated page to [learn more about pricing](/legacy/pricing).
+
+
+**By default your sandbox has 2 vCPU and 512 MiB RAM.**
+
+To customize your sandbox compute, you need to build your custom sandbox template using the [E2B CLI](/legacy/cli/installation).
+Run [`e2b template build`](/legacy/cli/commands#template-build) and specify the `--cpu-count` and `--memory-mb` options.
+
+For example, this custom build command gives your sandbox 8 vCPU and 4GiB of RAM
+```sh
+e2b template build --cpu-count 8 --memory-mb 4096
+```
+
+
+
+ +[Let us know](/legacy/getting-help) if you need more powerful compute. \ No newline at end of file diff --git a/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/custom/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/custom/index.mdx new file mode 100644 index 0000000000..c728220f97 --- /dev/null +++ b/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/custom/index.mdx @@ -0,0 +1,55 @@ +--- +title: "Customizing Sandbox" +--- + +You are reading a legacy (pre v1.0) document.
+
+
+Custom sandboxes allows you to spawn a sandbox with a pre-defined environment by you and then control it with our SDK.
+
+You can build a custom sandbox by creating the [Sandbox Template](/legacy/sandbox/templates/overview). Sandbox template is a Dockerfile that describes the environment of your sandbox.
+
+Once you build your custom sandbox template, you can spawn multiple isolated sandboxes from it.
+
+## How it works
+1. [Provide the sandbox template file](/legacy/sandbox/templates/template-file)
+1. [Build a sandbox template from it using our CLI](/legacy/guide/custom-sandbox#4-build-custom-sandbox)
+1. Get a template ID from the CLI:
+ ```sh
+ # ... truncated CLI output
+ ✅ Building sandbox template 3y5bvra6kgq0kaumgztu finished.
+ ```
+1. Pass the template ID to our SDK like this:
+
+ ```js JavaScript & TypeScript
+ import { Sandbox } from 'e2b'
+
+ // Create new sandbox
+ const sandbox = await Sandbox.create({
+ template: '', // You get sandbox template ID from the CLI after you run `$ e2b template build`
+ })
+
+ // Close sandbox once done
+ await sandbox.close()
+ ```
+
+ ```python Python
+ from e2b import Sandbox
+
+ # Create new sandbox
+ sandbox = Sandbox.create(
+ template="", # You get sandbox template from the CLI after you run `$ e2b template build`
+ )
+
+ # Close sandbox once done
+ sandbox.close()
+ ```
+
+1. Run the code and we spawn a sandbox based on the template you built in step 2
+
+Now you can do step 4/5 multiple times using the same ID, always creating a separate sandbox instance.
+
+
+
+Read more on [Sandbox Templates](/legacy/sandbox/templates/overview) if you want to create your own custom sandbox.
+
\ No newline at end of file
diff --git a/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/overview/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/overview/index.mdx
new file mode 100644
index 0000000000..3521393bd3
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/overview/index.mdx
@@ -0,0 +1,81 @@
+---
+title: "Overview"
+---
+
+You are reading a legacy (pre v1.0) document.
+
+
+**The E2B's sandboxes are isolated cloud environments made specifcially for AI code interpreting or code execution.**
+
+The E2B sandboxes are an ideal fit as a playground for AI assistants like coding copilots, code interpreters, AI data analysts, AI browser assistants, and other AI-powered apps.
+
+## Features
+
+
+
+
+E2B Sandboxes are made exactly to solve these challenges. The sandbox is like an isolated runtime or playground for the LLM. **We give you our SDK to spawn and control these sandboxes.**
+
+
+## How sandboxes work under the hood
+When you create a new sandbox session, we start a small VM in our cloud. This VM is running a Ubuntu OS and it takes about 400-600ms to start it.
+
+Inside this sandbox, your AI app can [run code and start any programs](/legacy/sandbox/api/process), access the internet to download or upload data, use the [filesystem](/legacy/sandbox/api/filesystem), start long running processes such as web servers, and more.
+You can also [upload](/legacy/sandbox/api/upload) to sandbox and [download](/legacy/sandbox/api/upload) from sandbox any file you want.
+
+To start and control the sandbox, use the [E2B SDK](/legacy/getting-started/installation) for Python or JavaScript.
+
+
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create()
+
+await sandbox.close()
+```
+```python Python
+from e2b import Sandbox
+
+sandbox = Sandbox.create()
+sandbox.close()
+```
+
+
+
+Make sure you have the `E2B_API_KEY` environment variable set with your [API key](/legacy/getting-started/api-key).
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/templates/overview/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/templates/overview/index.mdx
new file mode 100644
index 0000000000..d850f027ba
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/templates/overview/index.mdx
@@ -0,0 +1,68 @@
+---
+title: "Custom Sandbox"
+---
+
+You are reading a legacy (pre v1.0) document.
+
+
+Custom sandboxes allow you to spawn a sandbox with an environment predefined by you and then control it with our SDK.
+
+
+The E2B Sandbox is a secure way to run your AI app. It is a long-running cloud environment where you can let any LLM (GPTs, Claude, local LLMs, etc) use tools exactly like you would do locally.
+
+Read more about E2B Sandboxes [here](/legacy/sandbox/overview).
+
+
+
+## How Custom Sandboxes Work
+
+
+Follow our [guide](/legacy/guide/custom-sandbox) on how to create a custom sandbox.
+
+
+1. You build a custom sandbox by creating the [Sandbox Template](/legacy/sandbox/templates/template-file) which is a Dockerfile describing the environment of your sandbox.
+1. Build a sandbox template from it using our CLI
+1. Get a template ID from the CLI:
+ ```sh
+ # ... truncated CLI output
+ ✅ Building sandbox template 3y5bvra6kgq0kaumgztu finished.
+ ```
+1. Pass the template ID to our SDK like this:
+
+ ```js JavaScript & TypeScript highlight={6}
+ import { Sandbox } from 'e2b'
+
+ // Create new sandbox
+ const sandbox = await Sandbox.create({
+ // You get sandbox template from the CLI after you run `$ e2b template build`
+ template: '',
+ })
+
+ // Close sandbox once done
+ await sandbox.close()
+ ```
+
+ ```python Python highlight={6}
+ from e2b import Sandbox
+
+ # Create new sandbox
+ sandbox = Sandbox.create(
+ # You get sandbox template from the CLI after you run `$ e2b template build`
+ template="",
+ )
+
+ # Close sandbox once done
+ sandbox.close()
+ ```
+
+1. Run the code and we spawn a sandbox based on the template you built in step 2
+
+Once you build your custom sandbox template, you can spawn multiple isolated sandboxes from it. You can repeat the steps 4, 5 multiple times using the same ID, always creating a separate sandbox instance.
+
+
+ 
+
+
+
+Follow [our guide](/legacy/guide/custom-sandbox) on how to create a custom sandbox.
+
\ No newline at end of file
diff --git a/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/templates/template-file/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/templates/template-file/index.mdx
new file mode 100644
index 0000000000..c7e9555815
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/templates/template-file/index.mdx
@@ -0,0 +1,49 @@
+---
+title: "Template File"
+---
+
+You are reading a legacy (pre v1.0) document.
+
+
+The template file is a Dockerfile named `e2b.Dockerfile`. The template file is used to define an environment for your custom sandbox.
+
+
+Follow our [guide](/legacy/guide/custom-sandbox) on how to create a custom sandbox.
+
+
+
+
+
+
+## `e2b.Dockerfile`
+The Dockerfile must be Debian based (e.g. Ubuntu). Only the following [Dockerfile commands](https://docs.docker.com/engine/reference/builder/) are supported:
+ - `FROM`
+ - `ADD`
+ - `COPY`
+ - `RUN`
+ - `WORKDIR`
+ - `ARG`
+
+## Example
+
+The following example template file defines a Ubuntu-based sandbox with installed GitHub CLI.
+
+
+
+```sh
+# You can use most of the Debian-based base images
+FROM ubuntu:22.04
+
+# Install dependencies and customize sandbox
+RUN apt update \
+ && apt install sudo
+
+# Install GitHub CLI
+RUN type -p curl >/dev/null || (sudo apt update && sudo apt install curl -y)
+RUN curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg | sudo dd of=/usr/share/keyrings/githubcli-archive-keyring.gpg \
+ && sudo chmod go+r /usr/share/keyrings/githubcli-archive-keyring.gpg \
+ && echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | sudo tee /etc/apt/sources.list.d/github-cli.list > /dev/null \
+ && sudo apt update \
+ && sudo apt install gh -y
+```
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/legacy/supported/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/legacy/supported/index.mdx
new file mode 100644
index 0000000000..645360a999
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/legacy/supported/index.mdx
@@ -0,0 +1,15 @@
+---
+title: "Supported LLMs and AI frameworks"
+---
+
+You are reading a legacy (pre v1.0) document.
+
+
+E2B is LLM agnostic - it supports any LLM models and any AI frameworks.
+
+Usually, all you need from the model is just support for tool use. You then use the E2B code interpreter as a tool.
+If the LLM doesn't support tool use, you can ask the LLM to respond with Markdown or XML and parse the LLM's output on your own. Then just pass the parsed code from code blocks to the code interpreter.
+
+
+Check out our [cookbook](https://github.com/e2b-dev/e2b-cookbook) for examples.
+
\ No newline at end of file
diff --git a/apps/web/src/app/(docs)/mintlify-docs/logo/logo_dark.svg b/apps/web/src/app/(docs)/mintlify-docs/logo/logo_dark.svg
new file mode 100644
index 0000000000..51c7a9247e
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/logo/logo_dark.svg
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/apps/web/src/app/(docs)/mintlify-docs/logo/logo_light.svg b/apps/web/src/app/(docs)/mintlify-docs/logo/logo_light.svg
new file mode 100644
index 0000000000..bde45a2f40
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/logo/logo_light.svg
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/apps/web/src/app/(docs)/mintlify-docs/logo/white.svg b/apps/web/src/app/(docs)/mintlify-docs/logo/white.svg
new file mode 100644
index 0000000000..b8fb4e8928
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/logo/white.svg
@@ -0,0 +1,7 @@
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/migration/v2/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/migration/v2/index.mdx
new file mode 100644
index 0000000000..b478426e2e
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/migration/v2/index.mdx
@@ -0,0 +1,146 @@
+---
+title: "SDK v2 Migration Guide"
+---
+
+This guide helps you migrate from E2B SDK v1 to v2, covering all breaking changes and new patterns.
+
+## Table of contents
+
+SDK v2 introduces several important changes:
+- [**New creation pattern in Python Synchronous SDK**](#1-sandbox-creation-in-synchronous-python-sdk)
+- [**Secure by default**](#2-secure-communication-by-default)
+- [**Updated file operations in Python SDK**](#3-file-writing-in-python-sdk)
+- [**Updated list method**](#4-listing-sandboxes)
+
+## Breaking changes
+
+### 1. Sandbox creation in synchronous Python SDK
+
+In v2, the synchronous Python SDK uses a class method `create()` instead of the constructor `Sandbox()`.
+
+
+```python Python
+from e2b_code_interpreter import Sandbox
+
+sandbox = Sandbox.create()
+sandbox = Sandbox.create(template="base")
+```
+
+
+In the v1, you would instantiate directly:
+
+
+```python Python
+from e2b_code_interpreter import Sandbox
+
+sandbox = Sandbox()
+sandbox = Sandbox(template="base")
+```
+
+
+### 2. Secure communication by default
+
+Sandboxes are now **secure by default**. That means you cannot access the sandbox directly via its URL; there's authentication required. If you use the SDK, this is handled for you automatically.
+
+This shouldn't affect you, but if you need to access sandbox directly without SDK and you are now getting 401, you may need to set `secure` to `false`.
+
+
+ If you are using custom code interpreter templates, it may be necessary to rebuild the template to ensure compatibility with secure sandboxes.
+
+
+
+```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
+```
+
+
+### 3. File writing in Python SDK
+
+The file writing API in Python has been made more consistent.
+
+In v2, use `sandbox.files.write()` for single files and `sandbox.files.write_files()` for multiple files:
+
+```python v2
+from e2b_code_interpreter import Sandbox
+
+sandbox = Sandbox.create()
+
+# Write single file
+info = sandbox.files.write("/tmp/file.txt", "content")
+
+# Write multiple files
+infos = sandbox.files.write_files([
+ {"path": "/tmp/file1.txt", "data": "content1"},
+ {"path": "/tmp/file2.txt", "data": "content2"}
+])
+```
+
+
+In v1, the same `write()` method was overloaded for both single and multiple files:
+
+
+```python v1
+from e2b_code_interpreter import Sandbox
+
+sandbox = Sandbox.create()
+
+# Write single file
+info = sandbox.write(path="/tmp/file.txt", data="content")
+
+# Write multiple files
+infos = sandbox.write([
+ {"path": "/tmp/file1.txt", "data": "content1"},
+ {"path": "/tmp/file2.txt", "data": "content2"}
+])
+```
+
+
+### 4. Listing sandboxes
+
+The method for listing sandboxes has been updated to use pagination.
+
+
+```js JavaScript & TypeScript
+import { Sandbox, SandboxInfo } from '@e2b/code-interpreter'
+
+// Get paginator
+const paginator = Sandbox.list()
+
+// Iterate through all sandboxes
+for (const sandbox of await paginator.nextItems()) {
+ console.log(sandbox.sandboxId)
+}
+
+// Iterate through all sandboxes
+const allSandboxes: SandboxInfo[] = []
+while (paginator.hasNext) {
+ const items = await paginator.nextItems()
+ allSandboxes.push(...items)
+}
+
+// With query
+const queryPaginator = Sandbox.list({query: {metadata: {key: "value"}}})
+```
+```python Python
+from e2b_code_interpreter import Sandbox, SandboxQuery
+
+# Get paginator
+paginator = Sandbox.list()
+
+# Iterate through all sandboxes
+while paginator.has_next:
+ sandboxes = paginator.next_items()
+ print(sandboxes)
+
+# With query
+paginator = Sandbox.list(query=SandboxQuery(metadata={"key": "value"}))
+```
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/quickstart/connect-llms/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/quickstart/connect-llms/index.mdx
new file mode 100644
index 0000000000..adfbc664d1
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/quickstart/connect-llms/index.mdx
@@ -0,0 +1,807 @@
+---
+title: "Connect LLMs to E2B"
+---
+
+E2B can work with any LLM and AI framework. The easiest way to connect an LLM to E2B is to use the tool use capabilities of the LLM (sometimes known as function calling).
+
+If the LLM doesn't support tool use, you can, for example, prompt the LLM to output code snippets and then manually extract the code snippets with [RegEx](https://en.wikipedia.org/wiki/Regular_expression).
+
+## Contents
+- [OpenAI](#openai)
+- [Anthropic](#anthropic)
+- [Mistral](#mistral)
+- [Groq](#groq)
+- [Vercel AI SDK](#vercel-ai-sdk)
+- [CrewAI](#crewai)
+- [LangChain](#langchain)
+- [LlamaIndex](#llamaindex)
+- [Ollama](#ollama)
+- [Hugging Face](#hugging-face)
+
+---
+
+## OpenAI
+
+### Simple
+
+
+```python Python
+# pip install openai e2b-code-interpreter
+from openai import OpenAI
+from e2b_code_interpreter import Sandbox
+
+# Create OpenAI client
+client = OpenAI()
+system = "You are a helpful assistant that can execute python code in a Jupyter notebook. Only respond with the code to be executed and nothing else. Strip backticks in code blocks."
+prompt = "Calculate how many r's are in the word 'strawberry'"
+
+# Send messages to OpenAI API
+response = client.chat.completions.create(
+ model="gpt-4o",
+ messages=[
+ {"role": "system", "content": system},
+ {"role": "user", "content": prompt}
+ ]
+)
+
+# Extract the code from the response
+code = response.choices[0].message.content
+
+# Execute code in E2B Sandbox
+if code:
+ with Sandbox.create() as sandbox:
+ execution = sandbox.run_code(code)
+ result = execution.text
+
+ print(result)
+```
+
+
+### Function calling
+
+
+```python Python
+# pip install openai e2b-code-interpreter
+import json
+from openai import OpenAI
+from e2b_code_interpreter import Sandbox
+
+# Create OpenAI client
+client = OpenAI()
+model = "gpt-4o"
+
+# Define the messages
+messages = [
+ {
+ "role": "user",
+ "content": "Calculate how many r's are in the word 'strawberry'"
+ }
+]
+
+# Define the tools
+tools = [{
+ "type": "function",
+ "function": {
+ "name": "execute_python",
+ "description": "Execute python code in a Jupyter notebook cell and return result",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "code": {
+ "type": "string",
+ "description": "The python code to execute in a single cell"
+ }
+ },
+ "required": ["code"]
+ }
+ }
+}]
+
+# Generate text with OpenAI
+response = client.chat.completions.create(
+ model=model,
+ messages=messages,
+ tools=tools,
+)
+
+# Append the response message to the messages list
+response_message = response.choices[0].message
+messages.append(response_message)
+
+# Execute the tool if it's called by the model
+if response_message.tool_calls:
+ for tool_call in response_message.tool_calls:
+ if tool_call.function.name == "execute_python":
+ # Create a sandbox and execute the code
+ with Sandbox.create() as sandbox:
+ code = json.loads(tool_call.function.arguments)['code']
+ execution = sandbox.run_code(code)
+ result = execution.text
+
+ # Send the result back to the model
+ messages.append({
+ "role": "tool",
+ "name": "execute_python",
+ "content": result,
+ "tool_call_id": tool_call.id,
+ })
+
+# Generate the final response
+final_response = client.chat.completions.create(
+ model=model,
+ messages=messages
+)
+
+print(final_response.choices[0].message.content)
+```
+
+
+---
+
+## Anthropic
+
+### Simple
+
+
+```python Python
+# pip install anthropic e2b-code-interpreter
+from anthropic import Anthropic
+from e2b_code_interpreter import Sandbox
+
+# Create Anthropic client
+anthropic = Anthropic()
+system_prompt = "You are a helpful assistant that can execute python code in a Jupyter notebook. Only respond with the code to be executed and nothing else. Strip backticks in code blocks."
+prompt = "Calculate how many r's are in the word 'strawberry'"
+
+# Send messages to Anthropic API
+response = anthropic.messages.create(
+ model="claude-3-5-sonnet-20240620",
+ max_tokens=1024,
+ messages=[
+ {"role": "assistant", "content": system_prompt},
+ {"role": "user", "content": prompt}
+ ]
+)
+
+# Extract code from response
+code = response.content[0].text
+
+# Execute code in E2B Sandbox
+with Sandbox.create() as sandbox:
+ execution = sandbox.run_code(code)
+ result = execution.logs.stdout
+
+print(result)
+```
+
+
+### Function calling
+
+
+```python Python
+# pip install anthropic e2b-code-interpreter
+from anthropic import Anthropic
+from e2b_code_interpreter import Sandbox
+
+# Create Anthropic client
+client = Anthropic()
+model = "claude-3-5-sonnet-20240620"
+
+# Define the messages
+messages = [
+ {
+ "role": "user",
+ "content": "Calculate how many r's are in the word 'strawberry'"
+ }
+]
+
+# Define the tools
+tools = [{
+ "name": "execute_python",
+ "description": "Execute python code in a Jupyter notebook cell and return (not print) the result",
+ "input_schema": {
+ "type": "object",
+ "properties": {
+ "code": {
+ "type": "string",
+ "description": "The python code to execute in a single cell"
+ }
+ },
+ "required": ["code"]
+ }
+}]
+
+# Generate text with Anthropic
+message = client.messages.create(
+ model=model,
+ max_tokens=1024,
+ messages=messages,
+ tools=tools
+)
+
+# Append the response message to the messages list
+messages.append({
+ "role": "assistant",
+ "content": message.content
+})
+
+# Execute the tool if it's called by the model
+if message.stop_reason == "tool_use":
+ tool_use = next(block for block in message.content if block.type == "tool_use")
+ tool_name = tool_use.name
+ tool_input = tool_use.input
+
+ if tool_name == "execute_python":
+ with Sandbox.create() as sandbox:
+ code = tool_input['code']
+ execution = sandbox.run_code(code)
+ result = execution.text
+
+ # Append the tool result to the messages list
+ messages.append({
+ "role": "user",
+ "content": [
+ {
+ "type": "tool_result",
+ "tool_use_id": tool_use.id,
+ "content": result,
+ }
+ ],
+ })
+
+# Generate the final response
+final_response = client.messages.create(
+ model=model,
+ max_tokens=1024,
+ messages=messages,
+ tools=tools
+)
+
+print(final_response.content[0].text)
+```
+
+
+---
+
+## Mistral
+
+### Simple
+
+
+```python Python
+# pip install mistralai e2b-code-interpreter
+import os
+from mistralai import Mistral
+from e2b_code_interpreter import Sandbox
+
+# Create Mistral client
+client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
+system_prompt = "You are a helpful assistant that can execute python code in a Jupyter notebook. Only respond with the code to be executed and nothing else. Strip backticks in code blocks."
+prompt = "Calculate how many r's are in the word 'strawberry'"
+
+# Send the prompt to the model
+response = client.chat.complete(
+ model="codestral-latest",
+ messages=[
+ {"role": "system", "content": system_prompt},
+ {"role": "user", "content": prompt}
+ ]
+)
+
+# Extract the code from the response
+code = response.choices[0].message.content
+
+# Execute code in E2B Sandbox
+with Sandbox.create() as sandbox:
+ execution = sandbox.run_code(code)
+ result = execution.text
+
+print(result)
+```
+
+
+### Function calling
+
+
+```python Python
+# pip install mistralai e2b-code-interpreter
+import os
+import json
+from mistralai import Mistral
+from e2b_code_interpreter import Sandbox
+
+# Create Mistral client
+client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
+model = "mistral-large-latest"
+messages = [
+ {
+ "role": "user",
+ "content": "Calculate how many r's are in the word 'strawberry'"
+ }
+]
+
+# Define the tools
+tools = [{
+ "type": "function",
+ "function": {
+ "name": "execute_python",
+ "description": "Execute python code in a Jupyter notebook cell and return result",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "code": {
+ "type": "string",
+ "description": "The python code to execute in a single cell"
+ }
+ },
+ "required": ["code"]
+ }
+ }
+}]
+
+# Send the prompt to the model
+response = client.chat.complete(
+ model=model,
+ messages=messages,
+ tools=tools
+)
+
+# Append the response message to the messages list
+response_message = response.choices[0].message
+messages.append(response_message)
+
+# Execute the tool if it's called by the model
+if response_message.tool_calls:
+ for tool_call in response_message.tool_calls:
+ if tool_call.function.name == "execute_python":
+ # Create a sandbox and execute the code
+ with Sandbox.create() as sandbox:
+ code = json.loads(tool_call.function.arguments)['code']
+ execution = sandbox.run_code(code)
+ result = execution.text
+
+ # Send the result back to the model
+ messages.append({
+ "role": "tool",
+ "name": "execute_python",
+ "content": result,
+ "tool_call_id": tool_call.id,
+ })
+
+# Generate the final response
+final_response = client.chat.complete(
+ model=model,
+ messages=messages,
+)
+
+print(final_response.choices[0].message.content)
+```
+
+
+---
+
+## Groq
+
+```python Python
+
+# pip install groq e2b-code-interpreter
+import os
+from groq import Groq
+from e2b_code_interpreter import Sandbox
+
+api_key = os.environ["GROQ_API_KEY"]
+
+# Create Groq client
+client = Groq(api_key=api_key)
+system_prompt = "You are a helpful assistant that can execute python code in a Jupyter notebook. Only respond with the code to be executed and nothing else. Strip backticks in code blocks."
+prompt = "Calculate how many r's are in the word 'strawberry.'"
+
+# Send the prompt to the model
+response = client.chat.completions.create(
+ model="llama3-70b-8192",
+ messages=[
+ {"role": "system", "content": system_prompt},
+ {"role": "user", "content": prompt},
+ ]
+)
+
+# Extract the code from the response
+code = response.choices[0].message.content
+
+# Execute code in E2B Sandbox
+with Sandbox.create() as sandbox:
+ execution = sandbox.run_code(code)
+ result = execution.text
+
+print(result)
+
+```
+
+
+---
+
+## Vercel AI SDK
+Vercel's [AI SDK](https://sdk.vercel.ai) offers support for multiple different LLM providers through a unified JavaScript interface that's easy to use.
+
+### Simple
+
+
+```js JavaScript & TypeScript
+// npm install ai @ai-sdk/openai @e2b/code-interpreter
+import { openai } from '@ai-sdk/openai'
+import { generateText } from 'ai'
+import { Sandbox } from '@e2b/code-interpreter'
+
+// Create OpenAI client
+const model = openai('gpt-4o')
+const system = "You are a helpful assistant that can execute python code in a Jupyter notebook. Only respond with the code to be executed and nothing else. Strip backticks in code blocks."
+const prompt = "Calculate how many r's are in the word 'strawberry'"
+
+// Generate code with OpenAI
+const { text: code } = await generateText({
+ model,
+ system,
+ prompt
+})
+
+// Run the code in E2B Sandbox
+const sandbox = await Sandbox.create()
+const { text, results, logs, error } = await sandbox.runCode(code)
+
+console.log(text)
+```
+
+
+### Function calling
+
+
+```js JavaScript & TypeScript
+// npm install ai @ai-sdk/openai zod @e2b/code-interpreter
+import { openai } from '@ai-sdk/openai'
+import { generateText } from 'ai'
+import z from 'zod'
+import { Sandbox } from '@e2b/code-interpreter'
+
+// Create OpenAI client
+const model = openai('gpt-4o')
+
+const prompt = "Calculate how many r's are in the word 'strawberry'"
+
+// Generate text with OpenAI
+const { text } = await generateText({
+ model,
+ prompt,
+ tools: {
+ // Define a tool that runs code in a sandbox
+ execute_python: {
+ description: 'Execute python code in a Jupyter notebook cell and return result',
+ parameters: z.object({
+ code: z.string().describe('The python code to execute in a single cell'),
+ }),
+ execute: async ({ code }) => {
+ // Create a sandbox, execute LLM-generated code, and return the result
+ const sandbox = await Sandbox.create()
+ const { text, results, logs, error } = await sandbox.runCode(code)
+ return results
+ },
+ },
+ },
+ // This is required to feed the tool call result back to the LLM
+ maxSteps: 2
+})
+
+console.log(text)
+```
+
+
+---
+
+## CrewAI
+[CrewAI](https://crewai.com/) is a platform for building AI agents.
+
+
+```python Python
+# pip install crewai e2b-code-interpreter
+from crewai.tools import tool
+from crewai import Agent, Task, Crew, LLM
+from e2b_code_interpreter import Sandbox
+
+# Update tool definition using the decorator
+@tool("Python Interpreter")
+def execute_python(code: str) -> str:
+ """
+ Execute Python code and return the results.
+ """
+ with Sandbox.create() as sandbox:
+ execution = sandbox.run_code(code)
+ return execution.text
+
+# Define the agent
+python_executor = Agent(
+ role='Python Executor',
+ goal='Execute Python code and return the results',
+ backstory='You are an expert Python programmer capable of executing code and returning results.',
+ tools=[execute_python],
+ llm=LLM(model="gpt-4o")
+)
+
+# Define the task
+execute_task = Task(
+ description="Calculate how many r's are in the word 'strawberry'",
+ agent=python_executor,
+ expected_output="The number of r's in the word 'strawberry'"
+)
+
+# Create the crew
+code_execution_crew = Crew(
+ agents=[python_executor],
+ tasks=[execute_task],
+ verbose=True,
+)
+
+# Run the crew
+result = code_execution_crew.kickoff()
+print(result)
+```
+
+
+---
+
+## LangChain
+[LangChain](https://langchain.com/) offers support multiple different LLM providers.
+
+### Simple
+
+
+```python Python
+# pip install langchain langchain-openai e2b-code-interpreter
+from langchain_openai import ChatOpenAI
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.output_parsers import StrOutputParser
+from e2b_code_interpreter import Sandbox
+
+system_prompt = "You are a helpful assistant that can execute python code in a Jupyter notebook. Only respond with the code to be executed and nothing else. Strip backticks in code blocks."
+prompt = "Calculate how many r's are in the word 'strawberry'"
+
+# Create LangChain components
+llm = ChatOpenAI(model="gpt-4o")
+prompt_template = ChatPromptTemplate.from_messages([
+ ("system", system_prompt),
+ ("human", "{input}")
+])
+
+output_parser = StrOutputParser()
+
+# Create the chain
+chain = prompt_template | llm | output_parser
+
+# Run the chain
+code = chain.invoke({"input": prompt})
+
+# Execute code in E2B Sandbox
+with Sandbox.create() as sandbox:
+ execution = sandbox.run_code(code)
+ result = execution.text
+
+print(result)
+```
+
+
+### Agent
+
+
+```python Python
+# pip install langchain langchain-openai e2b-code-interpreter
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.tools import tool
+from langchain.agents import create_tool_calling_agent, AgentExecutor
+from langchain_openai import ChatOpenAI
+from e2b_code_interpreter import Sandbox
+
+system_prompt = "You are a helpful assistant that can execute python code in a Jupyter notebook. Only respond with the code to be executed and nothing else. Strip backticks in code blocks."
+prompt = "Calculate how many r's are in the word 'strawberry'"
+
+# Define the tool
+@tool
+def execute_python(code: str):
+ """
+ Execute python code in a Jupyter notebook.
+ """
+ with Sandbox.create() as sandbox:
+ execution = sandbox.run_code(code)
+ return execution.text
+
+# Define LangChain components
+prompt_template = ChatPromptTemplate.from_messages([
+ ("system", system_prompt),
+ ("human", "{input}"),
+ ("placeholder", "{agent_scratchpad}"),
+])
+
+tools = [execute_python]
+llm = ChatOpenAI(model="gpt-4o", temperature=0)
+
+agent = create_tool_calling_agent(llm, tools, prompt_template)
+agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
+
+# Run the agent
+agent_executor.invoke({"input": prompt})
+```
+
+
+### Function calling
+
+
+```python Python
+# pip install langchain langchain-openai e2b-code-interpreter
+from langchain_openai import ChatOpenAI
+from langchain.tools import Tool
+from langchain.schema import HumanMessage, AIMessage, FunctionMessage
+from e2b_code_interpreter import Sandbox
+
+def execute_python(code: str):
+ with Sandbox.create() as sandbox:
+ execution = sandbox.run_code(code)
+ return execution.text
+
+# Define a tool that uses the E2B Sandbox
+e2b_sandbox_tool = Tool(
+ name="execute_python",
+ func=execute_python,
+ description="Execute python code in a Jupyter notebook cell and return result"
+)
+
+# Initialize the language model and bind the tool
+llm = ChatOpenAI(model="gpt-4o").bind_tools([e2b_sandbox_tool])
+
+# Define the messages
+messages = [
+ HumanMessage(content="Calculate how many 'r's are in the word 'strawberry'.")
+]
+
+# Run the model with a prompt
+result = llm.invoke(messages)
+messages.append(AIMessage(content=result.content))
+
+# Check if the model called the tool
+if result.additional_kwargs.get('tool_calls'):
+ tool_call = result.additional_kwargs['tool_calls'][0]
+ if tool_call['function']['name'] == "execute_python":
+ code = tool_call['function']['arguments']
+ execution_result = execute_python(code)
+
+ # Send the result back to the model
+ messages.append(
+ FunctionMessage(name="execute_python", content=execution_result)
+ )
+
+final_result = llm.invoke(messages)
+print(final_result.content)
+```
+
+
+---
+
+## LlamaIndex
+[LlamaIndex](https://www.llamaindex.ai/) offers support multiple different LLM providers.
+
+```python Python
+# pip install llama-index e2b-code-interpreter
+from llama_index.core.tools import FunctionTool
+from llama_index.llms.openai import OpenAI
+from llama_index.core.agent import ReActAgent
+from e2b_code_interpreter import Sandbox
+
+# Define the tool
+def execute_python(code: str):
+ with Sandbox.create() as sandbox:
+ execution = sandbox.run_code(code)
+ return execution.text
+
+e2b_sandbox_tool = FunctionTool.from_defaults(
+ name="execute_python",
+ description="Execute python code in a Jupyter notebook cell and return result",
+ fn=execute_python
+)
+
+# Initialize LLM
+llm = OpenAI(model="gpt-4o")
+
+# Initialize ReAct agent
+agent = ReActAgent.from_tools([e2b_sandbox_tool], llm=llm, verbose=True)
+agent.chat("Calculate how many r's are in the word 'strawberry'")
+```
+
+
+## Ollama
+
+
+```python Python
+# pip install ollama
+import ollama
+from e2b_code_interpreter import Sandbox
+
+# Send the prompt to the model
+response = ollama.chat(
+ model="llama3.2",
+ messages=[{
+ "role": "system",
+ "content": "You are a helpful assistant that can execute python code in a Jupyter notebook. Only respond with the code to be executed and nothing else. Strip backticks in code blocks."
+ },
+ {
+ "role": "user",
+ "content": "Calculate how many r's are in the word 'strawberry'"
+ }
+])
+
+# Extract the code from the response
+code = response['message']['content']
+
+# Execute code in E2B Sandbox
+with Sandbox.create() as sandbox:
+ execution = sandbox.run_code(code)
+ result = execution.logs.stdout
+
+print(result)
+```
+
+
+---
+
+## Hugging Face
+
+Hugging Face offers support for serverless inference for models on their model hub with [Hugging Face's Inference API](https://huggingface.co/docs/inference-providers/en/index).
+
+
+Note that not every model on Hugging Face has native support for tool use and function calling.
+
+
+
+```python Python
+from huggingface_hub import InferenceClient
+from e2b_code_interpreter import Sandbox
+import re
+
+# Not all models are capable of direct tools use - we need to extract the code block manually and prompting the LLM to generate the code.
+def match_code_block(llm_response):
+ pattern = re.compile(r'```python Python\n(.*?)\n```', re.DOTALL) # Match everything in between ```python and ```
+ match = pattern.search(llm_response)
+ if match:
+ code = match.group(1)
+ print(code)
+ return code
+ return ""
+
+
+system_prompt = """You are a helpful coding assistant that can execute python code in a Jupyter notebook. You are given tasks to complete and you run Python code to solve them.
+Generally, you follow these rules:
+- ALWAYS FORMAT YOUR RESPONSE IN MARKDOWN
+- ALWAYS RESPOND ONLY WITH CODE IN CODE BLOCK LIKE THIS:
+\`\`\`python
+{code}
+\`\`\`
+"""
+prompt = "Calculate how many r's are in the word 'strawberry.'"
+
+# Initialize the client
+client = InferenceClient(
+ provider="hf-inference",
+ api_key="HF_INFERENCE_API_KEY"
+)
+
+completion = client.chat.completions.create(
+ model="Qwen/Qwen3-235B-A22B", # Or use any other model from Hugging Face
+ messages=[
+ {"role": "system", "content": system_prompt},
+ {"role": "user", "content": prompt},
+ ]
+)
+
+content = completion.choices[0].message.content
+code = match_code_block(content)
+
+with Sandbox.create() as sandbox:
+ execution = sandbox.run_code(code)
+ print(execution)
+```
+
\ No newline at end of file
diff --git a/apps/web/src/app/(docs)/mintlify-docs/quickstart/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/quickstart/index.mdx
new file mode 100644
index 0000000000..9890edc285
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/quickstart/index.mdx
@@ -0,0 +1,71 @@
+---
+title: Running your first Sandbox
+description: This guide will show you how to start your first E2B Sandbox.
+---
+
+
+
+Every new E2B account get $100 in credits. You can sign up [here](https://e2b.dev/auth/sign-up).
+
+
+1. Navigate to the E2B Dashboard.
+2. Copy your API key.
+3. Paste your E2B API key into your .env file.
+
+```bash .env
+E2B_API_KEY=e2b_***
+```
+
+
+Install the E2B SDK to your project by running the following command in your terminal.
+
+```javascript JavaScript & TypeScript
+npm i @e2b/code-interpreter dotenv
+```
+```python Python
+pip install e2b-code-interpreter python-dotenv
+```
+
+
+
+We'll write the minimal code for starting Sandbox, executing Python inside it and listing all files inside the root directory.
+
+```javascript JavaScript & TypeScript
+// index.ts
+import 'dotenv/config'
+import { Sandbox } from '@e2b/code-interpreter'
+
+const sbx = await Sandbox.create() // By default the sandbox is alive for 5 minutes
+const execution = await sbx.runCode('print("hello world")') // Execute Python inside the sandbox
+console.log(execution.logs)
+
+const files = await sbx.files.list('/')
+console.log(files)
+```
+```python Python
+# main.py
+from dotenv import load_dotenv
+load_dotenv()
+from e2b_code_interpreter import Sandbox
+
+sbx = Sandbox() # By default the sandbox is alive for 5 minutes
+execution = sbx.run_code("print('hello world')") # Execute Python inside the sandbox
+print(execution.logs)
+
+files = sbx.files.list("/")
+print(files)
+```
+
+
+
+Run the code with the following command:
+
+```bash JavaScript & TypeScript
+npx tsx ./index.ts
+```
+```bash Python
+python main.py
+```
+
+
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/quickstart/install-custom-packages/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/quickstart/install-custom-packages/index.mdx
new file mode 100644
index 0000000000..26b63225e8
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/quickstart/install-custom-packages/index.mdx
@@ -0,0 +1,189 @@
+---
+title: "Install custom packages"
+---
+
+There are two ways to install custom packages in the E2B Sandbox.
+
+1. [Create custom sandbox with preinstalled packages](#create-a-custom-sandbox).
+2. [Install packages during the sandbox runtime](#install-packages-during-the-sandbox-runtime).
+
+---
+
+## Create a custom sandbox
+
+Use this option if you know beforehand what packages you need in the sandbox.
+
+Prerequisites:
+- E2B CLI
+- Docker running
+
+
+Custom sandbox template is a Docker image that we automatically convert to a sandbox that you can then start with our SDK.
+
+
+
+### 1. Install E2B CLI
+
+**Using Homebrew (on macOS)**
+
+
+```bash Terminal
+brew install e2b
+```
+
+
+**Using NPM**
+
+
+```bash Terminal
+npm i -g @e2b/cli
+```
+
+
+### 2. Login to E2B CLI
+Before you can create a custom sandbox, you need to login to E2B CLI.
+
+```bash Terminal
+e2b auth login
+```
+
+
+### 2. Initialize a sandbox template
+
+```bash Terminal
+e2b template init
+```
+
+
+### 3. Specify the packages you need in `e2b.Dockerfile`
+Edit the E2B Dockerfile to install the packages you need.
+
+
+You need to use the `e2bdev/code-interpreter:latest` base image.
+
+
+
+```bash e2b.Dockerfile
+FROM e2bdev/code-interpreter:latest
+
+RUN pip install cowsay
+RUN npm install cowsay
+```
+
+
+### 4. Build the sandbox template
+Run the following command to build the sandbox template.
+
+```bash Terminal
+e2b template build -c "/root/.jupyter/start-up.sh"
+```
+
+
+This will take a while, as it convert the Docker image to a sandbox which is a small VM.
+At the end of the process you will see the sandbox ID like this:
+```
+Running postprocessing. It can take up to few minutes.
+
+Postprocessing finished.
+
+✅ Building sandbox template YOUR_TEMPLATE_ID finished.
+```
+
+### 5. Start your custom sandbox
+Now you can pass the template ID to the SDK to start your custom sandbox.
+
+```js JavaScript & TypeScript
+import { Sandbox } from '@e2b/code-interpreter'
+
+const sbx = Sandbox.create({
+ template: 'YOUR_TEMPLATE_ID',
+})
+```
+```python Python
+from e2b_code_interpreter import Sandbox
+
+sbx = Sandbox.create(template='YOUR_TEMPLATE_ID')
+```
+
+
+---
+
+
+## Install packages during the sandbox runtime
+Use this option if don't know beforehand what packages you need in the sandbox. You can install packages with the package manager of your choice.
+
+
+The packages installed during the runtime are available only in the running sandbox instance.
+When you start a new sandbox instance, the packages are not be available.
+
+
+### 1. Install Python packages with PIP
+
+```js JavaScript & TypeScript
+import { Sandbox } from '@e2b/code-interpreter'
+
+const sbx = Sandbox.create()
+sbx.commands.run('pip install cowsay') // This will install the cowsay package
+sbx.runCode(`
+ import cowsay
+ cowsay.cow("Hello, world!")
+`)
+```
+```python Python
+from e2b_code_interpreter import Sandbox
+
+sbx = Sandbox.create()
+sbx.commands.run("pip install cowsay") # This will install the cowsay package
+sbx.run_code("""
+ import cowsay
+ cowsay.cow("Hello, world!")
+""")
+```
+
+
+
+### 2. Install Node.js packages with NPM
+
+```js JavaScript & TypeScript
+import { Sandbox } from '@e2b/code-interpreter'
+
+const sbx = Sandbox.create()
+sbx.commands.run('npm install cowsay') // This will install the cowsay package
+sbx.runCode(`
+ const cowsay = require('cowsay')
+ console.log(cowsay.say({ text: 'Hello, world!' }))
+`, { language: 'javascript' })
+```
+```python Python
+from e2b_code_interpreter import Sandbox
+
+sbx = Sandbox.create()
+sbx.commands.run("npm install cowsay") # This will install the cowsay package
+sbx.run_code("""
+ import { say } from 'cowsay'
+ console.log(say('Hello, world!'))
+""", language="javascript")
+```
+
+
+
+### 3. Install packages with package manager of your choice
+Since E2B Sandboxes are Debian based machines, you can use any package manager supported by Debian.
+You just need to make sure that the package manager is already installed in the sandbox.
+
+For example, to install `curl` and `git`, you can use the following commands:
+
+
+```js JavaScript & TypeScript
+import { Sandbox } from '@e2b/code-interpreter'
+
+const sbx = Sandbox.create()
+await sbx.commands.run('apt-get update && apt-get install -y curl git')
+```
+```python Python
+from e2b_code_interpreter import Sandbox
+
+sbx = Sandbox.create()
+sbx.commands.run("apt-get update && apt-get install -y curl git")
+```
+
\ No newline at end of file
diff --git a/apps/web/src/app/(docs)/mintlify-docs/quickstart/upload-download-files/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/quickstart/upload-download-files/index.mdx
new file mode 100644
index 0000000000..5c4345858c
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/quickstart/upload-download-files/index.mdx
@@ -0,0 +1,150 @@
+---
+title: "Upload & downloads files"
+---
+
+E2B Sandbox allows you to upload and downloads file to and from the Sandbox.
+
+An alternative way to get your data to the sandbox is to create a [custom sandbox template](/sandbox-template).
+
+
+## Upload file
+
+```ts JavaScript & TypeScript
+import { Sandbox } from '@e2b/code-interpreter'
+
+// Read local file relative to the current working directory
+const content = fs.readFileSync('local/file')
+
+const sbx = await Sandbox.create()
+// Upload file to the sandbox to absolute path '/home/user/my-file'
+await sbx.files.write('/home/user/my-file', content)
+```
+
+```python Python
+from e2b_code_interpreter import Sandbox
+
+sbx = Sandbox.create()
+
+# Read local file relative to the current working directory
+with open("local/file", "rb") as file:
+ # Upload file to the sandbox to absolute path '/home/user/my-file'
+ sbx.files.write("/home/user/my-file", file)
+```
+
+
+
+## Upload multiple files
+Currently, if you want to upload multiple files, you need to upload each one of the separately.
+We're working on a better solution.
+
+
+```ts JavaScript & TypeScript
+import { Sandbox } from '@e2b/code-interpreter'
+
+// Read local file relative to the current working directory
+const fileA = fs.readFileSync('local/file/a')
+const fileB = fs.readFileSync('local/file/b')
+
+const sbx = await Sandbox.create()
+// Upload file A to the sandbox to absolute path '/home/user/my-file-a'
+await sbx.files.write('/home/user/my-file-a', fileA)
+// Upload file B to the sandbox to absolute path '/home/user/my-file-b'
+await sbx.files.write('/home/user/my-file-b', fileB)
+```
+
+```python Python
+from e2b_code_interpreter import Sandbox
+
+sbx = Sandbox.create()
+
+# Read local file relative to the current working directory
+with open("local/file/a", "rb") as file:
+ # Upload file to the sandbox to absolute path '/home/user/my-file-a'
+ sbx.files.write("/home/user/my-file-a", file)
+
+with open("local/file/b", "rb") as file:
+ # Upload file to the sandbox to absolute path '/home/user/my-file-b'
+ sbx.files.write("/home/user/my-file-b", file)
+```
+
+
+
+## Upload directory
+We currently don't support an easy way to upload a whole directory.
+You need to upload each file separately.
+
+We're working on a better solution.
+
+---
+
+## Download file
+To download a file, you need to first get the file's content and then write it to a local file.
+
+
+```ts JavaScript & TypeScript
+import { Sandbox } from '@e2b/code-interpreter'
+
+const sbx = await Sandbox.create()
+// Download file from the sandbox to absolute path '/home/user/my-file'
+const content = await sbx.files.read('/home/user/my-file')
+// Write file to local path relative to the current working directory
+fs.writeFileSync('local/file', content)
+```
+
+```python Python
+from e2b_code_interpreter import Sandbox
+
+sbx = Sandbox.create()
+# Download file from the sandbox to absolute path '/home/user/my-file'
+content = sbx.files.read('/home/user/my-file')
+# Write file to local path relative to the current working directory
+with open('local/file', 'w') as file:
+ file.write(content)
+```
+
+
+## Download multiple files
+To download multiple files, you need to download each one of them separately from the sandbox.
+
+We're working on a better solution.
+
+
+
+```ts JavaScript & TypeScript
+import { Sandbox } from '@e2b/code-interpreter'
+
+const sbx = await Sandbox.create()
+// Download file A from the sandbox by absolute path '/home/user/my-file-a'
+const contentA = await sbx.files.read('/home/user/my-file-a')
+// Write file A to local path relative to the current working directory
+fs.writeFileSync('local/file/a', contentA)
+
+// Download file B from the sandbox by absolute path '/home/user/my-file-b'
+const contentB = await sbx.files.read('/home/user/my-file-b')
+// Write file B to local path relative to the current working directory
+fs.writeFileSync('local/file/b', contentB)
+```
+
+```python Python
+from e2b_code_interpreter import Sandbox
+
+sbx = Sandbox.create()
+# Download file A from the sandbox by absolute path '/home/user/my-file-a'
+contentA = sbx.files.read('/home/user/my-file-a')
+# Write file A to local path relative to the current working directory
+with open('local/file/a', 'w') as file:
+ file.write(contentA)
+
+# Download file B from the sandbox by absolute path '/home/user/my-file-b'
+contentB = sbx.files.read('/home/user/my-file-b')
+# Write file B to local path relative to the current working directory
+with open('local/file/b', 'w') as file:
+ file.write(contentB)
+```
+
+
+## Download directory
+We currently don't support an easy way to download a whole directory.
+You need to download each file separately.
+
+We're working on a better solution.
diff --git a/apps/web/src/app/(docs)/mintlify-docs/sandbox-template/customize-cpu-ram/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/sandbox-template/customize-cpu-ram/index.mdx
new file mode 100644
index 0000000000..dc669f6a05
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/sandbox-template/customize-cpu-ram/index.mdx
@@ -0,0 +1,18 @@
+---
+title: "Customize sandbox CPU & RAM"
+sidebarTitle: Customize CPU & RAM
+---
+
+You can customize the CPU and RAM of your sandbox template via E2B CLI.
+
+You'll need to create a sandbox [template first](/sandbox-template).
+
+During the build step, you can specify the CPU and RAM of your sandbox template.
+
+The following command will create a sandbox template with 2 CPUs and 2GB of RAM.
+
+
+```bash Terminal
+e2b template build -c "/root/.jupyter/start-up.sh" --cpu-count 2 --memory-mb 2048
+```
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/sandbox-template/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/sandbox-template/index.mdx
new file mode 100644
index 0000000000..5ceff2375b
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/sandbox-template/index.mdx
@@ -0,0 +1,138 @@
+---
+title: "Sandbox templates"
+sidebarTitle: Sandbox customization
+---
+
+Sandbox templates allow you to customize the sandbox environment to your needs.
+
+To create a sandbox template, you specify the `e2b.Dockerfile`. We then take this Dockerfile and create a new sandbox template from it and give you back a template ID.
+
+You can then use this template ID to create a new sandbox with the SDK based on the template you created.
+
+## How to create custom sandbox
+
+**Steps**
+1. [Install E2B CLI](#1-install-e2b-cli)
+1. [Initialize sandbox template](#2-initialize-sandbox-template)
+1. [Customize `e2b.Dockerfile`](#3-customize-e2b-dockerfile)
+1. [Build your sandbox template](#4-build-your-sandbox-template)
+1. [Start your custom sandbox](#5-start-your-custom-sandbox)
+
+
+### 1. Install E2B CLI
+
+**Using Homebrew (on macOS)**
+
+
+ ```bash Homebrew
+ brew install e2b
+ ```
+
+
+**Using NPM**
+
+
+ ```bash NPM
+ npm i -g @e2b/cli
+ ```
+
+
+### 2. Initialize sandbox template
+The following command will create a basic `e2b.Dockerfile` in the current directory.
+
+
+ ```bash bash
+ e2b template init
+ ```
+
+
+### 3. Customize `e2b.Dockerfile`
+Now you can customize your sandbox template by editing the `e2b.Dockerfile` file.
+
+ ```bash e2b.Dockerfile highlight={2,5}
+ # Make sure to use this base image
+ FROM e2bdev/code-interpreter:latest
+
+ # Install some Python packages
+ RUN pip install cowsay
+ ```
+
+
+
+ Only [Debian-based](https://en.wikipedia.org/wiki/List_of_Linux_distributions#Debian-based) images
+ (e.g., Debian, Ubuntu, or [E2B images](https://hub.docker.com/u/e2bdev)) are supported.
+
+
+### 4. Build your sandbox template
+Now you can build your sandbox template. We'll use Docker and the E2B CLI.
+What is going to happen is that E2B CLI will call Docker to build the image and then push it to the E2B cloud.
+Then we convert the Docker image to a micro VM that can be then launched as a sandbox with our SDK.
+
+
+ ```bash bash
+ e2b template build -c "/root/.jupyter/start-up.sh"
+ ```
+
+
+This process will take a moment. In the end, you'll see your template ID that you'll need to use to create a sandbox with the SDK.
+
+### 5. Start your custom sandbox
+Now you can use the template ID to create a sandbox with the SDK.
+
+
+ ```javascript JavaScript & TypeScript highlight={4,6}
+ import { Sandbox } from '@e2b/code-interpreter'
+
+ // Your template ID from the previous step
+ const templateID = 'id-of-your-template'
+ // Pass the template ID to the `Sandbox.create` method
+ const sandbox = await Sandbox.create(templateID)
+
+ // The template installed cowsay, so we can use it
+ const execution = await sandbox.runCode(`
+ import cowsay
+ cowsay.say('Hello from E2B!')
+ `)
+
+ console.log(execution.stdout)
+ ```
+ ```python Python highlight={4,6}
+ from e2b_code_interpreter import Sandbox
+
+ # Your template ID from the previous step
+ template_id = 'id-of-your-template'
+ # Pass the template ID to the `Sandbox.create` method
+ sandbox = Sandbox.create(template_id)
+
+ # The template installed cowsay, so we can use it
+ execution = sandbox.run_code("""
+ import cowsay
+ cowsay.say('Hello from E2B!')
+ """)
+
+ print(execution.stdout)
+ ```
+
+
+## How it works
+Every time you are building a sandbox template, we create a container based on the [`e2b.Dockerfile`](/sandbox-template#3-customize-e2b-dockerfile) file you create in the process.
+We extract the container's filesystem, do provisioning and configuration (e.g. installing required dependencies), and start a sandbox.
+
+Then, these steps happen:
+
+ 1. We take the running sandbox.
+ 2. (Only if you specified the [start command](/sandbox-template/start-cmd), otherwise this step is skipped) Execute the start command.
+ 3. Wait for readiness (by default 20 seconds if start command is specified, otherwise immediately ready). Readiness check can be configured using [ready command](/sandbox-template/ready-cmd).
+ 4. Snapshot the sandbox and make it ready for you to spawn it with the SDK.
+
+We call this sandbox snapshot a _sandbox template_.
+
+
+ **Sandbox Snapshot**
+
+ Snapshots are saved running sandboxes. We serialize and save the whole sandbox's filesystem together with all the
+ running processes in a way that can be loaded later.
+
+ This allows us to load the sandbox in a few hundred milliseconds any time later with all the processes already running
+ and the filesystem exactly as it was.
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/sandbox-template/ready-cmd/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/sandbox-template/ready-cmd/index.mdx
new file mode 100644
index 0000000000..4d5b4c54ae
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/sandbox-template/ready-cmd/index.mdx
@@ -0,0 +1,51 @@
+---
+title: "Ready Command"
+sidebarTitle: Ready command
+---
+
+The ready command allows you to specify a command that will determine **template sandbox** readiness before a [snapshot](/sandbox-template#how-it-works) is created.
+It is executed in an infinite loop until it returns a successful **exit code 0**.
+This way you can control how long should we wait for the [start command](/sandbox-template/start-cmd) or any system state.
+
+
+## How to add ready command
+
+When you are building a sandbox template you can specify the ready command by using the [`--ready-cmd`](/sdk-reference/cli/v1.5.0/template#e2b-template-build) option:
+
+```bash
+e2b template build --ready-cmd ""
+```
+
+### Sandbox template config
+You can specify the ready command inside the `e2b.toml` in the same directory where you run `e2b template build`.
+
+ ```toml e2b.toml highlight={5}
+ # This is a config for E2B sandbox template
+ template_id = "1wdqsf9le9gk21ztb4mo"
+ dockerfile = "e2b.Dockerfile"
+ template_name = "my-agent-sandbox"
+ ready_cmd = ""
+ ```
+
+
+## Default values
+By default, the ready command is set to `sleep 0`, which means the sandbox template will be ready immediatelly.
+If the [start command](/sandbox-template/start-cmd) is defined, the default is set to `sleep 20`, which means that the template sandbox will wait for 20 seconds before taking the snapshot.
+
+## Examples
+Here are some examples of the ready command you can use.
+
+### Wait for URL to return 200 status code
+```bash
+ready_cmd = 'curl -s -o /dev/null -w "%{http_code}" http://localhost:3000 | grep -q "200"'
+```
+
+### Wait for a specific process to start
+```bash
+ready_cmd = 'pgrep my-process-name > /dev/null'
+```
+
+### Wait for a file to exist
+```bash
+ready_cmd = '[ -f /tmp/ready.flag ]'
+```
\ No newline at end of file
diff --git a/apps/web/src/app/(docs)/mintlify-docs/sandbox-template/start-cmd/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/sandbox-template/start-cmd/index.mdx
new file mode 100644
index 0000000000..ea85d5faf9
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/sandbox-template/start-cmd/index.mdx
@@ -0,0 +1,47 @@
+---
+title: "Start Command"
+sidebarTitle: Start command
+---
+
+The start command allows you to specify a command that will be **already running** when you spawn your custom sandbox.
+This way, you can for example have running servers or seeded databases inside the sandbox that are already fully ready when you spawn the sandbox using the SDK and with zero waiting time for your users during the runtime.
+
+The idea behind the start command feature is to lower the wait times for your users and have everything ready for your users when you spawn your sandbox.
+
+You can see how it works [here](/sandbox-template#how-it-works).
+
+## How to add start command
+
+When you are building a sandbox template you can specify the start command by using the [`-c`](/sdk-reference/cli/v1.0.9/template#e2b-template-build) option:
+
+```bash
+e2b template build -c ""
+```
+
+When you spawn the custom sandbox you built, the start command will be already running if there was no error when we tried to execute it.
+
+### Sandbox template config
+You can specify the start command also inside the `e2b.toml` in the same directory where you run `e2b template build`.
+
+ ```toml e2b.toml highlight={5}
+ # This is a config for E2B sandbox template
+ template_id = "1wdqsf9le9gk21ztb4mo"
+ dockerfile = "e2b.Dockerfile"
+ template_name = "my-agent-sandbox"
+ start_cmd = ""
+ ```
+
+
+
+## Logs
+You can retrieve the start command's logs using the CLI:
+
+
+```bash bash
+e2b sandbox logs
+```
+
+
+
+These logs include logs from the start command during the build phase.
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/sandbox/connect-bucket/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/sandbox/connect-bucket/index.mdx
new file mode 100644
index 0000000000..b162c7b90d
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/sandbox/connect-bucket/index.mdx
@@ -0,0 +1,166 @@
+---
+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](/sandbox-template).
+
+## 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 `Dockerfile` that can be used to create a container with the `gcsfuse` installed.
+
+```docker
+FROM e2bdev/code-interpreter:latest
+
+RUN apt-get update && apt-get install -y gnupg lsb-release wget
+
+RUN lsb_release -c -s > /tmp/lsb_release
+RUN GCSFUSE_REPO=$(cat /tmp/lsb_release) && echo "deb https://packages.cloud.google.com/apt gcsfuse-$GCSFUSE_REPO main" | tee /etc/apt/sources.list.d/gcsfuse.list
+RUN wget -O - https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key add -
+
+RUN apt-get update && apt-get install -y gcsfuse
+
+```
+
+The bucket is mounted during the sandbox runtime using the `gcsfuse` command.
+
+
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create('')
+await sandbox.files.makeDir('/home/user/bucket')
+await sandbox.files.write('key.json', '')
+
+await sandbox.commands.run('sudo gcsfuse --key-file /home/user/key.json /home/user/bucket')
+```
+
+```python Python
+from e2b import Sandbox
+
+sandbox = Sandbox.create("")
+sandbox.files.make_dir("/home/user/bucket")
+sandbox.files.write("key.json", "")
+
+output = sandbox.commands.run(
+ "sudo gcsfuse --key-file /home/user/key.json /home/user/bucket"
+)
+```
+
+
+### 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 `Dockerfile` setup is similar to that of Google Cloud Storage.
+
+```docker
+FROM ubuntu:latest
+
+RUN apt-get update && apt-get install s3fs
+```
+
+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.
+
+
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create('')
+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', ':')
+await sandbox.commands.run('sudo chmod 600 /root/.passwd-s3fs')
+
+await sandbox.commands.run('sudo s3fs /home/user/bucket')
+```
+
+```python Python
+from e2b import Sandbox
+
+sandbox = Sandbox.create("")
+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", ":")
+sandbox.commands.run("sudo chmod 600 /root/.passwd-s3fs")
+
+sandbox.commands.run("sudo s3fs /home/user/bucket")
+```
+
+
+### 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 `Dockerfile` remains the same as for S3. However, the mounting differs slightly; we need to specify the endpoint for R2.
+
+
+```js JavaScript & TypeScript
+import { Sandbox } from 'e2b'
+
+const sandbox = await Sandbox.create({ template: '' })
+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', ':')
+await sandbox.commands.run('sudo chmod 600 /root/.passwd-s3fs')
+
+await sandbox.commands.run('sudo s3fs -o url=https://.r2.cloudflarestorage.com /home/user/bucket')
+```
+
+```python Python
+from e2b import Sandbox
+
+sandbox = Sandbox.create("")
+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", ":")
+sandbox.commands.run("sudo chmod 600 /root/.passwd-s3fs")
+
+sandbox.commands.run(
+ "sudo s3fs -o url=https://.r2.cloudflarestorage.com /home/user/bucket"
+)
+```
+
+
+### Flags
+
+It's the same as for S3.
diff --git a/apps/web/src/app/(docs)/mintlify-docs/sandbox/connect/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/sandbox/connect/index.mdx
new file mode 100644
index 0000000000..d2bd054294
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/sandbox/connect/index.mdx
@@ -0,0 +1,88 @@
+---
+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.
+
+
+```js JavaScript & TypeScript highlight={6}
+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 highlight={4}
+from e2b_code_interpreter import Sandbox
+
+# 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
+
+```
+
+
+## 2. Connect to the sandbox
+
+Now that you have the sandbox ID, you can connect to the sandbox using the `Sandbox.connect()` method.
+
+
+```js JavaScript & TypeScript highlight={14}
+import { Sandbox } from "@e2b/code-interpreter"
+
+// Get all running sandboxes
+const runningSandboxes = await Sandbox.list()
+
+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
+
+// Connect to the sandbox
+const sandbox = await Sandbox.connect(sandboxId)
+// Now you can use the sandbox as usual
+// ...
+```
+```python Python highlight={13}
+from e2b_code_interpreter import Sandbox
+
+# Get all running sandboxes
+running_sandboxes = Sandbox.list()
+
+# Get the ID of the sandbox you want to connect to
+if len(running_sandboxes) == 0:
+ raise Exception("No running sandboxes found")
+
+sandbox_id = running_sandboxes[0].sandbox_id
+
+# Connect to the sandbox
+sandbox = Sandbox.connect(sandbox_id)
+# Now you can use the sandbox as usual
+# ...
+```
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/sandbox/environment-variables/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/sandbox/environment-variables/index.mdx
new file mode 100644
index 0000000000..3f91b1a5d3
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/sandbox/environment-variables/index.mdx
@@ -0,0 +1,123 @@
+---
+title: "Environment variables"
+---
+
+This page covers how to set and use environment variables in a sandbox, and default environment variables inside the sandbox.
+
+## 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:
+- `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_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:
+
+
+```js JavaScript & TypeScript
+const sandbox = await Sandbox.create()
+const result = await sandbox.commands.run('echo $E2B_SANDBOX_ID')
+```
+```python Python
+sandbox = Sandbox.create()
+result = sandbox.commands.run("echo $E2B_SANDBOX_ID")
+```
+
+
+
+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
+```
+
+
+---
+
+## Setting environment variables
+There are 3 ways to set environment variables in a sandbox:
+1. [Global environment variables when creating the sandbox](/sandbox/environment-variables#1-global-environment-variables-when-creating-the-sandbox).
+2. [When running code in the sandbox](/sandbox/environment-variables#2-setting-environment-variables-when-running-code).
+3. [When running commands in the sandbox](/sandbox/environment-variables#3-setting-environment-variables-when-running-commands).
+
+### 1. Global environment variables
+You can set global environment variables when creating a sandbox.
+
+
+```js JavaScript & TypeScript highlight={4-6}
+import { Sandbox } from '@e2b/code-interpreter'
+
+const sandbox = await Sandbox.create({
+ envs: {
+ MY_VAR: 'my_value',
+ },
+})
+```
+```python Python highlight={4-6}
+from e2b_code_interpreter import Sandbox
+
+sandbox = Sandbox.create(
+ envs={
+ 'MY_VAR': 'my_value',
+ },
+)
+```
+
+
+### 2. Setting environment variables when running code
+You can set environment variables for specific code execution call in the sandbox.
+
+
+- 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.
+
+
+
+```js JavaScript & TypeScript highlight={3-5}
+const sandbox = await Sandbox.create()
+const result = await sandbox.runCode('import os; print(os.environ.get("MY_VAR"))', {
+ envs: {
+ MY_VAR: 'my_value',
+ },
+})
+```
+```python Python highlight={4-6}
+sandbox = Sandbox.create()
+result = sandbox.run_code(
+ 'import os; print(os.environ.get("MY_VAR"))',
+ envs={
+ 'MY_VAR': 'my_value'
+ }
+)
+```
+
+
+### 3. Setting environment variables when running commands
+You can set environment variables for specific command execution in the sandbox.
+
+
+- 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.
+
+
+
+```js JavaScript & TypeScript highlight={3-5}
+const sandbox = await Sandbox.create()
+sandbox.commands.run('echo $MY_VAR', {
+ envs: {
+ MY_VAR: '123',
+ },
+})
+```
+```python Python highlight={4-6}
+sandbox = Sandbox.create()
+sandbox.commands.run(
+ 'echo $MY_VAR',
+ envs={
+ 'MY_VAR': '123'
+ }
+)
+```
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/sandbox/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/sandbox/index.mdx
new file mode 100644
index 0000000000..5b25f8a3ac
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/sandbox/index.mdx
@@ -0,0 +1,132 @@
+---
+title: "Sandbox lifecycle"
+sidebarTitle: Lifecycle
+---
+
+When you start the sandbox, it stays alive for 5 minutes by default but you can change it by passing the `timeout` parameter.
+After the time passes, the sandbox will be automatically shutdown.
+
+```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,
+)
+```
+
+
+
+## Change sandbox timeout during runtime
+
+You can change the sandbox timeout when it's running by calling the 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 timout every time user interacts with it in your app.
+
+
+```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)
+```
+```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)
+```
+
+
+## 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.
+
+
+```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()
+
+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_code_interpreter 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)
+
+# 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())
+# )
+```
+
+
+## Shutdown sandbox
+
+You can shutdown the sandbox any time even before the timeout is up by calling the `kill` method.
+
+
+```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()
+```
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/sandbox/internet-access/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/sandbox/internet-access/index.mdx
new file mode 100644
index 0000000000..d9ebaddd10
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/sandbox/internet-access/index.mdx
@@ -0,0 +1,160 @@
+---
+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.
+
+
+```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)
+```
+
+
+When internet access is disabled, the sandbox cannot make outbound network connections, which provides an additional layer of security for sensitive code execution.
+
+## Sandbox public URL
+Every sandbox has a public URL that can be used to access running services inside the sandbox.
+
+
+```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}')
+```
+
+
+The code above will print something like this:
+
+
+```bash JavaScript & TypeScript
+https://3000-i62mff4ahtrdfdkyn2esc-b0b684e9.e2b.dev
+```
+```bash Python
+https://3000-i62mff4ahtrdfdkyn2esc-b0b684e9.e2b.dev
+```
+
+
+The first leftmost part of the host is the port number we passed to the method.
+
+## 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.
+
+
+```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
+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 = sandbox.commands.run(f"curl {url}")
+data = response.stdout
+print("Response from server inside sandbox:", data)
+
+# Kill the server process inside the sandbox.
+process.kill()
+```
+
+
+
+This output will look like this:
+
+```bash JavaScript & TypeScript
+Server started at: https://3000-ip3nfrvajtqu5ktoxugc7-b0b684e9.e2b.dev
+Response from server inside sandbox:
+
+
+
+Directory listing for /
+
+
+
+
+ + +``` +```bash Python +Server started at: https://3000-ip3nfrvajtqu5ktoxugc7-b0b684e9.e2b.dev +Response from server inside sandbox: + + + +Directory listing for /
+
+
+
+
+ + +``` +
diff --git a/apps/web/src/app/(docs)/mintlify-docs/sandbox/lifecycle-events-api/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/sandbox/lifecycle-events-api/index.mdx
new file mode 100644
index 0000000000..d9166e7518
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/sandbox/lifecycle-events-api/index.mdx
@@ -0,0 +1,151 @@
+---
+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, or killed, along with metadata.
+All requests require authentication using your team [API key](/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)
+
+
+
+```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)
+
+// [
+// {
+// "eventCategory": "lifecycle",
+// "eventData": null,
+// "eventLabel": "kill",
+// "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"
+// },
+// {
+// "eventCategory": "lifecycle",
+// "eventData": {
+// "set_timeout": "2025-08-06T20:59:59Z"
+// },
+// "eventLabel": "update",
+// "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"
+// },
+// [...]
+// {
+// "eventCategory": "lifecycle",
+// "eventData": null,
+// "eventLabel": "create",
+// "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()
+
+# 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)
+
+# [
+# {
+# "eventCategory": "lifecycle",
+# "eventData": null,
+# "eventLabel": "kill",
+# "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"
+# },
+# {
+# "eventCategory": "lifecycle",
+# "eventData": {
+# "set_timeout": "2025-08-06T20:59:59Z"
+# },
+# "eventLabel": "update",
+# "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"
+# },
+# [...]
+# {
+# "eventCategory": "lifecycle",
+# "eventData": null,
+# "eventLabel": "create",
+# "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"
+# }
+# ]
+```
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/sandbox/lifecycle-events-webhooks/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/sandbox/lifecycle-events-webhooks/index.mdx
new file mode 100644
index 0000000000..bf6aa23c9d
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/sandbox/lifecycle-events-webhooks/index.mdx
@@ -0,0 +1,270 @@
+---
+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](/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. You will receive webhook notifications for sandbox lifecycle events from sandboxes created by your team with the [following payload](#webhook-payload).
+
+
+
+```js JavaScript & TypeScript
+// Register a new webhook
+const resp = await fetch(
+ 'https://api.e2b.app/events/webhooks/sandboxes',
+ {
+ method: 'POST',
+ headers: {
+ 'X-API-Key': E2B_API_KEY,
+ 'Content-Type': 'application/json',
+ },
+ body: JSON.stringify({
+ url: 'https://your-webhook-endpoint.com/webhook',
+ events: ['create', 'kill', 'update']
+ }),
+ }
+)
+
+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/sandboxes",
+ headers={
+ "X-API-Key": E2B_API_KEY,
+ "Content-Type": "application/json",
+ },
+ json={
+ "url": "https://your-webhook-endpoint.com/webhook",
+ "events": ["create", "kill", "update"]
+ }
+)
+
+if resp.status_code == 201:
+ print("Webhook registered successfully")
+```
+
+
+
+### Get webhook configuration
+
+Retrieve the current webhook configuration for your team.
+
+
+```js JavaScript & TypeScript
+// Get current webhook configuration
+const resp = await fetch(
+ 'https://api.e2b.app/events/webhooks/sandboxes',
+ {
+ method: 'GET',
+ headers: {
+ 'X-API-Key': E2B_API_KEY,
+ },
+ }
+)
+const webhookConfig = await resp.json()
+console.log(webhookConfig)
+// {
+// "teamID": "",
+// "url": "https://your-webhook-endpoint.com/webhook",
+// "events": ["create", "kill"]
+// }
+
+```
+```python Python
+import requests
+
+# Get current webhook configuration
+resp = requests.get(
+ "https://api.e2b.app/events/webhooks/sandboxes",
+ headers={
+ "X-API-Key": E2B_API_KEY,
+ }
+)
+
+webhook_config = resp.json()
+print(webhook_config)
+# {
+# "teamID": "",
+# "events": ["create", "kill"]
+# "url": "https://your-webhook-endpoint.com/webhook",
+# }
+```
+
+
+### Update webhook configuration
+
+Update an existing webhook configuration. The update will replace the previous configuration fields with provided fields.
+
+
+```js JavaScript & TypeScript
+// Update webhook configuration
+const resp = await fetch(
+ 'https://api.e2b.app/events/webhooks/sandboxes',
+ {
+ method: 'PATCH',
+ headers: {
+ 'X-API-Key': E2B_API_KEY,
+ 'Content-Type': 'application/json',
+ },
+ body: JSON.stringify({
+ url: 'https://your-updated-webhook-endpoint.com/webhook',
+ events: ['create']
+ }),
+ }
+)
+
+const updatedWebhookConfig = await resp.json()
+console.log(updatedWebhookConfig)
+// {
+// "teamID": "",
+// "events": ["create"],
+// "url": "https://your-updated-webhook-endpoint.com/webhook"
+// }
+```
+```python Python
+import requests
+
+# Update webhook configuration
+resp = requests.patch(
+ "https://api.e2b.app/events/webhooks/sandboxes",
+ headers={
+ "X-API-Key": E2B_API_KEY,
+ "Content-Type": "application/json",
+ },
+ json={
+ "url": "https://your-updated-webhook-endpoint.com/webhook",
+ "events": ["create"]
+ }
+)
+
+updated_webhook_config = resp.json()
+print(updated_webhook_config)
+# {
+# "teamID": "",
+# "events": ["create"],
+# "url": "https://your-updated-webhook-endpoint.com/webhook"
+# }
+```
+
+
+### Delete webhook
+
+Unregister the webhook.
+
+
+```js JavaScript & TypeScript
+// Delete webhook configuration
+const resp = await fetch(
+ 'https://api.e2b.app/events/webhooks/sandboxes',
+ {
+ 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/sandboxes",
+ headers={
+ "X-API-Key": E2B_API_KEY,
+ }
+)
+
+if resp.status_code == 200:
+ print("Webhook deleted successfully")
+```
+
+
+### Test webhook
+
+Send a test webhook to verify your endpoint is working correctly.
+
+
+```js JavaScript & TypeScript
+// Test webhook endpoint
+const resp = await fetch(
+ 'https://api.e2b.app/events/webhooks/sandboxes/test',
+ {
+ method: 'POST',
+ headers: {
+ 'X-API-Key': E2B_API_KEY,
+ },
+ }
+)
+
+if (resp.status === 200) {
+ console.log('Test webhook sent successfully')
+}
+```
+```python Python
+import requests
+
+# Test webhook endpoint
+resp = requests.post(
+ "https://api.e2b.app/events/webhooks/sandboxes/test",
+ headers={
+ "X-API-Key": E2B_API_KEY,
+ }
+)
+
+if resp.status_code == 200:
+ print("Test webhook sent successfully")
+```
+
+
+## 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
+{
+ "eventCategory": "lifecycle",
+ "eventData": {
+ "sandbox_metadata": {
+ "": ""
+ }
+ },
+ "eventLabel": "create",
+ "sandboxBuildId": "a979a14b-bdcc-49e6-bc04-1189fc9fe7c2",
+ "sandboxExecutionId": "1dae9a1c-9957-4ce7-a236-a99d5779aadf",
+ "sandboxId": "",
+ "sandboxTeamId": "",
+ "sandboxTemplateId": "rki5dems9wqfm4r03t7g",
+ "timestamp": "2025-08-06T20:59:24Z"
+}
+```
+
+## Available event types
+
+The following event types can be subscribed to via webhooks, they are used as the `eventLabel` field in the [payload](#webhook-payload).
+
+- `create` - Sandbox creation
+- `kill` - Sandbox termination
+- `update` - Sandbox configuration updates
+- `pause` - Sandbox pausing
+- `resume` - Sandbox resuming
+
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/sandbox/list/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/sandbox/list/index.mdx
new file mode 100644
index 0000000000..aa49e531a1
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/sandbox/list/index.mdx
@@ -0,0 +1,339 @@
+---
+title: "List sandboxes"
+---
+
+You can list sandboxes using the `Sandbox.list()` method.
+
+
+ Once you have information about running sandbox, you can [connect](/sandbox/connect) to it using the `Sandbox.connect()` method.
+
+
+### Listing sandboxes
+
+The `Sandbox.list()` method supports pagination. In the [advanced pagination](/sandbox/list#advanced-pagination) section, you can find more information about pagination techniques using the updated method.
+
+
+ ```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()
+ ```
+
+The code above will output something like this:
+
+ ```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
+ ```
+
+
+
+### 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.
+
+
+ ```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()
+ ```
+
+
+Filter sandboxes by the metadata key value pairs specified during Sandbox creation.
+
+
+ ```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()
+ ```
+
+
+### 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.
+
+
+ ```js JavaScript & TypeScript highlight={4-5,16}
+ import { Sandbox } from '@e2b/code-interpreter'
+
+ const paginator = Sandbox.list({
+ limit: 100,
+ nextToken: '',
+ })
+
+ // 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="",
+ )
+
+ paginator.has_next # Whether there is a next page
+ paginator.next_token # Next page token
+
+ # Fetch the next page
+ paginator.next_items()
+ ```
+
+
+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:
+
+
+ ```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)
+ ```
+
+
+## Old SDK (v1.x.y)
+
+
+ If you're using SDK with version lower than `2.0.0`, the `Sandbox.list()` method behaves differently.
+
+
+
+
+ ```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)
+ ```
+
+
+## Filtering sandboxes
+
+You can filter sandboxes by specifying [Metadata](/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.
+
+
+ ```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",
+ }
+ ),
+ )
+ ```
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/sandbox/metadata/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/sandbox/metadata/index.mdx
new file mode 100644
index 0000000000..b45f88cbb3
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/sandbox/metadata/index.mdx
@@ -0,0 +1,59 @@
+---
+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](/sandbox/connect).
+
+You specify metadata when creating a sandbox and can access it later through listing running sandboxes with `Sandbox.list()` method.
+
+
+If you're using the [beta version of the SDK](/sandbox/installing-beta-sdks), the `Sandbox.list()` method was updated. See [List Sandboxes](/sandbox/list#changes-in-the-beta-sdks) for more information.
+
+
+
+```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 runningSandboxes = await Sandbox.list()
+// 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.
+running_sandboxes = Sandbox.list()
+# Will print:
+# {
+# 'userId': '123',
+# }
+print(running_sandboxes[0].metadata)
+```
+
+
+## Filtering sandboxes by metadata
+You can also filter sandboxes by metadata, you can find more about it [here](/sandbox/list#filtering-sandboxes).
\ No newline at end of file
diff --git a/apps/web/src/app/(docs)/mintlify-docs/sandbox/metrics/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/sandbox/metrics/index.mdx
new file mode 100644
index 0000000000..99769f479a
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/sandbox/metrics/index.mdx
@@ -0,0 +1,110 @@
+---
+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
+
+
+```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()),
+# ),
+# ]
+```
+
+
+### Getting sandbox metrics using the CLI
+
+```bash Terminal highlight={1}
+e2b sandbox metrics
+
+# Metrics for sandbox
+#
+# [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
+```
+
+
+
+ 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.
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/sandbox/persistence/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/sandbox/persistence/index.mdx
new file mode 100644
index 0000000000..86254c7cc2
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/sandbox/persistence/index.mdx
@@ -0,0 +1,277 @@
+---
+title: "Sandbox persistence"
+sidebarTitle: Persistence
+---
+
+
+Sandbox persistence is currently in public beta:
+1. Consider [some limitations](#limitations-while-in-beta).
+2. The persistence is free for all users during the beta.
+
+
+The sandbox persistence allows you to pause your sandbox and resume it later from the same state it was in when you paused it.
+
+This includes not only state of the sandbox's filesystem but also the sandbox's memory. This means all running processes, loaded variables, data, etc.
+
+## Sandbox State Transitions
+
+Understanding how sandboxes transition between different states is crucial for managing their lifecycle effectively. Here's a diagram showing the possible state transitions:
+
+
+
+
+
+### State descriptions
+
+- **Running**: The sandbox is actively running and can execute code. This is the initial state after creation.
+- **Paused**: The sandbox execution is suspended but its state is preserved.
+- **Killed**: The sandbox is terminated and all resources are released. This is a terminal state.
+
+### Changing sandbox's state
+
+
+```js JavaScript & TypeScript
+import { Sandbox } from '@e2b/code-interpreter'
+
+const sandbox = await Sandbox.create() // Starts in Running state
+
+// Pause the sandbox
+await sandbox.betaPause() // Running → Paused
+
+// Resume the sandbox
+await sandbox.connect() // Running/Paused → Running
+
+// Kill the sandbox (from any state)
+await sandbox.kill() // Running/Paused → Killed
+```
+
+```python Python
+from e2b_code_interpreter import Sandbox
+
+sandbox = Sandbox.create() # Starts in Running state
+
+# Pause the sandbox
+sandbox.betaPause() # Running → Paused
+
+# Resume the sandbox
+sandbox.connect() # Running/Paused → Running
+
+# Kill the sandbox (from any state)
+sandbox.kill() # Running/Paused → Killed
+```
+
+
+## Pausing sandbox
+When you pause a sandbox, both the sandbox's filesystem and memory state will be saved. This includes all the files in the sandbox's filesystem and all the running processes, loaded variables, data, etc.
+
+
+```js JavaScript & TypeScript highlight={8-9}
+import { Sandbox } from '@e2b/code-interpreter'
+
+const sbx = await Sandbox.create()
+console.log('Sandbox created', sbx.sandboxId)
+
+// Pause the sandbox
+// You can save the sandbox ID in your database to resume the sandbox later
+await sbx.betaPause()
+console.log('Sandbox paused', sbx.sandboxId)
+```
+```python Python highlight={8-9}
+from e2b_code_interpreter import Sandbox
+
+sbx = Sandbox.create()
+print('Sandbox created', sbx.sandbox_id)
+
+# Pause the sandbox
+# You can save the sandbox ID in your database to resume the sandbox later
+sbx.beta_pause()
+print('Sandbox paused', sbx.sandbox_id)
+```
+
+
+
+## Resuming sandbox
+When you resume a sandbox, it will be in the same state it was in when you paused it.
+This means that all the files in the sandbox's filesystem will be restored and all the running processes, loaded variables, data, etc. will be restored.
+
+
+```js JavaScript & TypeScript highlight={12-13}
+import { Sandbox } from '@e2b/code-interpreter'
+
+const sbx = await Sandbox.create()
+console.log('Sandbox created', sbx.sandboxId)
+
+// Pause the sandbox
+// You can save the sandbox ID in your database to resume the sandbox later
+await sbx.betaPause()
+console.log('Sandbox paused', sbx.sandboxId)
+
+// Connect to the sandbox (it will automatically resume the sandbox, if paused)
+const sameSbx = await sbx.connect()
+console.log('Connected to the sandbox', sameSbx.sandboxId)
+```
+```python Python highlight={12-13}
+from e2b_code_interpreter import Sandbox
+
+sbx = Sandbox.create()
+print('Sandbox created', sbx.sandbox_id)
+
+# Pause the sandbox
+# You can save the sandbox ID in your database to resume the sandbox later
+sbx.beta_pause()
+print('Sandbox paused', sandbox_id)
+
+# Connect to the sandbox (it will automatically resume the sandbox, if paused)
+same_sbx = sbx.connect()
+print('Connected to the sandbox', same_sbx.sandbox_id)
+```
+
+
+## Listing paused sandboxes
+You can list all paused sandboxes by calling the `Sandbox.list` method and supplying the `state` query parameter.
+More information about using the method can be found in [List Sandboxes](/sandbox/list).
+
+
+```js JavaScript & TypeScript highlight={4,7}
+import { Sandbox, SandboxInfo } from '@e2b/code-interpreter'
+
+// List all paused sandboxes
+const paginator = Sandbox.list({ query: { state: ['paused'] } })
+
+// Get the first page of paused sandboxes
+const sandboxes = await paginator.nextItems()
+
+// Get all paused sandboxes
+while (paginator.hasNext) {
+ const items = await paginator.nextItems()
+ sandboxes.push(...items)
+}
+```
+```python Python highlight={4,7}
+# List all paused sandboxes
+from e2b_code_interpreter import Sandbox, SandboxQuery, SandboxState
+
+paginator = Sandbox.list(SandboxQuery(state=[SandboxState.PAUSED]))
+
+# Get the first page of paused sandboxes
+sandboxes = paginator.next_items()
+
+# Get all paused sandboxes
+while paginator.has_next:
+ items = paginator.next_items()
+ sandboxes.extend(items)
+```
+
+
+## Removing paused sandboxes
+
+You can remove paused sandboxes by calling the `kill` method on the Sandbox instance.
+
+
+```js JavaScript & TypeScript highlight={11,14}
+import { Sandbox } from '@e2b/code-interpreter'
+
+const sbx = await Sandbox.create()
+console.log('Sandbox created', sbx.sandboxId)
+
+// Pause the sandbox
+// You can save the sandbox ID in your database to resume the sandbox later
+await sbx.betaPause()
+
+// Remove the sandbox
+await sbx.kill()
+
+// Remove sandbox by id
+await Sandbox.kill(sbx.sandboxId)
+```
+```python Python highlight={9,12}
+from e2b_code_interpreter import Sandbox
+
+sbx = Sandbox.create()
+
+# Pause the sandbox
+sbx.beta_pause()
+
+# Remove the sandbox
+sbx.kill()
+
+# Remove sandbox by id
+Sandbox.kill(sbx.sandbox_id)
+```
+
+
+## Sandbox's timeout
+When you connect to a sandbox, the sandbox's timeout is reset to the default timeout of an E2B sandbox - 5 minutes.
+
+You can pass a custom timeout to the `Sandbox.connect()`/`Sandbox.connect()` method like this:
+
+
+```js JavaScript & TypeScript
+import { Sandbox } from '@e2b/code-interpreter'
+
+const sbx = await Sandbox.connect(sandboxId, { timeoutMs: 60 * 1000 }) // 60 seconds
+```
+```python Python
+from e2b_code_interpreter import Sandbox
+
+sbx = Sandbox.connect(sandbox_id, timeout=60) # 60 seconds
+```
+
+
+
+### Auto-pause (beta)
+
+**Note: Auto-pause is currently in beta and available through `Sandbox.betaCreate()`/`Sandbox.beta_create()` method.**
+
+Sandboxes can now automatically pause after they time out. When a sandbox is paused, it stops consuming compute but preserves its state. The default inactivity timeout is 10 minutes. You can change the timeout by passing the `timeoutMs`/`timeout` parameter to the `Sandbox.connect()`/`Sandbox.connect()` method.
+
+
+```js JavaScript & TypeScript
+import { Sandbox } from '@e2b/code-interpreter'
+
+// Create sandbox with auto-pause enabled
+const sandbox = await Sandbox.betaCreate({
+ autoPause: true,
+ timeoutMs: 10 * 60 * 1000 // Optional: change the default timeout (10 minutes)
+})
+```python Python
+from e2b_code_interpreter import Sandbox
+# Create sandbox with auto-pause enabled (Beta)
+sandbox = Sandbox.beta_create(
+ auto_pause=True # Auto-pause after the sandbox times out
+ timeout=10 * 60, # Optional: change the default timeout (10 minutes)
+)
+
+
+The auto-pause is persistent, meaning that if your sandbox resumes and it times out, it will be automatically paused again.
+
+If you `.kill()` the sandbox, it will be permanently deleted and you won't be able to resume it.
+
+
+```js JavaScript & TypeScript
+import { Sandbox } from '@e2b/code-interpreter'
+
+// Create sandbox with auto-pause enabled (Beta)
+const sandbox = await Sandbox.betaCreate({
+ autoPause: true // Auto-pause after the sandbox times out
+})
+```
+```python Python
+from e2b_code_interpreter import Sandbox
+# Create sandbox with auto-pause enabled (Beta)
+sandbox = Sandbox.beta_create(
+ auto_pause=True # Auto-pause after the sandbox times out
+)
+```
+
+
+## Network
+If you have a service (for example a server) running inside your sandbox and you pause the sandbox, the service won't be accessible from the outside and all the clients will be disconnected.
+If you resume the sandbox, the service will be accessible again but you need to connect clients again.
+
+
+## Limitations while in beta
+- Pausing a sandbox takes about 4 seconds per 1 GiB of RAM
+- Resuming a sandbox takes about 1 second
+- Sandbox can be used up to 30 days
+ - After 30 days from the sandbox creation, the sandbox data may be deleted. This retention period is based on the original sandbox creation date and is not extended or reset by subsequent resumes. Attempting to resume a sandbox that was deleted or does not exist will result in a `NotFoundError` (JavaScript SDK) or `NotFoundException` (Python SDK).
\ No newline at end of file
diff --git a/apps/web/src/app/(docs)/mintlify-docs/sandbox/rate-limits/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/sandbox/rate-limits/index.mdx
new file mode 100644
index 0000000000..2f975eb177
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/sandbox/rate-limits/index.mdx
@@ -0,0 +1,128 @@
+---
+title: "Rate Limits"
+sidebarTitle: "Rate limits"
+---
+
+This page describes API and sandbox rate limits of the E2B platform.
+
+## Table of Contents
+
+- [Sandbox lifecycle & management API](##sandbox-lifecycle-%26-management-api)
+- [Sandbox operations & requests to sandboxes](#sandbox-operations-%26-requests-to-sandboxes)
+- [Concurrent Sandboxes](#concurrent-sandboxes)
+- [Sandbox creation rate](#sandbox-creation-rate)
+- [Reaching limits](#reaching-limits)
+- [Increasing and avoiding rate limits](#increasing-and-avoiding-rate-limits)
+
+Here's a limits breakdown table based on the plan:
+
+
+
+
+
+
+ * Pro plan default is 100 concurrent sandboxes. Higher concurrency up to 1,100 is available as a separate addon that can be purchased.
+
+
+---
+
+## Sandbox lifecycle & 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 & 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.
+
+
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** + +
+Can go up to 1,100 with a separate addon available for purchase.
+
+
+
+### 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**
+
+## 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 addons) 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.
+After the number of running sandboxes drops below 100 or you purchase the concurrency addon, you'll be able to create new sandboxes again.
+
+## Increasing and avoiding rate limits
+
+You can avoid rate limits by either increasing your plan 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/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.0/auth/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.0/auth/index.mdx
new file mode 100644
index 0000000000..3062eb5af8
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.0/auth/index.mdx
@@ -0,0 +1,62 @@
+---
+title: Auth
+---
+
+## e2b auth
+
+
+authentication commands
+
+##### Usage
+
+```bash
+e2b auth [options] [command]
+```
+## e2b auth login
+
+
+log in to CLI
+
+##### Usage
+
+```bash
+e2b auth login [options]
+```
+
+
+## e2b auth logout
+
+
+log out of CLI
+
+##### Usage
+
+```bash
+e2b auth logout [options]
+```
+
+
+## e2b auth info
+
+
+get information about the current user
+
+##### Usage
+
+```bash
+e2b auth info [options]
+```
+
+
+## e2b auth configure
+
+
+configure user
+
+##### Usage
+
+```bash
+e2b auth configure [options]
+```
+
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.0/sandbox/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.0/sandbox/index.mdx
new file mode 100644
index 0000000000..ec8e950a46
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.0/sandbox/index.mdx
@@ -0,0 +1,93 @@
+---
+title: Sandbox
+---
+
+## e2b sandbox
+
+
+work with sandboxes
+
+##### Usage
+
+```bash
+e2b sandbox [options] [command]
+```
+## e2b sandbox connect
+
+
+connect terminal to already running sandbox
+
+##### Usage
+
+```bash
+e2b sandbox connect [options]
+```
+
+
+## e2b sandbox list
+
+
+list all running sandboxes
+
+##### Usage
+
+```bash
+e2b sandbox list [options]
+```
+
+
+## e2b sandbox kill
+
+
+kill sandbox
+
+##### Usage
+
+```bash
+e2b sandbox kill [options] [sandboxID]
+```
+
+##### Options
+
+
+ - `-a, --all: kill all running sandboxes `
+
+
+## e2b sandbox spawn
+
+
+spawn sandbox and connect terminal to it
+
+##### Usage
+
+```bash
+e2b sandbox spawn [options] [template]
+```
+
+##### Options
+
+
+ - `-p, --path : change root directory where command is executed to directory `
+ - `--config : specify path to the E2B config toml. By default E2B tries to find ./e2b.toml in root directory. `
+
+
+## e2b sandbox logs
+
+
+show logs for sandbox
+
+##### Usage
+
+```bash
+e2b sandbox logs [options]
+```
+
+##### Options
+
+
+ - `--level : filter logs by level (DEBUG, INFO, WARN, ERROR). The logs with the higher levels will be also shown. [default: INFO]`
+ - `-f, --follow: keep streaming logs until the sandbox is closed `
+ - `--format : specify format for printing logs (json, pretty) [default: pretty]`
+ - `--loggers [loggers]: filter logs by loggers. Specify multiple loggers by separating them with a comma. `
+
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.0/template/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.0/template/index.mdx
new file mode 100644
index 0000000000..1a03bda563
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.0/template/index.mdx
@@ -0,0 +1,94 @@
+---
+title: Template
+---
+
+## e2b template
+
+
+manage sandbox templates
+
+##### Usage
+
+```bash
+e2b template [options] [command]
+```
+## e2b template build
+
+
+build sandbox template defined by ./e2b.Dockerfile or ./Dockerfile in root directory. By default the root directory is the current working directory. This command also creates e2b.toml config.
+
+##### Usage
+
+```bash
+e2b template build [options] [template]
+```
+
+##### Options
+
+
+ - `-p, --path : change root directory where command is executed to directory `
+ - `-d, --dockerfile : specify path to Dockerfile. By default E2B tries to find e2b.Dockerfile or Dockerfile in root directory. `
+ - `-n, --name : specify sandbox template name. You can use the template name to start the sandbox with SDK. The template name must be lowercase and contain only letters, numbers, dashes and underscores. `
+ - `-c, --cmd : specify command that will be executed when the sandbox is started. `
+ - `-t, --team : specify the team ID that the operation will be associated with. You can find team ID in the team settings in the E2B dashboard (https://e2b.dev/dashboard?tab=team). `
+ - `--config : specify path to the E2B config toml. By default E2B tries to find ./e2b.toml in root directory. `
+ - `--cpu-count : specify the number of CPUs that will be used to run the sandbox. The default value is 2. `
+ - `--memory-mb : specify the amount of memory in megabytes that will be used to run the sandbox. Must be an even number. The default value is 512. `
+ - `--build-arg : specify additional build arguments for the build command. The format should be =. `
+
+
+## e2b template list
+
+
+list sandbox templates
+
+##### Usage
+
+```bash
+e2b template list [options]
+```
+
+##### Options
+
+
+ - `-t, --team : specify the team ID that the operation will be associated with. You can find team ID in the team settings in the E2B dashboard (https://e2b.dev/dashboard?tab=team). `
+
+
+## e2b template init
+
+
+create basic E2B Dockerfile (./e2b.Dockerfile) in root directory. You can then run e2b template build to build sandbox template from this Dockerfile
+
+##### Usage
+
+```bash
+e2b template init [options]
+```
+
+##### Options
+
+
+ - `-p, --path : change root directory where command is executed to directory `
+
+
+## e2b template delete
+
+
+delete sandbox template and e2b.toml config
+
+##### Usage
+
+```bash
+e2b template delete [options] [template]
+```
+
+##### Options
+
+
+ - `-p, --path : change root directory where command is executed to directory `
+ - `--config : specify path to the E2B config toml. By default E2B tries to find ./e2b.toml in root directory. `
+ - `-s, --select: select sandbox template from interactive list `
+ - `-t, --team : specify the team ID that the operation will be associated with. You can find team ID in the team settings in the E2B dashboard (https://e2b.dev/dashboard?tab=team). `
+ - `-y, --yes: skip manual delete confirmation `
+
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.1/auth/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.1/auth/index.mdx
new file mode 100644
index 0000000000..3062eb5af8
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.1/auth/index.mdx
@@ -0,0 +1,62 @@
+---
+title: Auth
+---
+
+## e2b auth
+
+
+authentication commands
+
+##### Usage
+
+```bash
+e2b auth [options] [command]
+```
+## e2b auth login
+
+
+log in to CLI
+
+##### Usage
+
+```bash
+e2b auth login [options]
+```
+
+
+## e2b auth logout
+
+
+log out of CLI
+
+##### Usage
+
+```bash
+e2b auth logout [options]
+```
+
+
+## e2b auth info
+
+
+get information about the current user
+
+##### Usage
+
+```bash
+e2b auth info [options]
+```
+
+
+## e2b auth configure
+
+
+configure user
+
+##### Usage
+
+```bash
+e2b auth configure [options]
+```
+
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.1/sandbox/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.1/sandbox/index.mdx
new file mode 100644
index 0000000000..ec8e950a46
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.1/sandbox/index.mdx
@@ -0,0 +1,93 @@
+---
+title: Sandbox
+---
+
+## e2b sandbox
+
+
+work with sandboxes
+
+##### Usage
+
+```bash
+e2b sandbox [options] [command]
+```
+## e2b sandbox connect
+
+
+connect terminal to already running sandbox
+
+##### Usage
+
+```bash
+e2b sandbox connect [options]
+```
+
+
+## e2b sandbox list
+
+
+list all running sandboxes
+
+##### Usage
+
+```bash
+e2b sandbox list [options]
+```
+
+
+## e2b sandbox kill
+
+
+kill sandbox
+
+##### Usage
+
+```bash
+e2b sandbox kill [options] [sandboxID]
+```
+
+##### Options
+
+
+ - `-a, --all: kill all running sandboxes `
+
+
+## e2b sandbox spawn
+
+
+spawn sandbox and connect terminal to it
+
+##### Usage
+
+```bash
+e2b sandbox spawn [options] [template]
+```
+
+##### Options
+
+
+ - `-p, --path : change root directory where command is executed to directory `
+ - `--config : specify path to the E2B config toml. By default E2B tries to find ./e2b.toml in root directory. `
+
+
+## e2b sandbox logs
+
+
+show logs for sandbox
+
+##### Usage
+
+```bash
+e2b sandbox logs [options]
+```
+
+##### Options
+
+
+ - `--level : filter logs by level (DEBUG, INFO, WARN, ERROR). The logs with the higher levels will be also shown. [default: INFO]`
+ - `-f, --follow: keep streaming logs until the sandbox is closed `
+ - `--format : specify format for printing logs (json, pretty) [default: pretty]`
+ - `--loggers [loggers]: filter logs by loggers. Specify multiple loggers by separating them with a comma. `
+
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.1/template/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.1/template/index.mdx
new file mode 100644
index 0000000000..1a03bda563
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.1/template/index.mdx
@@ -0,0 +1,94 @@
+---
+title: Template
+---
+
+## e2b template
+
+
+manage sandbox templates
+
+##### Usage
+
+```bash
+e2b template [options] [command]
+```
+## e2b template build
+
+
+build sandbox template defined by ./e2b.Dockerfile or ./Dockerfile in root directory. By default the root directory is the current working directory. This command also creates e2b.toml config.
+
+##### Usage
+
+```bash
+e2b template build [options] [template]
+```
+
+##### Options
+
+
+ - `-p, --path : change root directory where command is executed to directory `
+ - `-d, --dockerfile : specify path to Dockerfile. By default E2B tries to find e2b.Dockerfile or Dockerfile in root directory. `
+ - `-n, --name : specify sandbox template name. You can use the template name to start the sandbox with SDK. The template name must be lowercase and contain only letters, numbers, dashes and underscores. `
+ - `-c, --cmd : specify command that will be executed when the sandbox is started. `
+ - `-t, --team : specify the team ID that the operation will be associated with. You can find team ID in the team settings in the E2B dashboard (https://e2b.dev/dashboard?tab=team). `
+ - `--config : specify path to the E2B config toml. By default E2B tries to find ./e2b.toml in root directory. `
+ - `--cpu-count : specify the number of CPUs that will be used to run the sandbox. The default value is 2. `
+ - `--memory-mb : specify the amount of memory in megabytes that will be used to run the sandbox. Must be an even number. The default value is 512. `
+ - `--build-arg : specify additional build arguments for the build command. The format should be =. `
+
+
+## e2b template list
+
+
+list sandbox templates
+
+##### Usage
+
+```bash
+e2b template list [options]
+```
+
+##### Options
+
+
+ - `-t, --team : specify the team ID that the operation will be associated with. You can find team ID in the team settings in the E2B dashboard (https://e2b.dev/dashboard?tab=team). `
+
+
+## e2b template init
+
+
+create basic E2B Dockerfile (./e2b.Dockerfile) in root directory. You can then run e2b template build to build sandbox template from this Dockerfile
+
+##### Usage
+
+```bash
+e2b template init [options]
+```
+
+##### Options
+
+
+ - `-p, --path : change root directory where command is executed to directory `
+
+
+## e2b template delete
+
+
+delete sandbox template and e2b.toml config
+
+##### Usage
+
+```bash
+e2b template delete [options] [template]
+```
+
+##### Options
+
+
+ - `-p, --path : change root directory where command is executed to directory `
+ - `--config : specify path to the E2B config toml. By default E2B tries to find ./e2b.toml in root directory. `
+ - `-s, --select: select sandbox template from interactive list `
+ - `-t, --team : specify the team ID that the operation will be associated with. You can find team ID in the team settings in the E2B dashboard (https://e2b.dev/dashboard?tab=team). `
+ - `-y, --yes: skip manual delete confirmation `
+
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.10/auth/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.10/auth/index.mdx
new file mode 100644
index 0000000000..3062eb5af8
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.10/auth/index.mdx
@@ -0,0 +1,62 @@
+---
+title: Auth
+---
+
+## e2b auth
+
+
+authentication commands
+
+##### Usage
+
+```bash
+e2b auth [options] [command]
+```
+## e2b auth login
+
+
+log in to CLI
+
+##### Usage
+
+```bash
+e2b auth login [options]
+```
+
+
+## e2b auth logout
+
+
+log out of CLI
+
+##### Usage
+
+```bash
+e2b auth logout [options]
+```
+
+
+## e2b auth info
+
+
+get information about the current user
+
+##### Usage
+
+```bash
+e2b auth info [options]
+```
+
+
+## e2b auth configure
+
+
+configure user
+
+##### Usage
+
+```bash
+e2b auth configure [options]
+```
+
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.10/sandbox/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.10/sandbox/index.mdx
new file mode 100644
index 0000000000..ec8e950a46
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.10/sandbox/index.mdx
@@ -0,0 +1,93 @@
+---
+title: Sandbox
+---
+
+## e2b sandbox
+
+
+work with sandboxes
+
+##### Usage
+
+```bash
+e2b sandbox [options] [command]
+```
+## e2b sandbox connect
+
+
+connect terminal to already running sandbox
+
+##### Usage
+
+```bash
+e2b sandbox connect [options]
+```
+
+
+## e2b sandbox list
+
+
+list all running sandboxes
+
+##### Usage
+
+```bash
+e2b sandbox list [options]
+```
+
+
+## e2b sandbox kill
+
+
+kill sandbox
+
+##### Usage
+
+```bash
+e2b sandbox kill [options] [sandboxID]
+```
+
+##### Options
+
+
+ - `-a, --all: kill all running sandboxes `
+
+
+## e2b sandbox spawn
+
+
+spawn sandbox and connect terminal to it
+
+##### Usage
+
+```bash
+e2b sandbox spawn [options] [template]
+```
+
+##### Options
+
+
+ - `-p, --path : change root directory where command is executed to directory `
+ - `--config : specify path to the E2B config toml. By default E2B tries to find ./e2b.toml in root directory. `
+
+
+## e2b sandbox logs
+
+
+show logs for sandbox
+
+##### Usage
+
+```bash
+e2b sandbox logs [options]
+```
+
+##### Options
+
+
+ - `--level : filter logs by level (DEBUG, INFO, WARN, ERROR). The logs with the higher levels will be also shown. [default: INFO]`
+ - `-f, --follow: keep streaming logs until the sandbox is closed `
+ - `--format : specify format for printing logs (json, pretty) [default: pretty]`
+ - `--loggers [loggers]: filter logs by loggers. Specify multiple loggers by separating them with a comma. `
+
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.10/template/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.10/template/index.mdx
new file mode 100644
index 0000000000..b121c54831
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.10/template/index.mdx
@@ -0,0 +1,136 @@
+---
+title: Template
+---
+
+## e2b template
+
+
+manage sandbox templates
+
+##### Usage
+
+```bash
+e2b template [options] [command]
+```
+## e2b template build
+
+
+build sandbox template defined by ./e2b.Dockerfile or ./Dockerfile in root directory. By default the root directory is the current working directory. This command also creates e2b.toml config.
+
+##### Usage
+
+```bash
+e2b template build [options] [template]
+```
+
+##### Options
+
+
+ - `-p, --path : change root directory where command is executed to directory `
+ - `-d, --dockerfile : specify path to Dockerfile. By default E2B tries to find e2b.Dockerfile or Dockerfile in root directory. `
+ - `-n, --name : specify sandbox template name. You can use the template name to start the sandbox with SDK. The template name must be lowercase and contain only letters, numbers, dashes and underscores. `
+ - `-c, --cmd : specify command that will be executed when the sandbox is started. `
+ - `-t, --team : specify the team ID that the operation will be associated with. You can find team ID in the team settings in the E2B dashboard (https://e2b.dev/dashboard?tab=team). `
+ - `--config : specify path to the E2B config toml. By default E2B tries to find ./e2b.toml in root directory. `
+ - `--cpu-count : specify the number of CPUs that will be used to run the sandbox. The default value is 2. `
+ - `--memory-mb : specify the amount of memory in megabytes that will be used to run the sandbox. Must be an even number. The default value is 512. `
+ - `--build-arg : specify additional build arguments for the build command. The format should be =. `
+
+
+## e2b template list
+
+
+list sandbox templates
+
+##### Usage
+
+```bash
+e2b template list [options]
+```
+
+##### Options
+
+
+ - `-t, --team : specify the team ID that the operation will be associated with. You can find team ID in the team settings in the E2B dashboard (https://e2b.dev/dashboard?tab=team). `
+
+
+## e2b template init
+
+
+create basic E2B Dockerfile (./e2b.Dockerfile) in root directory. You can then run e2b template build to build sandbox template from this Dockerfile
+
+##### Usage
+
+```bash
+e2b template init [options]
+```
+
+##### Options
+
+
+ - `-p, --path : change root directory where command is executed to directory `
+
+
+## e2b template delete
+
+
+delete sandbox template and e2b.toml config
+
+##### Usage
+
+```bash
+e2b template delete [options] [template]
+```
+
+##### Options
+
+
+ - `-p, --path : change root directory where command is executed to directory `
+ - `--config : specify path to the E2B config toml. By default E2B tries to find ./e2b.toml in root directory. `
+ - `-s, --select: select sandbox template from interactive list `
+ - `-t, --team : specify the team ID that the operation will be associated with. You can find team ID in the team settings in the E2B dashboard (https://e2b.dev/dashboard?tab=team). `
+ - `-y, --yes: skip manual delete confirmation `
+
+
+## e2b template publish
+
+
+publish sandbox template
+
+##### Usage
+
+```bash
+e2b template publish [options] [template]
+```
+
+##### Options
+
+
+ - `-p, --path : change root directory where command is executed to directory `
+ - `--config : specify path to the E2B config toml. By default E2B tries to find ./e2b.toml in root directory. `
+ - `-s, --select: select sandbox template from interactive list `
+ - `-t, --team : specify the team ID that the operation will be associated with. You can find team ID in the team settings in the E2B dashboard (https://e2b.dev/dashboard?tab=team). `
+ - `-y, --yes: skip manual publish confirmation `
+
+
+## e2b template unpublish
+
+
+unpublish sandbox template
+
+##### Usage
+
+```bash
+e2b template unpublish [options] [template]
+```
+
+##### Options
+
+
+ - `-p, --path : change root directory where command is executed to directory `
+ - `--config : specify path to the E2B config toml. By default E2B tries to find ./e2b.toml in root directory. `
+ - `-s, --select: select sandbox template from interactive list `
+ - `-t, --team : specify the team ID that the operation will be associated with. You can find team ID in the team settings in the E2B dashboard (https://e2b.dev/dashboard?tab=team). `
+ - `-y, --yes: skip manual unpublish confirmation `
+
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.2/auth/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.2/auth/index.mdx
new file mode 100644
index 0000000000..3062eb5af8
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.2/auth/index.mdx
@@ -0,0 +1,62 @@
+---
+title: Auth
+---
+
+## e2b auth
+
+
+authentication commands
+
+##### Usage
+
+```bash
+e2b auth [options] [command]
+```
+## e2b auth login
+
+
+log in to CLI
+
+##### Usage
+
+```bash
+e2b auth login [options]
+```
+
+
+## e2b auth logout
+
+
+log out of CLI
+
+##### Usage
+
+```bash
+e2b auth logout [options]
+```
+
+
+## e2b auth info
+
+
+get information about the current user
+
+##### Usage
+
+```bash
+e2b auth info [options]
+```
+
+
+## e2b auth configure
+
+
+configure user
+
+##### Usage
+
+```bash
+e2b auth configure [options]
+```
+
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.2/sandbox/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.2/sandbox/index.mdx
new file mode 100644
index 0000000000..ec8e950a46
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.2/sandbox/index.mdx
@@ -0,0 +1,93 @@
+---
+title: Sandbox
+---
+
+## e2b sandbox
+
+
+work with sandboxes
+
+##### Usage
+
+```bash
+e2b sandbox [options] [command]
+```
+## e2b sandbox connect
+
+
+connect terminal to already running sandbox
+
+##### Usage
+
+```bash
+e2b sandbox connect [options]
+```
+
+
+## e2b sandbox list
+
+
+list all running sandboxes
+
+##### Usage
+
+```bash
+e2b sandbox list [options]
+```
+
+
+## e2b sandbox kill
+
+
+kill sandbox
+
+##### Usage
+
+```bash
+e2b sandbox kill [options] [sandboxID]
+```
+
+##### Options
+
+
+ - `-a, --all: kill all running sandboxes `
+
+
+## e2b sandbox spawn
+
+
+spawn sandbox and connect terminal to it
+
+##### Usage
+
+```bash
+e2b sandbox spawn [options] [template]
+```
+
+##### Options
+
+
+ - `-p, --path : change root directory where command is executed to directory `
+ - `--config : specify path to the E2B config toml. By default E2B tries to find ./e2b.toml in root directory. `
+
+
+## e2b sandbox logs
+
+
+show logs for sandbox
+
+##### Usage
+
+```bash
+e2b sandbox logs [options]
+```
+
+##### Options
+
+
+ - `--level : filter logs by level (DEBUG, INFO, WARN, ERROR). The logs with the higher levels will be also shown. [default: INFO]`
+ - `-f, --follow: keep streaming logs until the sandbox is closed `
+ - `--format : specify format for printing logs (json, pretty) [default: pretty]`
+ - `--loggers [loggers]: filter logs by loggers. Specify multiple loggers by separating them with a comma. `
+
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.2/template/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.2/template/index.mdx
new file mode 100644
index 0000000000..1a03bda563
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.2/template/index.mdx
@@ -0,0 +1,94 @@
+---
+title: Template
+---
+
+## e2b template
+
+
+manage sandbox templates
+
+##### Usage
+
+```bash
+e2b template [options] [command]
+```
+## e2b template build
+
+
+build sandbox template defined by ./e2b.Dockerfile or ./Dockerfile in root directory. By default the root directory is the current working directory. This command also creates e2b.toml config.
+
+##### Usage
+
+```bash
+e2b template build [options] [template]
+```
+
+##### Options
+
+
+ - `-p, --path : change root directory where command is executed to directory `
+ - `-d, --dockerfile : specify path to Dockerfile. By default E2B tries to find e2b.Dockerfile or Dockerfile in root directory. `
+ - `-n, --name : specify sandbox template name. You can use the template name to start the sandbox with SDK. The template name must be lowercase and contain only letters, numbers, dashes and underscores. `
+ - `-c, --cmd : specify command that will be executed when the sandbox is started. `
+ - `-t, --team : specify the team ID that the operation will be associated with. You can find team ID in the team settings in the E2B dashboard (https://e2b.dev/dashboard?tab=team). `
+ - `--config : specify path to the E2B config toml. By default E2B tries to find ./e2b.toml in root directory. `
+ - `--cpu-count : specify the number of CPUs that will be used to run the sandbox. The default value is 2. `
+ - `--memory-mb : specify the amount of memory in megabytes that will be used to run the sandbox. Must be an even number. The default value is 512. `
+ - `--build-arg : specify additional build arguments for the build command. The format should be =. `
+
+
+## e2b template list
+
+
+list sandbox templates
+
+##### Usage
+
+```bash
+e2b template list [options]
+```
+
+##### Options
+
+
+ - `-t, --team : specify the team ID that the operation will be associated with. You can find team ID in the team settings in the E2B dashboard (https://e2b.dev/dashboard?tab=team). `
+
+
+## e2b template init
+
+
+create basic E2B Dockerfile (./e2b.Dockerfile) in root directory. You can then run e2b template build to build sandbox template from this Dockerfile
+
+##### Usage
+
+```bash
+e2b template init [options]
+```
+
+##### Options
+
+
+ - `-p, --path : change root directory where command is executed to directory `
+
+
+## e2b template delete
+
+
+delete sandbox template and e2b.toml config
+
+##### Usage
+
+```bash
+e2b template delete [options] [template]
+```
+
+##### Options
+
+
+ - `-p, --path : change root directory where command is executed to directory `
+ - `--config : specify path to the E2B config toml. By default E2B tries to find ./e2b.toml in root directory. `
+ - `-s, --select: select sandbox template from interactive list `
+ - `-t, --team : specify the team ID that the operation will be associated with. You can find team ID in the team settings in the E2B dashboard (https://e2b.dev/dashboard?tab=team). `
+ - `-y, --yes: skip manual delete confirmation `
+
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.3/auth/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.3/auth/index.mdx
new file mode 100644
index 0000000000..3062eb5af8
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.3/auth/index.mdx
@@ -0,0 +1,62 @@
+---
+title: Auth
+---
+
+## e2b auth
+
+
+authentication commands
+
+##### Usage
+
+```bash
+e2b auth [options] [command]
+```
+## e2b auth login
+
+
+log in to CLI
+
+##### Usage
+
+```bash
+e2b auth login [options]
+```
+
+
+## e2b auth logout
+
+
+log out of CLI
+
+##### Usage
+
+```bash
+e2b auth logout [options]
+```
+
+
+## e2b auth info
+
+
+get information about the current user
+
+##### Usage
+
+```bash
+e2b auth info [options]
+```
+
+
+## e2b auth configure
+
+
+configure user
+
+##### Usage
+
+```bash
+e2b auth configure [options]
+```
+
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.3/sandbox/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.3/sandbox/index.mdx
new file mode 100644
index 0000000000..ec8e950a46
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.3/sandbox/index.mdx
@@ -0,0 +1,93 @@
+---
+title: Sandbox
+---
+
+## e2b sandbox
+
+
+work with sandboxes
+
+##### Usage
+
+```bash
+e2b sandbox [options] [command]
+```
+## e2b sandbox connect
+
+
+connect terminal to already running sandbox
+
+##### Usage
+
+```bash
+e2b sandbox connect [options]
+```
+
+
+## e2b sandbox list
+
+
+list all running sandboxes
+
+##### Usage
+
+```bash
+e2b sandbox list [options]
+```
+
+
+## e2b sandbox kill
+
+
+kill sandbox
+
+##### Usage
+
+```bash
+e2b sandbox kill [options] [sandboxID]
+```
+
+##### Options
+
+
+ - `-a, --all: kill all running sandboxes `
+
+
+## e2b sandbox spawn
+
+
+spawn sandbox and connect terminal to it
+
+##### Usage
+
+```bash
+e2b sandbox spawn [options] [template]
+```
+
+##### Options
+
+
+ - `-p, --path : change root directory where command is executed to directory `
+ - `--config : specify path to the E2B config toml. By default E2B tries to find ./e2b.toml in root directory. `
+
+
+## e2b sandbox logs
+
+
+show logs for sandbox
+
+##### Usage
+
+```bash
+e2b sandbox logs [options]
+```
+
+##### Options
+
+
+ - `--level : filter logs by level (DEBUG, INFO, WARN, ERROR). The logs with the higher levels will be also shown. [default: INFO]`
+ - `-f, --follow: keep streaming logs until the sandbox is closed `
+ - `--format : specify format for printing logs (json, pretty) [default: pretty]`
+ - `--loggers [loggers]: filter logs by loggers. Specify multiple loggers by separating them with a comma. `
+
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.3/template/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.3/template/index.mdx
new file mode 100644
index 0000000000..1a03bda563
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.3/template/index.mdx
@@ -0,0 +1,94 @@
+---
+title: Template
+---
+
+## e2b template
+
+
+manage sandbox templates
+
+##### Usage
+
+```bash
+e2b template [options] [command]
+```
+## e2b template build
+
+
+build sandbox template defined by ./e2b.Dockerfile or ./Dockerfile in root directory. By default the root directory is the current working directory. This command also creates e2b.toml config.
+
+##### Usage
+
+```bash
+e2b template build [options] [template]
+```
+
+##### Options
+
+
+ - `-p, --path : change root directory where command is executed to directory `
+ - `-d, --dockerfile : specify path to Dockerfile. By default E2B tries to find e2b.Dockerfile or Dockerfile in root directory. `
+ - `-n, --name : specify sandbox template name. You can use the template name to start the sandbox with SDK. The template name must be lowercase and contain only letters, numbers, dashes and underscores. `
+ - `-c, --cmd : specify command that will be executed when the sandbox is started. `
+ - `-t, --team : specify the team ID that the operation will be associated with. You can find team ID in the team settings in the E2B dashboard (https://e2b.dev/dashboard?tab=team). `
+ - `--config : specify path to the E2B config toml. By default E2B tries to find ./e2b.toml in root directory. `
+ - `--cpu-count : specify the number of CPUs that will be used to run the sandbox. The default value is 2. `
+ - `--memory-mb : specify the amount of memory in megabytes that will be used to run the sandbox. Must be an even number. The default value is 512. `
+ - `--build-arg : specify additional build arguments for the build command. The format should be =. `
+
+
+## e2b template list
+
+
+list sandbox templates
+
+##### Usage
+
+```bash
+e2b template list [options]
+```
+
+##### Options
+
+
+ - `-t, --team : specify the team ID that the operation will be associated with. You can find team ID in the team settings in the E2B dashboard (https://e2b.dev/dashboard?tab=team). `
+
+
+## e2b template init
+
+
+create basic E2B Dockerfile (./e2b.Dockerfile) in root directory. You can then run e2b template build to build sandbox template from this Dockerfile
+
+##### Usage
+
+```bash
+e2b template init [options]
+```
+
+##### Options
+
+
+ - `-p, --path : change root directory where command is executed to directory `
+
+
+## e2b template delete
+
+
+delete sandbox template and e2b.toml config
+
+##### Usage
+
+```bash
+e2b template delete [options] [template]
+```
+
+##### Options
+
+
+ - `-p, --path : change root directory where command is executed to directory `
+ - `--config : specify path to the E2B config toml. By default E2B tries to find ./e2b.toml in root directory. `
+ - `-s, --select: select sandbox template from interactive list `
+ - `-t, --team : specify the team ID that the operation will be associated with. You can find team ID in the team settings in the E2B dashboard (https://e2b.dev/dashboard?tab=team). `
+ - `-y, --yes: skip manual delete confirmation `
+
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.4/auth/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.4/auth/index.mdx
new file mode 100644
index 0000000000..3062eb5af8
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.4/auth/index.mdx
@@ -0,0 +1,62 @@
+---
+title: Auth
+---
+
+## e2b auth
+
+
+authentication commands
+
+##### Usage
+
+```bash
+e2b auth [options] [command]
+```
+## e2b auth login
+
+
+log in to CLI
+
+##### Usage
+
+```bash
+e2b auth login [options]
+```
+
+
+## e2b auth logout
+
+
+log out of CLI
+
+##### Usage
+
+```bash
+e2b auth logout [options]
+```
+
+
+## e2b auth info
+
+
+get information about the current user
+
+##### Usage
+
+```bash
+e2b auth info [options]
+```
+
+
+## e2b auth configure
+
+
+configure user
+
+##### Usage
+
+```bash
+e2b auth configure [options]
+```
+
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.4/sandbox/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.4/sandbox/index.mdx
new file mode 100644
index 0000000000..ec8e950a46
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.4/sandbox/index.mdx
@@ -0,0 +1,93 @@
+---
+title: Sandbox
+---
+
+## e2b sandbox
+
+
+work with sandboxes
+
+##### Usage
+
+```bash
+e2b sandbox [options] [command]
+```
+## e2b sandbox connect
+
+
+connect terminal to already running sandbox
+
+##### Usage
+
+```bash
+e2b sandbox connect [options]
+```
+
+
+## e2b sandbox list
+
+
+list all running sandboxes
+
+##### Usage
+
+```bash
+e2b sandbox list [options]
+```
+
+
+## e2b sandbox kill
+
+
+kill sandbox
+
+##### Usage
+
+```bash
+e2b sandbox kill [options] [sandboxID]
+```
+
+##### Options
+
+
+ - `-a, --all: kill all running sandboxes `
+
+
+## e2b sandbox spawn
+
+
+spawn sandbox and connect terminal to it
+
+##### Usage
+
+```bash
+e2b sandbox spawn [options] [template]
+```
+
+##### Options
+
+
+ - `-p, --path : change root directory where command is executed to directory `
+ - `--config : specify path to the E2B config toml. By default E2B tries to find ./e2b.toml in root directory. `
+
+
+## e2b sandbox logs
+
+
+show logs for sandbox
+
+##### Usage
+
+```bash
+e2b sandbox logs [options]
+```
+
+##### Options
+
+
+ - `--level : filter logs by level (DEBUG, INFO, WARN, ERROR). The logs with the higher levels will be also shown. [default: INFO]`
+ - `-f, --follow: keep streaming logs until the sandbox is closed `
+ - `--format : specify format for printing logs (json, pretty) [default: pretty]`
+ - `--loggers [loggers]: filter logs by loggers. Specify multiple loggers by separating them with a comma. `
+
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.4/template/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.4/template/index.mdx
new file mode 100644
index 0000000000..1a03bda563
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.4/template/index.mdx
@@ -0,0 +1,94 @@
+---
+title: Template
+---
+
+## e2b template
+
+
+manage sandbox templates
+
+##### Usage
+
+```bash
+e2b template [options] [command]
+```
+## e2b template build
+
+
+build sandbox template defined by ./e2b.Dockerfile or ./Dockerfile in root directory. By default the root directory is the current working directory. This command also creates e2b.toml config.
+
+##### Usage
+
+```bash
+e2b template build [options] [template]
+```
+
+##### Options
+
+
+ - `-p, --path : change root directory where command is executed to directory `
+ - `-d, --dockerfile : specify path to Dockerfile. By default E2B tries to find e2b.Dockerfile or Dockerfile in root directory. `
+ - `-n, --name : specify sandbox template name. You can use the template name to start the sandbox with SDK. The template name must be lowercase and contain only letters, numbers, dashes and underscores. `
+ - `-c, --cmd : specify command that will be executed when the sandbox is started. `
+ - `-t, --team : specify the team ID that the operation will be associated with. You can find team ID in the team settings in the E2B dashboard (https://e2b.dev/dashboard?tab=team). `
+ - `--config : specify path to the E2B config toml. By default E2B tries to find ./e2b.toml in root directory. `
+ - `--cpu-count : specify the number of CPUs that will be used to run the sandbox. The default value is 2. `
+ - `--memory-mb : specify the amount of memory in megabytes that will be used to run the sandbox. Must be an even number. The default value is 512. `
+ - `--build-arg : specify additional build arguments for the build command. The format should be =. `
+
+
+## e2b template list
+
+
+list sandbox templates
+
+##### Usage
+
+```bash
+e2b template list [options]
+```
+
+##### Options
+
+
+ - `-t, --team : specify the team ID that the operation will be associated with. You can find team ID in the team settings in the E2B dashboard (https://e2b.dev/dashboard?tab=team). `
+
+
+## e2b template init
+
+
+create basic E2B Dockerfile (./e2b.Dockerfile) in root directory. You can then run e2b template build to build sandbox template from this Dockerfile
+
+##### Usage
+
+```bash
+e2b template init [options]
+```
+
+##### Options
+
+
+ - `-p, --path : change root directory where command is executed to directory `
+
+
+## e2b template delete
+
+
+delete sandbox template and e2b.toml config
+
+##### Usage
+
+```bash
+e2b template delete [options] [template]
+```
+
+##### Options
+
+
+ - `-p, --path : change root directory where command is executed to directory `
+ - `--config : specify path to the E2B config toml. By default E2B tries to find ./e2b.toml in root directory. `
+ - `-s, --select: select sandbox template from interactive list `
+ - `-t, --team : specify the team ID that the operation will be associated with. You can find team ID in the team settings in the E2B dashboard (https://e2b.dev/dashboard?tab=team). `
+ - `-y, --yes: skip manual delete confirmation `
+
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.5/auth/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.5/auth/index.mdx
new file mode 100644
index 0000000000..3062eb5af8
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.5/auth/index.mdx
@@ -0,0 +1,62 @@
+---
+title: Auth
+---
+
+## e2b auth
+
+
+authentication commands
+
+##### Usage
+
+```bash
+e2b auth [options] [command]
+```
+## e2b auth login
+
+
+log in to CLI
+
+##### Usage
+
+```bash
+e2b auth login [options]
+```
+
+
+## e2b auth logout
+
+
+log out of CLI
+
+##### Usage
+
+```bash
+e2b auth logout [options]
+```
+
+
+## e2b auth info
+
+
+get information about the current user
+
+##### Usage
+
+```bash
+e2b auth info [options]
+```
+
+
+## e2b auth configure
+
+
+configure user
+
+##### Usage
+
+```bash
+e2b auth configure [options]
+```
+
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.5/sandbox/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.5/sandbox/index.mdx
new file mode 100644
index 0000000000..ec8e950a46
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.5/sandbox/index.mdx
@@ -0,0 +1,93 @@
+---
+title: Sandbox
+---
+
+## e2b sandbox
+
+
+work with sandboxes
+
+##### Usage
+
+```bash
+e2b sandbox [options] [command]
+```
+## e2b sandbox connect
+
+
+connect terminal to already running sandbox
+
+##### Usage
+
+```bash
+e2b sandbox connect [options]
+```
+
+
+## e2b sandbox list
+
+
+list all running sandboxes
+
+##### Usage
+
+```bash
+e2b sandbox list [options]
+```
+
+
+## e2b sandbox kill
+
+
+kill sandbox
+
+##### Usage
+
+```bash
+e2b sandbox kill [options] [sandboxID]
+```
+
+##### Options
+
+
+ - `-a, --all: kill all running sandboxes `
+
+
+## e2b sandbox spawn
+
+
+spawn sandbox and connect terminal to it
+
+##### Usage
+
+```bash
+e2b sandbox spawn [options] [template]
+```
+
+##### Options
+
+
+ - `-p, --path : change root directory where command is executed to directory `
+ - `--config : specify path to the E2B config toml. By default E2B tries to find ./e2b.toml in root directory. `
+
+
+## e2b sandbox logs
+
+
+show logs for sandbox
+
+##### Usage
+
+```bash
+e2b sandbox logs [options]
+```
+
+##### Options
+
+
+ - `--level : filter logs by level (DEBUG, INFO, WARN, ERROR). The logs with the higher levels will be also shown. [default: INFO]`
+ - `-f, --follow: keep streaming logs until the sandbox is closed `
+ - `--format : specify format for printing logs (json, pretty) [default: pretty]`
+ - `--loggers [loggers]: filter logs by loggers. Specify multiple loggers by separating them with a comma. `
+
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.5/template/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.5/template/index.mdx
new file mode 100644
index 0000000000..1a03bda563
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.5/template/index.mdx
@@ -0,0 +1,94 @@
+---
+title: Template
+---
+
+## e2b template
+
+
+manage sandbox templates
+
+##### Usage
+
+```bash
+e2b template [options] [command]
+```
+## e2b template build
+
+
+build sandbox template defined by ./e2b.Dockerfile or ./Dockerfile in root directory. By default the root directory is the current working directory. This command also creates e2b.toml config.
+
+##### Usage
+
+```bash
+e2b template build [options] [template]
+```
+
+##### Options
+
+
+ - `-p, --path : change root directory where command is executed to directory `
+ - `-d, --dockerfile : specify path to Dockerfile. By default E2B tries to find e2b.Dockerfile or Dockerfile in root directory. `
+ - `-n, --name : specify sandbox template name. You can use the template name to start the sandbox with SDK. The template name must be lowercase and contain only letters, numbers, dashes and underscores. `
+ - `-c, --cmd : specify command that will be executed when the sandbox is started. `
+ - `-t, --team : specify the team ID that the operation will be associated with. You can find team ID in the team settings in the E2B dashboard (https://e2b.dev/dashboard?tab=team). `
+ - `--config : specify path to the E2B config toml. By default E2B tries to find ./e2b.toml in root directory. `
+ - `--cpu-count : specify the number of CPUs that will be used to run the sandbox. The default value is 2. `
+ - `--memory-mb : specify the amount of memory in megabytes that will be used to run the sandbox. Must be an even number. The default value is 512. `
+ - `--build-arg : specify additional build arguments for the build command. The format should be =. `
+
+
+## e2b template list
+
+
+list sandbox templates
+
+##### Usage
+
+```bash
+e2b template list [options]
+```
+
+##### Options
+
+
+ - `-t, --team : specify the team ID that the operation will be associated with. You can find team ID in the team settings in the E2B dashboard (https://e2b.dev/dashboard?tab=team). `
+
+
+## e2b template init
+
+
+create basic E2B Dockerfile (./e2b.Dockerfile) in root directory. You can then run e2b template build to build sandbox template from this Dockerfile
+
+##### Usage
+
+```bash
+e2b template init [options]
+```
+
+##### Options
+
+
+ - `-p, --path : change root directory where command is executed to directory `
+
+
+## e2b template delete
+
+
+delete sandbox template and e2b.toml config
+
+##### Usage
+
+```bash
+e2b template delete [options] [template]
+```
+
+##### Options
+
+
+ - `-p, --path : change root directory where command is executed to directory `
+ - `--config : specify path to the E2B config toml. By default E2B tries to find ./e2b.toml in root directory. `
+ - `-s, --select: select sandbox template from interactive list `
+ - `-t, --team : specify the team ID that the operation will be associated with. You can find team ID in the team settings in the E2B dashboard (https://e2b.dev/dashboard?tab=team). `
+ - `-y, --yes: skip manual delete confirmation `
+
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.6/auth/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.6/auth/index.mdx
new file mode 100644
index 0000000000..3062eb5af8
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.6/auth/index.mdx
@@ -0,0 +1,62 @@
+---
+title: Auth
+---
+
+## e2b auth
+
+
+authentication commands
+
+##### Usage
+
+```bash
+e2b auth [options] [command]
+```
+## e2b auth login
+
+
+log in to CLI
+
+##### Usage
+
+```bash
+e2b auth login [options]
+```
+
+
+## e2b auth logout
+
+
+log out of CLI
+
+##### Usage
+
+```bash
+e2b auth logout [options]
+```
+
+
+## e2b auth info
+
+
+get information about the current user
+
+##### Usage
+
+```bash
+e2b auth info [options]
+```
+
+
+## e2b auth configure
+
+
+configure user
+
+##### Usage
+
+```bash
+e2b auth configure [options]
+```
+
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.6/sandbox/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.6/sandbox/index.mdx
new file mode 100644
index 0000000000..ec8e950a46
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.6/sandbox/index.mdx
@@ -0,0 +1,93 @@
+---
+title: Sandbox
+---
+
+## e2b sandbox
+
+
+work with sandboxes
+
+##### Usage
+
+```bash
+e2b sandbox [options] [command]
+```
+## e2b sandbox connect
+
+
+connect terminal to already running sandbox
+
+##### Usage
+
+```bash
+e2b sandbox connect [options]
+```
+
+
+## e2b sandbox list
+
+
+list all running sandboxes
+
+##### Usage
+
+```bash
+e2b sandbox list [options]
+```
+
+
+## e2b sandbox kill
+
+
+kill sandbox
+
+##### Usage
+
+```bash
+e2b sandbox kill [options] [sandboxID]
+```
+
+##### Options
+
+
+ - `-a, --all: kill all running sandboxes `
+
+
+## e2b sandbox spawn
+
+
+spawn sandbox and connect terminal to it
+
+##### Usage
+
+```bash
+e2b sandbox spawn [options] [template]
+```
+
+##### Options
+
+
+ - `-p, --path : change root directory where command is executed to directory `
+ - `--config : specify path to the E2B config toml. By default E2B tries to find ./e2b.toml in root directory. `
+
+
+## e2b sandbox logs
+
+
+show logs for sandbox
+
+##### Usage
+
+```bash
+e2b sandbox logs [options]
+```
+
+##### Options
+
+
+ - `--level : filter logs by level (DEBUG, INFO, WARN, ERROR). The logs with the higher levels will be also shown. [default: INFO]`
+ - `-f, --follow: keep streaming logs until the sandbox is closed `
+ - `--format : specify format for printing logs (json, pretty) [default: pretty]`
+ - `--loggers [loggers]: filter logs by loggers. Specify multiple loggers by separating them with a comma. `
+
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.6/template/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.6/template/index.mdx
new file mode 100644
index 0000000000..1a03bda563
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.6/template/index.mdx
@@ -0,0 +1,94 @@
+---
+title: Template
+---
+
+## e2b template
+
+
+manage sandbox templates
+
+##### Usage
+
+```bash
+e2b template [options] [command]
+```
+## e2b template build
+
+
+build sandbox template defined by ./e2b.Dockerfile or ./Dockerfile in root directory. By default the root directory is the current working directory. This command also creates e2b.toml config.
+
+##### Usage
+
+```bash
+e2b template build [options] [template]
+```
+
+##### Options
+
+
+ - `-p, --path : change root directory where command is executed to directory `
+ - `-d, --dockerfile : specify path to Dockerfile. By default E2B tries to find e2b.Dockerfile or Dockerfile in root directory. `
+ - `-n, --name : specify sandbox template name. You can use the template name to start the sandbox with SDK. The template name must be lowercase and contain only letters, numbers, dashes and underscores. `
+ - `-c, --cmd : specify command that will be executed when the sandbox is started. `
+ - `-t, --team : specify the team ID that the operation will be associated with. You can find team ID in the team settings in the E2B dashboard (https://e2b.dev/dashboard?tab=team). `
+ - `--config : specify path to the E2B config toml. By default E2B tries to find ./e2b.toml in root directory. `
+ - `--cpu-count : specify the number of CPUs that will be used to run the sandbox. The default value is 2. `
+ - `--memory-mb : specify the amount of memory in megabytes that will be used to run the sandbox. Must be an even number. The default value is 512. `
+ - `--build-arg : specify additional build arguments for the build command. The format should be =. `
+
+
+## e2b template list
+
+
+list sandbox templates
+
+##### Usage
+
+```bash
+e2b template list [options]
+```
+
+##### Options
+
+
+ - `-t, --team : specify the team ID that the operation will be associated with. You can find team ID in the team settings in the E2B dashboard (https://e2b.dev/dashboard?tab=team). `
+
+
+## e2b template init
+
+
+create basic E2B Dockerfile (./e2b.Dockerfile) in root directory. You can then run e2b template build to build sandbox template from this Dockerfile
+
+##### Usage
+
+```bash
+e2b template init [options]
+```
+
+##### Options
+
+
+ - `-p, --path : change root directory where command is executed to directory `
+
+
+## e2b template delete
+
+
+delete sandbox template and e2b.toml config
+
+##### Usage
+
+```bash
+e2b template delete [options] [template]
+```
+
+##### Options
+
+
+ - `-p, --path : change root directory where command is executed to directory `
+ - `--config : specify path to the E2B config toml. By default E2B tries to find ./e2b.toml in root directory. `
+ - `-s, --select: select sandbox template from interactive list `
+ - `-t, --team : specify the team ID that the operation will be associated with. You can find team ID in the team settings in the E2B dashboard (https://e2b.dev/dashboard?tab=team). `
+ - `-y, --yes: skip manual delete confirmation `
+
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.7/auth/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.7/auth/index.mdx
new file mode 100644
index 0000000000..3062eb5af8
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.7/auth/index.mdx
@@ -0,0 +1,62 @@
+---
+title: Auth
+---
+
+## e2b auth
+
+
+authentication commands
+
+##### Usage
+
+```bash
+e2b auth [options] [command]
+```
+## e2b auth login
+
+
+log in to CLI
+
+##### Usage
+
+```bash
+e2b auth login [options]
+```
+
+
+## e2b auth logout
+
+
+log out of CLI
+
+##### Usage
+
+```bash
+e2b auth logout [options]
+```
+
+
+## e2b auth info
+
+
+get information about the current user
+
+##### Usage
+
+```bash
+e2b auth info [options]
+```
+
+
+## e2b auth configure
+
+
+configure user
+
+##### Usage
+
+```bash
+e2b auth configure [options]
+```
+
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.7/sandbox/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.7/sandbox/index.mdx
new file mode 100644
index 0000000000..ec8e950a46
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.7/sandbox/index.mdx
@@ -0,0 +1,93 @@
+---
+title: Sandbox
+---
+
+## e2b sandbox
+
+
+work with sandboxes
+
+##### Usage
+
+```bash
+e2b sandbox [options] [command]
+```
+## e2b sandbox connect
+
+
+connect terminal to already running sandbox
+
+##### Usage
+
+```bash
+e2b sandbox connect [options]
+```
+
+
+## e2b sandbox list
+
+
+list all running sandboxes
+
+##### Usage
+
+```bash
+e2b sandbox list [options]
+```
+
+
+## e2b sandbox kill
+
+
+kill sandbox
+
+##### Usage
+
+```bash
+e2b sandbox kill [options] [sandboxID]
+```
+
+##### Options
+
+
+ - `-a, --all: kill all running sandboxes `
+
+
+## e2b sandbox spawn
+
+
+spawn sandbox and connect terminal to it
+
+##### Usage
+
+```bash
+e2b sandbox spawn [options] [template]
+```
+
+##### Options
+
+
+ - `-p, --path : change root directory where command is executed to directory `
+ - `--config : specify path to the E2B config toml. By default E2B tries to find ./e2b.toml in root directory. `
+
+
+## e2b sandbox logs
+
+
+show logs for sandbox
+
+##### Usage
+
+```bash
+e2b sandbox logs [options]
+```
+
+##### Options
+
+
+ - `--level : filter logs by level (DEBUG, INFO, WARN, ERROR). The logs with the higher levels will be also shown. [default: INFO]`
+ - `-f, --follow: keep streaming logs until the sandbox is closed `
+ - `--format : specify format for printing logs (json, pretty) [default: pretty]`
+ - `--loggers [loggers]: filter logs by loggers. Specify multiple loggers by separating them with a comma. `
+
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.7/template/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.7/template/index.mdx
new file mode 100644
index 0000000000..b121c54831
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/sdk-reference/cli/v1.0.7/template/index.mdx
@@ -0,0 +1,136 @@
+---
+title: Template
+---
+
+## e2b template
+
+
+manage sandbox templates
+
+##### Usage
+
+```bash
+e2b template [options] [command]
+```
+## e2b template build
+
+
+build sandbox template defined by ./e2b.Dockerfile or ./Dockerfile in root directory. By default the root directory is the current working directory. This command also creates e2b.toml config.
+
+##### Usage
+
+```bash
+e2b template build [options] [template]
+```
+
+##### Options
+
+
+ - `-p, --path : change root directory where command is executed to directory `
+ - `-d, --dockerfile : specify path to Dockerfile. By default E2B tries to find e2b.Dockerfile or Dockerfile in root directory. `
+ - `-n, --name : specify sandbox template name. You can use the template name to start the sandbox with SDK. The template name must be lowercase and contain only letters, numbers, dashes and underscores. `
+ - `-c, --cmd : specify command that will be executed when the sandbox is started. `
+ - `-t, --team : specify the team ID that the operation will be associated with. You can find team ID in the team settings in the E2B dashboard (https://e2b.dev/dashboard?tab=team). `
+ - `--config : specify path to the E2B config toml. By default E2B tries to find ./e2b.toml in root directory. `
+ - `--cpu-count : specify the number of CPUs that will be used to run the sandbox. The default value is 2. `
+ - `--memory-mb : specify the amount of memory in megabytes that will be used to run the sandbox. Must be an even number. The default value is 512. `
+ - `--build-arg : specify additional build arguments for the build command. The format should be =. `
+
+
+## e2b template list
+
+
+list sandbox templates
+
+##### Usage
+
+```bash
+e2b template list [options]
+```
+
+##### Options
+
+
+ - `-t, --team : specify the team ID that the operation will be associated with. You can find team ID in the team settings in the E2B dashboard (https://e2b.dev/dashboard?tab=team). `
+
+
+## e2b template init
+
+
+create basic E2B Dockerfile (./e2b.Dockerfile) in root directory. You can then run e2b template build to build sandbox template from this Dockerfile
+
+##### Usage
+
+```bash
+e2b template init [options]
+```
+
+##### Options
+
+
+ - `-p, --path
+
diff --git a/apps/web/src/app/(docs)/mintlify-docs/legacy/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/legacy/index.mdx
new file mode 100644
index 0000000000..9b1f174f18
--- /dev/null
+++ b/apps/web/src/app/(docs)/mintlify-docs/legacy/index.mdx
@@ -0,0 +1,53 @@
+---
+title: "Code interpreting for your AI app"
+---
+
++[Let us know](/legacy/getting-help) if you need more powerful compute. diff --git a/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/api/cwd/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/api/cwd/index.mdx new file mode 100644 index 0000000000..b7bbdb1d33 --- /dev/null +++ b/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/api/cwd/index.mdx @@ -0,0 +1,136 @@ +--- +title: "Current Working Directory" +--- + +
+ +[Let us know](/legacy/getting-help) if you need more powerful compute. \ No newline at end of file diff --git a/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/custom/index.mdx b/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/custom/index.mdx new file mode 100644 index 0000000000..c728220f97 --- /dev/null +++ b/apps/web/src/app/(docs)/mintlify-docs/legacy/sandbox/custom/index.mdx @@ -0,0 +1,55 @@ +--- +title: "Customizing Sandbox" +--- + +
+
+
+E2B Sandboxes are made exactly to solve these challenges. The sandbox is like an isolated runtime or playground for the LLM. **We give you our SDK to spawn and control these sandboxes.**
+
+
+## How sandboxes work under the hood
+When you create a new sandbox session, we start a small VM in our cloud. This VM is running a Ubuntu OS and it takes about 400-600ms to start it.
+
+Inside this sandbox, your AI app can [run code and start any programs](/legacy/sandbox/api/process), access the internet to download or upload data, use the [filesystem](/legacy/sandbox/api/filesystem), start long running processes such as web servers, and more.
+You can also [upload](/legacy/sandbox/api/upload) to sandbox and [download](/legacy/sandbox/api/upload) from sandbox any file you want.
+
+To start and control the sandbox, use the [E2B SDK](/legacy/getting-started/installation) for Python or JavaScript.
+
+
+
+
+
+
+
+## `e2b.Dockerfile`
+The Dockerfile must be Debian based (e.g. Ubuntu). Only the following [Dockerfile commands](https://docs.docker.com/engine/reference/builder/) are supported:
+ - `FROM`
+ - `ADD`
+ - `COPY`
+ - `RUN`
+ - `WORKDIR`
+ - `ARG`
+
+## Example
+
+The following example template file defines a Ubuntu-based sandbox with installed GitHub CLI.
+
+
+Directory listing for /
++
-
+
- .bash_logout +
- .bashrc +
- .profile +
+ + +``` +```bash Python +Server started at: https://3000-ip3nfrvajtqu5ktoxugc7-b0b684e9.e2b.dev +Response from server inside sandbox: + + + +
Directory listing for /
++
-
+
- .bash_logout +
- .bashrc +
- .profile +
+ + +``` +
+
+
+### State descriptions
+
+- **Running**: The sandbox is actively running and can execute code. This is the initial state after creation.
+- **Paused**: The sandbox execution is suspended but its state is preserved.
+- **Killed**: The sandbox is terminated and all resources are released. This is a terminal state.
+
+### Changing sandbox's state
+
+| Plan | +Hobby | +Pro | +Enterprise | +
|---|---|---|---|
| Sandbox lifecycle & management API | +20,000 / 30s | +20,000 / 30s | +Custom | +
| Sandbox operations | +40,000 / 60s per IP | +40,000 / 60s per IP | +Custom | +
| Concurrent sandboxes | +20 | +100 - 1,100* | +Custom | +
| Sandbox creation rate | +1 / sec | +5 / sec | +Custom | +
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** + +