Sphere Engine alternative: public prices, a free tier and built-in judging

The short answer

• Stay with Sphere Engine if you need problems and test cases stored with the provider, a problem widget for your students, custom checker programs, interactive problems, several files per program, preinstalled scientific Python, image output, more than 512 MB of memory, or test files over 100 KB. Also if procurement wants a written SLA, 24/7 support, reserved capacity for exam days, an on-premise install or quarterly invoices. We don't offer any of those yet.
• Switch to OnlineCompiler.io if you want to start without a sales call: published prices, 100,000 free runs a month and an API key in a minute. Also if you want one call that returns the output, test-case judging with weighted scoring and a float tolerance you choose, runtimes about two years newer, Judge0- and Piston-compatible endpoints, an MCP server for AI agents, or a sandbox you can read about.

Sphere Engine also sells Containers, which runs whole projects in your own Docker images and opens browser workspaces. We have nothing like it; this page compares the Compilers and Problems modules.

Price

Sphere Engine has published no prices since 2018. After a 14-day trial it quotes from the project's scope, the number of students or candidates, expected submissions and the support level, and bills quarterly or annually. Its last public list, from 2017, charged $249 a month for 30,000 runs.

Ours are on the pricing page: 100,000 runs a month free, then Starter at $10 for 150k, Pro at $49 for 1M and Business at $199 for 4M, billed monthly. A judged test counts as one run.

Running code: Sphere Engine Compilers

Judging: Sphere Engine Problems

Problems is Sphere Engine's judge: you store a problem with its test cases, then submit code against it. Ours works the other way around: POST /api/run-tests/ takes the code and the tests in one request, so there is nothing to set up first and your tests stay in your own database.

curl -X POST https://api.onlinecompiler.io/api/run-tests/ \
  -H "Authorization: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "compiler": "python-3.14",
    "code": "a, b = map(int, input().split())\nprint(a + b)",
    "tests": [
      {"input": "1 2\n", "expected_output": "3\n"},
      {"input": "-4 10\n", "expected_output": "6\n", "hidden": true}
    ],
    "scoring": "percent"
  }'

Each run is stateless and nothing is stored with us but your run history, so a problem bank, a submissions table and a leaderboard stay in your own database. How to build an online judge walks through the rest.

Language versions

Sphere Engine keeps several versions of each language, chosen with compilerVersionId; we run one current version per compiler id. Its newest versions came out in mid-2024 or earlier, and its C# and Visual Basic run on .NET 6, which Microsoft stopped supporting in November 2024. Sphere Engine's newest version (languages page, 18 Oct 2026):

Sphere Engine runs about eleven languages we don't, nearly all older or esoteric ones such as AWK, Forth, Raku, Sed, Smalltalk and Tcl. We run Crystal, FreeBASIC, Nim, PowerShell and Zig, which it doesn't.

Moving a Sphere Engine call

A Sphere Engine Compilers call is three steps: create, poll, then fetch the output. Ours is one synchronous call, or an async one that posts the result to your callback URL. Keep the API key on your server, as you did with the access token.

# 1. Create the submission. The token goes in the URL.
curl -X POST "https://YOUR_ID.compilers.sphere-engine.com/api/v4/submissions?access_token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"compilerId": 116, "source": "print(input()[::-1])", "input": "sphere"}'

# 2. Every 2 seconds, until "executing" is false:
curl "https://YOUR_ID.compilers.sphere-engine.com/api/v4/submissions/SUBMISSION_ID?access_token=YOUR_TOKEN"

# 3. Fetch each stream you need on its own:
curl "https://YOUR_ID.compilers.sphere-engine.com/api/v4/submissions/SUBMISSION_ID/output?access_token=YOUR_TOKEN"

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(input()[::-1])",
    "input": "sphere"
  }'

For Problems, send each problem's tests with the submission to /api/run-tests/, as in the judging example above. For more options, see the wider comparison of code execution APIs.

Frequently asked questions

How much does Sphere Engine cost?

Sphere Engine publishes no prices. It offers a 14-day trial without a card, then a quote based on the project, the number of students or candidates, expected submissions and the support level, billed quarterly or annually. Its last public price list, from 2017, charged $249 a month for 30,000 runs.

Does Sphere Engine have a free plan?

No. It has a 14-day trial and sends free users to Ideone and SPOJ, its free sites. OnlineCompiler.io's free plan includes 100,000 runs a month, allows commercial use and needs no credit card.

Can OnlineCompiler.io replace Sphere Engine Problems?

For judging a submission against tests you send with the request, yes: POST /api/run-tests/ returns a verdict for each test, an overall verdict and a score, with hidden tests, four checkers and weighted scoring. It does not store problems, run custom checker programs, judge interactive problems or provide a problem widget, and most languages compile the program again in every test, so slow-compiling ones fit fewer tests in one request.

Is OnlineCompiler.io compatible with Sphere Engine's API?

No. It has its own API plus Judge0- and Piston-compatible endpoints. Moving a Sphere Engine Compilers call means renaming a few fields and dropping the polling, as the table on this page shows.

Which runs newer language versions?

OnlineCompiler.io, by about two years on most languages. On 18 October 2026 Sphere Engine's newest versions were Python 3.12, GCC 13.2, Java 22 and Go 1.22.4, and it ran C# and Visual Basic on .NET 6, which Microsoft stopped supporting in November 2024.

Can I use both?

Yes. Keep stored problems, custom checkers and interactive problems on Sphere Engine, and send plain runs and test-case judging to OnlineCompiler.io. Both are HTTP APIs, so a small router in your backend is enough.