Modal vs Blaxel: pricing, isolation and limits

Modal bills a sandbox's requested core and memory under gVisor; Blaxel bills memory only while active and nothing for compute in standby.

Between runs Blaxel is cheap and Modal is not; within a run, only Runtime bills by use, which puts it 84% below Modal and 77% below Blaxel. 1,000 one-minute runs of a 2 vCPU, 4 GiB sandbox cost $3.97 on Modal, $2.76 on Blaxel and $0.64 on Runtime. Runtime charges measured CPU plus memory at $0.0075 a GiB-hour, inside a Firecracker microVM with its own kernel. Rates checked 23 September 2026.

At a glance

Modal's CPU unit is the physical core, equal to two vCPUs.

	Modal Sandboxes	Blaxel	Runtime
Isolation	gVisor, a user-space kernel that intercepts system calls	Lightweight virtual machines	Firecracker microVM, own kernel
CPU	$0.1419 per physical core-hour (2 vCPUs), request or use	Included with memory; 8 GB gets 4 cores	$0.025 per vCPU-hour of measured CPU, with a small floor
Memory	$0.0240 per GiB-hour, request or use	$0.0000115 per GB-second of active time ($0.0414/h)	$0.0075 per reserved GiB-hour
When idle	Billed until timeout or idle_timeout ends it	Standby about 15 seconds after connections close	Pause on request or after an idle time you set
Keeping state	Filesystem snapshots	Standby snapshot, $0.20 per GB-month	Paused storage with memory, $0.08 per GB-month
Resume	A new sandbox from a snapshot	About 25 ms from standby	Wakes with files, memory and processes
At once	100 containers on Starter; 5,000 on Team	10 sandboxes on Tier 0; over 100,000 on the top tier	8 on the trial; 100 to start on a paid account
Plan fee	Starter $0 with $30 a month of compute; Team $250 a month	None; tiers grow with credit added	None; prepaid credit from $10
Free start	$30 of compute a month on Starter	Up to $200 of credit	50 sandbox hours, no card

What does an idle sandbox cost?

This is the widest gap between the two rivals.

A Modal sandbox bills its requested core and memory for as long as it runs, whether its code is working or waiting. It runs until its timeout, 5 minutes by default and up to 24 hours, or until idle_timeout ends it; state that must outlive it goes into a filesystem snapshot for the next sandbox.

A Blaxel sandbox goes to standby by itself about 15 seconds after its last connection closes. Standby costs nothing for compute, only $0.20 per GB a month for the snapshot, and the sandbox resumes in about 25 ms.

A Runtime sandbox pauses when you call pause(), or after the idlePauseSeconds you set, and keeps its files, memory and running processes for 1 to 365 days at $0.08 per GB a month. A request to a paused sandbox wakes it. While it runs, the waiting is cheap too: CPU is billed as measured, with a floor of a twentieth of a vCPU.

TypeScriptimport { Sandbox } from "withruntime";const sbx = await Sandbox.create({ timeoutSeconds: 600 });await sbx.exec("echo state > /workspace/state.txt");await sbx.pause(); // memory and files are kept; compute billing stops// ... later, even from another process:const again = await Sandbox.connect(sbx.id);await again.wake({ timeoutSeconds: 1200 });await again.extend(600); // more time before the lease endsawait again.stop();

Cost for the same job

The job: 1,000 runs, 60 seconds each, on 2 vCPU and 4 GiB (a single physical core on Modal, 4 GB on Blaxel), with 20 CPU-seconds of real work per run.

TextModal    CPU    1,000 × 60 s × 1 core × $0.00003942 = $2.37         Memory 1,000 × 60 s × 4 × $0.00000667      = $1.60         Total                                         $3.97Blaxel   Memory 1,000 × 60 s × 4 × $0.0000115       = $2.76Runtime  CPU    1,000 × 20 s / 3,600 × $0.025       = $0.14         Memory 1,000 × 60 s / 3,600 × 4 × $0.0075  = $0.50         Total                                         $0.64

At 100,000 runs a month, Modal bills $396.60, Blaxel $276.00 and Runtime $63.89. With both CPUs busy for the whole minute, it is $1.33 on Runtime, $3.97 on Modal and $2.76 on Blaxel. Blaxel is priced as if standby began the instant each run finished. Plan fees, snapshots, network and free credit are excluded.

Inside a run, neither rival's price responds to load: Modal charges the request, and Blaxel charges memory with CPU folded in. Blaxel saves money only between runs, through standby.

Which one to pick

• Modal, if the sandboxes need GPUs or should live in the same SDK as your Modal functions, web endpoints and scheduled jobs.
• Blaxel, if sandboxes spend long stretches asleep and must resume in milliseconds, or the fleet runs past 100,000 at once.
• Runtime, if you want a microVM per sandbox at a sixth of Modal's price and under a quarter of Blaxel's, CPU billed as used within each run, and a pause that holds memory and processes for up to a year.

Moving to Runtime

Modal code ports one call at a time and drops the App: modal.Sandbox.create(app=...) is Sandbox.create(), sb.exec(*args) is exec, and idle_timeout is idlePauseSeconds. Blaxel code maps create to Sandbox.create() and a process to exec, while standby is replaced by automatic wake, on by default. Everything else is in the migration table.

npx withruntime compare --from blaxel shows what your Blaxel sandboxes would have cost at Runtime's rates, and npx withruntime switch --from modal before the first top-up matches that top-up with credit, up to $100. A coding agent can do the port from the one instruction in migration, on a branch, on the free trial. See Runtime vs Modal and Runtime vs Blaxel.

Sources

Modal pricing, Modal Sandboxes and Blaxel pricing pages rechecked 25 September 2026; the rest checked 23 September 2026.

• Modal pricing, Modal resources and billing, Modal Sandboxes, Modal security
• Blaxel pricing, Blaxel sandboxes
• Runtime pricing

Facts on this page were checked on 25 September 2026.