SandboxAPI V4.0 8 languages MCP-native

The code execution backend for AI agents

8 languages. Stateful sessions. gVisor isolation. MCP-native. Build agents that execute code safely, validate generated snippets, or run programming lessons without local Docker.

Get an API key Try the Playground
8
Languages
4
Integration modes
gVisor
Kernel isolation
agent code interpreter
# 1. Open a stateful session $ curl -X POST .../v1/sessions \ -d '{"language":"python3"}' → {"id":"sess_abc"}   # 2. Install a package $ curl -X POST .../sessions/sess_abc/install \ -d '{"manager":"pip","packages":["pandas","numpy"]}'   # 3. Execute — files and installed packages persist $ curl -X POST .../sessions/sess_abc/execute \ -d '{"code":"import pandas; print(\"ready\")"}' → "ready\n"
Features

Six things that make SandboxAPI different

Every other code-execution API stops at "send code, get output." We ship the full toolkit AI agents and modern developer tooling actually need.

Stateful Sessions

Persistent sandboxes retain files and installed packages across calls. Interpreter globals reset between calls, so agents store state on disk.

# Files persist
→ POST "open('x.txt','w').write('42')"
→ POST "print(open('x.txt').read())"
→ stdout: "42"

Package Install

Stable pip and npm install direct requested artifacts from a curated cache behind the managed install proxy. List every required package explicitly; transitive resolution is planned.

# Controlled cached install path
manager: "pip"
packages: ["pandas",
            "numpy"]

Streaming Output

Server-Sent Events deliver live stdout/stderr as code runs. No polling, no buffering. Render to a terminal in real time.

# SSE events
→ stdout: "Step 1"
→ stdout: "Step 2"
→ result: exit 0

Async Polling

Enabled in production: submit a long-running job, get a job ID, and poll until it finishes. Ultra supports 300s and Mega 600s here; an unavailable async queue returns 503 instead of falling back to sync.

# Fire-and-poll
async: true
job_id: "job_abc"
GET /v1/executions/job_abc

8 Modern Languages

Python 3.12, Node 22, TypeScript 5.6.3, Go 1.22, Java 21, GCC 12 for C/C++, and Bash 5.2. Focused coverage for the languages agents and coding platforms use most.

# Current runtimes
"python3"    // 3.12
"javascript" // Node 22
"typescript" // 5.6.3 via esbuild
"go"         // 1.22

gVisor Security

gVisor mediates application syscalls through a user-space kernel, adding an isolation boundary beyond the container runtime. Production requires the runsc runtime.

# Isolation stack
code
  → Docker
  → gVisor (runsc)
  → host kernel
Languages

8 modern runtimes

Current, verified runtime versions. Pre-warmed pools. Strict resource limits. Each runs in its own isolated gVisor sandbox.

Integration modes

Four ways to integrate

Same API, four execution patterns. Pick the one that matches your workflow.

Sync

Best for one-shot execution and AI tool calls
curl -X POST .../v1/execute \
  -H "X-RapidAPI-Key: $KEY" \
  -d '{"language":"python3","code":"print(2+2)"}'

Streaming

Best for live output and long-running code
curl -N -X POST .../v1/execute/stream \
  -H "X-RapidAPI-Key: $KEY" \
  -d '{"language":"python3","code":"..."}'

Async

Best for long jobs and polling workflows
curl -X POST ".../v1/execute?async=true" \
  -H "X-RapidAPI-Key: $KEY" \
  -d '{"language":"python3","code":"..."}'

Sessions

Best for iterative agents that persist files and packages
curl -X POST .../v1/sessions/$SID/execute \
  -H "X-RapidAPI-Key: $KEY" \
  -d '{"code":"print(open(\"state.txt\").read())"}'
Read the full API docs →
RapidAPI-backed MCP

Connect Claude Code, Codex, Cursor, and more

The hosted Streamable HTTP adapter exposes four stateless tools and routes every invocation through RapidAPI. Sessions, package install, managed HTTPS, streaming, and async remain REST-only.

Use your RapidAPI subscription

Claude Code, Codex, Cursor, VS Code, and Antigravity can connect over Streamable HTTP using your RapidAPI key as a Bearer token. Pick your client's setup in the integration guide.

  • execute_code, execute_batch, list_languages
  • get_capabilities
  • One tool invocation maps to one RapidAPI request
MCP integration guide → 
# Codex: ~/.codex/config.toml
# Provide the key through the Codex environment.
[mcp_servers.sandboxapi]
url = "https://mcp.sandboxapi.dev/mcp"
bearer_token_env_var = "SANDBOXAPI_RAPIDAPI_KEY"
tool_timeout_sec = 180

Migrating from Judge0?

Field-level mapping, honest comparison, and recommendations by persona.

SandboxAPI vs Judge0 →
Use Cases

See it in action

Real-world examples you can run right now. Click any example to try it in the playground.

Python

Validate LLM-Generated Code

Run AI-generated functions against a test harness, get structured pass/fail results

Try it →
Python

Code interpreter loop

Stateful sessions and package install for a debugging agent that retries on errors and learns from compile failures

See pattern →
JavaScript

Execute Validation Logic

Run generated business rules to validate records with detailed error reporting

Try it →
C++

Submission grader

Run submitted code against a harness and return stdout, stderr, exit code, time, and memory usage

Try it →
Java

Performance Benchmark

Benchmark solutions at scale and verify time complexity meets O(n) requirement

Try it →
Bash

Multi-Language Runner

Run the same challenge across 8 languages and verify output consistency in your own harness

Try it →
Python

Auto-Grade Assignment

Score student code against a weighted rubric with 14 test cases across 3 categories

Try it →
C++

Code Challenge Runner

Validate student functions against hidden test suites with detailed feedback

Try it →
JavaScript

Interactive Challenge

Test student expressions with stdin input and automated evaluation

Try it →
Python

Validate Deploy Config

Check production configs against security rules, flag errors and warnings

Try it →
Go

Generate Sales Report

Transform raw sales data into formatted reports with leaderboards and breakdowns

Try it →
Bash

Test Data Pipeline

Run ETL pipeline steps and validate each transformation produces correct output

Try it →
Pricing

Predictable pricing, four plans

All plans include 8 languages, gVisor isolation, stdin, batch execution, and streaming. Pro is the recommended first paid step; Ultra is built for serious workflows, and Mega is the high-volume RapidAPI plan.

Basic
$0/mo
500 requests / RapidAPI subscription period
  • Safe free code execution
  • 8 languages
  • 30s max timeout
  • Up to 10 accepted items per batch
  • No outbound network
Start free
Pro
$19/mo
10,000 requests / RapidAPI subscription period
  • Everything in Basic
  • 60s max timeout
  • Up to 50 accepted items per batch
  • 2 concurrent sessions
  • Direct pip/npm artifacts (curated cache)
  • Shipped: opt-in managed public HTTPS
Subscribe
Ultra
$49/mo
50,000 requests / RapidAPI subscription period
  • Everything in Pro
  • 150s sync/session · 300s async
  • Up to 100 accepted items per batch
  • 5 concurrent sessions
  • Curated popular-package cache
  • Optional exact/wildcard domain rules (max 32)
Subscribe
Mega
$149/mo
200,000 requests / RapidAPI subscription period
  • Everything in Ultra
  • 150s sync/session · 600s async · up to 200 accepted items/batch
  • 60 requests/minute
  • 8 concurrent sessions · 30m idle max
  • Curated package cache · 300 installs/account/hour
  • Opt-in HTTPS with optional domain rules
  • Planned: customer audit logs; static egress IP is deployment-dependent
Choose Mega

Network is off by default; Basic and playground traffic cannot enable it. Paid API requests can opt in to managed public HTTPS with network.enabled, while Ultra and Mega can optionally set allowed_domains. This is an explicit HTTPS_PROXY path: clients must honor or be configured for that proxy, and raw public sockets are unavailable. One endpoint call is one RapidAPI request; batch limits are maximum accepted items, processed through bounded workers within a 150-second request wall-clock budget. RapidAPI's gateway maximum is 180 seconds, leaving 30 seconds for delivery and cleanup. RapidAPI meters bandwidth in 1 MB units, with 10,240 MB/month currently included on every plan, then $0.001 per MB above that allowance and owns each subscription-period request allowance; SandboxAPI applies per-minute burst limits per RapidAPI subscriber identity. Session caps are per-RapidAPI-account ceilings. Shared service capacity is not reserved; during saturation, session creation may return HTTP 503 with Retry-After.

Detailed pricing comparison →

Stop building sandbox infrastructure

Get your API key and start executing code in minutes. Basic includes 500 requests per RapidAPI subscription period.

Get API key on RapidAPI Open the Playground