E2B API reference

New to Corsair? See API access, authentication, and error handling.

Envd

getEnvironmentVariables

envd.getEnvironmentVariables Environment variables Risk: read

await corsair.e2b.api.envd.getEnvironmentVariables({"headers":{"e2bSandboxId":"test","e2bSandboxPort":49983,"e2bAccessToken":"test-sandbox-access-token"}});

Input

Name	Type	Required	Description
`headers`	`object`	Yes	—

Requires an E2B sandbox access token; the response contains environment values and should be handled as sensitive data.

headers full type

{
  e2bSandboxId: string,
  e2bSandboxPort: number,
  e2bAccessToken: string
}

Output: empty object

health

envd.health Check the health of the service Risk: read

await corsair.e2b.api.envd.health({"headers":{"e2bSandboxId":"test","e2bSandboxPort":49983}});

Input

Name	Type	Required	Description
`headers`	`object`	Yes	—

headers full type

{
  e2bSandboxId: string,
  e2bSandboxPort: number
}

Output: void

metrics

envd.metrics Service stats Risk: read

await corsair.e2b.api.envd.metrics({"headers":{"e2bSandboxId":"test","e2bSandboxPort":49983,"e2bAccessToken":"test-sandbox-access-token"}});

Input

Name	Type	Required	Description
`headers`	`object`	Yes	—

headers full type

{
  e2bSandboxId: string,
  e2bSandboxPort: number,
  e2bAccessToken: string
}

Output

Name	Type	Required	Description
`ts`	`number`	No	—
`cpu_count`	`number`	No	—
`cpu_possible`	`number`	No	—
`cpu_target`	`number`	No	—
`cpu_target_attempts`	`number`	No	—
`cpu_write_pending_ms`	`number`	No	—
`cpu_used_pct`	`number`	No	—
`mem_total`	`number`	No	—
`mem_used`	`number`	No	—
`mem_cache`	`number`	No	—
`disk_used`	`number`	No	—
`disk_total`	`number`	No	—
`oom_kills`	`object[]`	No	—
`mem_used_mib`	`number`	No	—
`mem_total_mib`	`number`	No	—

oom_kills full type

{
  seq: number,
  process: string
}[]

Events

list

events.list List events Risk: read

await corsair.e2b.api.events.list({"query":{"offset":0,"limit":10,"orderAsc":false,"types":["test"]}});

Input

Name	Type	Required	Description
`query`	`object`	No	—

query full type

{
  offset?: number,
  limit?: number,
  orderAsc?: boolean,
  types?: string[]
}

Output: object[]

Output full type

{
  id: string,
  version: string,
  type: string,
  eventCategory?: string,
  eventLabel?: string,
  eventData?: {
  } | null,
  timestamp: string,
  sandboxId: string,
  sandboxExecutionId: string,
  sandboxTemplateId: string,
  sandboxBuildId: string,
  sandboxTeamId: string
}[]

listBySandbox

events.listBySandbox List sandbox events Risk: read

await corsair.e2b.api.events.listBySandbox({"path":{"sandboxID":"test"},"query":{"offset":0,"limit":10,"orderAsc":false,"types":["test"]}});

Input

Name	Type	Required	Description
`path`	`object`	Yes	—
`query`	`object`	No	—

path full type

{
  sandboxID: string
}

query full type

{
  offset?: number,
  limit?: number,
  orderAsc?: boolean,
  types?: string[]
}

Output: object[]

Output full type

{
  id: string,
  version: string,
  type: string,
  eventCategory?: string,
  eventLabel?: string,
  eventData?: {
  } | null,
  timestamp: string,
  sandboxId: string,
  sandboxExecutionId: string,
  sandboxTemplateId: string,
  sandboxBuildId: string,
  sandboxTeamId: string
}[]

Filesystem

createDir

filesystem.createDir MakeDir Risk: write

await corsair.e2b.api.filesystem.createDir({"headers":{"e2bSandboxId":"test","e2bSandboxPort":49983,"e2bAccessToken":"test-sandbox-access-token"},"body":{"path":"/tmp/corsair-e2b"}});

Input

Name	Type	Required	Description
`headers`	`object`	Yes	—
`body`	`object`	Yes	—

headers full type

{
  e2bSandboxId: string,
  e2bSandboxPort: number,
  connectTimeoutMs?: number,
  e2bAccessToken: string
}

body full type

{
  path?: string
}

Output

Name	Type	Required	Description
`entry`	`object`	No	—

entry full type

{
  name?: string,
  type?: FILE_TYPE_UNSPECIFIED | FILE_TYPE_FILE | FILE_TYPE_DIRECTORY | FILE_TYPE_SYMLINK | string,
  path?: string,
  size?: number | string,
  mode?: number,
  permissions?: string,
  owner?: string,
  group?: string,
  modifiedTime?: string,
  symlinkTarget?: string | null,
  metadata?: {
  },
  isSymlink?: boolean
}

createWatcher

filesystem.createWatcher CreateWatcher Risk: write

await corsair.e2b.api.filesystem.createWatcher({"headers":{"e2bSandboxId":"test","e2bSandboxPort":49983,"e2bAccessToken":"test-sandbox-access-token"},"body":{}});

Input

Name	Type	Required	Description
`headers`	`object`	Yes	—
`body`	`object`	Yes	—

This is the unary watcher-creation operation; streaming WatchDir remains out of scope.

headers full type

{
  e2bSandboxId: string,
  e2bSandboxPort: number,
  connectTimeoutMs?: number,
  e2bAccessToken: string
}

body full type

{
  path?: string,
  recursive?: boolean,
  includeEntry?: boolean,
  allowNetworkMounts?: boolean
}

Output

Name	Type	Required	Description
`watcherId`	`string`	No	—

getWatcherEvents

filesystem.getWatcherEvents GetWatcherEvents Risk: read

await corsair.e2b.api.filesystem.getWatcherEvents({"headers":{"e2bSandboxId":"test","e2bSandboxPort":49983,"e2bAccessToken":"test-sandbox-access-token"},"body":{}});

Input

Name	Type	Required	Description
`headers`	`object`	Yes	—
`body`	`object`	Yes	—

headers full type

{
  e2bSandboxId: string,
  e2bSandboxPort: number,
  connectTimeoutMs?: number,
  e2bAccessToken: string
}

body full type

{
  watcherId?: string
}

Output

Name	Type	Required	Description
`events`	`object[]`	No	—

events full type

{
  name?: string,
  type?: EVENT_TYPE_UNSPECIFIED | EVENT_TYPE_CREATE | EVENT_TYPE_WRITE | EVENT_TYPE_REMOVE | EVENT_TYPE_RENAME | EVENT_TYPE_CHMOD | string,
  entry?: {
    name?: string,
    type?: FILE_TYPE_UNSPECIFIED | FILE_TYPE_FILE | FILE_TYPE_DIRECTORY | FILE_TYPE_SYMLINK | string,
    path?: string,
    size?: number | string,
    mode?: number,
    permissions?: string,
    owner?: string,
    group?: string,
    modifiedTime?: string,
    symlinkTarget?: string | null,
    metadata?: {
    },
    isSymlink?: boolean
  } | null
}[]

listDir

filesystem.listDir ListDir Risk: read

await corsair.e2b.api.filesystem.listDir({"headers":{"e2bSandboxId":"test","e2bSandboxPort":49983,"e2bAccessToken":"test-sandbox-access-token"},"body":{"path":"/tmp/corsair-e2b"}});

Input

Name	Type	Required	Description
`headers`	`object`	Yes	—
`body`	`object`	Yes	—

headers full type

{
  e2bSandboxId: string,
  e2bSandboxPort: number,
  connectTimeoutMs?: number,
  e2bAccessToken: string
}

body full type

{
  path?: string,
  depth?: number
}

Output

Name	Type	Required	Description
`entries`	`object[]`	No	—

entries full type

{
  name?: string,
  type?: FILE_TYPE_UNSPECIFIED | FILE_TYPE_FILE | FILE_TYPE_DIRECTORY | FILE_TYPE_SYMLINK | string,
  path?: string,
  size?: number | string,
  mode?: number,
  permissions?: string,
  owner?: string,
  group?: string,
  modifiedTime?: string,
  symlinkTarget?: string | null,
  metadata?: {
  },
  isSymlink?: boolean
}[]

move

filesystem.move Move Risk: write

await corsair.e2b.api.filesystem.move({"headers":{"e2bSandboxId":"test","e2bSandboxPort":49983,"e2bAccessToken":"test-sandbox-access-token"},"body":{"source":"/tmp/corsair-e2b/a.txt","destination":"/tmp/corsair-e2b/b.txt"}});

Input

Name	Type	Required	Description
`headers`	`object`	Yes	—
`body`	`object`	Yes	—

headers full type

{
  e2bSandboxId: string,
  e2bSandboxPort: number,
  connectTimeoutMs?: number,
  e2bAccessToken: string
}

body full type

{
  source?: string,
  destination?: string
}

Output

Name	Type	Required	Description
`entry`	`object`	No	—

entry full type

{
  name?: string,
  type?: FILE_TYPE_UNSPECIFIED | FILE_TYPE_FILE | FILE_TYPE_DIRECTORY | FILE_TYPE_SYMLINK | string,
  path?: string,
  size?: number | string,
  mode?: number,
  permissions?: string,
  owner?: string,
  group?: string,
  modifiedTime?: string,
  symlinkTarget?: string | null,
  metadata?: {
  },
  isSymlink?: boolean
}

remove

filesystem.remove Remove Risk: destructive

await corsair.e2b.api.filesystem.remove({"headers":{"e2bSandboxId":"test","e2bSandboxPort":49983,"e2bAccessToken":"test-sandbox-access-token"},"body":{"path":"/tmp/corsair-e2b"}});

Input

Name	Type	Required	Description
`headers`	`object`	Yes	—
`body`	`object`	Yes	—

headers full type

{
  e2bSandboxId: string,
  e2bSandboxPort: number,
  connectTimeoutMs?: number,
  e2bAccessToken: string
}

body full type

{
  path?: string
}

Output: empty object

removeWatcher

filesystem.removeWatcher RemoveWatcher Risk: write

await corsair.e2b.api.filesystem.removeWatcher({"headers":{"e2bSandboxId":"test","e2bSandboxPort":49983,"e2bAccessToken":"test-sandbox-access-token"},"body":{}});

Input

Name	Type	Required	Description
`headers`	`object`	Yes	—
`body`	`object`	Yes	—

headers full type

{
  e2bSandboxId: string,
  e2bSandboxPort: number,
  connectTimeoutMs?: number,
  e2bAccessToken: string
}

body full type

{
  watcherId?: string
}

Output: empty object

stat

filesystem.stat Stat Risk: read

await corsair.e2b.api.filesystem.stat({"headers":{"e2bSandboxId":"test","e2bSandboxPort":49983,"e2bAccessToken":"test-sandbox-access-token"},"body":{"path":"/tmp/corsair-e2b"}});

Input

Name	Type	Required	Description
`headers`	`object`	Yes	—
`body`	`object`	Yes	—

headers full type

{
  e2bSandboxId: string,
  e2bSandboxPort: number,
  connectTimeoutMs?: number,
  e2bAccessToken: string
}

body full type

{
  path?: string
}

Output

Name	Type	Required	Description
`entry`	`object`	No	—

entry full type

{
  name?: string,
  type?: FILE_TYPE_UNSPECIFIED | FILE_TYPE_FILE | FILE_TYPE_DIRECTORY | FILE_TYPE_SYMLINK | string,
  path?: string,
  size?: number | string,
  mode?: number,
  permissions?: string,
  owner?: string,
  group?: string,
  modifiedTime?: string,
  symlinkTarget?: string | null,
  metadata?: {
  },
  isSymlink?: boolean
}

Process

closeStdin

process.closeStdin CloseStdin Risk: write

await corsair.e2b.api.process.closeStdin({"headers":{"e2bSandboxId":"test","e2bSandboxPort":49983,"e2bAccessToken":"test-sandbox-access-token"},"body":{"process":{"pid":101}}});

Input

Name	Type	Required	Description
`headers`	`object`	Yes	—
`body`	`object`	Yes	—

headers full type

{
  e2bSandboxId: string,
  e2bSandboxPort: number,
  connectTimeoutMs?: number,
  e2bAccessToken: string
}

body full type

{
  process?: {
    pid: number
  } | {
    tag: string
  }
}

Output: empty object

list

process.list List Risk: read

await corsair.e2b.api.process.list({"headers":{"e2bSandboxId":"test","e2bSandboxPort":49983,"e2bAccessToken":"test-sandbox-access-token"},"body":{}});

Input

Name	Type	Required	Description
`headers`	`object`	Yes	—
`body`	`object`	Yes	—

headers full type

{
  e2bSandboxId: string,
  e2bSandboxPort: number,
  connectTimeoutMs?: number,
  e2bAccessToken: string
}

body full type

{
}

Output

Name	Type	Required	Description
`processes`	`object[]`	No	—

processes full type

{
  config?: {
    cmd?: string,
    args?: string[],
    envs?: {
    },
    cwd?: string | null
  },
  pid?: number,
  tag?: string | null
}[]

sendInput

process.sendInput SendInput Risk: write

await corsair.e2b.api.process.sendInput({"headers":{"e2bSandboxId":"test","e2bSandboxPort":49983,"e2bAccessToken":"test-sandbox-access-token"},"body":{"process":{"pid":101},"input":{"stdin":"aGVsbG8="}}});

Input

Name	Type	Required	Description
`headers`	`object`	Yes	—
`body`	`object`	Yes	—

stdin and pty bytes use the Connect JSON base64 representation; encode the bytes before passing the string.

headers full type

{
  e2bSandboxId: string,
  e2bSandboxPort: number,
  connectTimeoutMs?: number,
  e2bAccessToken: string
}

body full type

{
  process?: {
    pid: number
  } | {
    tag: string
  },
  input?: {
    pty: string
  } | {
    stdin: string
  }
}

Output: empty object

sendSignal

process.sendSignal SendSignal Risk: destructive

await corsair.e2b.api.process.sendSignal({"headers":{"e2bSandboxId":"test","e2bSandboxPort":49983,"e2bAccessToken":"test-sandbox-access-token"},"body":{"process":{"pid":101},"signal":"SIGNAL_SIGTERM"}});

Input

Name	Type	Required	Description
`headers`	`object`	Yes	—
`body`	`object`	Yes	—

headers full type

{
  e2bSandboxId: string,
  e2bSandboxPort: number,
  connectTimeoutMs?: number,
  e2bAccessToken: string
}

body full type

{
  process?: {
    pid: number
  } | {
    tag: string
  },
  signal?: SIGNAL_UNSPECIFIED | SIGNAL_SIGTERM | SIGNAL_SIGKILL
}

Output: empty object

update

process.update Update Risk: write

await corsair.e2b.api.process.update({"headers":{"e2bSandboxId":"test","e2bSandboxPort":49983,"e2bAccessToken":"test-sandbox-access-token"},"body":{"process":{"pid":101},"pty":{"size":{"cols":80,"rows":24}}}});

Input

Name	Type	Required	Description
`headers`	`object`	Yes	—
`body`	`object`	Yes	—

headers full type

{
  e2bSandboxId: string,
  e2bSandboxPort: number,
  connectTimeoutMs?: number,
  e2bAccessToken: string
}

body full type

{
  process?: {
    pid: number
  } | {
    tag: string
  },
  pty?: {
    size?: {
      cols?: number,
      rows?: number
    }
  } | null
}

Output: empty object

Sandboxes

connect

sandboxes.connect Connect sandbox (v2) Risk: destructive

await corsair.e2b.api.sandboxes.connect({"path":{"sandboxID":"test"},"body":{}});

Input

Name	Type	Required	Description
`path`	`object`	Yes	—
`body`	`object`	No	—

path full type

{
  sandboxID: string
}

body full type

{
  timeout?: number,
  memory?: boolean
}

Output

Name	Type	Required	Description
`templateID`	`string`	Yes	—
`sandboxID`	`string`	Yes	—
`alias`	`string`	No	—
`clientID`	`string`	Yes	—
`envdVersion`	`string`	Yes	—
`envdAccessToken`	`string`	No	—
`trafficAccessToken`	`string \| null`	No	—
`domain`	`string \| null`	No	—

create

sandboxes.create Create sandbox (v2) Risk: destructive

await corsair.e2b.api.sandboxes.create({"headers":{"idempotencyKey":"test"},"body":{"templateID":"test"}});

Input

Name	Type	Required	Description
`headers`	`object`	No	—
`body`	`object`	Yes	—

metadata and envVars are string maps; mcp is an extensible JSON object, as specified by E2B’s OpenAPI.

headers full type

{
  idempotencyKey?: string
}

body full type

{
  templateID: string,
  timeout?: number,
  cpuCount?: number,
  autoPause?: boolean,
  autoPauseMemory?: boolean,
  autoResume?: {
    enabled: boolean
  },
  allow_internet_access?: boolean,
  network?: {
    allowPublicTraffic?: boolean | null,
    allowOut?: string[],
    denyOut?: string[],
    dnsServers?: string[],
    egressProxy?: {
      address: string,
      username?: string,
      password?: string,
      tls?: {
        enabled: boolean,
        serverName?: string,
        caCert?: string
      } | null
    } | null,
    maskRequestHost?: string,
    httpsPorts?: number[],
    rules?: {
    }
  },
  metadata?: {
  },
  envVars?: {
  },
  mcp?: {
  } | null,
  iam?: {
    tokens?: {
    }
  },
  volumeMounts?: {
    name: string,
    path: string
  }[]
}

Output

Name	Type	Required	Description
`templateID`	`string`	Yes	—
`sandboxID`	`string`	Yes	—
`alias`	`string`	No	—
`clientID`	`string`	Yes	—
`envdVersion`	`string`	Yes	—
`envdAccessToken`	`string`	No	—
`trafficAccessToken`	`string \| null`	No	—
`domain`	`string \| null`	No	—

createSnapshot

sandboxes.createSnapshot Create snapshot Risk: write

await corsair.e2b.api.sandboxes.createSnapshot({"path":{"sandboxID":"test"},"headers":{"idempotencyKey":"test"},"body":{}});

Input

Name	Type	Required	Description
`path`	`object`	Yes	—
`headers`	`object`	No	—
`body`	`object`	Yes	—

path full type

{
  sandboxID: string
}

headers full type

{
  idempotencyKey?: string
}

body full type

{
  name?: string,
  memory?: boolean
}

Output

Name	Type	Required	Description
`snapshotID`	`string`	Yes	—
`names`	`string[]`	Yes	—

fork

sandboxes.fork Fork sandbox Risk: destructive

await corsair.e2b.api.sandboxes.fork({"path":{"sandboxID":"test"},"body":{}});

Input

Name	Type	Required	Description
`path`	`object`	Yes	—
`body`	`object`	No	—

path full type

{
  sandboxID: string
}

body full type

{
  timeout?: number,
  count?: number
}

Output: object[]

Output full type

{
  sandbox?: {
    templateID: string,
    sandboxID: string,
    alias?: string,
    clientID: string,
    envdVersion: string,
    envdAccessToken?: string,
    trafficAccessToken?: string | null,
    domain?: string | null
  },
  error?: {
    code: number,
    error_code?: string,
    message: string
  }
}[]

get

sandboxes.get Get sandbox Risk: read

await corsair.e2b.api.sandboxes.get({"path":{"sandboxID":"test"}});

Input

Name	Type	Required	Description
`path`	`object`	Yes	—

path full type

{
  sandboxID: string
}

Output

Name	Type	Required	Description
`templateID`	`string`	Yes	—
`alias`	`string`	No	—
`sandboxID`	`string`	Yes	—
`clientID`	`string`	Yes	—
`startedAt`	`string`	Yes	—
`endAt`	`string`	Yes	—
`envdVersion`	`string`	Yes	—
`envdUnresponsiveAtPause`	`boolean`	No	—
`envdAccessToken`	`string`	No	—
`allowInternetAccess`	`boolean \| null`	No	—
`domain`	`string \| null`	No	—
`cpuCount`	`number`	Yes	—
`memoryMB`	`number`	Yes	—
`diskSizeMB`	`number`	Yes	—
`metadata`	`object`	No	—
`state`	`running \| paused \| string`	Yes	—
`network`	`object`	No	—
`lifecycle`	`object`	No	—
`pauseMode`	`full \| filesystem \| string`	No	—
`volumeMounts`	`object[]`	No	—

metadata full type

{
}

network full type

{
  allowPublicTraffic?: boolean | null,
  allowOut?: string[],
  denyOut?: string[],
  dnsServers?: string[],
  egressProxy?: {
    address: string,
    username?: string,
    password?: string,
    tls?: {
      enabled: boolean,
      serverName?: string,
      caCert?: string
    } | null
  } | null,
  maskRequestHost?: string,
  httpsPorts?: number[],
  rules?: {
  }
}

lifecycle full type

{
  autoResume: boolean,
  onTimeout: kill | pause | string
}

volumeMounts full type

{
  name: string,
  path: string
}[]

getLogs

sandboxes.getLogs Get sandbox logs (v2) Risk: read

await corsair.e2b.api.sandboxes.getLogs({"path":{"sandboxID":"test"},"query":{"cursor":0,"limit":1000,"direction":"forward","level":"test","search":"test"}});

Input

Name	Type	Required	Description
`path`	`object`	Yes	—
`query`	`object`	No	—

path full type

{
  sandboxID: string
}

query full type

{
  cursor?: number,
  limit?: number,
  direction?: forward | backward,
  level?: string,
  search?: string
}

Output

Name	Type	Required	Description
`logs`	`object[]`	Yes	—

logs full type

{
  timestamp: string,
  message: string,
  level: string,
  fields: {
  }
}[]

getMetrics

sandboxes.getMetrics Get sandbox metrics Risk: read

await corsair.e2b.api.sandboxes.getMetrics({"path":{"sandboxID":"test"},"query":{"start":0,"end":0}});

Input

Name	Type	Required	Description
`path`	`object`	Yes	—
`query`	`object`	No	—

path full type

{
  sandboxID: string
}

query full type

{
  start?: number,
  end?: number
}

Output: object[]

Output full type

{
  timestamp: string,
  timestampUnix: number,
  cpuCount: number,
  cpuUsedPct: number,
  memUsed: number,
  memTotal: number,
  memCache: number,
  diskUsed: number,
  diskTotal: number
}[]

kill

sandboxes.kill Delete sandbox Risk: destructive

await corsair.e2b.api.sandboxes.kill({"path":{"sandboxID":"test"}});

Input

Name	Type	Required	Description
`path`	`object`	Yes	—

path full type

{
  sandboxID: string
}

Output: void

list

sandboxes.list List sandboxes (v2) Risk: read

await corsair.e2b.api.sandboxes.list({"query":{"metadata":"test","state":["running"],"order":"desc","startedAfter":"2026-01-01T00:00:00Z","template":"test","nextToken":"test","limit":100}});

Input

Name	Type	Required	Description
`query`	`object`	No	—

The v2 list operation accepts state as a comma-separated array and returns { items, nextToken?, totalRunning? }; pass nextToken as query.nextToken to continue.

query full type

{
  metadata?: string,
  state?: (running | paused)[],
  order?: asc | desc,
  startedAfter?: string,
  template?: string,
  nextToken?: string,
  limit?: number
}

Output

Name	Type	Required	Description
`items`	`object[]`	Yes	—
`nextToken`	`string`	No	—
`totalRunning`	`number`	No	—

items full type

{
  templateID: string,
  alias?: string,
  sandboxID: string,
  clientID: string,
  startedAt: string,
  endAt: string,
  cpuCount: number,
  memoryMB: number,
  diskSizeMB: number,
  metadata?: {
  },
  state: running | paused | string,
  envdVersion: string,
  envdUnresponsiveAtPause?: boolean,
  volumeMounts?: {
    name: string,
    path: string
  }[]
}[]

listMetrics

sandboxes.listMetrics List sandbox metrics Risk: read

await corsair.e2b.api.sandboxes.listMetrics({"query":{"sandbox_ids":["test"]}});

Input

Name	Type	Required	Description
`query`	`object`	Yes	—

query full type

{
  sandbox_ids: string[]
}

Output

Name	Type	Required	Description
`sandboxes`	`object`	Yes	—

sandboxes full type

{
}

listSnapshots

sandboxes.listSnapshots List snapshots Risk: read

await corsair.e2b.api.sandboxes.listSnapshots({"query":{"sandboxID":"test","name":"test","limit":100,"nextToken":"test"}});

Input

Name	Type	Required	Description
`query`	`object`	No	—

Returns { items, nextToken? }; pass X-Next-Token as query.nextToken to continue.

query full type

{
  sandboxID?: string,
  name?: string,
  limit?: number,
  nextToken?: string
}

Output

Name	Type	Required	Description
`items`	`object[]`	Yes	—
`nextToken`	`string`	No	—

items full type

{
  snapshotID: string,
  names: string[]
}[]

pause

sandboxes.pause Pause sandbox Risk: write

await corsair.e2b.api.sandboxes.pause({"path":{"sandboxID":"test"},"body":{}});

Input

Name	Type	Required	Description
`path`	`object`	Yes	—
`body`	`object`	No	—

path full type

{
  sandboxID: string
}

body full type

{
  memory?: boolean,
  requireHealthyGuest?: boolean
}

Output: void

refresh

sandboxes.refresh Refresh sandbox Risk: destructive

await corsair.e2b.api.sandboxes.refresh({"path":{"sandboxID":"test"},"body":{}});

Input

Name	Type	Required	Description
`path`	`object`	Yes	—
`body`	`object`	No	—

path full type

{
  sandboxID: string
}

body full type

{
  duration?: number
}

Output: void

setTimeout

sandboxes.setTimeout Set sandbox timeout Risk: destructive

await corsair.e2b.api.sandboxes.setTimeout({"path":{"sandboxID":"test"},"body":{"timeout":0}});

Input

Name	Type	Required	Description
`path`	`object`	Yes	—
`body`	`object`	No	—

path full type

{
  sandboxID: string
}

body full type

{
  timeout: number
}

Output: void

updateNetwork

sandboxes.updateNetwork Update sandbox network Risk: write

await corsair.e2b.api.sandboxes.updateNetwork({"path":{"sandboxID":"test"},"body":{}});

Input

Name	Type	Required	Description
`path`	`object`	Yes	—
`body`	`object`	Yes	—

path full type

{
  sandboxID: string
}

body full type

{
  allowOut?: string[],
  denyOut?: string[],
  dnsServers?: string[],
  egressProxy?: {
    address: string,
    username?: string,
    password?: string,
    tls?: {
      enabled: boolean,
      serverName?: string,
      caCert?: string
    } | null
  } | null,
  rules?: {
  },
  allow_internet_access?: boolean
}

Output: void

Secrets

create

secrets.create Create secret Risk: write

await corsair.e2b.api.secrets.create({"body":{"name":"test","value":"test"}});

Input

Name	Type	Required	Description
`body`	`object`	Yes	—

Secret values are accepted only on create/update and are never returned by list/get operations.

body full type

{
  name: string,
  value: string,
  metadata?: {
  }
}

Output

Name	Type	Required	Description
`secretID`	`string`	Yes	—
`name`	`string`	Yes	—
`currentVersion`	`number`	Yes	—
`metadata`	`object`	Yes	—
`createdAt`	`string`	Yes	—
`updatedAt`	`string`	Yes	—

metadata full type

{
}

delete

secrets.delete Delete secret Risk: destructive

await corsair.e2b.api.secrets.delete({"path":{"secretID":"test"}});

Input

Name	Type	Required	Description
`path`	`object`	Yes	—

path full type

{
  secretID: string
}

Output: void

get

secrets.get Get secret Risk: read

await corsair.e2b.api.secrets.get({"path":{"secretID":"test"}});

Input

Name	Type	Required	Description
`path`	`object`	Yes	—

path full type

{
  secretID: string
}

Output

Name	Type	Required	Description
`secretID`	`string`	Yes	—
`name`	`string`	Yes	—
`currentVersion`	`number`	Yes	—
`metadata`	`object`	Yes	—
`createdAt`	`string`	Yes	—
`updatedAt`	`string`	Yes	—

metadata full type

{
}

list

secrets.list List secrets Risk: read

await corsair.e2b.api.secrets.list({"query":{"nextToken":"test","limit":100}});

Input

Name	Type	Required	Description
`query`	`object`	No	—

Returns { items, nextToken? }; pass X-Next-Token as query.nextToken to continue. The response never includes secret values.

query full type

{
  nextToken?: string,
  limit?: number
}

Output

Name	Type	Required	Description
`items`	`object[]`	Yes	—
`nextToken`	`string`	No	—

items full type

{
  secretID: string,
  name: string,
  currentVersion: number,
  metadata: {
  },
  createdAt: string,
  updatedAt: string
}[]

update

secrets.update Update secret Risk: write

await corsair.e2b.api.secrets.update({"path":{"secretID":"test"},"body":{"value":"test"}});

Input

Name	Type	Required	Description
`path`	`object`	Yes	—
`body`	`object`	Yes	—

path full type

{
  secretID: string
}

body full type

{
  value: string,
  metadata?: {
  }
}

Output

Name	Type	Required	Description
`secretID`	`string`	Yes	—
`name`	`string`	Yes	—
`currentVersion`	`number`	Yes	—
`metadata`	`object`	Yes	—
`createdAt`	`string`	Yes	—
`updatedAt`	`string`	Yes	—

metadata full type

{
}

Teams

getMaxMetrics

teams.getMaxMetrics Get team metrics max Risk: read

await corsair.e2b.api.teams.getMaxMetrics({"path":{"teamID":"test"},"query":{"start":0,"end":0,"metric":"concurrent_sandboxes"}});

Input

Name	Type	Required	Description
`path`	`object`	Yes	—
`query`	`object`	Yes	—

path full type

{
  teamID: string
}

query full type

{
  start?: number,
  end?: number,
  metric: concurrent_sandboxes | sandbox_start_rate
}

Output

Name	Type	Required	Description
`timestamp`	`string`	Yes	—
`timestampUnix`	`number`	Yes	—
`value`	`number`	Yes	—

getMetrics

teams.getMetrics Get team metrics Risk: read

await corsair.e2b.api.teams.getMetrics({"path":{"teamID":"test"},"query":{"start":0,"end":0}});

Input

Name	Type	Required	Description
`path`	`object`	Yes	—
`query`	`object`	No	—

path full type

{
  teamID: string
}

query full type

{
  start?: number,
  end?: number
}

Output: object[]

Output full type

{
  timestamp: string,
  timestampUnix: number,
  concurrentSandboxes: number,
  sandboxStartRate: number
}[]

Templates

create

templates.create Create template (v3) Risk: write

await corsair.e2b.api.templates.create({"headers":{"idempotencyKey":"test"},"body":{}});

Input

Name	Type	Required	Description
`headers`	`object`	No	—
`body`	`object`	Yes	—

headers full type

{
  idempotencyKey?: string
}

body full type

{
  name?: string,
  tags?: string[],
  alias?: string,
  teamID?: string,
  cpuCount?: number,
  maxCpuCount?: number,
  memoryMB?: number,
  minFreeDiskMb?: number
}

Output

Name	Type	Required	Description
`templateID`	`string`	Yes	—
`buildID`	`string`	Yes	—
`public`	`boolean`	Yes	—
`names`	`string[]`	Yes	—
`tags`	`string[]`	Yes	—
`aliases`	`string[]`	Yes	—

delete

templates.delete Delete template Risk: destructive

await corsair.e2b.api.templates.delete({"path":{"templateID":"test"}});

Input

Name	Type	Required	Description
`path`	`object`	Yes	—

path full type

{
  templateID: string
}

Output: void

get

templates.get Get template Risk: read

await corsair.e2b.api.templates.get({"path":{"templateID":"test"},"query":{"nextToken":"test","limit":100}});

Input

Name	Type	Required	Description
`path`	`object`	Yes	—
`query`	`object`	No	—

Returns the template and its build page, including nextToken from X-Next-Token; pass it as query.nextToken to continue.

path full type

{
  templateID: string
}

query full type

{
  nextToken?: string,
  limit?: number
}

Output: object

Output full type

{
  templateID: string,
  buildID: string,
  cpuCount: number | 0,
  maxCpuCount?: number,
  memoryMB: number | 0,
  diskSizeMB: number,
  public: boolean,
  aliases: string[],
  names: string[],
  createdAt: string,
  updatedAt: string,
  createdBy: {
    id: string,
    email: string | null
  } | null,
  lastSpawnedAt: string | null,
  spawnCount: number,
  buildCount: number,
  envdVersion: string,
  buildStatus: building | waiting | ready | error | uploaded | string,
  isDefault?: boolean,
  description?: string
}& {
  builds: {
    buildID: string,
    status: building | waiting | ready | error | uploaded | string,
    createdAt: string,
    updatedAt: string,
    finishedAt?: string,
    cpuCount: number,
    maxCpuCount?: number,
    memoryMB: number,
    diskSizeMB?: number,
    envdVersion?: string
  }[],
  nextToken?: string
}

getBuildLogs

templates.getBuildLogs Get build logs Risk: read

await corsair.e2b.api.templates.getBuildLogs({"path":{"templateID":"test","buildID":"test"},"query":{"cursor":0,"limit":100,"direction":"forward","level":"test","source":"temporary"}});

Input

Name	Type	Required	Description
`path`	`object`	Yes	—
`query`	`object`	No	—

path full type

{
  templateID: string,
  buildID: string
}

query full type

{
  cursor?: number,
  limit?: number,
  direction?: forward | backward,
  level?: string,
  source?: temporary | persistent
}

Output

Name	Type	Required	Description
`logs`	`object[]`	Yes	—

logs full type

{
  timestamp: string,
  message: string,
  level: string,
  step?: string
}[]

getBuildStatus

templates.getBuildStatus Get build status Risk: read

await corsair.e2b.api.templates.getBuildStatus({"path":{"templateID":"test","buildID":"test"},"query":{"logsOffset":0,"limit":100,"level":"test"}});

Input

Name	Type	Required	Description
`path`	`object`	Yes	—
`query`	`object`	No	—

path full type

{
  templateID: string,
  buildID: string
}

query full type

{
  logsOffset?: number,
  limit?: number,
  level?: string
}

Output

Name	Type	Required	Description
`logs`	`string[]`	Yes	—
`logEntries`	`object[]`	Yes	—
`templateID`	`string`	Yes	—
`buildID`	`string`	Yes	—
`status`	`building \| waiting \| ready \| error \| uploaded \| string`	Yes	—
`reason`	`object`	No	—

logEntries full type

{
  timestamp: string,
  message: string,
  level: string,
  step?: string
}[]

reason full type

{
  message: string,
  step?: string,
  logEntries?: {
    timestamp: string,
    message: string,
    level: string,
    step?: string
  }[]
}

getBuildUploadLink

templates.getBuildUploadLink Get build upload link Risk: read

await corsair.e2b.api.templates.getBuildUploadLink({"path":{"templateID":"test","hash":"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}});

Input

Name	Type	Required	Description
`path`	`object`	Yes	—

Returns an upload URL and headers for a template build file. Treat the response as a short-lived capability; avoid logging it.

path full type

{
  templateID: string,
  hash: string
}

Output

Name	Type	Required	Description
`present`	`boolean`	Yes	—
`url`	`string`	No	—
`headers`	`object`	No	—

headers full type

{
}

getByAlias

templates.getByAlias Get template by alias Risk: read

await corsair.e2b.api.templates.getByAlias({"path":{"alias":"test"}});

Input

Name	Type	Required	Description
`path`	`object`	Yes	—

path full type

{
  alias: string
}

Output

Name	Type	Required	Description
`templateID`	`string`	Yes	—
`public`	`boolean`	Yes	—

list

templates.list List templates (v2) Risk: read

await corsair.e2b.api.templates.list({"query":{"teamID":"test","nextToken":"test","limit":100}});

Input

Name	Type	Required	Description
`query`	`object`	No	—

Returns { items, nextToken? }; pass X-Next-Token as query.nextToken to continue.

query full type

{
  teamID?: string,
  nextToken?: string,
  limit?: number
}

Output

Name	Type	Required	Description
`items`	`object[]`	Yes	—
`nextToken`	`string`	No	—

items full type

{
  templateID: string,
  buildID: string,
  cpuCount: number | 0,
  maxCpuCount?: number,
  memoryMB: number | 0,
  diskSizeMB: number,
  public: boolean,
  aliases: string[],
  names: string[],
  createdAt: string,
  updatedAt: string,
  createdBy: {
    id: string,
    email: string | null
  } | null,
  lastSpawnedAt: string | null,
  spawnCount: number,
  buildCount: number,
  envdVersion: string,
  buildStatus: building | waiting | ready | error | uploaded | string,
  isDefault?: boolean,
  description?: string
}[]

listDefault

templates.listDefault List default templates Risk: read

await corsair.e2b.api.templates.listDefault({});

Input: empty object Output: object[]

Output full type

{
  templateID: string,
  buildID: string,
  cpuCount: number | 0,
  maxCpuCount?: number,
  memoryMB: number | 0,
  diskSizeMB: number,
  public: boolean,
  aliases: string[],
  names: string[],
  createdAt: string,
  updatedAt: string,
  createdBy: {
    id: string,
    email: string | null
  } | null,
  lastSpawnedAt: string | null,
  spawnCount: number,
  buildCount: number,
  envdVersion: string,
  buildStatus: building | waiting | ready | error | uploaded | string,
  isDefault?: boolean,
  description?: string
}[]

startBuild

templates.startBuild Start build (v2) Risk: write

await corsair.e2b.api.templates.startBuild({"path":{"templateID":"test","buildID":"test"},"headers":{"idempotencyKey":"test"},"body":{}});

Input

Name	Type	Required	Description
`path`	`object`	Yes	—
`headers`	`object`	No	—
`body`	`object`	Yes	—

path full type

{
  templateID: string,
  buildID: string
}

headers full type

{
  idempotencyKey?: string
}

body full type

{
  fromImage?: string,
  fromTemplate?: string,
  fromImageRegistry?: {
    type: aws,
    awsAccessKeyId: string,
    awsSecretAccessKey: string,
    awsRegion: string
  } | {
    type: gcp,
    serviceAccountJson: string
  } | {
    type: registry,
    username: string,
    password: string
  },
  force?: boolean,
  steps?: {
    type: string,
    args?: string[],
    filesHash?: string,
    force?: boolean
  }[],
  startCmd?: string,
  readyCmd?: string
}

Output: void

update

templates.update Update template (v2) Risk: write

await corsair.e2b.api.templates.update({"path":{"templateID":"test"},"body":{}});

Input

Name	Type	Required	Description
`path`	`object`	Yes	—
`body`	`object`	Yes	—

path full type

{
  templateID: string
}

body full type

{
  public?: boolean
}

Output

Name	Type	Required	Description
`names`	`string[]`	Yes	—

Volumes

create

volumes.create Create team volume Risk: write

await corsair.e2b.api.volumes.create({"body":{"name":"test"}});

Input

Name	Type	Required	Description
`body`	`object`	Yes	—

body full type

{
  name: string
}

Output

Name	Type	Required	Description
`volumeID`	`string`	Yes	—
`name`	`string`	Yes	—
`token`	`string`	Yes	—
`domain`	`string`	No	—

delete

volumes.delete Delete team volume Risk: destructive

await corsair.e2b.api.volumes.delete({"path":{"volumeID":"test"}});

Input

Name	Type	Required	Description
`path`	`object`	Yes	—

path full type

{
  volumeID: string
}

Output: void

get

volumes.get Team volume Risk: read

await corsair.e2b.api.volumes.get({"path":{"volumeID":"test"}});

Input

Name	Type	Required	Description
`path`	`object`	Yes	—

path full type

{
  volumeID: string
}

Output

Name	Type	Required	Description
`volumeID`	`string`	Yes	—
`name`	`string`	Yes	—
`token`	`string`	Yes	—
`domain`	`string`	No	—

list

volumes.list List team volumes Risk: read

await corsair.e2b.api.volumes.list({});

Input: empty object Output: object[]

Output full type

{
  volumeID: string,
  name: string
}[]

Envd

getEnvironmentVariables

health

metrics

Events

list

listBySandbox

Filesystem

createDir

createWatcher

getWatcherEvents

listDir

move

remove

removeWatcher

stat

Process

closeStdin

list

sendInput

sendSignal

update

Sandboxes

connect

create

createSnapshot

fork

get

getLogs

getMetrics

kill

list

listMetrics

listSnapshots

pause

refresh

setTimeout

updateNetwork

Secrets

create

delete

get

list

update

Tags

assign

count

delete

exists

list

listAssignments

listGroups

Teams

getMaxMetrics

getMetrics

Templates

create

delete

get

getBuildLogs

getBuildStatus

getBuildUploadLink

getByAlias

list

listDefault

startBuild

update

Volumes

create

delete

get

list