Sandbox

betaPause(opts?: SandboxPauseOpts): Promise<boolean>

connect(opts?: SandboxConnectOpts): Promise<Sandbox>

const sandbox = await Sandbox.create()
await sandbox.betaPause()

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

createSnapshot(opts?: CreateSnapshotOpts): Promise<SnapshotInfo>

const sandbox = await Sandbox.create()
await sandbox.files.write('/app/state.json', '{"step": 1}')

// Create a snapshot
const snapshot = await sandbox.createSnapshot({ name: 'my-snapshot' })

// Create a new sandbox from the snapshot
const newSandbox = await Sandbox.create(snapshot.snapshotId)

// Filesystem-only snapshot: sandboxes created from it start fresh from disk
const fsSnapshot = await sandbox.createSnapshot({ mode: 'filesystem' })

doubleClick(x?: number, y?: number): Promise<void>

downloadUrl(path: string, opts?: SandboxUrlOpts): Promise<string>

drag(from: [number, number], to: [number, number]): Promise<void>

fork(opts?: SandboxForkOpts): Promise<(Sandbox | Error)[]>

const sandbox = await Sandbox.create()

const [fork1, fork2] = await sandbox.fork({ count: 2 })
if (fork1 instanceof Sandbox) {
  await fork1.commands.run('echo "hello from fork"')
}

getApplicationWindows(application: string): Promise<string[]>

getCurrentWindowId(): Promise<string>

getCursorPosition(): Promise<CursorPosition>

getHost(port: number): string

const sandbox = await Sandbox.create()
// Start an HTTP server
await sandbox.commands.run('python3 -m http.server 3000', { background: true })
// Get the hostname of the HTTP server
const serverURL = sandbox.getHost(3000)

getInfo(opts?: Pick<SandboxOpts, "requestTimeoutMs" | "signal">): Promise<SandboxInfo>

getMcpToken(): Promise<undefined | string>

getMcpUrl(): string

getMetrics(opts?: SandboxMetricsOpts): Promise<SandboxMetrics[]>

getScreenSize(): Promise<ScreenSize>

getWindowTitle(windowId: string): Promise<string>

isRunning(opts?: Pick<ConnectionOpts, "requestTimeoutMs" | "signal">): Promise<boolean>

const sandbox = await Sandbox.create()
await sandbox.isRunning() // Returns true

await sandbox.kill()
await sandbox.isRunning() // Returns false

kill(opts?: Pick<SandboxOpts, "requestTimeoutMs" | "signal">): Promise<boolean>

launch(application: string, uri?: string): Promise<void>

leftClick(x?: number, y?: number): Promise<void>

listSnapshots(opts?: Omit<SnapshotListOpts, "sandboxId">): SnapshotPaginator

middleClick(x?: number, y?: number): Promise<void>

mousePress(button: "left" | "right" | "middle"): Promise<void>

mouseRelease(button: "left" | "right" | "middle"): Promise<void>

moveMouse(x: number, y: number): Promise<void>

open(fileOrUrl: string): Promise<void>

pause(opts?: SandboxPauseOpts): Promise<boolean>

const sandbox = await Sandbox.create()
await sandbox.pause()

// filesystem-only snapshot (resume reboots the sandbox)
await sandbox.pause({ mode: 'filesystem' })

press(key: string | string[]): Promise<void>

rightClick(x?: number, y?: number): Promise<void>

screenshot(): Promise<Uint8Array<ArrayBufferLike>>

screenshot(format: "bytes"): Promise<Uint8Array<ArrayBufferLike>>

screenshot(format: "blob"): Promise<Blob>

screenshot(format: "stream"): Promise<ReadableStream<Uint8Array<ArrayBufferLike>>>

scroll(direction: "down" | "up", amount: number): Promise<void>

setTimeout(timeoutMs: number, opts?: Pick<SandboxOpts, "requestTimeoutMs" | "signal">): Promise<void>

updateNetwork(network: SandboxNetworkUpdate, opts?: Pick<SandboxOpts, "requestTimeoutMs" | "signal">): Promise<void>

uploadUrl(path?: string, opts?: SandboxUrlOpts): Promise<string>

wait(ms: number): Promise<void>

waitAndVerify(
   cmd: string, 
   onResult: (result: CommandResult) => boolean, 
   timeout: number, 
interval: number): Promise<boolean>

write(text: string, options: object): Promise<void>

static betaPause(sandboxId: string, opts?: SandboxPauseOpts): Promise<boolean>

static connect<S>(
   this: S, 
   sandboxId: string, 
opts?: SandboxConnectOpts): Promise<InstanceType<S>>

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

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

static create<S>(this: S, opts?: SandboxOpts): Promise<InstanceType<S>>

const sandbox = await Sandbox.create()

static create<S>(
   this: S, 
   template: string, 
opts?: SandboxOpts): Promise<InstanceType<S>>

const sandbox = await Sandbox.create('<template-name-or-id>')

static createSnapshot(sandboxId: string, opts?: CreateSnapshotOpts): Promise<SnapshotInfo>

static deleteSnapshot(snapshotId: string, opts?: SandboxApiOpts): Promise<boolean>

static fork<S>(
   this: S, 
   sandboxId: string, 
opts?: SandboxForkOpts): Promise<(Error | InstanceType<S>)[]>

const sandbox = await Sandbox.create()

const [fork1, fork2] = await Sandbox.fork(sandbox.sandboxId, { count: 2 })
if (fork1 instanceof Sandbox) {
  await fork1.commands.run('echo "hello from fork"')
}

static getFullInfo(sandboxId: string, opts?: SandboxApiOpts): Promise<SandboxInfo>

static getInfo(sandboxId: string, opts?: SandboxApiOpts): Promise<SandboxInfo>

static getMetrics(sandboxId: string, opts?: SandboxMetricsOpts): Promise<SandboxMetrics[]>

static kill(sandboxId: string, opts?: SandboxApiOpts): Promise<boolean>

static list(opts?: SandboxListOpts): SandboxPaginator

static listSnapshots(opts?: SnapshotListOpts): SnapshotPaginator

static pause(sandboxId: string, opts?: SandboxPauseOpts): Promise<boolean>

static setTimeout(
   sandboxId: string, 
   timeoutMs: number, 
opts?: SandboxApiOpts): Promise<void>

static updateNetwork(
   sandboxId: string, 
   network: SandboxNetworkUpdate, 
opts?: SandboxApiOpts): Promise<void>

optional allowInternetAccess: boolean;

optional apiHeaders: Record<string, string>;

optional apiKey: string;

E2B_API_KEY // environment variable

optional display: string;

optional domain: string;

optional dpi: number;

optional envs: Record<string, string>;

{}

optional headers: Record<string, string>;

optional httpVersion: HttpVersion;

optional iam: SandboxIamOpts;

const sandbox = await Sandbox.create({
  iam: {
    tokens: {
      aws: Secret.iamToken({
        audience: 'sts.amazonaws.com',
        tokenType: 'JWT-SVID',
      }),
    },
  },
})

optional lifecycle: SandboxLifecycle;

optional logger: Logger;

optional mcp: McpServer$1;

undefined

optional metadata: Record<string, string>;

{}

optional network: SandboxNetworkOpts;

optional proxy: string;

'http://user:pass@127.0.0.1:8080'

optional requestTimeoutMs: number;

60_000 // 60 seconds

optional resolution: [number, number];

optional retries: number;

3

optional sandboxUrl: string;

optional secure: boolean;

optional signal: AbortSignal;

optional template: string;

optional timeoutMs: number;

optional validateApiKey: boolean;

optional volumeMounts: Record<string, string | Volume>;

undefined