> **Building with AI coding agents?** Install the authstack plugin with one command. This equips your agent with accurate Scalekit implementation patterns. > > **Recommended** (the `-y` flags skip prompts, so the command runs without an interactive terminal): > ```bash > npx -y @scalekit-inc/cli setup -y > ``` > > Global: > ```bash > npm install -g @scalekit-inc/cli > scalekit setup -y > ``` > > Supports Claude Code, Cursor, GitHub Copilot, Codex + skills for other Agent Skills-compatible agents in `~/.agents/skills`. > Skills: integrate-agentkit, implement-saaskit, add-mcp-oauth, implement-sso, implement-scim. > [Full setup guide](https://docs.scalekit.com/dev-kit/build-with-ai/) --- # Connect AI agents to E2B The E2B connector lets your AI agent act in each user's E2B account. Each user connects their own E2B API key once, and Scalekit sends it with every call, so your agent never handles credentials. It comes with 38 tools. **Authentication:** API Key **Categories:** Developer Tools, AI **Tools:** 38: 20 read, 13 write, 5 destructive **Users sign in with:** API key **Built by:** Scalekit connector **Try it:** [Playground in the Scalekit dashboard](https://app.scalekit.com/ws/signup?sk_intent=playground&provider=E2B) ## Setup 1. ### Install the SDK **Node.js** ```bash npm install @scalekit-sdk/node dotenv ``` **Python** ```bash pip install scalekit-sdk-python python-dotenv ``` 2. ### Set your credentials Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. ```sh title=".env" SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Create the E2B connection In **AgentKit > Connections**, create an E2B connection. The name you give it is the `connection_name` your code passes. See [Configure connections](/agentkit/connections/). 4. ### Authorize a user and make your first call **Node.js** (`quickstart.mts`) ```typescript import { ScalekitClient } from '@scalekit-sdk/node' import 'dotenv/config' import { createInterface } from 'node:readline/promises' const scalekit = new ScalekitClient( process.env.SCALEKIT_ENVIRONMENT_URL, process.env.SCALEKIT_CLIENT_ID, process.env.SCALEKIT_CLIENT_SECRET, ) const actions = scalekit.actions const connector = 'e2b' const identifier = 'user_123' // Generate an authorization link for the user const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) console.log('Authorize E2B:', link) const rl = createInterface({ input: process.stdin, output: process.stdout }) await rl.question('Press Enter after authorizing...') rl.close() // Make your first call const result = await actions.executeTool({ connector, identifier, toolName: 'e2b_list_events', toolInput: {}, }) console.log(result) ``` ```bash npx tsx quickstart.mts ``` **Python** (`quickstart.py`) ```python import os from scalekit import ScalekitClient from dotenv import load_dotenv load_dotenv() scalekit_client = ScalekitClient( env_url=os.getenv("SCALEKIT_ENVIRONMENT_URL"), client_id=os.getenv("SCALEKIT_CLIENT_ID"), client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), ) actions = scalekit_client.actions connection_name = "e2b" identifier = "user_123" # Generate an authorization link for the user link_response = actions.get_authorization_link( connection_name=connection_name, identifier=identifier, ) print("Authorize E2B:", link_response.link) input("Press Enter after authorizing...") # Make your first call result = actions.execute_tool( tool_input={}, tool_name="e2b_list_events", connection_name=connection_name, identifier=identifier, ) print(result) ``` ```bash python quickstart.py ``` Each user opens the link once and enters their E2B credentials there. See [Authorize a user](/agentkit/tools/authorize/) for the full flow and statuses. ## Tools Pass the exact name to `execute_tool`, with an input like each tool's example. To ask for a tool that's missing, use the [request form](https://scalekitsupport.portal.usepylon.com/forms/request-a-connector-tool). **Node.js** ```typescript const result = await actions.executeTool({ toolName: 'e2b_get_sandbox', toolInput: { sandbox_id: '', }, connector: 'e2b', identifier: 'user_123', }) ``` **Python** ```python result = actions.execute_tool( tool_name="e2b_get_sandbox", tool_input={ "sandbox_id": "", }, connection_name="e2b", identifier="user_123", ) ``` `result.data` is the app's response as JSON, and `result.execution_id` (`executionId` in Node.js) is the ID of the call. ### `e2b_get_sandbox` Get Sandbox · Read-only Get one E2B sandbox by its ID. Returns sandboxID, templateID, alias, state, startedAt, endAt, cpuCount, memoryMB, diskSizeMB, metadata, envdVersion, envdAccessToken, domain, allowInternetAccess, network, lifecycle (autoResume and onTimeout) and volumeMounts. Use this for a single sandbox's details. Use e2b_list_sandboxes to find sandbox IDs. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `sandbox_id` (`string`, required): ID of the sandbox to get, as returned by e2b_create_sandbox or e2b_list_sandboxes (sandboxID). Example: iiny0783cype8gmoawzmx Example input: `{"sandbox_id":""}` ### `e2b_get_sandbox_logs` Get Sandbox Logs · Read-only Get the logs of an E2B sandbox, optionally filtered by level or text. Returns logs, an array of entries with timestamp, level, message and fields. Use this to debug what happened in a sandbox. Use e2b_list_sandbox_events for lifecycle events such as created or killed. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `sandbox_id` (`string`, required): ID of the sandbox to get logs for, as returned by e2b_create_sandbox or e2b_list_sandboxes (sandboxID). Example: iiny0783cype8gmoawzmx - `cursor` (`integer`, optional): Timestamp in Unix milliseconds to start returning logs from. Example: 1760486400000 - `direction` (`string`, optional): Read direction from the cursor: forward (newer) or backward (older). One of: `forward`, `backward`. - `level` (`string`, optional): Minimum log level to return, such as info, warn or error; lower levels are left out. Example: warn - `limit` (`integer`, optional): Maximum number of log entries to return, from 0 to 1000. Defaults to 1000. Example: 200. Default: `1000`. - `search` (`string`, optional): Case-sensitive text that the log message must contain. Example: Traceback Example input: `{"sandbox_id":""}` ### `e2b_get_sandbox_metrics` Get Sandbox Metrics · Read-only Get resource usage metrics over time for one E2B sandbox. Returns an array of samples with timestampUnix, cpuCount, cpuUsedPct, memUsed, memTotal, memCache, diskUsed and diskTotal (bytes). Use this for one sandbox's usage history. Use e2b_list_sandbox_metrics for the latest sample of several sandboxes at once. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `sandbox_id` (`string`, required): ID of the sandbox to get metrics for, as returned by e2b_create_sandbox or e2b_list_sandboxes (sandboxID). Example: iiny0783cype8gmoawzmx - `end` (`integer`, optional): End of the time interval as a Unix timestamp in seconds. Leave empty to use E2B's default window. Example: 1760490000 - `start` (`integer`, optional): Start of the time interval as a Unix timestamp in seconds. Leave empty to use E2B's default window. Example: 1760486400 Example input: `{"sandbox_id":""}` ### `e2b_get_secret` Get Secret · Read-only Get one E2B secret's metadata by its ID or name. Returns secretID, name, currentVersion, metadata, createdAt and updatedAt; the secret value is never returned. Use this to check a secret exists and see its current version. Use e2b_list_secrets to browse. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `secret_id` (`string`, required): The secret to get: its ID (sec_...) or its name. Example: stripe_api_key Example input: `{"secret_id":""}` ### `e2b_get_team_max_metric` Get Team Max Metric · Read-only Get the peak value of one E2B team metric in a time window. Returns timestampUnix and value of the maximum. Use this to check peak concurrency or start rate against plan limits. Use e2b_get_team_metrics for the full time series. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `metric` (`string`, required): Metric to get the maximum of: concurrent_sandboxes or sandbox_start_rate. One of: `concurrent_sandboxes`, `sandbox_start_rate`. - `team_id` (`string`, required): Your team identifier, as its UUID or its public project ID (prj_...), shown in the E2B console. Example: prj_8f3k2l9q - `end` (`integer`, optional): End of the time interval as a Unix timestamp in seconds. Leave empty to use E2B's default window. Example: 1760490000 - `start` (`integer`, optional): Start of the time interval as a Unix timestamp in seconds. Leave empty to use E2B's default window. Example: 1760486400 Example input: `{"metric":"concurrent_sandboxes","team_id":""}` ### `e2b_get_team_metrics` Get Team Metrics · Read-only Get your E2B team's sandbox usage over time. Returns an array of samples with timestampUnix, concurrentSandboxes and sandboxStartRate. Use this to chart concurrency and start rate. Use e2b_get_team_max_metric for the peak value in a window. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `team_id` (`string`, required): Your team identifier, as its UUID or its public project ID (prj_...), shown in the E2B console. Example: prj_8f3k2l9q - `end` (`integer`, optional): End of the time interval as a Unix timestamp in seconds. Leave empty to use E2B's default window. Example: 1760490000 - `start` (`integer`, optional): Start of the time interval as a Unix timestamp in seconds. Leave empty to use E2B's default window. Example: 1760486400 Example input: `{"team_id":""}` ### `e2b_get_template` Get Template · Read-only Get one E2B template and its builds. Returns templateID, names, aliases, public, createdAt, updatedAt, lastSpawnedAt, spawnCount and builds (each with buildID, status, cpuCount, memoryMB, diskSizeMB, envdVersion, createdAt and finishedAt). The cursor for more builds is in the X-Next-Token response header. Use this to see a template's build history and get a buildID. Use e2b_list_templates to find template IDs. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `template_id` (`string`, required): ID of the template to get, as returned by e2b_list_templates (templateID). Example: rki5dems9wqfm4r03t7g - `limit` (`integer`, optional): Maximum number of builds to return per page, from 1 to 100. Defaults to 100. Example: 50. Default: `100`. - `next_token` (`string`, optional): Pagination cursor. Pass the value of the X-Next-Token response header from the previous page to get the next page; leave empty for the first page. Example input: `{"template_id":""}` ### `e2b_get_template_build_logs` Get Template Build Logs · Read-only Get the logs of an E2B template build, paged by time. Returns logs, an array of entries with timestamp, level, message and step. Use this to read a long build log. Use e2b_get_template_build_status to check whether the build succeeded. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `build_id` (`string`, required): ID of the template build, from the builds list in e2b_get_template (buildID). Example: a979a14b-bdcc-49e6-bc04-1189fc9fe7c2 - `template_id` (`string`, required): ID of the template to read logs for, as returned by e2b_list_templates (templateID). Example: rki5dems9wqfm4r03t7g - `cursor` (`integer`, optional): Timestamp in Unix milliseconds to start returning logs from. Example: 1760486400000 - `direction` (`string`, optional): Read direction from the cursor: forward (newer) or backward (older). One of: `forward`, `backward`. - `level` (`string`, optional): Minimum log level to return, such as info, warn or error. Example: warn - `limit` (`integer`, optional): Maximum number of log entries to return, from 0 to 100. Defaults to 100. Example: 50. Default: `100`. - `source` (`string`, optional): Where to read logs from: temporary (live build logs) or persistent (stored logs). One of: `temporary`, `persistent`. Example input: `{"build_id":"","template_id":""}` ### `e2b_get_template_build_status` Get Template Build Status · Read-only Get the status of an E2B template build, with its structured build logs. Returns templateID, buildID, status (building, waiting, ready, error or uploaded), reason (message and failed step on error) and logEntries (timestamp, level, message, step). Use this to check whether a build finished. Use e2b_get_template_build_logs to page through logs by time. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `build_id` (`string`, required): ID of the template build, from the builds list in e2b_get_template (buildID). Example: a979a14b-bdcc-49e6-bc04-1189fc9fe7c2 - `template_id` (`string`, required): ID of the template to check, as returned by e2b_list_templates (templateID). Example: rki5dems9wqfm4r03t7g - `level` (`string`, optional): Minimum log level to return, such as info, warn or error. Example: error - `limit` (`integer`, optional): Maximum number of log entries to return, from 0 to 100. Defaults to 100. Example: 50. Default: `100`. - `logs_offset` (`integer`, optional): Index of the first build log entry to return. Defaults to 0. Example: 100. Default: `0`. Example input: `{"build_id":"","template_id":""}` ### `e2b_get_template_by_alias` Get Template by Alias · Read-only Look up an E2B template by its alias to check that it exists. Returns the template's templateID and whether it is public. Use this to turn a template name into its ID. Use e2b_get_template for full details once you have the ID. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `alias` (`string`, required): The template alias (name) to look up. Example: code-interpreter-v1 Example input: `{"alias":""}` ### `e2b_get_volume` Get Volume · Read-only Get one E2B volume by its ID. Returns volumeID, name, token and domain. Use this to get a volume's access token and domain. Use e2b_list_volumes to find volume IDs. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `volume_id` (`string`, required): ID of the volume, as returned by e2b_list_volumes (volumeID). Example: 7d3f9a2e-1c4b-4e8a-9f60-2b5d8c1e4a73 Example input: `{"volume_id":""}` ### `e2b_list_events` List Events · Read-only List lifecycle events for all sandboxes in the E2B project, such as created, paused, resumed and killed. Returns an array of events with id, type, timestamp, eventData, sandboxId, sandboxExecutionId, sandboxTemplateId, sandboxBuildId and sandboxTeamId. Use this for project-wide sandbox activity. Use e2b_list_sandbox_events for one sandbox. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `limit` (`integer`, optional): Maximum number of events to return, from 1 to 100. Defaults to 10. Example: 50. Default: `10`. - `offset` (`integer`, optional): Number of events to skip, for paging through results. Defaults to 0. Example: 10. Default: `0`. - `order_asc` (`boolean`, optional): Set to true to return events oldest first. Defaults to false (newest first). Default: `false`. - `types` (`array`, optional): Only return events of these types. Known lifecycle types: sandbox.lifecycle.created, sandbox.lifecycle.killed, sandbox.lifecycle.paused, sandbox.lifecycle.resumed, sandbox.lifecycle.updated, sandbox.lifecycle.checkpointed. Example: ["sandbox.lifecycle.created", "sandbox.lifecycle.killed"] Example input: `{}` ### `e2b_list_sandbox_events` List Sandbox Events · Read-only List lifecycle events for one E2B sandbox, such as created, paused, resumed and killed. Returns an array of events with id, type, timestamp, eventData, sandboxId, sandboxExecutionId, sandboxTemplateId, sandboxBuildId and sandboxTeamId. Use this for one sandbox's history. Use e2b_list_events for every sandbox in the project, and e2b_get_sandbox_logs for its log output. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `sandbox_id` (`string`, required): ID of the sandbox to list events for, as returned by e2b_create_sandbox or e2b_list_sandboxes (sandboxID). Example: iiny0783cype8gmoawzmx - `limit` (`integer`, optional): Maximum number of events to return, from 1 to 100. Defaults to 10. Example: 50. Default: `10`. - `offset` (`integer`, optional): Number of events to skip, for paging through results. Defaults to 0. Example: 10. Default: `0`. - `order_asc` (`boolean`, optional): Set to true to return events oldest first. Defaults to false (newest first). Default: `false`. - `types` (`array`, optional): Only return events of these types. Known lifecycle types: sandbox.lifecycle.created, sandbox.lifecycle.killed, sandbox.lifecycle.paused, sandbox.lifecycle.resumed, sandbox.lifecycle.updated, sandbox.lifecycle.checkpointed. Example: ["sandbox.lifecycle.created", "sandbox.lifecycle.killed"] Example input: `{"sandbox_id":""}` ### `e2b_list_sandbox_metrics` List Sandbox Metrics · Read-only Get the latest resource usage metrics for several E2B sandboxes in one call. Returns sandboxes, an object keyed by sandbox ID whose values hold timestampUnix, cpuCount, cpuUsedPct, memUsed, memTotal, memCache, diskUsed and diskTotal. Use this to compare current usage across sandboxes. Use e2b_get_sandbox_metrics for one sandbox's history. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `sandbox_ids` (`string`, required): Comma-separated list of sandbox IDs to get metrics for. Example: iiny0783cype8gmoawzmx,ig6f1yt6idvxkxl562scj Example input: `{"sandbox_ids":""}` ### `e2b_list_sandboxes` List Sandboxes · Read-only List the sandboxes in the E2B project, optionally filtered by state, metadata, template or start time. Returns an array of sandboxes with sandboxID, templateID, alias, state (running or paused), startedAt, endAt, cpuCount, memoryMB, diskSizeMB, metadata and volumeMounts. The cursor for the next page is in the X-Next-Token response header. Use this to find sandboxes. Use e2b_get_sandbox for one sandbox's full details, including its network and lifecycle settings. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `limit` (`integer`, optional): Maximum number of sandboxes to return per page, from 1 to 100. Defaults to 100. Example: 50. Default: `100`. - `metadata` (`string`, optional): Filter by sandbox metadata, written as key=value pairs joined with &. Example: user=abc&app=prod - `next_token` (`string`, optional): Pagination cursor. Pass the value of the X-Next-Token response header from the previous page to get the next page; leave empty for the first page. - `order` (`string`, optional): Sort direction by sandbox start time: desc (newest first, the default) or asc. One of: `asc`, `desc`. Default: `desc`. - `started_after` (`string`, optional): Only return sandboxes started at or after this time, as an RFC 3339 timestamp. Example: 2026-10-01T00:00:00Z - `state` (`string`, optional): Filter by sandbox state: running, paused, or both as a comma-separated list. Example: running,paused - `template` (`string`, optional): Only return sandboxes created from this template ID or alias. Example: rki5dems9wqfm4r03t7g Example input: `{}` ### `e2b_list_secrets` List Secrets · Read-only List the secrets stored in the E2B project. Returns an array of secrets with secretID, name, currentVersion, metadata, createdAt and updatedAt; secret values are never returned. The cursor for the next page is in the X-Next-Token response header. Use this to find a secret. Use e2b_get_secret for one secret. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `limit` (`integer`, optional): Maximum number of secrets to return per page, from 1 to 100. Defaults to 100. Example: 50. Default: `100`. - `next_token` (`string`, optional): Pagination cursor. Pass the value of the X-Next-Token response header from the previous page to get the next page; leave empty for the first page. Example input: `{}` ### `e2b_list_snapshots` List Snapshots · Read-only List the snapshots in the E2B project, optionally filtered by source sandbox or name. Returns an array of snapshots with snapshotID and names. The cursor for the next page is in the X-Next-Token response header. Use this to find a snapshot to start a sandbox from. Create one with e2b_create_snapshot. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `limit` (`integer`, optional): Maximum number of snapshots to return per page, from 1 to 100. Defaults to 100. Example: 50. Default: `100`. - `name` (`string`, optional): Filter by snapshot name or ID, optionally with a team or tag. Example: my-snapshot:v1 - `next_token` (`string`, optional): Pagination cursor. Pass the value of the X-Next-Token response header from the previous page to get the next page; leave empty for the first page. - `sandbox_id` (`string`, optional): Only return snapshots taken from this sandbox. Example: iiny0783cype8gmoawzmx Example input: `{}` ### `e2b_list_template_tags` List Template Tags · Read-only List the tags on an E2B template. Returns an array of tags with tag, buildID and createdAt. Use this to see which build each tag points to. Use e2b_assign_template_tags to add tags. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `template_id` (`string`, required): ID of the template to list tags for, as returned by e2b_list_templates (templateID). Example: rki5dems9wqfm4r03t7g Example input: `{"template_id":""}` ### `e2b_list_templates` List Templates · Read-only List the sandbox templates in the E2B project. Returns an array of templates with templateID, buildID, names, aliases, public, buildStatus, cpuCount, memoryMB, diskSizeMB, envdVersion, createdAt, updatedAt, lastSpawnedAt, spawnCount and buildCount. The cursor for the next page is in the X-Next-Token response header. Use this to find a template ID for e2b_create_sandbox. Use e2b_get_template for a template's builds, or e2b_get_template_by_alias to look one up by name. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `limit` (`integer`, optional): Maximum number of templates to return per page, from 1 to 100. Defaults to 100. Example: 50. Default: `100`. - `next_token` (`string`, optional): Pagination cursor. Pass the value of the X-Next-Token response header from the previous page to get the next page; leave empty for the first page. - `team_id` (`string`, optional): Optional team identifier, as its UUID or public project ID (prj_...). Usually not needed, because the API key is already scoped to one project. Example: prj_8f3k2l9q Example input: `{}` ### `e2b_list_volumes` List Volumes · Read-only List the persistent volumes in the E2B project. Returns an array of volumes with volumeID and name. Use this to find a volume to mount with e2b_create_sandbox. Use e2b_get_volume for a volume's access details. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: none. Example input: `{}` ### `e2b_assign_template_tags` Assign Template Tags · Write Assign one or more tags to a build of an E2B template. Returns tags (the assigned tags) and buildID. Use this to label a build, for example as production. Use e2b_delete_template_tags to remove tags. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `tags` (`array`, required): Tags to assign to the target build. Example: ["production", "v2"] - `target` (`string`, required): The template build to tag, written as template-name:existing-tag. Example: my-template:latest Example input: `{"tags":["production","v2"],"target":""}` ### `e2b_connect_sandbox` Connect Sandbox · Write Connect to an E2B sandbox, resuming it first if it is paused, and extend its time to live. Returns sandboxID, templateID, alias, envdVersion, envdAccessToken, trafficAccessToken and domain. Use this to resume a paused sandbox or to get a running sandbox's access tokens. The timeout only ever extends the sandbox's life; use e2b_set_sandbox_timeout to shorten it. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `sandbox_id` (`string`, required): ID of the sandbox to connect to, as returned by e2b_create_sandbox or e2b_list_sandboxes (sandboxID). Example: iiny0783cype8gmoawzmx - `memory` (`boolean`, optional): Only used when the sandbox is paused. true (the API default) restores its memory; false cold-boots it from its disk state only. - `timeout` (`integer`, optional): Seconds from now after which the sandbox should expire. Only extends the current time to live. Defaults to 300. Example: 600. Default: `300`. Example input: `{"sandbox_id":""}` ### `e2b_create_sandbox` Create Sandbox · Write Start a new E2B sandbox from a template, with an optional time to live, auto-pause, metadata, environment variables, network rules and volume mounts. Returns the new sandbox's sandboxID, templateID, alias, envdVersion, envdAccessToken, trafficAccessToken and domain. Use this to start a sandbox. Use e2b_connect_sandbox to resume a paused one, and e2b_fork_sandbox to clone a running one. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `template_id` (`string`, required): ID or alias of the template to start the sandbox from. Use base for E2B's default template, or an ID from e2b_list_templates. Example: rki5dems9wqfm4r03t7g - `allow_internet_access` (`boolean`, optional): Set to false to block all outbound internet access (same as denying 0.0.0.0/0). Leave empty to keep the default, which allows outbound access. - `auto_pause` (`boolean`, optional): Set to true to pause the sandbox instead of killing it when the timeout runs out. Defaults to false. Default: `false`. - `auto_pause_memory` (`boolean`, optional): Only used when auto_pause is true. true (the API default) keeps a full memory snapshot on auto-pause; false keeps only the filesystem, and resuming then reboots the sandbox. false can't be combined with auto_resume. - `auto_resume` (`boolean`, optional): Set to true to let a paused sandbox resume automatically when traffic reaches it. Leave empty for the API default (off). - `env_vars` (`object`, optional): Environment variables to set inside the sandbox, as a JSON object of string values. Example: {"NODE_ENV": "production"} - `metadata` (`object`, optional): String key-value pairs to attach to the sandbox, used later to filter e2b_list_sandboxes. Example: {"user": "abc", "app": "prod"} - `network` (`object`, optional): Egress and access rules for the sandbox. Supported keys: allowOut and denyOut (lists of CIDRs, IPs, or for allowOut also domains), allowPublicTraffic (false requires auth on sandbox URLs), maskRequestHost, httpsPorts, egressProxy and rules. Allowed entries win over denied ones. Example: {"allowOut": ["api.github.com"], "denyOut": ["0.0.0.0/0"]} - `timeout` (`integer`, optional): Time to live for the sandbox in seconds; it is killed (or paused, if auto_pause is true) when this runs out. Defaults to 300. Your plan caps the maximum. Example: 600. Default: `300`. - `volume_mounts` (`array`, optional): Volumes to mount in the sandbox. Each entry gives the volume's name (from e2b_list_volumes) and the absolute path to mount it at. Example: [{"name": "my-data", "path": "/mnt/data"}] Example input: `{"template_id":""}` ### `e2b_create_secret` Create Secret · Write Store a new secret in E2B so sandboxes can use it through network rules without seeing its value. Returns secretID, name, currentVersion, metadata, createdAt and updatedAt; the secret value is never returned. Use this for a new secret name; a name that already exists returns 409. Use e2b_update_secret to rotate an existing secret's value. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `name` (`string`, required): Name of the secret, unique in the project: 1-128 letters, digits, underscores or hyphens, stored in lowercase. It can't start with sec_. Example: stripe_api_key - `value` (`string`, required): The secret value to store, such as an API key. E2B stores it encrypted and injects it into matching outbound requests from sandboxes; it is never returned. Example: sk_live_... - `metadata` (`object`, optional): String key-value labels for the secret, at most 32 entries. Example: {"environment": "production"} Example input: `{"name":"","value":""}` ### `e2b_create_snapshot` Create Snapshot · Write Create a persistent snapshot of an E2B sandbox's current state that new sandboxes can start from. Returns snapshotID and names (the snapshot's template names). Use this to save a sandbox's state beyond its lifetime; start from it later with e2b_create_sandbox using a returned name. Use e2b_fork_sandbox to copy a sandbox right away. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `sandbox_id` (`string`, required): ID of the sandbox to snapshot, as returned by e2b_create_sandbox or e2b_list_sandboxes (sandboxID). Example: iiny0783cype8gmoawzmx - `memory` (`boolean`, optional): Set to false to save only the filesystem: smaller and faster, but sandboxes started from it boot fresh. Leave empty for the API default (full memory snapshot). - `name` (`string`, optional): Optional snapshot name. If a snapshot with this name already exists, the new snapshot becomes a new build of it. Example: my-snapshot Example input: `{"sandbox_id":""}` ### `e2b_create_volume` Create Volume · Write Create a persistent E2B volume that can be mounted into sandboxes. Returns volumeID, name, token and domain. Use this to make shared storage that outlives sandboxes, then mount it by name with e2b_create_sandbox. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `name` (`string`, required): Name of the new volume; you use it to mount the volume in a sandbox. Example: my-data Example input: `{"name":""}` ### `e2b_fork_sandbox` Fork Sandbox · Write Fork a running E2B sandbox: snapshot it in place, with full memory, and start one or more new sandboxes from that snapshot. Returns an array with one result per fork, each holding either sandbox (sandboxID, templateID, envdAccessToken, domain and more) or error. Use this to clone a sandbox's exact live state. Use e2b_create_snapshot to save a reusable snapshot without starting new sandboxes. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `sandbox_id` (`string`, required): ID of the sandbox to fork, as returned by e2b_create_sandbox or e2b_list_sandboxes (sandboxID). Example: iiny0783cype8gmoawzmx - `count` (`integer`, optional): Number of forked sandboxes to create, from 1 to 100. Defaults to 1. Each fork succeeds or fails on its own. Example: 3. Default: `1`. - `timeout` (`integer`, optional): Time to live for each new forked sandbox, in seconds. Defaults to 15. Example: 300. Default: `15`. Example input: `{"sandbox_id":""}` ### `e2b_pause_sandbox` Pause Sandbox · Write Pause a running E2B sandbox so it stops billing but keeps its state. Returns an empty response (HTTP 204) when the sandbox is paused. Use this to suspend a sandbox and come back later with e2b_connect_sandbox. Use e2b_kill_sandbox to end it instead. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `sandbox_id` (`string`, required): ID of the sandbox to pause, as returned by e2b_create_sandbox or e2b_list_sandboxes (sandboxID). Example: iiny0783cype8gmoawzmx - `memory` (`boolean`, optional): true (the API default) captures a full memory snapshot. false persists only the filesystem, so resuming reboots the sandbox and loses in-memory state. Example input: `{"sandbox_id":""}` ### `e2b_refresh_sandbox` Refresh Sandbox · Write Keep an E2B sandbox alive longer by refreshing its time to live. Returns an empty response (HTTP 204) when the sandbox is refreshed. Use this as a keep-alive for a running sandbox. Use e2b_set_sandbox_timeout to set an exact expiry. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `sandbox_id` (`string`, required): ID of the sandbox to refresh, as returned by e2b_create_sandbox or e2b_list_sandboxes (sandboxID). Example: iiny0783cype8gmoawzmx - `duration` (`integer`, optional): Seconds to keep the sandbox alive, from 0 to 3600. Leave empty for the API default. Example: 300 Example input: `{"sandbox_id":""}` ### `e2b_set_sandbox_timeout` Set Sandbox Timeout · Write Set when an E2B sandbox expires, counted in seconds from now. Returns an empty response (HTTP 204) when the timeout is set. Use this to shorten or lengthen a sandbox's life; each call replaces the previous timeout. Use e2b_refresh_sandbox to add time without replacing it. Read only: no. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `sandbox_id` (`string`, required): ID of the sandbox to update, as returned by e2b_create_sandbox or e2b_list_sandboxes (sandboxID). Example: iiny0783cype8gmoawzmx - `timeout` (`integer`, required): Seconds from now after which the sandbox should expire. Replaces the current timeout. Example: 900 Example input: `{"sandbox_id":"","timeout":900}` ### `e2b_update_sandbox_network` Update Sandbox Network · Write Replace the egress network rules of a running E2B sandbox. Returns an empty response (HTTP 204) when the rules are updated. Use this to change what a sandbox can reach after it starts. Any field you leave out is cleared, so send the full set of rules you want. Set rules at start with e2b_create_sandbox's network input. Read only: no. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `sandbox_id` (`string`, required): ID of the sandbox to update, as returned by e2b_create_sandbox or e2b_list_sandboxes (sandboxID). Example: iiny0783cype8gmoawzmx - `allow_internet_access` (`boolean`, optional): Set to false to block all outbound internet access (same as denying 0.0.0.0/0). - `allow_out` (`array`, optional): Destinations the sandbox may reach: CIDR blocks, bare IPs or domain names (wildcards like *.example.com allowed). Allowed entries win over denied ones. Example: ["api.github.com", "8.8.8.8/32"] - `deny_out` (`array`, optional): CIDR blocks or IPs the sandbox may not reach. Domain names aren't supported here. Example: ["0.0.0.0/0"] - `egress_proxy` (`object`, optional): SOCKS5 proxy that outbound TCP is tunneled through after allow/deny filtering. Needs an address in host:port form; username, password and a tls object ({"enabled": true}) are optional. Example: {"address": "proxy.example.com:1080"} - `rules` (`object`, optional): Per-domain transforms for outbound HTTPS requests, keyed by domain (exact or *.wildcard), each a list of rules that inject headers. Replaces all existing rules. Rules don't grant access; allow the domain in allow_out too. Example: {"api.example.com": [{"transform": {"headers": {"X-Env": "sandbox"}}}]} Example input: `{"sandbox_id":""}` ### `e2b_update_secret` Update Secret · Write Rotate an E2B secret by storing a new value as its next version. Returns secretID, name, currentVersion, metadata, createdAt and updatedAt; the secret value is never returned. Use this to change an existing secret's value; running sandboxes pick it up on their next request. Use e2b_create_secret for a new name. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `secret_id` (`string`, required): The secret to update: its ID (sec_...) or its name. Example: stripe_api_key - `value` (`string`, required): The secret value to store, such as an API key. E2B stores it encrypted and injects it into matching outbound requests from sandboxes; it is never returned. Example: sk_live_... - `metadata` (`object`, optional): String key-value labels for the secret, at most 32 entries. Example: {"environment": "production"} Example input: `{"secret_id":"","value":""}` ### `e2b_update_template` Update Template · Write Make an E2B template public or private. Returns names, the template's names. Use this to share a template with other projects (public) or restrict it to your team (private). Read only: no. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `public` (`boolean`, required): true makes the template usable by any E2B project; false limits it to your team. - `template_id` (`string`, required): ID of the template to update, as returned by e2b_list_templates (templateID). Example: rki5dems9wqfm4r03t7g Example input: `{"public":true,"template_id":""}` ### `e2b_delete_secret` Delete Secret · Destructive Revoke an E2B secret and schedule its stored versions for cleanup. Returns an empty response (HTTP 204) when the secret is deleted. Use this to remove a secret for good. Use e2b_update_secret to change its value instead. Read only: no. Destructive: yes. Idempotent (safe to retry): yes. Inputs: - `secret_id` (`string`, required): The secret to delete: its ID (sec_...) or its name. Example: stripe_api_key Example input: `{"secret_id":""}` ### `e2b_delete_template` Delete Template · Destructive Delete an E2B template. Returns an empty response (HTTP 204) when the template is deleted. Use this to remove a template you no longer need. Use e2b_delete_template_tags to remove only some tags. Read only: no. Destructive: yes. Idempotent (safe to retry): yes. Inputs: - `template_id` (`string`, required): ID of the template to delete, as returned by e2b_list_templates (templateID). Example: rki5dems9wqfm4r03t7g Example input: `{"template_id":""}` ### `e2b_delete_template_tags` Delete Template Tags · Destructive Remove one or more tags from an E2B template. Returns an empty response (HTTP 204) when the tags are deleted. Use this to untag builds without deleting the template. Use e2b_delete_template to delete the whole template. Read only: no. Destructive: yes. Idempotent (safe to retry): yes. Inputs: - `name` (`string`, required): Name of the template to remove tags from. Example: my-template - `tags` (`array`, required): Tags to delete from the template. Example: ["v1"] Example input: `{"name":"","tags":["v1"]}` ### `e2b_delete_volume` Delete Volume · Destructive Delete an E2B volume and the data stored in it. Returns an empty response (HTTP 204) when the volume is deleted. Use this to remove storage you no longer need. Use e2b_list_volumes to find the volume ID. Read only: no. Destructive: yes. Idempotent (safe to retry): yes. Inputs: - `volume_id` (`string`, required): ID of the volume, as returned by e2b_list_volumes (volumeID). Example: 7d3f9a2e-1c4b-4e8a-9f60-2b5d8c1e4a73 Example input: `{"volume_id":""}` ### `e2b_kill_sandbox` Kill Sandbox · Destructive Kill an E2B sandbox, stopping it and discarding its state. Returns an empty response (HTTP 204) when the sandbox is killed. Use this to end a sandbox for good. Use e2b_pause_sandbox to stop it but keep its state for later. Read only: no. Destructive: yes. Idempotent (safe to retry): yes. Inputs: - `sandbox_id` (`string`, required): ID of the sandbox to kill, as returned by e2b_create_sandbox or e2b_list_sandboxes (sandboxID). Example: iiny0783cype8gmoawzmx Example input: `{"sandbox_id":""}` ## Related Other Developer Tools connectors ([all 117](/agentkit/connectors/?category=developer-tools)): - [GitHub](/agentkit/connectors/github/): Scalekit connector, OAuth, 217 tools - [Microsoft Entra ID](/agentkit/connectors/microsoftentraid/): Scalekit connector, OAuth, 82 tools - [Datadog](/agentkit/connectors/datadog/): Scalekit connector, API key, 105 tools --- ## More Scalekit documentation | Resource | What it contains | When to use it | |----------|-----------------|----------------| | [/llms.txt](/llms.txt) | Structured index with routing hints per product area | Start here — find which documentation set covers your topic before loading full content | | [/llms-full.txt](/llms-full.txt) | Complete documentation for all Scalekit products in one file | Use when you need exhaustive context across multiple products or when the topic spans several areas | | [sitemap-0.xml](https://docs.scalekit.com/sitemap-0.xml) | Full URL list of every documentation page | Use to discover specific page URLs you can fetch for targeted, page-level answers |