Redirected from /websites/e2b_dev_sdk-reference_js-sdk_v2_0_1
E2B

https://docs.e2b.dev/
Admin
E2B is an open-source infrastructure providing secure, isolated cloud sandboxes (VMs) for running...
Tokens:660,912
Snippets:5,393
Trust Score:9.6
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### bun_install usage examples

Source: https://docs.e2b.dev/sdk-reference/python-sdk/v2.51.0/template

Example usage of the bun_install method, showing installation of single and multiple packages, global installation, dev dependency installation, and installation from package.json.

```python
template.bun_install('express')
template.bun_install(['lodash', 'axios'])
template.bun_install('tsx', g=True)
template.bun_install('typescript', dev=True)
template.bun_install()  # Installs from package.json

```

--------------------------------

### npm_install usage examples

Source: https://docs.e2b.dev/sdk-reference/python-sdk/v2.51.0/template

Example usage of the npm_install method, showing installation of single and multiple packages, global installation, and installation from package.json.

```python
template.npm_install('express')
template.npm_install(['lodash', 'axios'])
template.npm_install('typescript', g=True)
template.npm_install()  # Installs from package.json

```

--------------------------------

### Full example

Source: https://docs.e2b.dev/agents/google-adk

Complete runnable example combining plugin setup, agent creation, and execution with asyncio.

```python
import asyncio

from google.adk.agents import Agent
from google.adk.apps import App
from google.adk.runners import InMemoryRunner

from e2b_adk import E2BPlugin

INSTRUCTION = """You are a data analyst. You never guess numbers — you compute
them. Save any data you are given to a file with write_file, analyse it by
running real pandas with run_code, fix and re-run if the code errors, and report
the figures you computed. Never report a number you have not verified by running
code."""

DATASET = """month,region,marketing_spend,revenue
2024-01,North,12000,48000
2024-02,North,15000,61000
2024-03,North,9000,37000
2024-04,North,18000,72000
2024-01,South,8000,26000
2024-02,South,11000,30000
2024-03,South,14000,33000
2024-04,South,17000,38000"""


async def main() -> None:
    plugin = E2BPlugin(metadata={"example": "data-analysis"})
    agent = Agent(
        model="gemini-2.5-flash",
        name="data_analyst",
        instruction=INSTRUCTION,
        tools=plugin.get_tools(),
    )
    app = App(name="data_analysis", root_agent=agent, plugins=[plugin])

    async with InMemoryRunner(app=app) as runner:
        # run_debug prints the conversation as it runs.
        await runner.run_debug(
            f"Here is marketing spend and revenue as CSV:\n\n{DATASET}\n\n"
            "Save it to sales.csv, then tell me which region converts spend "
            "into revenue more efficiently and which month performed best."
        )


asyncio.run(main())
```

--------------------------------

### Install and run nginx in sandbox

Source: https://docs.e2b.dev/network/custom-domain

Installs and starts nginx inside the sandbox to test the custom domain setup.

```bash
sudo apt install nginx
sudo systemctl start nginx

```

--------------------------------

### pip_install usage examples

Source: https://docs.e2b.dev/sdk-reference/python-sdk/v2.51.0/template

Example usage of the pip_install method, showing installation of single and multiple packages, user-only installation, and installation from the current directory.

```python
template.pip_install('numpy')
template.pip_install(['pandas', 'scikit-learn'])
template.pip_install('numpy', g=False)  # Install for user only
template.pip_install()  # Installs from current directory

```

--------------------------------

### apt_install usage examples

Source: https://docs.e2b.dev/sdk-reference/python-sdk/v2.51.0/template

Example usage of the apt_install method, showing installation of single and multiple packages, and fixing missing packages.

```python
template.apt_install('vim')
template.apt_install(['git', 'curl', 'wget'])
template.apt_install('vim', fix_missing=True)

```

--------------------------------

### beta_set_dev_container_start usage

Source: https://docs.e2b.dev/sdk-reference/python-sdk/v2.51.0/template

Example usage of beta_set_dev_container_start. The first example clones a repository and sets the devcontainer start. The second example additionally calls beta_dev_container_prebuild before setting the start command.

```python
template.git_clone('https://myrepo.com/project.git', '/my-devcontainer')
template.beta_set_dev_container_start('/my-devcontainer')

template.git_clone('https://myrepo.com/project.git', '/my-devcontainer')
template.beta_dev_container_prebuild('/my-devcontainer')
template.beta_set_dev_container_start('/my-devcontainer')

```

--------------------------------

### from_base_image method and example

Source: https://docs.e2b.dev/sdk-reference/python-sdk/v2.51.0/template

Start template from the E2B base image (e2bdev/base:latest). Returns TemplateBuilder. Example shows no arguments.

```python
def from_base_image() -> TemplateBuilder

```

```python
Template().from_base_image()

```

--------------------------------

### add_mcp_server usage examples

Source: https://docs.e2b.dev/sdk-reference/python-sdk/v2.51.0/template

Example usage of the add_mcp_server method, showing installation of a single MCP server and multiple MCP servers.

```python
template.add_mcp_server('exa')
template.add_mcp_server(['brave', 'firecrawl', 'duckduckgo'])

```

--------------------------------

### Instance connect example

Source: https://docs.e2b.dev/sdk-reference/python-sdk/v2.51.0/sandbox_sync

Example usage of the instance `connect` method. Creates a sandbox, pauses it, then connects to the same sandbox using the instance method.

```python
sandbox = Sandbox.create()
sandbox.pause()

same_sandbox = sandbox.connect()

```

--------------------------------

### from_debian_image method and example

Source: https://docs.e2b.dev/sdk-reference/python-sdk/v2.51.0/template

Start template from a Debian base image. Arguments: variant (Debian image variant). Returns TemplateBuilder. Example uses 'bookworm'.

```python
def from_debian_image(variant: str = "stable") -> TemplateBuilder

```

```python
Template().from_debian_image('bookworm')

```

--------------------------------

### Build sandbox template with start command

Source: https://docs.e2b.dev/changelog

Use this command when building a sandbox template to specify a start command that will run when the sandbox is spawned. The -c option sets the command, for example to start your app or any specific process.

```bash
e2b build -c "npm start"

```

--------------------------------

### Static connect example

Source: https://docs.e2b.dev/sdk-reference/python-sdk/v2.51.0/sandbox_sync

Example usage of the static `connect` method. Creates a sandbox, pauses it using the static `pause` method, then connects using the sandbox ID.

```python
sandbox = Sandbox.create()
Sandbox.pause(sandbox.sandbox_id)

same_sandbox = Sandbox.connect(sandbox.sandbox_id)

```

--------------------------------

### SnapshotPaginator usage example

Source: https://docs.e2b.dev/sdk-reference/python-sdk/v2.51.0/sandbox_sync

Example of using SnapshotPaginator to iterate through pages of snapshots.

```python
paginator = Sandbox.list_snapshots()

while paginator.has_next:
    snapshots = paginator.next_items()
    print(snapshots)

```

--------------------------------

### SandboxPaginator usage example

Source: https://docs.e2b.dev/sdk-reference/python-sdk/v2.51.0/sandbox_sync

Example of using SandboxPaginator to iterate through pages of sandboxes.

```python
paginator = Sandbox.list()

while paginator.has_next:
    sandboxes = paginator.next_items()
    print(sandboxes)

```

--------------------------------

### Pty.create(size, user, cwd, envs, timeout, request_timeout)

Source: https://docs.e2b.dev/sdk-reference/python-sdk/v2.51.0/sandbox_sync

Starts a new PTY (pseudo-terminal) with the given size, user, working directory, environment variables, and timeout. Returns a handle to interact with the PTY.

```APIDOC
## Pty.create

### Description
Start a new PTY (pseudo-terminal) in the sandbox.

### Method
create

### Signature
```python
def create(size: PtySize, user: Optional[Username] = None, cwd: Optional[str] = None, envs: Optional[Dict[str, str]] = None, timeout: Optional[float] = 60, request_timeout: Optional[float] = None) -> CommandHandle
```

### Parameters
- **size** (PtySize) - Required - Size of the PTY
- **user** (Optional[Username]) - Optional - User to use for the PTY
- **cwd** (Optional[str]) - Optional - Working directory for the PTY
- **envs** (Optional[Dict[str, str]]) - Optional - Environment variables for the PTY
- **timeout** (Optional[float]) - Optional - Timeout for the PTY in seconds (default: 60)
- **request_timeout** (Optional[float]) - Optional - Not applied to this streaming call — both opening the stream and the stream itself are bounded by `timeout` (unlimited when `0`)

### Returns
- **CommandHandle** - Handle to interact with the PTY

```

--------------------------------

### get_info (instance)

Source: https://docs.e2b.dev/sdk-reference/python-sdk/v2.51.0/sandbox_sync

Instance method to get information about the current sandbox.

```APIDOC
## get_info(**opts: Unpack[ApiParams]) -> SandboxInfo

### Description
Get sandbox information like sandbox ID, template, metadata, started at/end at date.

### Method
Instance method

### Signature
`get_info(**opts: Unpack[ApiParams]) -> SandboxInfo`

### Returns
SandboxInfo - Sandbox info
```

--------------------------------

### Run E2B examples test suite with npm

Source: https://docs.e2b.dev/cookbook

Install dependencies and run the example test suite. Use `npm test` to run all examples, or `npm test -- hello-world` to filter by substring. Requires an `E2B_API_KEY` and provider keys as needed.

```bash
npm install
npm test                      # all of them
npm test -- hello-world       # substring filter, one or a few
```

--------------------------------

### Start a preview server and resolve exposed port

Source: https://docs.e2b.dev/agents/openai-agents-sdk

After the agent finishes, installs dependencies, starts the Vite dev server, and resolves the exposed port to get a live preview URL.

```python
await session.exec(
    "sh", "-lc",
    (
        "npm install >/tmp/e2b-demo-npm-install.log 2>&1 && "
        "nohup npm run dev -- --host 0.0.0.0 --port 4173 "
        ">/tmp/e2b-demo-vite.log 2>&1 &"
    ),
    shell=False,
    timeout=120,
)
preview_url = (await session.resolve_exposed_port(4173)).url_for("http")

```

--------------------------------

### get_info (static)

Source: https://docs.e2b.dev/sdk-reference/python-sdk/v2.51.0/sandbox_sync

Static method to get information about a sandbox by its ID.

```APIDOC
## get_info(sandbox_id: str, **opts: Unpack[ApiParams]) -> SandboxInfo

### Description
Get sandbox information like sandbox ID, template, metadata, started at/end at date.

### Method
Static method

### Signature
`get_info(sandbox_id: str, **opts: Unpack[ApiParams]) -> SandboxInfo`

### Parameters
- **sandbox_id** (str) - Required - Sandbox ID

### Returns
SandboxInfo - Sandbox info
```

--------------------------------

### Quickstart: create session and run command

Source: https://docs.e2b.dev/agents/vercel-ai-sdk

Creates an E2B sandbox session, writes a file, runs a command, and destroys the session. The session also supports readTextFile and spawn for long-running processes.

```typescript
import { createE2BSandbox } from '@e2b/ai-sdk-sandbox'

const session = await createE2BSandbox({ template: 'base' }).createSession()

await session.writeTextFile({ path: 'hello.txt', content: 'hi from e2b' })

const { stdout } = await session.run({ command: 'cat hello.txt' })
console.log(stdout) // "hi from e2b"

await session.destroy()

```

--------------------------------

### get_metrics (instance)

Source: https://docs.e2b.dev/sdk-reference/python-sdk/v2.51.0/sandbox_sync

Instance method to get metrics of the current sandbox.

```APIDOC
## get_metrics(start: Optional[datetime.datetime] = None, end: Optional[datetime.datetime] = None, **opts: Unpack[ApiParams]) -> List[SandboxMetrics]

### Description
Get the metrics of the current sandbox.

### Method
Instance method

### Signature
`get_metrics(start: Optional[datetime.datetime] = None, end: Optional[datetime.datetime] = None, **opts: Unpack[ApiParams]) -> List[SandboxMetrics]`

### Parameters
- **start** (Optional[datetime.datetime]) - Optional - Start time for the metrics, defaults to the start of the sandbox
- **end** (Optional[datetime.datetime]) - Optional - End time for the metrics, defaults to the current time

### Returns
List[SandboxMetrics] - List of sandbox metrics containing CPU, memory and disk usage information
```

--------------------------------

### More examples with wait_for_url and wait_for_port (Python)

Source: https://docs.e2b.dev/template/start-ready-command

Python equivalent of the multiple examples. Shows set_start_cmd calls for Next.js, Python HTTP server, and VNC desktop.

```python
from e2b import Template, wait_for_url, wait_for_port

# Next.js app — wait for the dev server URL
template.set_start_cmd("npx next --turbo", wait_for_url("http://localhost:3000"))

# Python HTTP server — wait for port 8000
template.set_start_cmd("python -m http.server 8000", wait_for_port(8000))

# VNC desktop — wait for the VNC port
template.set_start_cmd("/start_command.sh", wait_for_port(6080))

```

--------------------------------

### Clone and set up the webhook-managed example directory

Source: https://docs.e2b.dev/agents/openai-agents-api

Clones the e2b-cookbook repository and navigates to the webhook-managed example directory, then copies the .env.example file to .env. The .env file is gitignored and holds the five required values.

```bash
git clone https://github.com/e2b-dev/e2b-cookbook
cd e2b-cookbook/examples/openai-agents-api-python-sdk-webhook-managed
cp .env.example .env

```

--------------------------------

### Filter sandboxes by start time

Source: https://docs.e2b.dev/sandbox/list

Filter sandboxes by their start time. Only sandboxes started at or after the given timestamp are returned. The JavaScript example uses a `Date` object, while the Python example uses a timezone-aware `datetime`.

```javascript
import { Sandbox } from 'e2b'

const paginator = Sandbox.list({
  query: {
    startedAfter: new Date('2025-01-01T00:00:00Z'),
  },
})

const sandboxes = await paginator.nextItems()

```

```python
from datetime import datetime, timezone
from e2b import Sandbox, SandboxQuery

paginator = Sandbox.list(
    query=SandboxQuery(
        started_after=datetime(2025, 1, 1, tzinfo=timezone.utc),
    ),
)

sandboxes = paginator.next_items()

```

--------------------------------

### send_stdin

Source: https://docs.e2b.dev/sdk-reference/python-sdk/v2.51.0/sandbox_sync

Sends data to the command's stdin. The command must have been started with `stdin=True`.

```APIDOC
## send_stdin

### Description
Sends data to the command's stdin. The command must have been started with `stdin=True`.

### Method
`send_stdin`

### Parameters
- **data** (Union[str, bytes]) - Data to send to the command.
- **request_timeout** (float, optional) - Timeout for the request in seconds.

### Returns
- **None**
```

--------------------------------

### Full example (Python)

Source: https://docs.e2b.dev/use-cases/remote-browser

Complete Python example combining sandbox creation and agent execution in one script. Includes comments marking the two steps.

```python
import os
from e2b import Sandbox

# 1. Create the sandbox with API keys
sandbox = Sandbox.create(
    "kernel-browser",
    envs={
        "KERNEL_API_KEY": os.environ["KERNEL_API_KEY"],
        "ANTHROPIC_API_KEY": os.environ["ANTHROPIC_API_KEY"],
    },
    timeout=300,
)

# 2. Write and run the Browser Use agent
AGENT_SCRIPT = '''
import asyncio
from kernel import Kernel
from browser_use import Agent, Browser, ChatAnthropic

async def main():
    kernel = Kernel()
    kb = kernel.browsers.create()
    browser = Browser(cdp_url=kb.cdp_ws_url)

    agent = Agent(
        task="Go to https://news.ycombinator.com, find the top 5 stories, and return their titles and point counts as JSON",
        llm=ChatAnthropic(model="claude-sonnet-4"),
        browser=browser,
    )
    result = await agent.run()
    print(result)

asyncio.run(main())
'''

sandbox.files.write("/home/user/agent_task.py", AGENT_SCRIPT)
result = sandbox.commands.run("python3 /home/user/agent_task.py", timeout=180)
print(result.stdout)
sandbox.kill()
```

--------------------------------

### wait_for_timeout usage example

Source: https://docs.e2b.dev/sdk-reference/python-sdk/v2.51.0/readycmd

Example usage of wait_for_timeout with a Node image and start command.

```python
from e2b import Template, wait_for_timeout

template = (
    Template()
    .from_node_image()
    .set_start_cmd('npm start', wait_for_timeout(5000))  # Wait 5 seconds
)
```

--------------------------------

### Startup script (start_command.sh) for desktop template

Source: https://docs.e2b.dev/template/examples/desktop

Initializes the virtual display with Xvfb, launches the XFCE desktop session, starts the VNC server, and exposes the desktop via noVNC on port 6080. Runs automatically when the sandbox starts.

```bash
#!/bin/bash

# Set display
export DISPLAY=${DISPLAY:-:0}

# Start Xvfb
Xvfb $DISPLAY -ac -screen 0 1024x768x24 -nolisten tcp &
sleep 2

# Start XFCE session
startxfce4 &
sleep 5

# Start VNC server
x11vnc -bg -display $DISPLAY -forever -wait 50 -shared -rfbport 5900 -nopw \
    -noxdamage -noxfixes -nowf -noscr -ping 1 -repeat -speeds lan &
sleep 2

# Start noVNC server
cd /opt/noVNC/utils && ./novnc_proxy --vnc localhost:5900 --listen 6080 --web /opt/noVNC --heartbeat 30 &
sleep 2

```

--------------------------------

### wait_for_file usage example

Source: https://docs.e2b.dev/sdk-reference/python-sdk/v2.51.0/readycmd

Example usage of wait_for_file with a base image and start command.

```python
from e2b import Template, wait_for_file

template = (
    Template()
    .from_base_image()
    .set_start_cmd('./init.sh', wait_for_file('/tmp/ready'))
)
```

--------------------------------

### wait_for_process usage example

Source: https://docs.e2b.dev/sdk-reference/python-sdk/v2.51.0/readycmd

Example usage of wait_for_process with a base image and start command.

```python
from e2b import Template, wait_for_process

template = (
    Template()
    .from_base_image()
    .set_start_cmd('./my-daemon', wait_for_process('my-daemon'))
)
```

--------------------------------

### wait_for_url usage example

Source: https://docs.e2b.dev/sdk-reference/python-sdk/v2.51.0/readycmd

Example usage of wait_for_url with a Node image and start command.

```python
from e2b import Template, wait_for_url

template = (
    Template()
    .from_node_image()
    .set_start_cmd('npm start', wait_for_url('http://localhost:3000/health'))
)
```

--------------------------------

### Set up desktop sandbox and start VNC streaming

Source: https://docs.e2b.dev/use-cases/computer-use

Create a desktop sandbox with a 5-minute timeout and start VNC streaming for browser-based viewing. The stream URL is printed for access.

```javascript
import { Sandbox } from '@e2b/desktop'

// Create a desktop sandbox with a 5-minute timeout
const sandbox = await Sandbox.create({
  resolution: [1024, 720],
  dpi: 96,
  timeoutMs: 300_000,
})

// Start VNC streaming for browser-based viewing
await sandbox.stream.start()
const streamUrl = sandbox.stream.getUrl()
console.log('View desktop at:', streamUrl)

```

```python
from e2b_desktop import Sandbox

# Create a desktop sandbox with a 5-minute timeout
sandbox = Sandbox.create(
    resolution=(1024, 720),
    dpi=96,
    timeout=300,
)

# Start VNC streaming for browser-based viewing
sandbox.stream.start()
stream_url = sandbox.stream.get_url()
print("View desktop at:", stream_url)

```

--------------------------------

### Start build (v2)

Source: https://docs.e2b.dev/llms.txt

Start the build.

```APIDOC
## [POST] /v2/templates/{templateID}/builds

### Description
Start the build.

### Method
POST

### Endpoint
/v2/templates/{templateID}/builds
```

--------------------------------

### wait_for_port usage example

Source: https://docs.e2b.dev/sdk-reference/python-sdk/v2.51.0/readycmd

Example usage of wait_for_port with a Python image and start command.

```python
from e2b import Template, wait_for_port

template = (
    Template()
    .from_python_image()
    .set_start_cmd('python -m http.server 8000', wait_for_port(8000))
)
```

--------------------------------

### get_build_status example

Source: https://docs.e2b.dev/sdk-reference/python-sdk/v2.51.0/template_async

Example of getting build status using AsyncTemplate.get_build_status with a build_info from build_in_background.

```python
from e2b import AsyncTemplate

build_info = await AsyncTemplate.build_in_background(template, alias='my-template')
status = await AsyncTemplate.get_build_status(build_info)
```

--------------------------------

### from_ubuntu_image method and example

Source: https://docs.e2b.dev/sdk-reference/python-sdk/v2.51.0/template

Start template from an Ubuntu base image. Arguments: variant (Ubuntu image variant, default 'latest'). Returns TemplateBuilder. Example uses '24.04'.

```python
def from_ubuntu_image(variant: str = "latest") -> TemplateBuilder

```

```python
Template().from_ubuntu_image('24.04')

```

--------------------------------

### waitForProcess() usage example

Source: https://docs.e2b.dev/sdk-reference/js-sdk/v2.51.0/template-readycmd

Example showing how to use waitForProcess with Template to wait for a process before starting the command.

```typescript
import { Template, waitForProcess } from 'e2b'

const template = Template()
  .fromBaseImage()
  .setStartCmd('./my-daemon', waitForProcess('my-daemon'))

```

--------------------------------

### Install letta-client

Source: https://docs.e2b.dev/agents/letta

Install the Letta Python client.

```bash
pip install letta-client
```

--------------------------------

### waitForPort() usage example

Source: https://docs.e2b.dev/sdk-reference/js-sdk/v2.51.0/template-readycmd

Example showing how to use waitForPort with Template to wait for a port before starting the command.

```typescript
import { Template, waitForPort } from 'e2b'

const template = Template()
  .fromPythonImage()
  .setStartCmd('python -m http.server 8000', waitForPort(8000))

```

--------------------------------

### waitForFile() usage example

Source: https://docs.e2b.dev/sdk-reference/js-sdk/v2.51.0/template-readycmd

Example showing how to use waitForFile with Template to wait for a file before starting the command.

```typescript
import { Template, waitForFile } from 'e2b'

const template = Template()
  .fromBaseImage()
  .setStartCmd('./init.sh', waitForFile('/tmp/ready'))

```

--------------------------------

### Create sandbox and start OpenCode

Source: https://docs.e2b.dev/agents/opencode

Create a sandbox with the E2B CLI using the pre-built `opencode` template, then start OpenCode inside the sandbox.

```bash
e2b sbx create opencode
```

```bash
opencode
```

--------------------------------

### Python: More set_ready_cmd examples

Source: https://docs.e2b.dev/template/start-ready-command

Shows three additional readiness checks: waiting for a file, a fixed timeout, and a custom curl command.

```python
# Wait for a file to be created by a background process
template.set_ready_cmd(wait_for_file("/tmp/ready"))

# Wait a fixed duration for the system to stabilize
template.set_ready_cmd(wait_for_timeout(10_000))

# Custom readiness check
template.set_ready_cmd("curl -s http://localhost:8080/health")

```

--------------------------------

### waitForTimeout() usage example

Source: https://docs.e2b.dev/sdk-reference/js-sdk/v2.51.0/template-readycmd

Example showing how to use waitForTimeout with Template to wait for a fixed duration before starting the command.

```typescript
import { Template, waitForTimeout } from 'e2b'

const template = Template()
  .fromNodeImage()
  .setStartCmd('npm start', waitForTimeout(5000)) // Wait 5 seconds

```

--------------------------------

### Example: create and connect to a sandbox

Source: https://docs.e2b.dev/sdk-reference/js-sdk/v2.51.0/sandbox

Example showing how to create a sandbox and then connect to the same sandbox using its ID.

```typescript
const sandbox = await Sandbox.create()
const sandboxId = sandbox.sandboxId

// Connect to the same sandbox.
const sameSandbox = await Sandbox.connect(sandboxId)
```

--------------------------------

### Java Unirest GET /metrics

Source: https://docs.e2b.dev/api-reference/envd/service-stats

Java example using Unirest to GET /metrics. It returns the response as a string.

```java
HttpResponse<String> response = Unirest.get("https://sandbox.e2b.app/metrics")
  .header("E2b-Sandbox-Port", "49983")
  .header("E2b-Sandbox-Id", "<e2b-sandbox-id>")
  .header("X-Access-Token", "<api-key>")
  .asString();
```

--------------------------------

### fromArchImage() example

Source: https://docs.e2b.dev/sdk-reference/js-sdk/v2.51.0/template

Starts a template from an Arch Linux-based Docker image. Defaults to 'latest' because Arch is a rolling release and provisioning runs pacman -Syu.

```typescript
Template().fromArchImage('base-devel')
```

--------------------------------

### Go net/http GET /metrics

Source: https://docs.e2b.dev/api-reference/envd/service-stats

Go example using net/http to GET /metrics. It reads the response body and prints it.

```go
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://sandbox.e2b.app/metrics"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("E2b-Sandbox-Port", "49983")
	req.Header.Add("E2b-Sandbox-Id", "<e2b-sandbox-id>")
	req.Header.Add("X-Access-Token", "<api-key>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}
```

--------------------------------

### Start Devin and log in

Source: https://docs.e2b.dev/agents/devin

Starts Devin inside the sandbox and begins the interactive login flow. You can create a Devin account during sign up if you don't have one.

```bash
devin
```

--------------------------------

### JavaScript fetch GET /metrics

Source: https://docs.e2b.dev/api-reference/envd/service-stats

JavaScript example using fetch to GET /metrics. It parses the response as JSON and logs it.

```javascript
const options = {
  method: 'GET',
  headers: {
    'E2b-Sandbox-Port': '49983',
    'E2b-Sandbox-Id': '<e2b-sandbox-id>',
    'X-Access-Token': '<api-key>'
  }
};

fetch('https://sandbox.e2b.app/metrics', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));
```

--------------------------------

### Start build (v2) - POST /v2/templates/{templateID}/builds/{buildID}

Source: https://docs.e2b.dev/api-reference/templates/start-build-v2

These examples show how to call the E2B API endpoint POST /v2/templates/{templateID}/builds/{buildID} to start a build. Each example sends a JSON payload with fields like fromImage, fromTemplate, fromImageRegistry, force, steps, startCmd, and readyCmd, and requires the X-API-Key header. The cURL example is the canonical request; the other languages are equivalent client implementations.

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.e2b.app/v2/templates/{templateID}/builds/{buildID}")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["X-API-Key"] = '<api-key>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"fromImage\": \"<string>\",\n  \"fromTemplate\": \"<string>\",\n  \"fromImageRegistry\": {\n    \"type\": \"aws\",\n    \"awsAccessKeyId\": \"<string>\",\n    \"awsSecretAccessKey\": \"<string>\",\n    \"awsRegion\": \"<string>\"\n  },\n  \"force\": false,\n  \"steps\": [],\n  \"startCmd\": \"<string>\",\n  \"readyCmd\": \"<string>\"\n}"

response = http.request(request)
puts response.read_body
```

```bash
curl --request POST \
  --url https://api.e2b.app/v2/templates/{templateID}/builds/{buildID} \
  --header 'Content-Type: application/json' \
  --header 'X-API-Key: <api-key>' \
  --data '
{
  "fromImage": "<string>",
  "fromTemplate": "<string>",
  "fromImageRegistry": {
    "type": "aws",
    "awsAccessKeyId": "<string>",
    "awsSecretAccessKey": "<string>",
    "awsRegion": "<string>"
  },
  "force": false,
  "steps": [],
  "startCmd": "<string>",
  "readyCmd": "<string>"
}
'
```

```python
import requests

url = "https://api.e2b.app/v2/templates/{templateID}/builds/{buildID}"

payload = {
    "fromImage": "<string>",
    "fromTemplate": "<string>",
    "fromImageRegistry": {
        "type": "aws",
        "awsAccessKeyId": "<string>",
        "awsSecretAccessKey": "<string>",
        "awsRegion": "<string>"
    },
    "force": False,
    "steps": [],
    "startCmd": "<string>",
    "readyCmd": "<string>"
}
headers = {
    "X-API-Key": "<api-key>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.text)
```

```javascript
const options = {
  method: 'POST',
  headers: {'X-API-Key': '<api-key>', 'Content-Type': 'application/json'},
  body: JSON.stringify({
    fromImage: '<string>',
    fromTemplate: '<string>',
    fromImageRegistry: {
      type: 'aws',
      awsAccessKeyId: '<string>',
      awsSecretAccessKey: '<string>',
      awsRegion: '<string>'
    },
    force: false,
    steps: [],
    startCmd: '<string>',
    readyCmd: '<string>'
  })
};

fetch('https://api.e2b.app/v2/templates/{templateID}/builds/{buildID}', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));
```

```php
<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.e2b.app/v2/templates/{templateID}/builds/{buildID}",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'fromImage' => '<string>',
    'fromTemplate' => '<string>',
    'fromImageRegistry' => [
        'type' => 'aws',
        'awsAccessKeyId' => '<string>',
        'awsSecretAccessKey' => '<string>',
        'awsRegion' => '<string>'
    ],
    'force' => false,
    'steps' => [
        
    ],
    'startCmd' => '<string>',
    'readyCmd' => '<string>'
  ]),
  CURLOPT_HTTPHEADER => [
    "Content-Type: application/json",
    "X-API-Key: <api-key>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
```

```go
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.e2b.app/v2/templates/{templateID}/builds/{buildID}"

	payload := strings.NewReader("{\n  \"fromImage\": \"<string>\",\n  \"fromTemplate\": \"<string>\",\n  \"fromImageRegistry\": {\n    \"type\": \"aws\",\n    \"awsAccessKeyId\": \"<string>\",\n    \"awsSecretAccessKey\": \"<string>\",\n    \"awsRegion\": \"<string>\"\n  },\n  \"force\": false,\n  \"steps\": [],\n  \"startCmd\": \"<string>\",\n  \"readyCmd\": \"<string>\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("X-API-Key", "<api-key>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}
```

```java
HttpResponse<String> response = Unirest.post("https://api.e2b.app/v2/templates/{templateID}/builds/{buildID}")
  .header("X-API-Key", "<api-key>")
  .header("Content-Type", "application/json")
  .body("{\n  \"fromImage\": \"<string>\",\n  \"fromTemplate\": \"<string>\",\n  \"fromImageRegistry\": {\n    \"type\": \"aws\",\n    \"awsAccessKeyId\": \"<string>\",\n    \"awsSecretAccessKey\": \"<string>\",\n    \"awsRegion\": \"<string>\"\n  },\n  \"force\": false,\n  \"steps\": [],\n  \"startCmd\": \"<string>\",\n  \"readyCmd\": \"<string>\"\n}")
  .asString();
```

--------------------------------

### Python requests GET /metrics

Source: https://docs.e2b.dev/api-reference/envd/service-stats

Python example using the requests library to GET /metrics. It prints the response text.

```python
import requests

url = "https://sandbox.e2b.app/metrics"

headers = {
    "E2b-Sandbox-Port": "49983",
    "E2b-Sandbox-Id": "<e2b-sandbox-id>",
    "X-Access-Token": "<api-key>"
}

response = requests.get(url, headers=headers)

print(response.text)
```

--------------------------------

### POST /process.Process/Start

Source: https://docs.e2b.dev/api-reference/process/start

Starts a new process in a sandbox using the Connect protocol.

```APIDOC
## POST /process.Process/Start

### Description
Starts a new process in a sandbox. The request body is a JSON-encoded string that represents the process to start.

### Method
POST

### Endpoint
https://sandbox.e2b.app/process.Process/Start

### Parameters
#### Headers
- **Connect-Protocol-Version** (string) - Required - The Connect protocol version.
- **Content-Type** (string) - Required - Must be `application/connect+json`.
- **E2b-Sandbox-Id** (string) - Required - The ID of the sandbox.
- **E2b-Sandbox-Port** (string) - Required - The sandbox port, typically `49983`.
- **X-Access-Token** (string) - Required - The access token for the sandbox.

#### Request Body
- **body** (string) - Required - A JSON-encoded string representing the process to start.

### Request Example
```json
"<string>"
```

### Response
#### Success Response (200)
- **body** (string) - The response body, which may contain a terminal error if the flags indicate so.

#### Response Example
```json
"<string>"
```

#### Error Responses
- **400** - Bad request, e.g., missing header.
- **401** - Unauthorized.
- **500** - Internal server error.
- **502** - Bad gateway.

#### Error Example
```
"missing header\n"
```
```

--------------------------------

### Example pip install errors: MemoryError and OSError

Source: https://docs.e2b.dev/faq/pip-install-error

Two example errors that occur when pip install fails due to RAM-backed /tmp limits: a MemoryError from pip's cache serialization and an OSError indicating no space left on device.

```text
File "pip/_vendor/cachecontrol/serialize.py", line 70, in dumps
    return b",".join([b"cc=4", msgpack.dumps(data, use_bin_type=True)])
MemoryError

```

```text
ERROR: Could not install packages due to an OSError: [Errno 28] No space left on device

```
Tokens:
Raw