Function Compute:Browser template

Prepare the local environment

Python:

uv venv .venv --python 3.12
source .venv/bin/activate
uv pip install e2b==2.31.0 e2b-code-interpreter==2.8.1 'playwright>=1.49.0'
playwright install chromium

Node.js: use the following package.json, then run npm install.

{
  "name": "browser-template-demo",
  "version": "1.0.0",
  "type": "module",
  "dependencies": {
    "@e2b/code-interpreter": "^2.6.1",
    "e2b": "^2.31.0",
    "playwright-core": "^1.49.0"
  }
}

Build the browser template

Build a named template from the browser image, specifying CPU and memory (4 vCPU / 8192 MB recommended) at build time.

Python:

"""Browser template build example."""

import os

from dotenv import load_dotenv
from e2b import Template, default_build_logger

load_dotenv()

# The SDK reads E2B_API_KEY / E2B_API_URL / E2B_DOMAIN automatically.
FROM_IMAGE = "fc-e2b-registry.cn-beijing.cr.aliyuncs.com/runtime/browser:v0.0.44"

build = Template.build(
    Template().from_image(FROM_IMAGE),
    name="my-browser-template",
    cpu_count=4,
    memory_mb=8192,
    on_build_logs=default_build_logger(),
)
print(f"template_id: {build.template_id}")

Node.js:

// Browser template build example.
import { Template, defaultBuildLogger } from 'e2b';

// The SDK reads E2B_API_KEY / E2B_API_URL / E2B_DOMAIN automatically.
const FROM_IMAGE =
  'fc-e2b-registry.cn-beijing.cr.aliyuncs.com/runtime/browser:v0.0.44';

const build = await Template.build(Template().fromImage(FROM_IMAGE), 'my-browser-template', {
  cpuCount: 4,
  memoryMB: 8192,
  onBuildLogs: defaultBuildLogger(),
});
console.log(`template_id: ${build.templateId}`);

Run the template and verify

After creating the sandbox, poll /health until the browser service is ready, then connect Playwright over the CDP endpoint to open the target page and take a screenshot.

Python:

"""Browser template run example: create sandbox -> wait for health check -> CDP automation -> screenshot."""

import time

from e2b_code_interpreter import Sandbox
from playwright.sync_api import sync_playwright

# The SDK reads E2B_API_KEY / E2B_API_URL / E2B_DOMAIN automatically.
BROWSER_PORT = 3000


def wait_until_healthy(sbx: Sandbox, host: str, token: str, timeout: int = 60) -> None:
    """Poll the public gateway /health endpoint until the browser service is ready or times out."""
    token_header = f"-H 'X-Access-Token: {token}' " if token else ""
    deadline = time.time() + timeout
    while time.time() < deadline:
        result = sbx.commands.run(
            f"curl -sS -o /dev/null -w '%{{http_code}}' -m 4 {token_header}https://{host}/health",
            timeout=10,
        )
        if "".join(result.stdout or []).strip() == "200":
            return
        time.sleep(2)
    raise TimeoutError(f"browser service not ready within {timeout}s")


sbx = None
try:
    sbx = Sandbox.create(template="my-browser-template", timeout=900)
    host = sbx.get_host(BROWSER_PORT)
    token = sbx._envd_access_token  # the public gateway requires X-Access-Token, otherwise 403
    headers = {"X-Access-Token": token} if token else {}

    wait_until_healthy(sbx, host, token)

    with sync_playwright() as p:
        browser = p.chromium.connect_over_cdp(f"wss://{host}/ws/automation", headers=headers)
        context = browser.contexts[0] if browser.contexts else browser.new_context()
        page = context.new_page()
        page.goto("https://example.com", wait_until="domcontentloaded", timeout=30000)
        print(f"page.title() = {page.title()!r}")
        page.screenshot(path="browser-example.png", full_page=True)
        browser.close()
finally:
    if sbx is not None:
        sbx.kill()

Node.js:

// Browser template run example: create sandbox -> wait for health check -> CDP automation -> screenshot.
import { Sandbox } from '@e2b/code-interpreter';
import { chromium } from 'playwright-core';

// The SDK reads E2B_API_KEY / E2B_API_URL / E2B_DOMAIN automatically.
const BROWSER_PORT = 3000;
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

/** Poll the public gateway /health endpoint until the browser service is ready or times out. */
async function waitUntilHealthy(sbx, host, token, timeout = 60) {
  const tokenHeader = token ? `-H 'X-Access-Token: ${token}' ` : '';
  const deadline = Date.now() + timeout * 1000;
  while (Date.now() < deadline) {
    let result;
    try {
      result = await sbx.commands.run(
        `curl -sS -o /dev/null -w '%{http_code}' -m 4 ${tokenHeader}https://${host}/health`,
        { timeoutMs: 10_000 },
      );
    } catch (e) {
      result = e; // while the service is down curl exits non-zero; the exception still carries stdout
    }
    if ((result.stdout || '').trim() === '200') return;
    await sleep(2000);
  }
  throw new Error(`browser service not ready within ${timeout}s`);
}

let sbx = null;
try {
  sbx = await Sandbox.create('my-browser-template', { timeoutMs: 900_000 });
  const host = sbx.getHost(BROWSER_PORT);
  const token = sbx.envdAccessToken; // the public gateway requires X-Access-Token, otherwise 403
  const headers = token ? { 'X-Access-Token': token } : {};

  await waitUntilHealthy(sbx, host, token);

  const browser = await chromium.connectOverCDP(`wss://${host}/ws/automation`, { headers });
  const contexts = browser.contexts();
  const context = contexts.length ? contexts[0] : await browser.newContext();
  const page = await context.newPage();
  await page.goto('https://example.com', { waitUntil: 'domcontentloaded', timeout: 30_000 });
  console.log(`page.title() = ${JSON.stringify(await page.title())}`);
  await page.screenshot({ path: 'browser-example.png', fullPage: true });
  await browser.close();
} finally {
  if (sbx !== null) await sbx.kill();
}