# OnlineCompiler.io

> Code execution API (also called an online compiler API). Send source code in one of 46 languages, with optional stdin, and get back stdout, stderr, exit code, wall-clock run time and memory; or send test cases and get a verdict for each. Judge0- and Piston-compatible endpoints, an embeddable code editor and an MCP server use the same sandbox: a fresh gVisor container per run with no network access. Free up to 100,000 requests a month, commercial use included, no credit card.

Most users are developers building online judges and coding-challenge sites, coding courses and LMSs, and coding-test or interview platforms: anything that has to run code written by someone else, usually against stdin test cases. It also works as a sandbox for AI agents (MCP) and as an embeddable code editor for docs and blogs.

Base URL: `https://api.onlinecompiler.io`. Authenticate with your API key in the `Authorization` header (`Authorization: YOUR_API_KEY`). Get a key by signing in at https://api.onlinecompiler.io/compilers/api-keys/.

Example (sync, result in the response):

```
curl -X POST https://api.onlinecompiler.io/api/run-code-sync/ \
  -H "Authorization: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"compiler": "python-3.14", "code": "print(int(input()) * 2)", "input": "21"}'
```

Response fields: `output` (stdout), `error` (stderr or compiler errors), `status` ("success" or "error"), `exit_code`, `signal`, `time` (run-command wall time in seconds; includes compilation inside Java, F#, Deno, Dart, Erlang, Elixir, Clojure, Groovy and Racket), `total` (seconds, including compilation), `memory` (KB), `truncated` (true when output or error went over 64 KB and was cut), `time_limit` (the run's time limit in seconds), `files` (files the program wrote to `$OUTPUT_DIR`, each `{name, mime, size, content_base64, url}`; see Python data science, files in and out) and `files_truncated`. Output and error are UTF-8 text; NUL bytes and invalid UTF-8 come back as U+FFFD.

## Ways to run code

- [Sync REST API](https://onlinecompiler.io/docs/run-code#endpoint-sync): `POST /api/run-code-sync/` with `compiler`, `code` and optional `input` and `time_limit` (seconds the program may run, above 0 and up to 30; compiling before it does not count, and the run is stopped at it with exit code 124; Java, Groovy and F# compile as they start, so they get extra seconds on top: Java 1 s, Groovy 1.5 s and F# 2.5 s). Returns the result in the response. Optional `files` attach input files (see Python data science, files in and out).
- [Run tests](https://onlinecompiler.io/docs/run-tests): `POST /api/run-tests/` runs one program against a list of tests and returns a verdict for each, an overall verdict and a score; same `Authorization` header, and it waits for the result. Body: `compiler`, `code`, `tests` (objects with `input`, `expected_output`, optional `hidden` and `weight`), and optional `time_limit` (seconds per test, default 2, up to 30; plus the start-up allowance for Java 1 s, Groovy 1.5 s and F# 2.5 s), `files` (input files shared by every test), `checker` (`trim` default, `exact`, `tokens`, `float` with `tolerance`, `rows` for an unordered set of rows, with the same `tolerance`: a line with `|`, a comma or a tab splits at each one into fields, empty fields kept and spaces around them ignored, any other line splits at whitespace), `scoring` (`all_or_nothing` default, `percent`, `weighted`) and `stop_on_failure`. Response: `verdict`, `score` (0 to 100), `passed`, `total`, `time_limit`, `compile_error` and `tests`. Verdicts: `accepted`, `wrong_answer`, `time_limit_exceeded`, `compilation_error`, `runtime_error`, `output_limit_exceeded`, `memory_limit_exceeded`, `internal_error` and `skipped` (never started), plus `incomplete` for the overall verdict (the start cut-off skipped tests, usually because the host or the account's other runs kept the sandboxes busy; retry the request, which runs and counts every test again). Hidden and skipped tests return only `verdict` and `hidden`. Each test counts as one run and takes one of the account's pending slots from the request's arrival until that test finishes. Tests per request: 8 on Free, 20 on Starter, 40 on Pro, 80 on Business; tests run in rounds of at most 4 at once, and a round takes up to time_limit + start-up allowance + round overhead (3 s for compiling and starting; Crystal 13 s, Kotlin 6 s, Nim 5.5 s, Zig 4.5 s, Scala 4 s, C# 4 s and Visual Basic 4 s, since each test compiles again; C, C++ and Java compile once per request when there are more tests than run at once); all rounds must fit in 60 s and the last must start within 45 s, after which no test starts; inputs and expected outputs total at most 1 MB. Visible tests return their output files, at most 4 MB of file content per response (later tests get `files_truncated`), with `url` null; hidden tests never return files.
- [Async REST API](https://onlinecompiler.io/docs/run-code#endpoint): `POST /api/run-code/` returns 202 with a job id, then posts the result to the public HTTP(S) callback URL set on your API key; private IPs and redirects are rejected. Pass an `extra_params` JSON object (up to 8 KB) to get your own data back in the callback.
- [WebSocket](https://onlinecompiler.io/docs/websocket): real-time results for browser apps, using a separate WebSocket key.
- [Embeddable widget](https://onlinecompiler.io/docs/widget): add `<script src="https://onlinecompiler.io/widget.js"></script>` and a `<div class="runcode">` to put a runnable editor on any page. Put your code in a `<pre>` (or `<script type="text/plain">`, or a docs generator's fenced code block) inside the div and stdin in a `<pre data-stdin>`; readers can edit, run and reset it. `data-theme` takes dark, light or auto; `data-readonly` locks the code; a `data-template` element holds hidden code with `##CODE##` where the reader's code goes. A `<script type="application/json" data-result>` holding an earlier run's result (the `runcode:result` detail, files included) shows that output until the reader runs. Events `runcode:ready`, `runcode:run`, `runcode:result` and `runcode:error` bubble from the div, and `OnlineCompilerWidget.get(div)` returns a widget with `getCode`, `setCode`, `getInput`, `setInput`, `run` and `reset`. Widgets added or removed after page load (Docusaurus, Mintlify, MkDocs instant navigation) start and disconnect on their own. `data-height="fill"` fills the div's own height.
- [Iframe embed](https://onlinecompiler.io/docs/widget#embed): for sites that strip scripts, `<iframe src="https://api.onlinecompiler.io/embed/?key=WIDGET_KEY&lang=python-3.14#code=URL_ENCODED_CODE&input=URL_ENCODED_INPUT">` shows one widget filling the frame. `theme` and `readonly=1` are optional query parameters; code and input go after the `#`, so they never reach a server. A key restricted to a domain can only be framed by pages on that domain.
- [MCP server](https://onlinecompiler.io/mcp-code-execution#setup): `https://api.onlinecompiler.io/mcp` (streamable HTTP, `Authorization: Bearer YOUR_API_KEY`; the bare key also works, as in the REST API). Tools: `list_compilers`, `run_code` (optional `time_limit`) and `run_tests` (up to 10 tests; it runs every test unless the code fails to compile or the request runs out of time, and returns the run-tests response). Works with Claude Code, Claude Desktop, Cursor and VS Code. Listed in the official MCP Registry as `io.onlinecompiler/compiler`. Give each agent its own key with a monthly limit to cap what it can run.
- [Piston-compatible API](https://onlinecompiler.io/docs/piston): Piston v2 clients work by changing their base URL to `https://api.onlinecompiler.io/api/v2/piston` and sending `Authorization: YOUR_API_KEY`. `GET /runtimes` (no key) lists Piston names and aliases; `POST /execute` takes the program as the first entry of `files` plus `stdin`; further `files` entries are input files (same limits as the native `files` field). `run_timeout` and `run_cpu_time` stop the run at the lower of the two (capped at 30 s, compile not counted, plus the start-up allowance for Java 1 s, Groovy 1.5 s and F# 2.5 s); `version`, compile limits and memory limits are ignored, `args` are not supported, no output files come back, and compiler errors arrive in `run.stderr` (there is no separate compile stage). Errors come back as `{"message": "..."}`.
- [Judge0-compatible API](https://onlinecompiler.io/docs/judge0): Judge0 CE clients work by changing their base URL to `https://api.onlinecompiler.io/api/judge0` and sending the API key in `X-Auth-Token` (or `Authorization`). `POST /submissions` (with `wait=true`, or a token to poll at `GET /submissions/{token}`), `POST /submissions/batch` and `GET /submissions/batch?tokens=`, `base64_encoded`, `fields`, `expected_output`, `callback_url` (PUT, base64) and Judge0 status ids work as on Judge0; `GET /languages` and `GET /statuses` need no key. Older language ids such as 71 run on the current version. The lower of `cpu_time_limit` and `wall_time_limit` (capped at 30 s, compile not counted, plus the start-up allowance for Java 1 s, Groovy 1.5 s and F# 2.5 s) stops the run and gives Time Limit Exceeded; other limits are ignored. `compiler_options`, `command_line_arguments` and `enable_network` answer 422. `additional_files` (a base64 zip) is unpacked as input files under the same limits as the native `files` field. No output files come back. Compilation Error (6) is reported for C, C++, C#, Go, Rust, Haskell, Fortran, Visual Basic, Kotlin, Swift, COBOL, Pascal, Assembly, OCaml, D, FreeBASIC, Scala and Objective-C. A batch holds up to 20 submissions and no more than the account's pending limit, and is admitted whole or not at all.

## Languages

Compiler ids for the `compiler` field. `GET /api/compilers/` returns the same list and needs no key.

- `python-3.14`: Python (3.14). Run as `python3 code.py`.
- `gcc-15`: C (GCC 15). Compiled with `gcc -O2 code.c -o code.out -lm`, run as `./code.out`.
- `g++-15`: C++ (G++ 15). Compiled with `g++ -O2 -Wall code.cc -o code.out`, run as `./code.out`.
- `openjdk-25`: Java (OpenJDK 25). Run as `java -XX:ActiveProcessorCount=2 -XX:MaxRAMPercentage=60 code.java`.
- `dotnet-csharp-10`: C# (.NET SDK 10). Compiled with `csc /optimize+ /langversion:14.0 /out:out/code.dll code.cs`, run as `dotnet out/code.dll`.
- `dotnet-fsharp-10`: F# (.NET SDK 10). Run as `dotnet fsi --exec code.fsx`.
- `go-1.26`: Go (1.26). Compiled with `go build -p 2 -o program code.go`, run as `./program`.
- `rust-1.93`: Rust (1.93). Compiled with `rustc -C opt-level=2 -C overflow-checks=on code.rs -o code.out`, run as `./code.out`.
- `php-8.5`: PHP (8.5). Run as `php -d display_errors=stderr -d log_errors=Off code.php`.
- `ruby-4.0`: Ruby (4.0). Run as `ruby code.rb`.
- `haskell-9.12`: Haskell (GHC 9.12). Compiled with `ghc -v0 -o code code.hs`, run as `./code`.
- `typescript-deno`: TypeScript (Deno). Run as `deno run --quiet --cached-only --no-prompt --allow-read=/sandbox,/tmp --allow-write=/tmp/outputs --allow-env=OUTPUT_DIR code.ts`.
- `nodejs-24`: JavaScript (Node.js 24). Run as `node code.js`.
- `sqlite-3`: SQL (SQLite 3). Run as `sqlite3 -batch -bail < code.sql`.
- `duckdb-1.5`: DuckDB (1.5). Run as `duckdb -batch -bail -list -noheader -cmd "SET autoinstall_known_extensions=false; SET autoload_known_extensions=false; SET memory_limit='256MB'" < code.sql`.
- `bash-5.2`: Bash (5.2). Run as `bash code.sh`.
- `gfortran-15`: Fortran (gfortran 15). Compiled with `gfortran -O2 code.f90 -o code.out`, run as `./code.out`.
- `dotnet-vbnet-10`: Visual Basic (.NET SDK 10). Compiled with `vbc /optimize+ /out:out/code.dll code.vb`, run as `dotnet out/code.dll`.
- `kotlin-2.4`: Kotlin (2.4). Compiled with `kotlinc code.kt -include-runtime -d code.jar`, run as `java -XX:ActiveProcessorCount=2 -XX:MaxRAMPercentage=60 -jar code.jar`.
- `r-4.6`: R (4.6). Run as `Rscript code.R`.
- `swift-6.4`: Swift (6.4). Compiled with `swiftc -O -g code.swift -o code.out`, run as `./code.out`.
- `gnucobol-3.2`: COBOL (GnuCOBOL 3.2). Compiled with `cobc -x -free -Wno-missing-newline -A -w code.cob -o code.out`, run as `./code.out`.
- `perl-5.44`: Perl (5.44). Run as `perl code.pl`.
- `julia-1.13`: Julia (1.13). Run as `julia --startup-file=no --history-file=no code.jl`.
- `fpc-3.2`: Pascal (Free Pascal 3.2). Compiled with `fpc -l- -v0ew -O2 code.pas -ocode.out`, run as `./code.out`.
- `octave-11`: Octave (11). Run as `octave-cli --quiet --norc --no-history code.m`.
- `nasm-3`: Assembly (NASM 3). Compiled with `nasm -f elf64 code.asm -o code.o && ld code.o -o code.out`, run as `./code.out`.
- `lua-5.5`: Lua (5.5). Run as `lua code.lua`.
- `ocaml-5.4`: OCaml (5.4). Compiled with `ocamlopt -I +str -I +unix str.cmxa unix.cmxa code.ml -o code.out`, run as `./code.out`.
- `sbcl-2.6`: Common Lisp (SBCL 2.6). Run as `sbcl --dynamic-space-size 384MB --noinform --disable-ldb --end-runtime-options --script code.lisp`.
- `erlang-29`: Erlang (OTP 29). Run as `erl -noshell -boot no_dot_erlang -pa /runcode -run runcode_erlang main code.erl`.
- `elixir-1.20`: Elixir (1.20). Run as `elixir code.exs`.
- `swipl-10`: Prolog (SWI-Prolog 10). Run as `swipl -f /runcode/init.pl --on-error=status -q -t runcode_halt code.pl`.
- `ldc-1.43`: D (LDC 1.43). Compiled with `ldc2 -O code.d -of=code.out`, run as `./code.out`.
- `fbc-1.10`: FreeBASIC (1.10). Compiled with `fbc -x code.out code.bas`, run as `./code.out`.
- `dart-3.13`: Dart (3.13). Run as `dart run code.dart`.
- `clojure-1.12`: Clojure (1.12). Run as `clojure code.clj`.
- `groovy-6.0`: Groovy (6.0). Run as `groovy code.groovy`.
- `scala-3.10`: Scala (3.10). Compiled with `mkdir out && scalac -color:never -deprecation -d out code.scala`, run as `scala-run out`.
- `zig-0.17`: Zig (0.17). Compiled with `zig build-exe -j2 -target x86_64-linux code.zig -femit-bin=code.out`, run as `./code.out`.
- `nim-2.2`: Nim (2.2). Compiled with `nim c --hints:off --parallelBuild:2 --nimcache:/tmp/nimcache -o:code.out code.nim`, run as `./code.out`.
- `crystal-1.22`: Crystal (1.22). Compiled with `crystal build --no-color --single-module -o code.out code.cr`, run as `./code.out`.
- `gnat-15`: Ada (GNAT 15). Compiled with `gnatchop-15 -r -w -gnat2022 code.adb && gnatmake-15 -q -O2 -gnat2022 <main>.adb -o code.out`, run as `./code.out`.
- `powershell-7.6`: PowerShell (7.6). Run as `pwsh -NoLogo -NonInteractive -File code.ps1`.
- `racket-9.3`: Racket (9.3). Run as `racket code.rkt`.
- `clang-objc-21`: Objective-C (Clang 21). Compiled with `clang $(gnustep-config --objc-flags) -fobjc-weak code.m -o code.out $(gnustep-config --base-libs)`, run as `./code.out`.

The .NET 9 ids `dotnet-csharp-9`, `dotnet-fsharp-9` and `dotnet-vbnet-9` still work and run on .NET 10; send the `-10` ids in new code.

Every language reads `input` as stdin except `sqlite-3`, whose stdin is the program: it runs `code` on a fresh in-memory database and stops at the first error, and the script reads `input` with `readfile('input')`. `duckdb-1.5` works the same way (the program is the SQL, rows print as `a|b|c` with no header, the script reads `input` with `read_text('input')`, input files are read with `read_csv('name.csv')`), with a 256 MB memory limit and no extension downloads.

`nasm-3` is 64-bit Linux assembly: a program with a global `main` is linked by `gcc -no-pie` and can call the C library, and 32-bit `int 0x80` system calls crash. `gnucobol-3.2` compiles free format; start fixed-format code with `>>SOURCE FORMAT IS FIXED`. An `octave-11` file can't start with `function`. `julia-1.13` reports memory including its system image, often the full 512 MB. `erlang-29` starts at `main/1`, as an escript does, and `-module`/`-export` are optional. `swipl-10` runs a program from its `:- initialization(main).` directive, as GNU Prolog does, but double-quoted text is a string. `scala-3.10` needs exactly one entry point, an `@main` method or an object's `main`. `fbc-1.10` has no graphics: programs that use `Screen` fail to link. `zig-0.17` uses Zig 0.17's I/O: `main` takes `init: std.process.Init`, and stdin and stdout are `std.Io.File.reader(.stdin(), init.io, &buf)` and `std.Io.File.writer(.stdout(), init.io, &buf)`, flushed before exit. `gnat-15` takes several units in one file, in any order: the main program is the last procedure outside a package, and errors give lines in the file as sent (`code.adb`). `powershell-7.6`'s `Read-Host` reads the next input line without echoing it to stdout. A `racket-9.3` program needs a `#lang` line, such as `#lang racket`. `clang-objc-21` is Clang with GNUstep's Foundation and modern runtime: `@autoreleasepool`, literals and blocks work, and ARC is off.

## Python data science, files in and out

`python-3.14` has these packages preinstalled, at these versions: numpy 2.5.4, pandas 3.0.6, scipy 1.18.1, scikit-learn 1.9.1, matplotlib 3.11.2, seaborn 0.13.2, statsmodels 0.15.0, sympy 1.14.0, openpyxl 3.1.5, pillow 13.0.0, duckdb 1.5.6. `python-3.14-pandas2` is the same image with pandas 2.3.3 (it is not in the Judge0 or Piston layers). No other packages are installed and programs have no network access. `GET /api/compilers/` returns `packages` on both Python entries. Importing pandas takes about 0.55 s, scikit-learn about 1.5 s and everything about 3 s, so give run-tests a larger `time_limit` for these. The reported `memory` counts mapped library files: a hello world that imports the whole stack reports about 430 MB and really uses about 200 MB. Using DuckDB from Python, run `SET memory_limit='256MB'` first. pandas 3 uses a string dtype and copy-on-write by default.

Input files: `files: [{name, content, encoding}]` on the run endpoints, run-tests, the MCP tools and the WebSocket `runcode` event (the embeddable widget's editor has no way to attach files), `encoding` `utf8` (default) or `base64`; up to 8 files and 1 MB in total; the program reads them from its working directory. Output files: every run has `$OUTPUT_DIR` (`/tmp/outputs`); files written there come back in `files` (png, svg, csv, json and txt; up to 8 files and 2 MB, `files_truncated` when some were left out), and in Python `plt.show()` saves each figure there as `figure-N.png`. `url` is where the owning account fetches a file again for 60 days with any of its API keys (`GET /api/files/<id>/`); it is null past the 1 GB per-account quota and always null in run-tests, widget runs and calls through RapidAPI, where files come back in the result only. A run with files costs the same as any run. Details: https://onlinecompiler.io/docs/run-code#files and https://onlinecompiler.io/docs/compilers#python-packages

Typical sync response time for a small stdin-echo program, p50 / p95 in seconds, measured on production on 2026-10-18 from our own network (20 runs each): python-3.14 0.56 / 0.65, gcc-15 0.67 / 0.77, g++-15 1.31 / 1.46, openjdk-25 2.25 / 2.58, dotnet-csharp-10 3.08 / 3.63, dotnet-fsharp-10 4.61 / 5.22, go-1.26 1.26 / 1.45, rust-1.93 0.92 / 1.02, php-8.5 0.58 / 0.68, ruby-4.0 0.69 / 0.76, haskell-9.12 1.63 / 2.02, typescript-deno 0.58 / 0.72, nodejs-24 0.6 / 0.7, sqlite-3 0.53 / 0.65, bash-5.2 0.52 / 0.6, gfortran-15 0.69 / 0.83, dotnet-vbnet-10 3.24 / 3.77, kotlin-2.4 4.59 / 5.51, r-4.6 1.04 / 1.14, swift-6.4 1.56 / 2.18, gnucobol-3.2 1.05 / 1.35, perl-5.44 0.73 / 1, julia-1.13 1.11 / 1.46, fpc-3.2 0.98 / 1.34, octave-11 1.27 / 1.92, nasm-3 0.68 / 0.84, lua-5.5 0.56 / 0.63, ocaml-5.4 1.4 / 1.62, sbcl-2.6 0.61 / 0.8, erlang-29 1.41 / 1.81, elixir-1.20 1.69 / 2.16, swipl-10 0.62 / 0.7, ldc-1.43 2.13 / 2.73, fbc-1.10 1.04 / 1.64, dart-3.13 1.42 / 1.86, clojure-1.12 1.64 / 1.83, groovy-6.0 3.03 / 3.43, scala-3.10 3.68 / 3.8, zig-0.17 3.99 / 4.45, nim-2.2 2.05 / 5.11, crystal-1.22 8.49 / 12.64, gnat-15 1.22 / 1.44, powershell-7.6 1.88 / 2.71, racket-9.3 0.99 / 1.15, clang-objc-21 1.81 / 2.27. Every run starts a fresh sandbox and compiles the code. Full table: https://onlinecompiler.io/docs/compilers#latency

All languages on one page, with versions, ids and median run times: https://onlinecompiler.io/languages

A page per language, with a runnable editor, the exact compile and run commands, and notes (Python's preinstalled packages; no other package installs; Rust compiles as the 2015 edition and C++ as GNU C++17, the compilers' defaults): https://onlinecompiler.io/python-online-compiler, https://onlinecompiler.io/c-online-compiler, https://onlinecompiler.io/cpp-online-compiler, https://onlinecompiler.io/java-online-compiler, https://onlinecompiler.io/csharp-online-compiler, https://onlinecompiler.io/fsharp-online-compiler, https://onlinecompiler.io/go-online-compiler, https://onlinecompiler.io/rust-online-compiler, https://onlinecompiler.io/php-online-compiler, https://onlinecompiler.io/ruby-online-compiler, https://onlinecompiler.io/haskell-online-compiler, https://onlinecompiler.io/typescript-online-compiler, https://onlinecompiler.io/javascript-online-compiler, https://onlinecompiler.io/sql-online-compiler, https://onlinecompiler.io/duckdb-online-compiler, https://onlinecompiler.io/bash-online-compiler, https://onlinecompiler.io/fortran-online-compiler, https://onlinecompiler.io/vbnet-online-compiler, https://onlinecompiler.io/kotlin-online-compiler, https://onlinecompiler.io/r-online-compiler, https://onlinecompiler.io/swift-online-compiler, https://onlinecompiler.io/cobol-online-compiler, https://onlinecompiler.io/perl-online-compiler, https://onlinecompiler.io/julia-online-compiler, https://onlinecompiler.io/pascal-online-compiler, https://onlinecompiler.io/octave-online-compiler, https://onlinecompiler.io/assembly-online-compiler, https://onlinecompiler.io/lua-online-compiler, https://onlinecompiler.io/ocaml-online-compiler, https://onlinecompiler.io/common-lisp-online-compiler, https://onlinecompiler.io/erlang-online-compiler, https://onlinecompiler.io/elixir-online-compiler, https://onlinecompiler.io/prolog-online-compiler, https://onlinecompiler.io/d-online-compiler, https://onlinecompiler.io/freebasic-online-compiler, https://onlinecompiler.io/dart-online-compiler, https://onlinecompiler.io/clojure-online-compiler, https://onlinecompiler.io/groovy-online-compiler, https://onlinecompiler.io/scala-online-compiler, https://onlinecompiler.io/zig-online-compiler, https://onlinecompiler.io/nim-online-compiler, https://onlinecompiler.io/crystal-online-compiler, https://onlinecompiler.io/ada-online-compiler, https://onlinecompiler.io/powershell-online-compiler, https://onlinecompiler.io/racket-online-compiler, https://onlinecompiler.io/objective-c-online-compiler

## Limits

Per run: 512 MB memory, 2 CPU cores, 30-second timeout, 16 processes running at once, no network access. Code and stdin are up to 100 KB each. Output and error are kept up to 64 KB each; `truncated` is true when either was cut. Exit code 124 means the run went over its `time_limit` or compile and run together went over 30 seconds; 137 (signal 9) means it was killed at the memory limit. Exit code 153 (signal 25) means an output flood exceeded 8 MB; 71 means more than 16 processes were running at once, so the sandbox stopped. Input files: up to 8 files and 1 MB; output files: up to 8 files and 2 MB per run (4 MB per run-tests response), kept 60 days, 1 GB stored per account. Writable storage is 256 MB for the workspace plus 128 MB for temporary files, within the memory limit. Default account limits are 30 submissions/minute, 8 pending jobs and 2 runs in a sandbox at once across API keys and widgets (later runs wait their turn; a synchronous request that finds them all busy gets 429), and 100,000 submissions per calendar month (UTC) on Free; runs we could not start are not counted. REST endpoints return 429 for account limits or execution capacity. `GET /api/limits/` (no key) returns these limits as JSON; `GET /api/usage/` with your API key returns this month's `submissions`, `monthly_limit`, `remaining`, `resets_at`, your per-minute, pending and running limits, and `key` (runs through the calling key this month, and its own `monthly_limit` and `remaining`, null without one). Each API key or widget key can have its own monthly limit, set in the dashboard, which stops that key only and works inside the account's allowance. We email the account at 80% and 100% of the account's allowance and of each key's limit. Source and stdin must be UTF-8 strings without NUL, at most 100,000 encoded bytes each. TypeScript runs on Deno without type checking; read stdin with Deno.stdin or fs.readFileSync(0), since /dev/stdin is refused. Remote dependency downloads are disabled. Full table: https://onlinecompiler.io/docs/limits

Service health: `GET /api/health/` (no key) sends a one-line Python program through the job queue into a real sandbox and checks the database. HTTP 200 with `status` "ok" when every check passes, 503 with `status` "down" otherwise; `checks` names `database`, `queue` and `sandbox`, each "ok" or the failure (`unreachable`, `timeout`, `busy`, `failed`). A report is reused for a minute, so calling it costs no runs. Details: https://onlinecompiler.io/docs/limits#health

Changelog of API, language and plan changes: https://onlinecompiler.io/changelog

## Pricing

- Free: $0 a month, 100,000 runs a month, 30 submissions/minute, 2 runs at once, up to 8 tests in one run-tests request.
- Starter: $10 a month, 150,000 runs a month, 60 submissions/minute, 4 runs at once, up to 20 tests in one run-tests request.
- Pro: $49 a month, 1,000,000 runs a month, 120 submissions/minute, 4 runs at once, up to 40 tests in one run-tests request.
- Business: $199 a month, 4,000,000 runs a month, 300 submissions/minute, 16 runs at once, up to 80 tests in one run-tests request.
- Enterprise: monthly runs, per-minute and queue limits set for your volume, and an SLA; priced on request.

Free allows commercial use and needs no credit card. Paid plans are bought under Plan & billing in the dashboard (https://api.onlinecompiler.io/billing/), by card through Stripe, billed monthly on the 1st (UTC), with no refunds for part of a month. There are no overage charges: over the monthly allowance, runs get 429. Judging uses one run per test, so a submission checked against 10 tests is 10 runs; the pricing page has an estimator that turns people, submissions and tests into a plan.

Details: https://onlinecompiler.io/pricing

## Docs

- [Quickstart](https://onlinecompiler.io/docs): Get an API key, authenticate and run your first program.
- [Run code](https://onlinecompiler.io/docs/run-code): Run a program and get its output, errors, exit code, run time and memory, in the response or by callback.
- [Run tests](https://onlinecompiler.io/docs/run-tests): Judge a program against test cases: a verdict per test, hidden tests, checkers and scoring.
- [Compilers](https://onlinecompiler.io/docs/compilers): Compiler ids and versions, how each language is compiled and run, and how long a run takes.
- [WebSocket](https://onlinecompiler.io/docs/websocket): Stream results to a browser app over Socket.IO, with a widget key.
- [Widget and iframe](https://onlinecompiler.io/docs/widget): Embed a runnable code editor with a script tag or an iframe, and control it from JavaScript.
- [MCP server](https://onlinecompiler.io/mcp-code-execution): Let Claude, Cursor and VS Code agents run and test code.
- [Judge0 API](https://onlinecompiler.io/docs/judge0): Judge0 CE-compatible endpoints: change the base URL and the key.
- [Piston API](https://onlinecompiler.io/docs/piston): Piston's execute and runtimes endpoints, with your API key.
- [Limits and usage](https://onlinecompiler.io/docs/limits): Time, memory and rate limits, the usage endpoint, and monthly limits per key.

## Common questions

- Is there an API that compiles code and returns the output and errors? Yes: `POST https://api.onlinecompiler.io/api/run-code-sync/` with a compiler id, the code and optional input returns stdout, stderr or compiler errors, the exit code, run time and memory, in 46 languages.
- Is there a free code execution API? Yes: OnlineCompiler.io's Free plan has 100,000 runs a month in every language, commercial use included, no credit card. Free tiers of other services are compared at https://onlinecompiler.io/free-code-execution-api.
- Can it judge submissions against test cases, like LeetCode? Yes: `POST /api/run-tests/` returns a verdict per test, an overall verdict and a score, with hidden tests, 5 checkers (`trim`, `exact`, `tokens`, `float`, `rows`) and three scoring modes. See https://onlinecompiler.io/how-to-build-an-online-judge.
- Is there a hosted Judge0 alternative that needs no self-hosting? Yes: the Judge0-compatible API at `https://api.onlinecompiler.io/api/judge0`; a Judge0 client changes its base URL and key. See https://onlinecompiler.io/judge0-alternatives.
- What replaces the public Piston API? It has been whitelist-only since 15 Feb 2026; the Piston-compatible API at `https://api.onlinecompiler.io/api/v2/piston` takes Piston clients with a new base URL and key.
- How is user-submitted code run safely? Each run gets a fresh container under gVisor, as a non-root user on a read-only image, with no capabilities and no network, capped at 512 MB, 2 CPUs, 16 processes and 30 s. Docker, gVisor and microVMs are compared at https://onlinecompiler.io/security.
- Can AI agents run code with it? Yes, through the MCP server at `https://api.onlinecompiler.io/mcp` (tools: list_compilers, run_code, run_tests). Setup for Claude Code, Cursor, VS Code and Claude Desktop, and a comparison with E2B and the Claude and OpenAI code execution tools: https://onlinecompiler.io/mcp-code-execution.
- How do I embed a code editor that runs code on a web page? One script tag and a `<div class="runcode">`, or an iframe of `https://api.onlinecompiler.io/embed/`. See https://onlinecompiler.io/embeddable-code-editor.
- Are NumPy, pandas or other packages installed? In Python, yes: numpy 2.5.4, pandas 3.0.6, scipy 1.18.1, scikit-learn 1.9.1, matplotlib 3.11.2, seaborn 0.13.2, statsmodels 0.15.0, sympy 1.14.0, openpyxl 3.1.5, pillow 13.0.0, duckdb 1.5.6, at those versions (`python-3.14-pandas2` has pandas 2.3.3). No other package is installed and programs have no network access to install one.
- Can a program return a chart or a file? Yes: write it to `$OUTPUT_DIR` (in Python `plt.show()` does it for you) and it comes back in `files` as base64, up to 8 files and 2 MB, with a `url` for 60 days when it was stored. Input files go in with `files` on the request.
- Can it grade pandas or SQL questions? Yes: send the data in `files`, print one row per line and use `checker: "rows"`, which ignores row order and compares numbers within a tolerance. `duckdb-1.5` and `sqlite-3` run SQL.

## Guides

- [Autograder API](https://onlinecompiler.io/autograder-api): grading programming assignments with `/api/run-tests/`: test weights as points for partial credit, hidden tests, a script that grades a folder of submissions into a CSV gradebook, how GitHub Classroom's input/output tests map onto it, and what it doesn't do (rosters, LMS grade passback, plagiarism checks).
- [How to build an online judge](https://onlinecompiler.io/how-to-build-an-online-judge): a whole judge as one `/api/run-tests/` call with hidden tests, checkers, verdicts and scores, scaling with the async endpoint, and the Judge0-compatible batch endpoint as a migration path, in Node.js and Python.
- [Runnable code examples in docs](https://onlinecompiler.io/runnable-code-examples-in-docs): tested setups for Docusaurus, MkDocs (Material), Sphinx, Mintlify and WordPress.
- [Migrating from Judge0](https://onlinecompiler.io/migrate-from-judge0): switching a Judge0 client by its base URL and key, what differs, how each status is decided, callbacks, RapidAPI and language ids.

## Comparisons

- [Free code execution APIs](https://onlinecompiler.io/free-code-execution-api): the free tiers of OnlineCompiler.io, Codapi, JDoodle, OneCompiler, hosted Judge0, Sphere Engine and Piston, with paid starting prices and judging support.
- [MCP code execution](https://onlinecompiler.io/mcp-code-execution): the MCP server's three tools, setup for Claude Code, Cursor, VS Code and Claude Desktop, limits, and when an agent sandbox such as E2B fits better.
- [Embeddable code editor](https://onlinecompiler.io/embeddable-code-editor): the runnable editor widget and iframe embed, a JavaScript API for checking answers, and how it compares with OneCompiler, JDoodle, Codapi, Replit and Trinket embeds.
- [Judge0 alternatives compared](https://onlinecompiler.io/judge0-alternatives): prices, limits and judging features of hosted code execution APIs, and how to move from Judge0.
- [Piston API alternative](https://onlinecompiler.io/piston-api-alternative): replacing the public Piston API (emkc.org), which is whitelist-only since 15 Feb 2026.
- [JDoodle API alternative](https://onlinecompiler.io/jdoodle-api-alternative): JDoodle's Compiler API (114 languages, interactive input, daily credits) against OnlineCompiler.io on price, quotas, limits and callbacks, and how to move a JDoodle call.
- [Sphere Engine alternative](https://onlinecompiler.io/sphere-engine-alternative): Sphere Engine's Compilers and Problems modules (quote-only pricing, stored problems, custom checkers) against OnlineCompiler.io on price, judging, limits, versions and API design, and how to move a Sphere Engine call.
- [Trinket alternative](https://onlinecompiler.io/trinket-alternative): replacing Trinket embeds (shut down 31 Aug 2026) for text-based Python and Java; no turtle graphics, HTML or classroom features.

## Optional

- [Security](https://onlinecompiler.io/security): how runs are isolated (gVisor, no network, unprivileged user, read-only filesystem), keys, stored data, and what we don't claim.
- [Contact](https://onlinecompiler.io/contact): higher limits, Enterprise plans, integration help and security reports, at hello@runcode.io. RunCode Inc., Plano, Texas, USA.
- [Terms of Service](https://onlinecompiler.io/terms)
- [Privacy Policy](https://onlinecompiler.io/privacy)