Function Compute:Code interpreter v1 template

Create a sandbox and execute code

Use the e2b_code_interpreter SDK to create a sandbox and execute code through run_code:

from e2b_code_interpreter import Sandbox

sbx = Sandbox.create()
try:
    execution = sbx.run_code("print('hello from code interpreter')")
    print("".join(execution.logs.stdout))
finally:
    sbx.kill()

TypeScript example:

npm init -y
npm install @e2b/code-interpreter@^2.6.1 tsx

import { Sandbox } from "@e2b/code-interpreter";

const sbx = await Sandbox.create();

try {
  const execution = await sbx.runCode("print('hello from code interpreter')");
  console.log(execution.logs.stdout.join(""));
} finally {
  await sbx.kill();
}

logs.stdout and logs.stderr are both lists of strings, and need to be joined with "".join(...) (Python) or .join("") (TypeScript) to form complete text.

Main parameters of run_code / runCode:

The Execution result contains logs (stdout/stderr lists), results (final expression results with text representation), error (execution exceptions), and an execution count (execution_count in Python and executionCount in TypeScript).

Context persistence

In the default context of the same sandbox, variables, imports, and functions are retained across calls:

sbx = Sandbox.create(**kwargs)
try:
    sbx.run_code("x = 42")
    execution = sbx.run_code("print(x)")
    print("".join(execution.logs.stdout))  # 42
finally:
    sbx.kill()

Code context management

Each code context (Context) has independent variable state. Route code execution to a specified context through the context parameter; when context is not specified, the default context is used. Context management is currently provided by the Python SDK:

The context parameter of run_code must pass a Context object; restart_code_context / remove_code_context accept a Context object or a context ID string. create_code_context requires language (python or javascript), and cwd defaults to /home/user.

from e2b_code_interpreter import Sandbox

sbx = Sandbox.create(**kwargs)
try:
    # Create an independent context
    ctx = sbx.create_code_context(language="python", cwd="/home/user")
    sbx.run_code("y = 100", context=ctx)
    execution = sbx.run_code("print(y)", context=ctx)
    print("".join(execution.logs.stdout))  # 100

    # Variables in ctx are not accessible in the default context, execution.error contains NameError
    default_execution = sbx.run_code("print(y)")

    # Variables are cleared after restarting the context, execution.error contains NameError
    sbx.restart_code_context(ctx)
    restarted_execution = sbx.run_code("print(y)", context=ctx)

    # Delete the context
    sbx.remove_code_context(ctx)
finally:
    sbx.kill()

The runCode method of the TypeScript SDK executes code normally, but its context management methods (createCodeContext / listCodeContexts / restartCodeContext / removeCodeContext) are currently unavailable on this platform; use the Python SDK to manage independent contexts.

Multi-language execution

Specify the execution language through the language parameter, defaulting to python:

sbx = Sandbox.create(**kwargs)
try:
    execution = sbx.run_code("console.log('hello js')", language="javascript")
    print("".join(execution.logs.stdout))
finally:
    sbx.kill()

const sbx = await Sandbox.create();
try {
  const execution = await sbx.runCode("console.log('hello js')", { language: "javascript" });
  console.log(execution.logs.stdout.join(""));
} finally {
  await sbx.kill();
}

Using the general e2b SDK

When using the e2b SDK, you need to explicitly specify the template code-interpreter-v1. At this point, you can use the sandbox's basic capabilities (files, commands, processes), but it does not include run_code:

from e2b import Sandbox

sbx = Sandbox.create(template="code-interpreter-v1")
try:
    result = sbx.commands.run("python --version")
    print(result.stdout)
finally:
    sbx.kill()