Blaxel vs Morph: pricing, isolation and limits

Blaxel bills memory only while a sandbox is active; Morph bills a VM's size in MCUs. A 2 vCPU, 4 GB job: $2.76 on Blaxel, $1.67 on Morph.

Runtime runs the same job for 77% less than Blaxel and 62% less than Morph. 1,000 one-minute runs of a 2 vCPU, 4 GiB sandbox cost $2.76 on Blaxel, $1.67 on Morph and $0.64 on Runtime, because Runtime bills the CPU your code uses and prices memory at $0.0075 per GiB-hour. Rates checked 23 September 2026.

At a glance

	Blaxel	Morph	Runtime
Isolation	Lightweight virtual machines	Full virtual machines	Firecracker microVM, own kernel, every sandbox
How size is billed	$0.0000115 per GB of memory per active second	$0.05 per MCU-hour: 1 vCPU, 4 GB of memory or 16 GB disk	$0.025 per vCPU-hour of measured CPU, with a small floor
CPU	Set by memory: 8 GB gets 4 cores, 16 GB gets 6	Chosen; each vCPU is an MCU	Chosen apart from memory
2 vCPU, 4 GB, an hour	$0.1656 while active	$0.10 (2 MCUs)	$0.03125 waiting, $0.08 fully busy
Idle	Standby about 15 s after the last connection closes	Devboxes scale to zero when idle and keep memory	Pause keeps files, memory and processes, 1 to 365 days
Paused storage	$0.20 per GB-month of snapshot	One MCU covers 5 TB snapshot-hours	$0.08 per GB-month
Plan fee	None; tiers grow with credit added	Free with no credit; Developer $40 and Team $250 a month	None; prepaid credit from $10
Free start	Up to $200 of credit	No free credit; 1,000 MCUs come with Developer ($40)	50 sandbox hours, no card
At once	Tier 0 free: 10; $20 a month: 50; top tier: 100,000+	Devboxes: 8 on Free, 32 on Developer, 128 on Team	100 on a paid account to start; eight on the trial

Which one costs less when the sandbox sits idle?

Both are built to stop charging for compute between bursts of work, in different ways.

• Blaxel puts a sandbox on standby about 15 seconds after its last connection closes. Standby costs nothing for compute, only snapshot storage at $0.20 per GB-month, and Blaxel states a resume in under 25 ms.
• Morph bills a machine's MCUs for as long as it runs. Its Devboxes scale to zero when idle and keep their memory, and snapshot storage is billed from the same MCU balance: one MCU covers 5 TB snapshot-hours.

While active, Morph is the cheaper of the two for this size: $0.10 an hour for 2 MCUs against $0.1656 for 4 GB on Blaxel. Blaxel gives no separate price for CPU, but it also gives no choice of it: a sandbox gets the cores its memory size carries.

Runtime pauses a sandbox after idlePauseSeconds with no request (60 to 86,400), keeps its memory and running processes, and wakes it on the next request, usually in about half a second. Paused storage is $0.08 per GB-month, under half of Blaxel's snapshot rate.

Cost for the same job

1,000 runs of a 2 vCPU, 4 GiB sandbox (4 GB on Blaxel, which sets CPU from memory; 2 MCUs on Morph). Each run lasts 60 seconds and keeps the CPU busy for 20 CPU-seconds: an agent that mostly waits for a model.

TextBlaxel   Memory 1,000 × 60 s × 4 × $0.0000115        = $2.76Morph    Size   1,000 × 60 s / 3,600 × 2 MCU × $0.05 = $1.67Runtime  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 that is $276.00 on Blaxel, $166.67 on Morph and $63.89 on Runtime. With both CPUs busy for the whole minute, it is $1.33 on Runtime against $2.76 on Blaxel and $1.67 on Morph, so Runtime is cheaper however busy the sandbox is. The Blaxel figure assumes standby the moment each run ends. Plan fees, included credit, storage, network and taxes are left out.

Which one to pick

• Pick Blaxel if your sandboxes sit idle between short bursts and you want them back in milliseconds, or you plan a very large fleet: its top tier runs over 100,000 at once.
• Pick Morph for branching: its Infinibranch copies a running machine, memory included, to hundreds of parallel replicas, and its Free tier already allows machines up to 64 vCPUs and 256 GB of memory.
• Pick Runtime for a Firecracker microVM on every sandbox for 62% less than Morph and 77% less than Blaxel, CPU and memory chosen apart, pause and forks that keep memory and processes, and no plan fee.

Switch from either one

Runtime has no drop-in import for Blaxel or Morph, and the calls map directly (map the calls). Blaxel's SandboxInstance.create() becomes Sandbox.create(), its delete() becomes stop(), and Blaxel standby becomes automatic wake, which is on by default. To pause when idle, as Blaxel and Morph Devboxes do:

TypeScriptimport { Sandbox } from "withruntime";const sbx = await Sandbox.create({ idlePauseSeconds: 600 }); // ten idle minutesawait sbx.exec("echo state > /workspace/state.txt");// The next exec or file call wakes it with its memory and processes.console.log((await sbx.exec("cat /workspace/state.txt")).stdout);await sbx.stop();

Pythonfrom withruntime import Sandboxsbx = Sandbox.create(idle_pause_seconds=600)sbx.exec("echo state > /workspace/state.txt")print(sbx.exec("cat /workspace/state.txt").stdout)sbx.stop()

Or give your coding agent the one instruction in migration: it switches the project on a branch, tests it on the free trial and reports the monthly saving. npx withruntime compare --from blaxel (or --from morph) prices what you ran at the old provider's rates. The full side-by-sides are Runtime vs Blaxel and Runtime vs Morph; for idle handling see pause and resume a sandbox.

Sources

Rates checked 23 September 2026. Blaxel and Morph pricing pages and Blaxel's sandbox documentation reread 25 September 2026.

• Blaxel pricing, Blaxel sandboxes
• Morph Cloud pricing, Morph Devboxes
• Runtime pricing and JavaScript SDK

Facts on this page were checked on 25 September 2026.