CLAUDE.md Use pnpm for node and uv for python to install and update dependencies. Run `pnpm run format`, `pnpm run lint` and `pnpm run typecheck` before committing changes. When modifying the SDK packages, ensure equivalent changes are applied to both JS as well as sync and async Python implementations. Never edit the API, envd, or volume-content specs in spec/ by hand; they are synced with Copybara from e2b-dev/runtime and e2b-dev/belt at the commits pinned in spec/runtime-ref and spec/belt-ref (see copy.bara.sky and spec/README.md). To update the specs, bump the pins and re-run `make codegen`, which re-fetches them before generating. Create or update tests covering affected codepaths and run them using `pnpm run test`. Generate a changeset with `pnpm changeset` in the repository root when changing the public surface of packages/cli, packages/js-sdk, or packages/python-sdk; internal scripts, devtools, and tests don't need one. When creating a pull request, add usage examples for user-facing changes to the PR description. When opening a new pull request, use the Linear MCP if available to link to related issues, or create a new issue from the PR description. Keep PR descriptions up-to-date with changes. Default credentials are stored in .env.local in the repository root or inside ~/.e2b/config.json. --- name: stripe-projects description: "Use after E2B sandbox/API access has been provisioned through Stripe Projects and the user needs to use the resulting E2B API key with the E2B CLI, JavaScript SDK, Python SDK, or Code Interpreter SDK." --- # E2B Stripe Projects Use these patterns after E2B sandbox/API access has been provisioned through Stripe Projects. ## Credentials - Stripe Projects provisions E2B sandbox/API access and returns an E2B team API key. - Use that key as `E2B_API_KEY` for sandbox creation, sandbox control, and SDK clients. - Prefer setting `E2B_API_KEY` explicitly in runtime environments so commands and SDK calls use the intended E2B team. - Local defaults can also come from `.env.local` or `~/.e2b/config.json`. - In Stripe Projects checkouts, the E2B CLI may not be globally logged in. Before using `e2b sandbox ...`, prefer a Stripe Projects env pull plus per-command export instead of trying `e2b auth login`. - Do not print secret values. `stripe projects env --json` can return redacted placeholders, so do not use it as the source for a runnable `E2B_API_KEY`. Pull the managed env file, then read only the needed E2B variables into the command environment without echoing them. ```bash stripe projects env --pull --yes env_value() { awk -F= -v key="$1" '$1 == key {sub(/^[^=]*=/, ""); gsub(/^"|"$/, ""); print; exit}' .env } export E2B_API_KEY="$(env_value E2B_API_KEY)" export E2B_API_URL="$(env_value E2B_API_URL)" export E2B_DOMAIN="$(env_value E2B_DOMAIN)" e2b sandbox create base --detach ``` ## Stripe Projects CLI Add E2B to the current Stripe project: ```bash stripe projects add e2b/sandboxes ``` Inspect or pull provisioned credentials: ```bash stripe projects env stripe projects env --json stripe projects env --pull --yes ``` Export the E2B API key before using the E2B CLI or SDK. Prefer `stripe projects env --pull --yes` for command execution because JSON output may redact secret values. Read only the variables you need from `.env`; do not source `.env` as shell code: ```bash stripe projects env --pull --yes env_value() { awk -F= -v key="$1" '$1 == key {sub(/^[^=]*=/, ""); gsub(/^"|"$/, ""); print; exit}' .env } export E2B_API_KEY="$(env_value E2B_API_KEY)" export E2B_API_URL="$(env_value E2B_API_URL)" export E2B_DOMAIN="$(env_value E2B_DOMAIN)" ``` Use `stripe projects env --json` for structure checks only. In current Stripe Projects output, the E2B variables are under `data.resource_access_configurations[].access_configuration`, including `E2B_API_KEY`, `E2B_API_URL`, and `E2B_DOMAIN`, but the values may be redacted and unusable for CLI/SDK calls. ## E2B CLI If the E2B CLI is missing or a shell shim is broken, install it with Node instead of switching to SDK code: ```bash if ! e2b --version >/dev/null 2>&1; then npm install -g @e2b/cli fi ``` The CLI package requires Node 22 or newer. Prefer detached sandboxes for non-interactive work so the command returns a sandbox ID and does not attach an interactive terminal: ```bash e2b sandbox create --detach e2b sandbox create base --detach ``` Run shell commands in a sandbox with `--` before shell flags so the CLI does not parse them: ```bash e2b sandbox exec -- bash -lc 'pwd && ls -la' ``` For long-running processes, run them in the background and write a PID file in the sandbox: ```bash e2b sandbox exec -- bash -lc 'nohup python server.py >server.log 2>&1 & echo $! >server.pid' ``` The CLI has explicit resume, but sandbox creation does not currently expose an auto-resume flag: ```bash e2b sandbox resume ``` Use `sandbox exec` for operational commands against an existing sandbox: ```bash e2b sandbox exec -- bash -lc 'python --version' e2b sandbox exec -- bash -lc 'ls -la /tmp' ``` ## JavaScript SDK Use `Sandbox.create()` with `E2B_API_KEY` for a fresh sandbox: ```ts import Sandbox from 'e2b' const sandbox = await Sandbox.create('base') const result = await sandbox.commands.run('echo "hello from e2b"') console.log(result.stdout) ``` Use lifecycle options when the sandbox should pause on timeout and resume on later activity: ```ts const sandbox = await Sandbox.create('base', { lifecycle: { onTimeout: 'pause', autoResume: true }, }) ``` Use `Sandbox.connect()` when a CLI step already created the sandbox: ```ts import Sandbox from 'e2b' const sandbox = await Sandbox.connect(process.env.SANDBOX_ID!) const result = await sandbox.commands.run('cat important_file.md') console.log(result.stdout) ``` ## Python SDK Use the context manager with `E2B_API_KEY` for short-lived tasks: ```py from e2b import Sandbox with Sandbox.create("base") as sandbox: result = sandbox.commands.run('echo "hello from e2b"') print(result.stdout) ``` Use lifecycle options when the sandbox should pause on timeout and resume on later activity: ```py sandbox = Sandbox.create( "base", lifecycle={"on_timeout": "pause", "auto_resume": True}, ) ``` For workflows that share a sandbox across steps, keep the sandbox ID and connect to it later: ```py from e2b import Sandbox sandbox = Sandbox.connect(sandbox_id) result = sandbox.commands.run("cat important_file.md") print(result.stdout) ``` ## Practical Defaults - Use the `base` template unless a task requires a specific template. - Prefer `bash -lc` for multi-command CLI execution. - Put temporary files under `/tmp` or the current working directory inside the sandbox unless the task requires a specific path. - For workloads that need code execution with `run_code` or `runCode`, use the Code Interpreter SDK.

# E2B CLI This CLI tool allows you to build manager your running E2B sandbox and sandbox templates. Learn more in [our documentation](https://docs.e2b.dev/?utm_source=npm&utm_medium=referral&utm_campaign=readme&utm_content=e2b-cli). ### 1. Install the CLI **Using Homebrew (on macOS)** ```bash brew install e2b ``` **Using NPM** ```bash npm install -g @e2b/cli ``` ### 2. Authenticate ```bash e2b auth login ``` > [!NOTE] > To authenticate without the ability to open the browser (e.g. in CI/CD), > provide `E2B_API_KEY` as an environment variable. You can find your API key > in the [API Keys](https://e2b.dev/dashboard?tab=keys&utm_source=npm&utm_medium=referral&utm_campaign=readme&utm_content=e2b-cli) tab in the E2B dashboard. > Then use the CLI like this: `E2B_API_KEY=e2b_... e2b template create`. ### 3. Check out docs Visit our [CLI documentation](https://docs.e2b.dev/?utm_source=npm&utm_medium=referral&utm_campaign=readme&utm_content=e2b-cli) to learn more.

## What is E2B? [E2B](https://e2b.dev/?utm_source=npm&utm_medium=referral&utm_campaign=readme&utm_content=code-interpreter) is an open-source infrastructure that allows you run to AI-generated code in secure isolated sandboxes in the cloud. To start and control sandboxes, use our [JavaScript SDK](https://www.npmjs.com/package/@e2b/code-interpreter) or [Python SDK](https://pypi.org/project/e2b_code_interpreter). Source: [packages/code-interpreter-js](https://github.com/e2b-dev/E2B/tree/main/packages/code-interpreter-js) ## Run your first Sandbox ### 1. Install SDK ``` npm i @e2b/code-interpreter ``` ### 2. Get your E2B API key 1. Sign up to E2B [here](https://e2b.dev/?utm_source=npm&utm_medium=referral&utm_campaign=readme&utm_content=code-interpreter). 2. Get your API key [here](https://e2b.dev/dashboard?tab=keys&utm_source=npm&utm_medium=referral&utm_campaign=readme&utm_content=code-interpreter). 3. Set environment variable with your API key. ``` E2B_API_KEY=e2b_*** ``` ### 3. Execute code with code interpreter inside Sandbox ```ts import { Sandbox } from '@e2b/code-interpreter' const sbx = await Sandbox.create() await sbx.runCode('x = 1') const execution = await sbx.runCode('x+=1; x') console.log(execution.text) // outputs 2 ``` ### 4. Bind the configuration to a client The top-level `Sandbox` export reads its configuration from the environment variables. To use an explicit configuration — e.g. several API keys or domains in one process — create an `E2B` client and use the resources it exposes: ```ts import { E2B } from '@e2b/code-interpreter' const client = new E2B({ apiKey: 'e2b_***', domain: 'e2b.dev' }) const sbx = await client.Sandbox.create() const execution = await sbx.runCode('x = 1; x += 1; x') // The core resources are bound to the client's configuration as well. const volume = await client.Volume.create('my-volume') const exists = await client.Template.exists('my-template') await client.Secret.create('openai-api-key', 'sk-***') // The classes can be destructured and used like the top-level ones. const { Sandbox } = client const paginator = Sandbox.list() ``` Per-call options still take precedence over the client's options, and clients are isolated from each other and from the env-configured top-level exports. ### 5. Check docs Visit [E2B documentation](https://docs.e2b.dev/?utm_source=npm&utm_medium=referral&utm_campaign=readme&utm_content=code-interpreter). ### 6. E2B cookbook Visit our [Cookbook](https://github.com/e2b-dev/e2b-cookbook/tree/main) to get inspired by examples with different LLMs and AI frameworks.

## What is E2B? [E2B](https://e2b.dev/?utm_source=pypi&utm_medium=referral&utm_campaign=readme&utm_content=code-interpreter) is an open-source infrastructure that allows you run to AI-generated code in secure isolated sandboxes in the cloud. To start and control sandboxes, use our [JavaScript SDK](https://www.npmjs.com/package/@e2b/code-interpreter) or [Python SDK](https://pypi.org/project/e2b_code_interpreter). Source: [packages/code-interpreter-python](https://github.com/e2b-dev/E2B/tree/main/packages/code-interpreter-python) ## Run your first Sandbox ### 1. Install SDK ``` pip install e2b-code-interpreter ``` ### 2. Get your E2B API key 1. Sign up to E2B [here](https://e2b.dev/?utm_source=pypi&utm_medium=referral&utm_campaign=readme&utm_content=code-interpreter). 2. Get your API key [here](https://e2b.dev/dashboard?tab=keys&utm_source=pypi&utm_medium=referral&utm_campaign=readme&utm_content=code-interpreter). 3. Set environment variable with your API key. ``` E2B_API_KEY=e2b_*** ``` ### 3. Execute code with code interpreter inside Sandbox ```py from e2b_code_interpreter import Sandbox with Sandbox.create() as sandbox: sandbox.run_code("x = 1") execution = sandbox.run_code("x+=1; x") print(execution.text) # outputs 2 ``` ### 4. Bind the configuration to a client The top-level `Sandbox` and `AsyncSandbox` exports read their configuration from the environment variables. To use an explicit configuration — e.g. several API keys or domains in one process — create an `E2B` client and use the resource classes it exposes: ```py from e2b_code_interpreter import E2B client = E2B(api_key="e2b_***", domain="e2b.dev") with client.Sandbox.create() as sandbox: execution = sandbox.run_code("x = 1; x += 1; x") # The async variant is exposed as well. async_sandbox = await client.AsyncSandbox.create() # The core resources are bound to the client's configuration as well. volume = client.Volume.create("my-volume") exists = client.Template.exists("my-template") secret = client.Secret.create("openai-api-key", "sk-***") # The classes can be assigned and used like the top-level ones. Sandbox = client.Sandbox paginator = Sandbox.list() ``` Per-call params still take precedence over the client's params, and clients are isolated from each other and from the env-configured top-level exports. ### 5. Check docs Visit [E2B documentation](https://docs.e2b.dev/?utm_source=pypi&utm_medium=referral&utm_campaign=readme&utm_content=code-interpreter). ### 6. E2B cookbook Visit our [Cookbook](https://github.com/e2b-dev/e2b-cookbook/tree/main) to get inspired by examples with different LLMs and AI frameworks. # E2B Desktop Sandbox - Virtual Computer for Computer Use E2B Desktop Sandbox is a secure virtual desktop ready for Computer Use. Powered by [E2B](https://e2b.dev). Each sandbox is isolated from the others and can be customized with any dependencies you want. ![Desktop Sandbox](https://raw.githubusercontent.com/e2b-dev/E2B/refs/heads/main/packages/desktop-python/screenshot.png) Source: [packages/desktop-js](https://github.com/e2b-dev/E2B/tree/main/packages/desktop-js) ## Examples Check out the [example open-source app](https://github.com/e2b-dev/open-computer-use) in a separate repository. ## 🚀 Getting started The E2B Desktop Sandbox is built on top of [E2B Sandbox](https://e2b.dev/docs). ### 1. Get E2B API key Sign up at [E2B](https://e2b.dev) and get your API key. Set environment variable `E2B_API_KEY` with your API key. ### 2. Install SDK ```bash npm install @e2b/desktop ``` ### 3. Create Desktop Sandbox ```javascript import { Sandbox } from '@e2b/desktop' // Start a new desktop sandbox const desktop = await Sandbox.create() // Launch an application await desktop.launch('google-chrome') // or vscode, firefox, etc. // Wait 10s for the application to open await desktop.wait(10000) // Stream the application's window // Note: there can be only one stream at a time // You need to stop the current stream before streaming another application await desktop.stream.start({ windowId: await desktop.getCurrentWindowId(), // if not provided the whole desktop will be streamed requireAuth: true, }) // Get the stream auth key const authKey = desktop.stream.getAuthKey() // Print the stream URL console.log('Stream URL:', desktop.stream.getUrl({ authKey })) // Kill the sandbox after the tasks are finished // await desktop.kill() ``` ### 4. Bind the configuration to a client The top-level `Sandbox` export reads its configuration from the environment variables. To use an explicit configuration — e.g. several API keys or domains in one process — create an `E2B` client and use the resources it exposes: ```javascript import { E2B } from '@e2b/desktop' const client = new E2B({ apiKey: 'e2b_***', domain: 'e2b.dev' }) const desktop = await client.Sandbox.create() await desktop.stream.start() // The core resources are bound to the client's configuration as well. const volume = await client.Volume.create('my-volume') const exists = await client.Template.exists('my-template') await client.Secret.create('openai-api-key', 'sk-***') // The classes can be destructured and used like the top-level ones. const { Sandbox } = client const paginator = Sandbox.list() ``` Per-call options still take precedence over the client's options, and clients are isolated from each other and from the env-configured top-level exports. ## Features ### Streaming desktop's screen ```javascript import { Sandbox } from '@e2b/desktop' const desktop = await Sandbox.create() // Start the stream await desktop.stream.start() // Get stream URL const url = desktop.stream.getUrl() console.log(url) // Stop the stream await desktop.stream.stop() ``` ### Streaming with password protection ```javascript import { Sandbox } from '@e2b/desktop' const desktop = await Sandbox.create() // Start the stream await desktop.stream.start({ requireAuth: true, // Enable authentication with an auto-generated key }) // Retrieve the authentication key const authKey = await desktop.stream.getAuthKey() // Get stream URL const url = desktop.stream.getUrl({ authKey }) console.log(url) // Stop the stream await desktop.stream.stop() ``` ### Streaming specific application > [!WARNING] > > - Will throw an error if the desired application is not open yet > - The stream will close once the application closes > - Creating multiple streams at the same time is not supported, you may have to stop the current stream and start a new one for each application ```javascript import { Sandbox } from '@e2b/desktop' const desktop = await Sandbox.create() // Get current (active) window ID const windowId = await desktop.getCurrentWindowId() // Get all windows of the application const windowIds = await desktop.getApplicationWindows('Firefox') // Start the stream await desktop.stream.start({ windowId: windowIds[0] }) // Stop the stream await desktop.stream.stop() ``` ### Mouse control ```javascript import { Sandbox } from '@e2b/desktop' const desktop = await Sandbox.create() await desktop.doubleClick() await desktop.leftClick() await desktop.leftClick(100, 200) await desktop.rightClick() await desktop.rightClick(100, 200) await desktop.middleClick() await desktop.middleClick(100, 200) await desktop.scroll(10) // Scroll by the amount. Positive for up, negative for down. await desktop.moveMouse(100, 200) // Move to x, y coordinates await desktop.drag([100, 100], [200, 200]) // Drag using the mouse await desktop.mousePress('left') // Press the mouse button await desktop.mouseRelease('left') // Release the mouse button ``` ### Keyboard control ```javascript import { Sandbox } from '@e2b/desktop' const desktop = await Sandbox.create() // Write text at the current cursor position with customizable typing speed await desktop.write('Hello, world!') await desktop.write('Fast typing!', { chunkSize: 50, delayInMs: 25 }) // Faster typing // Press keys await desktop.press('enter') await desktop.press('space') await desktop.press('backspace') await desktop.press(['ctrl', 'c']) // Key combination ``` ### Window control ```javascript import { Sandbox } from '@e2b/desktop' const desktop = await Sandbox.create() // Get current (active) window ID const windowId = await desktop.getCurrentWindowId() // Get all windows of the application const windowIds = await desktop.getApplicationWindows('Firefox') // Get window title const title = await desktop.getWindowTitle(windowId) ``` ### Screenshot ```javascript import { Sandbox } from '@e2b/desktop' const desktop = await Sandbox.create() const image = await desktop.screenshot() // Save the image to a file fs.writeFileSync('screenshot.png', image) ``` ### Open file ```javascript import { Sandbox } from '@e2b/desktop' const desktop = await Sandbox.create() // Open file with default application await desktop.files.write('/home/user/index.js', "console.log('hello')") // First create the file await desktop.open('/home/user/index.js') // Then open it ``` ### Launch applications ```javascript import { Sandbox } from '@e2b/desktop' const desktop = await Sandbox.create() // Launch the application await desktop.launch('google-chrome') ``` ### Run any bash commands ```javascript import { Sandbox } from '@e2b/desktop' const desktop = await Sandbox.create() // Run any bash command const out = await desktop.commands.run('ls -la /home/user') console.log(out) ``` ### Wait ```javascript import { Sandbox } from '@e2b/desktop' const desktop = await Sandbox.create() await desktop.wait(1000) // Wait for 1 second ``` ## Under the hood The desktop-like environment is based on Linux and [Xfce](https://www.xfce.org/) at the moment. We chose Xfce because it's a fast and lightweight environment that's also popular and actively supported. However, this Sandbox template is fully customizable and you can create your own desktop environment. Check out the sandbox template's code [here](https://github.com/e2b-dev/desktop/tree/main/template). # E2B Desktop Sandbox - Virtual Computer for Computer Use E2B Desktop Sandbox is a secure virtual desktop ready for Computer Use. Powered by [E2B](https://e2b.dev). Each sandbox is isolated from the others and can be customized with any dependencies you want. ![Desktop Sandbox](https://raw.githubusercontent.com/e2b-dev/E2B/refs/heads/main/packages/desktop-python/screenshot.png) Source: [packages/desktop-python](https://github.com/e2b-dev/E2B/tree/main/packages/desktop-python) ## Examples Check out the [example open-source app](https://github.com/e2b-dev/open-computer-use) in a separate repository. ## 🚀 Getting started The E2B Desktop Sandbox is built on top of [E2B Sandbox](https://e2b.dev/docs). ### 1. Get E2B API key Sign up at [E2B](https://e2b.dev) and get your API key. Set environment variable `E2B_API_KEY` with your API key. ### 2. Install SDK ```bash pip install e2b-desktop ``` ### 3. Create Desktop Sandbox ```python from e2b_desktop import Sandbox # Create a new desktop sandbox desktop = Sandbox.create() # Launch an application desktop.launch('google-chrome') # or vscode, firefox, etc. # Wait 10s for the application to open desktop.wait(10000) # Stream the application's window # Note: There can be only one stream at a time # You need to stop the current stream before streaming another application desktop.stream.start( window_id=desktop.get_current_window_id(), # if not provided the whole desktop will be streamed require_auth=True ) # Get the stream auth key auth_key = desktop.stream.get_auth_key() # Print the stream URL print('Stream URL:', desktop.stream.get_url(auth_key=auth_key)) # Kill the sandbox after the tasks are finished # desktop.kill() ``` ### 4. Bind the configuration to a client The top-level `Sandbox` export reads its configuration from the environment variables. To use an explicit configuration — e.g. several API keys or domains in one process — create an `E2B` client and use the resource classes it exposes: ```python from e2b_desktop import E2B client = E2B(api_key="e2b_***", domain="e2b.dev") desktop = client.Sandbox.create() desktop.stream.start() # The core resources are bound to the client's configuration as well. volume = client.Volume.create("my-volume") exists = client.Template.exists("my-template") secret = client.Secret.create("openai-api-key", "sk-***") # The classes can be assigned and used like the top-level ones. Sandbox = client.Sandbox paginator = Sandbox.list() ``` Per-call params still take precedence over the client's params, and clients are isolated from each other and from the env-configured top-level exports. ## Features ### Streaming desktop's screen ```python from e2b_desktop import Sandbox desktop = Sandbox.create() # Start the stream desktop.stream.start() # Get stream URL url = desktop.stream.get_url() print(url) # Stop the stream desktop.stream.stop() ``` ### Streaming with password protection ```python from e2b_desktop import Sandbox desktop = Sandbox.create() # Start the stream desktop.stream.start( require_auth=True # Enable authentication with an auto-generated key ) # Retrieve the authentication key auth_key = desktop.stream.get_auth_key() # Get stream URL url = desktop.stream.get_url(auth_key=auth_key) print(url) # Stop the stream desktop.stream.stop() ``` ### Streaming specific application > [!WARNING] > > - Will raise an error if the desired application is not open yet > - The stream will close once the application closes > - Creating multiple streams at the same time is not supported, you may have to stop the current stream and start a new one for each application ```python from e2b_desktop import Sandbox desktop = Sandbox.create() # Get current (active) window ID window_id = desktop.get_current_window_id() # Get all windows of the application window_ids = desktop.get_application_windows("Firefox") # Start the stream desktop.stream.start(window_id=window_ids[0]) # Stop the stream desktop.stream.stop() ``` ### Mouse control ```python from e2b_desktop import Sandbox desktop = Sandbox.create() desktop.double_click() desktop.left_click() desktop.left_click(x=100, y=200) desktop.right_click() desktop.right_click(x=100, y=200) desktop.middle_click() desktop.middle_click(x=100, y=200) desktop.scroll(10) # Scroll by the amount. Positive for up, negative for down. desktop.move_mouse(100, 200) # Move to x, y coordinates desktop.drag((100, 100), (200, 200)) # Drag using the mouse desktop.mouse_press("left") # Press the mouse button desktop.mouse_release("left") # Release the mouse button ``` ### Keyboard control ```python from e2b_desktop import Sandbox desktop = Sandbox.create() # Write text at the current cursor position with customizable typing speed desktop.write("Hello, world!") # Default: chunk_size=25, delay_in_ms=75 desktop.write("Fast typing!", chunk_size=50, delay_in_ms=25) # Faster typing # Press keys desktop.press("enter") desktop.press("space") desktop.press("backspace") desktop.press(["ctrl", "c"]) # Key combination ``` ### Window control ```python from e2b_desktop import Sandbox desktop = Sandbox.create() # Get current (active) window ID window_id = desktop.get_current_window_id() # Get all windows of the application window_ids = desktop.get_application_windows("Firefox") # Get window title title = desktop.get_window_title(window_id) ``` ### Screenshot ```python from e2b_desktop import Sandbox desktop = Sandbox.create() # Take a screenshot and save it as "screenshot.png" locally image = desktop.screenshot() # Save the image to a file with open("screenshot.png", "wb") as f: f.write(image) ``` ### Open file ```python from e2b_desktop import Sandbox desktop = Sandbox.create() # Open file with default application desktop.files.write("/home/user/index.js", "console.log('hello')") # First create the file desktop.open("/home/user/index.js") # Then open it ``` ### Launch applications ```python from e2b_desktop import Sandbox desktop = Sandbox.create() # Launch the application desktop.launch('google-chrome') ``` ### Run any bash commands ```python from e2b_desktop import Sandbox desktop = Sandbox.create() # Run any bash command out = desktop.commands.run("ls -la /home/user") print(out) ``` ### Wait ```python from e2b_desktop import Sandbox desktop = Sandbox.create() desktop.wait(1000) # Wait for 1 second ``` ## Under the hood The desktop-like environment is based on Linux and [Xfce](https://www.xfce.org/) at the moment. We chose Xfce because it's a fast and lightweight environment that's also popular and actively supported. However, this Sandbox template is fully customizable and you can create your own desktop environment. Check out the sandbox template's code [here](https://github.com/e2b-dev/desktop/tree/main/template). # @e2b/dockerfile-utils Dockerfile parser and shell lexer ported from [BuildKit](https://github.com/moby/buildkit/tree/master/frontend/dockerfile) and a `.dockerignore` matcher ported from [moby/patternmatcher](https://github.com/moby/patternmatcher), with no runtime dependencies. Used by the [E2B SDK](https://www.npmjs.com/package/e2b) to implement `Template.fromDockerfile` and to filter the build context. ```ts import { parseDockerfileAst, ShellLex } from '@e2b/dockerfile-utils' const ast = parseDockerfileAst(` FROM node:24 AS build ENV KEY="a b" OTHER=c RUN < # e2b-dockerfile-utils Dockerfile parser and shell lexer ported from [BuildKit](https://github.com/moby/buildkit/tree/master/frontend/dockerfile) and a `.dockerignore` matcher ported from [moby/patternmatcher](https://github.com/moby/patternmatcher), with no runtime dependencies. Used by the [E2B SDK](https://pypi.org/project/e2b/) to implement `Template.from_dockerfile` and to filter the build context. ```python from e2b_dockerfile_utils import ShellLex, parse_dockerfile_ast ast = parse_dockerfile_ast( """ FROM node:24 AS build ENV KEY="a b" OTHER=c RUN <

## What is E2B? [E2B](https://e2b.dev/?utm_source=npm&utm_medium=referral&utm_campaign=readme&utm_content=e2b) is an open-source infrastructure that allows you to run AI-generated code in secure isolated sandboxes in the cloud. To start and control sandboxes, use our [JavaScript SDK](https://www.npmjs.com/package/e2b) or [Python SDK](https://pypi.org/project/e2b). ## Run your first Sandbox ### 1. Install SDK ```bash npm i e2b ``` ### 2. Get your E2B API key 1. Sign up to E2B [here](https://e2b.dev/?utm_source=npm&utm_medium=referral&utm_campaign=readme&utm_content=e2b). 2. Get your API key [here](https://e2b.dev/dashboard?tab=keys&utm_source=npm&utm_medium=referral&utm_campaign=readme&utm_content=e2b). 3. Set environment variable with your API key ``` E2B_API_KEY=e2b_*** ``` ### 3. Start a sandbox and run commands ```ts import { Sandbox } from 'e2b' const sandbox = await Sandbox.create() const result = await sandbox.commands.run('echo "Hello from E2B!"') console.log(result.stdout) // Hello from E2B! ``` ### 4. Bind the configuration to a client The top-level `Sandbox`, `Volume`, `Template` and `Secret` exports read their configuration from the environment variables. To use an explicit configuration — e.g. several API keys or domains in one process — create an `E2B` client and use the resources it exposes: ```ts import { E2B } from 'e2b' const client = new E2B({ apiKey: 'e2b_***', domain: 'e2b.dev' }) const sandbox = await client.Sandbox.create() const volume = await client.Volume.create('my-volume') const exists = await client.Template.exists('my-template') await client.Secret.create('openai-api-key', 'sk-***') // The classes can be destructured and used like the top-level ones. const { Sandbox } = client const paginator = Sandbox.list() ``` Per-call options still take precedence over the client's options, and clients are isolated from each other and from the env-configured top-level exports. ### 5. Code execution with Code Interpreter If you need [`runCode()`](https://docs.e2b.dev/code-interpreting/analyze-data-with-ai?utm_source=npm&utm_medium=referral&utm_campaign=readme&utm_content=e2b), install the [Code Interpreter SDK](https://github.com/e2b-dev/code-interpreter): ```bash npm i @e2b/code-interpreter ``` ```ts import { Sandbox } from '@e2b/code-interpreter' const sandbox = await Sandbox.create() const execution = await sandbox.runCode('x = 1; x += 1; x') console.log(execution.text) // outputs 2 ``` ### 6. Check docs Visit [E2B documentation](https://docs.e2b.dev/?utm_source=npm&utm_medium=referral&utm_campaign=readme&utm_content=e2b). ### 7. E2B cookbook Visit our [Cookbook](https://github.com/e2b-dev/e2b-cookbook/tree/main) to get inspired by examples with different LLMs and AI frameworks.

## What is E2B? [E2B](https://e2b.dev/?utm_source=pypi&utm_medium=referral&utm_campaign=readme&utm_content=e2b) is an open-source infrastructure that allows you to run AI-generated code in secure isolated sandboxes in the cloud. To start and control sandboxes, use our [JavaScript SDK](https://www.npmjs.com/package/e2b) or [Python SDK](https://pypi.org/project/e2b). ## Run your first Sandbox ### 1. Install SDK ``` pip install e2b ``` ### 2. Get your E2B API key 1. Sign up to E2B [here](https://e2b.dev/?utm_source=pypi&utm_medium=referral&utm_campaign=readme&utm_content=e2b). 2. Get your API key [here](https://e2b.dev/dashboard?tab=keys&utm_source=pypi&utm_medium=referral&utm_campaign=readme&utm_content=e2b). 3. Set environment variable with your API key ``` E2B_API_KEY=e2b_*** ``` ### 3. Start a sandbox and run commands ```py from e2b import Sandbox with Sandbox.create() as sandbox: result = sandbox.commands.run('echo "Hello from E2B!"') print(result.stdout) # Hello from E2B! ``` ### 4. Bind the configuration to a client The top-level `Sandbox`, `AsyncSandbox`, `Volume`, `AsyncVolume`, `Template`, `AsyncTemplate` and `Secret` exports read their configuration from the environment variables. To use an explicit configuration — e.g. several API keys or domains in one process — create an `E2B` client and use the resource classes it exposes: ```py from e2b import E2B client = E2B(api_key="e2b_***", domain="e2b.dev") sandbox = client.Sandbox.create() volume = client.Volume.create("my-volume") exists = client.Template.exists("my-template") secret = client.Secret.create("openai-api-key", "sk-***") # The async variants are exposed as well. async_sandbox = await client.AsyncSandbox.create() # The classes can be assigned and used like the top-level ones. Sandbox = client.Sandbox paginator = Sandbox.list() ``` Per-call params still take precedence over the client's params, and clients are isolated from each other and from the env-configured top-level exports. ### High-concurrency sandbox streams Sandbox `commands` and `files` traffic from all sandboxes in a process shares one HTTP/2 connection pool. Requests are spread over the pooled connections by free stream capacity, and a new connection is dialed only once every existing one is at the server's concurrent-stream limit (`100` for `sandbox.e2b.app`), up to `E2B_MAX_CONNECTIONS` connections per resolved address (default `200`). Past that cap, a request waits for a stream to free up. Long-running streams therefore never queue behind one connection's concurrent-stream limit, and idle processes keep a single connection. `E2B_MAX_CONNECTIONS` is read when `e2b` is imported: ```sh E2B_MAX_CONNECTIONS=400 python eval.py ``` ### 5. Code execution with Code Interpreter If you need [`run_code()`](https://docs.e2b.dev/code-interpreting/analyze-data-with-ai?utm_source=pypi&utm_medium=referral&utm_campaign=readme&utm_content=e2b), install the [Code Interpreter SDK](https://github.com/e2b-dev/code-interpreter): ``` pip install e2b-code-interpreter ``` ```py from e2b_code_interpreter import Sandbox with Sandbox.create() as sandbox: execution = sandbox.run_code("x = 1; x += 1; x") print(execution.text) # outputs 2 ``` ### 6. Check docs Visit [E2B documentation](https://docs.e2b.dev/?utm_source=pypi&utm_medium=referral&utm_campaign=readme&utm_content=e2b). ### 7. E2B cookbook Visit our [Cookbook](https://github.com/e2b-dev/e2b-cookbook/tree/main) to get inspired by examples with different LLMs and AI frameworks.

AI Agent Protocol & Instructions

Explore Related Technologies & Topics