Runtime

OpenAI Code Interpreter alternative: run code in your own sandbox

OpenAI's Code Interpreter runs Python in a hosted container; your own sandbox runs any model's code in seven languages, on your terms.

Runtime runs the same 20-minute, 4 GiB session for $0.0104 to $0.0267, against $0.12 for OpenAI's 4 GB container. Runtime bills the CPU the code uses and the memory it holds, so a session that mostly waits for the model costs little. OpenAI prices every container by its memory tier for each 20-minute session. OpenAI rates checked 25 September 2026; Runtime's are in pricing.

What Code Interpreter is

Code Interpreter is a built-in tool of OpenAI's Responses API. In OpenAI's words, it "allows models to write and run Python code in a sandboxed environment", and "the model knows it as the 'python tool'".

  • Containers. The tool runs in a container. With "type": "auto" OpenAI makes one, or create one yourself at /v1/containers and pass its id.
  • Memory. 1g (the default), 4g, 16g or 64g. OpenAI's guide and pricing name memory tiers, not CPU counts.
  • Lifetime. "A container expires if it is not used for 20 minutes." Its data is then "discarded from our systems and not recoverable".
  • Files. Files in the model input are uploaded to the container for you, and files the model makes come back as annotations on its message.
  • Network. A container created through the API takes a network_policy: outbound access disabled, or an allowlist of domains, with optional domain-scoped secrets.

What it costs

OpenAI's price list, checked 25 September 2026: "1 GB $0.03, 4 GB $0.12, 16 GB $0.48, 64 GB $1.92 per 20-minute session per container." Its footnote adds that "eligible container sessions will be billed by the minute, with a 5-minute minimum per session." Tokens are billed on top, at the model's rates.

The same sessions on Runtime at 2 vCPU and 4 GiB, which costs $0.03125 an hour while the code waits and $0.08 an hour with both CPUs busy:

Session OpenAI, 4 GB container Runtime, 2 vCPU and 4 GiB
20 minutes, mostly waiting $0.12 20 / 60 × $0.03125 = $0.0104
20 minutes, both CPUs busy $0.12 20 / 60 × $0.08 = $0.0267
One minute, where per-minute applies 5-minute minimum: 5 / 20 × $0.12 = $0.03 1 / 60 × $0.08 = $0.0013 at most
1,000 sessions of 20 minutes $120.00 $10.42 waiting, $26.67 busy

Model tokens are left out of both columns. Runtime has no minimum charge per session (pricing).

Where your own sandbox does more

Need OpenAI Code Interpreter Runtime sandbox
Model OpenAI models, through the Responses API Any model or framework; your code calls the sandbox
Languages in the notebook Python, "the python tool" Python, JavaScript, TypeScript, R, Java, Bash and Go
The machine OpenAI's container; a create takes memory, files, network and skills Your image: a package recipe, any public or private image, or a Dockerfile
An idle session Expires after 20 minutes unused, and its data is discarded Pauses with files, memory and processes, kept 1 to 365 days
Copies of a session None in OpenAI's guide Fork 1 to 10 running copies, memory included
Isolation "A sandboxed environment" A Firecracker microVM with its own Linux kernel
Billing Memory tier, per 20-minute session Measured CPU plus reserved memory while running, with no minimum

The interpreter keeps variables between cells, and charts come back as PNG and data frames as tables (code interpreter). Network rules bind root inside the sandbox too, because the host enforces them (security).

The Runtime equivalent

Install what the model needs, close the network, then run its cells. The sandbox pauses itself after ten quiet minutes and wakes on the next cell:

TypeScriptimport { Sandbox } from "withruntime";await using sbx = await Sandbox.create({  network: { internet: true, allow: ["pypi.org", "*.pythonhosted.org"] },  idlePauseSeconds: 600,});await sbx.exec("pip install --quiet scikit-learn", { check: true, timeoutMs: 300_000 });await sbx.network.set({ internet: false }); // nothing leaves while the model's code runsawait sbx.interpreter.run(  "from sklearn.datasets import load_iris\nX, y = load_iris(return_X_y=True)",);const cell = await sbx.interpreter.run("X.shape");console.log(cell.results[0]?.data["text/plain"]); // (150, 4)
Pythonfrom withruntime import Sandboxwith Sandbox.create(    network={"internet": True, "allow": ["pypi.org", "*.pythonhosted.org"]},    idle_pause_seconds=600,) as sbx:    sbx.exec("pip install --quiet scikit-learn", check=True, timeout_ms=300_000)    sbx.network.set(internet=False)  # nothing leaves while the model's code runs    sbx.interpreter.run("from sklearn.datasets import load_iris\nX, y = load_iris(return_X_y=True)")    cell = sbx.interpreter.run("X.shape")    print(cell["results"][0]["data"]["text/plain"])  # (150, 4)

Expose a function like this to the model as a tool and return the cell's output as the tool result. With the OpenAI Agents SDK, RuntimeCloudSandboxClient runs a SandboxAgent's shell and files in a Runtime sandbox with the agent unchanged (OpenAI Agents SDK).

Which one fits

  • Keep Code Interpreter for quick Python answers inside an OpenAI conversation, when a 20-minute session and the container's own packages cover the job.
  • Use your own sandbox when the code needs packages or tools you choose, a language other than Python, a session that survives a long pause, a model from more than one provider, or a bill that follows the CPU used.

Try it on the free trial:

Terminalnpx withruntime sandbox run --trial -- python3 -c 'print(6 * 7)'

The first run prints a link to approve in your browser; there is no API key to copy.

More: add a code interpreter to a chatbot, what is a code interpreter?, data analysis agent, Claude code execution tool alternative.

Sources

Checked 25 September 2026.

Facts on this page were checked on 25 September 2026.

Claim 50 hours free