Pricing Methodology
Builds on Common Methodology
Defines how sandbox costs are obtained from provider billing records, aggregated across benchmark trials, and verified against published list rates.
Cost Sources and Evidence
Evidence: Every cost comes from the provider's own records. BoxRouter's job-host clocks, guest clocks, and requested machine sizes never produce a cost. In the other direction, provider billing timestamps never replace BoxRouter's measured execution times on speed charts.
Cost Methods: Each provider's cost method uses the strongest evidence that provider supplies, and the pricing release's cost-method.json pins it. Each published result records the price version it used. In order of preference:
- Reported By Provider: The provider's billing or usage API reports the USD charge for that sandbox ID, and BoxRouter checks it against the provider's published list rates.
- Calculated: BoxRouter prices the provider's own reported usage quantities or lifecycle event timestamps at stored public list rates, following the provider's documented billing rules, state transitions, minimum durations, and rounding increments.
No Cost: Without either, the sandbox has no cost. That happens when neither a verified provider charge nor complete provider usage records are available, or when a required rate or resource class is unrecorded. It also happens when the sandbox's stop can't be confirmed and the provider gives no end time and no maximum lifetime, and then the trial is the provider's failure.
The result then records no total and lists each missing input as what held the cost back. A missing cost is never zero, a guess, a floor, or a range, and it is shown without a method label.
Settlement: Some billing records arrive after the sandbox is gone, so a cost settles over a revisit window. Each provider's billing.yaml sets the window, measured from the sandbox's end: when to read first, how often to read again, and when to stop.
While a late record can still arrive, or an early reported figure can still rise as trailing usage settles, the cost is Pending. Once the window closes, a complete cost is shown under its method's label, and a cost whose record never arrived or expired before collection is Unknown.
Modal Reports: Modal reports billing in hourly buckets, so a Modal sandbox's reported cost needs one dedicated App per sandbox. A Modal sandbox has a valid Reported By Provider cost only when all of these hold:
- A dedicated Modal App held that single sandbox alone, and its report has at least one row and no duplicate or out-of-span rows.
- The report was read after the revisit delay.
- The recorded request window covers every hour from the sandbox's start through its end; a covered hour with no row adds nothing.
Rate Verification: Stored list rates are checked against provider billing exports. Each billed quantity is converted to the unit of its rate and multiplied by the stored USD rate. A line item matches when the difference is within the pricing release's tolerance. Any mismatch is investigated as evidence and never hidden.
Trial, Unit, and Workload Cost
Successful Trials: A provider's cost is built up from its successful trials. Only successful trials contribute to the cost value. Failed, missed, and excluded trials stay in private evidence for cleanup verification and diagnosis, and never enter published cost figures. Cost is computed per unit in two steps: trial cost, then unit cost.
Trial Cost
Sandbox Sum: A trial's cost is the sum of its sandboxes' costs. The cost of a successful trial adds up the provider-sourced costs of all sandboxes created during the trial, each counted from its create or restore request to its confirmed deletion:
c_i = \sum_{s} c_{i,s}
-
c_i Provider-sourced cost of successful trial i: the sum of the costs of the sandboxes created during trial i. -
c_{i,s} Provider-sourced cost of sandbox s in trial i.
Sandboxes per Trial: Most benchmarks use one sandbox per trial. DeepSWE, Terminal-Bench 4.0, and CI Actions sum one sandbox per trial, and R2E-Gym sums its base sandbox and the rollout sandboxes restored from its snapshot.
Unit Cost
Two Summaries: Each unit's successful trial costs are summarized in two forms, and each chart scales them to the unit its cost label names, such as cost per trace on DeepSWE.
- Statistic selector: The statistic selected in the chart menu summarizes the unit's successful trial costs: Median by default, or Mean or p95. It follows the nearest-rank percentile and 20-trial tail rules in Common Methodology.
- Mean cost per success: The total cost of the unit's successful trials, divided by the number of successful trials.
Confidence Interval: The cost confidence interval is a bootstrap of the mean cost per success. It is a 95% percentile-bootstrap interval across 10000 resamples, drawn with replacement with the random seed fixed at 0.
Workload and Composite Cost
Workload Cost: A workload's cost is the geometric mean of its unit costs. On a multi-unit workload's All view, a provider's workload cost is the unweighted geometric mean of its per-unit costs under the selected statistic, across all units completed by at least one provider.
If a provider completed at least one unit in the workload but has no successful trials on a unit, its cost on that unit is the highest unit cost observed on it across all providers that completed it. This matches the missing-unit substitution in Common Methodology.
Composite Cost: The overview's composite cost averages workload costs the same way. On Overview, Composite Workload Cost is the unweighted geometric mean of a provider's workload costs across the workloads in the selected scope. A provider that failed an entire workload gets the highest observed workload cost for it.
Shared Units: In Composite Workload Time vs Cost, each provider's Composite Workload Time coordinate is computed over the same set of costed units that enter its Composite Workload Cost coordinate, so both axes compare the same units.
Stages and Missing Costs
Stage Cost: A stage's share of the cost follows its share of the time. When a workload chart splits a unit's time bar into stages (such as Read, Write, Install, Lint, Build, and Test), each stage is assigned a share of the unit's displayed cost in proportion to its share of the total stage time, under the same statistic:
c_s = C \times \dfrac{t_s}{t}
-
c_s The cost of stage s. -
C The unit's displayed cost. -
t_s Stage s's time. -
t The total time across stages.
Missing Costs: One missing sandbox cost removes the provider's cost for the whole view. If any sandbox in a trial lacks a provider-sourced cost, that trial has no cost.
If any counted trial in a unit or composite scope lacks a cost, or any unit's cost on the selected statistic is zero (which leaves the geometric mean undefined), the provider has no cost for that view and is listed under Not Displayed.
Priced Sections: Cost is published for workloads and the composites built on them. That covers the workloads (DeepSWE, Terminal-Bench 4.0, CI Actions, and R2E-Gym) and their composites (Composite Workload Cost, Composite Workload Time vs Cost, and the cost scores on provider pages). Sandbox Operations and Machine Performance show no cost.
Comparing Provider Pricing Models
Why Bills Differ: Similar hourly rates can produce very different bills, because providers meter different quantities, in different units, across different lifecycle states:
- CPU units: Most price CPU per vCPU; one prices it per physical core (two vCPUs), one bundles it into its memory rate, and one bills a flat machine-hour rate per size tier.
- Allocation or use: Some bill the reserved size while the sandbox runs, some only the CPU time or memory used, and some the larger of the two.
- Memory units: A GiB (1,024 MiB) is larger than a GB (1,000 MB), and a provider that prices per GB may bill a GiB of memory as a GB.
- Metering edges: Whole-minute minimums, whole-second truncation, or millisecond edges can outweigh rate differences for a short sandbox.
- Inactive states: A paused or stopped sandbox may cost nothing, keep paying for its disk, or pay for a retained snapshot.
This publication did not record the versions that priced its costs. The method of the pinned pricing release is shown.
A sandbox's cost is what the provider charges for that one sandbox at its published list price.
It leaves out account credits, free allowances, discounts, commitments, plan fees and taxes, and each result lists what it left out under excluded. It is not an invoice and not what a customer is charged.
- Reported By Provider
-
The provider's own cost for the sandbox, matching list price.
- Calculated
-
The provider's own usage records priced at list rates.
| Provider | Cost | CPU per vCPU-hour | Memory per GiB-hour | Disk per GiB-hour | Also Charged |
|---|
| Agent37 | Reported By Provider |
—
|
—
|
—
|
—
|
|---|
Formula Agent37's compute_micros for the instance, divided by one million. Check: billed minutes × (vCPUs × CPU rate + GB of RAM × memory rate) ÷ 43,800 for running minutes, plus GB of disk × disk rate ÷ 43,800 for every minute.
- Billed on
-
$0.80 per vCPU-month and $0.70 per GB-month of allocated RAM while running, plus $0.09 per GB-month of reserved disk in every state; a month is 730 hours, metered per minute.
- Billing starts
-
When the instance first reaches running; nothing is debited at create. Measured, the first billed minute began at the instance's created second, before create returned.
- Billing ends
-
At delete, which settles the final minutes. Measured, the last part minute before delete was billed in full.
- Rounding
-
Each period is billed in whole minutes, rounded up, and the next state starts at the end of the last billed minute; each settled debit is a whole micro-dollar.
- Idle and paused
-
Running and the transitional states bill the full rate; sleeping, stopped and waking bill disk only. A stopped instance measured billed disk alone. A sleeper parked in cold storage bills its compressed bytes at a separate rate.
- Billed separately
-
Managed LLM, search and tool calls debit the same wallet per instance within a budget that defaults to $0. Performance instances bill compute at 4x and VM instances at 2.5x. Backups and egress are not priced on the pages checked.
- Left out
-
Managed LLM, search and tool spend (the instance's other usage fields), Performance instances, cold-storage time, backups, egress, the sign-up credit and top-ups.
Rates checked 2026-11-12 Agent37's sources, measurements and 2 open questions |
| Blaxel | Reported By Provider |
—
|
$0.0414 per GiB-hour per GB, on active use
|
—
|
Snapshots $0.20 per GiB-month Images $0.045 per GiB-month Volumes $0.12 per GiB-month
|
|---|
Formula Blaxel's own cost for the sandbox. Check: active seconds × GB of memory × memory rate (CPU is included), plus snapshot GB × seconds in standby × snapshot rate.
- Billed on
-
Memory allocated at creation, per GB-second. CPU is not charged separately; it is allocated from the memory size. Our 4096 MiB sandbox was billed as 4 GB.
- Billing starts
-
Measured at create returned. Create sent is not ruled out for creates of 0.2 to 0.4 s; the one 2.13 s create fitted create returned only.
- Billing ends
-
Measured at destroy returned. Destroy sent is ruled out, as it would make the batch 1.8% shorter than billed.
- Rounding
-
Compute in whole seconds, truncated; every compute cost was a whole number of seconds at the list rate. Standby snapshot storage is added per second, so a total is not always whole seconds. No minimum or increment is stated on the pricing page.
- Idle and paused
-
Active is billed. Without an active connection a sandbox enters standby, where memory is not billed but snapshot storage is. Blaxel's pages say about 5 s or 15 s to standby, and we measured 22.7 to 34.8 s. Archived is "you stop paying for it". Paused and stopped are not stated.
- Billed separately
-
Snapshots $0.20, deployment images $0.045 and volumes $0.12, each per GiB-month. The sandbox's own disk has no separate charge, because its writable layer lives in the allocated memory that is billed. No creation fee or GPU price is stated. Egress is listed as included.
- Left out
-
Up to $200 free credits, tier top-ups (prepaid usage), support add-ons, custom domains, image and volume storage, and taxes. Standby snapshot storage is included in the reported cost. Whether free credit is drawn at list rates is not stated.
Rates checked 2026-11-07 Blaxel's sources, measurements and 7 open questions |
| Boat | Reported By Provider |
—
|
—
|
$0 per GiB-hour
|
—
|
|---|
Formula The sandbox's usage record, read with the meter stopped (running: false) or last read before Boat deleted the sandbox and its record (as of that read): its dollars at list price. No record, another sandbox's, or a moving meter with no known end is unknown.
- Billed on
-
Billable machine-seconds, weighted by size multiplier (0.5, 1, 2, 50/9 for small, default, large, xlarge), at $0.036 per hour of default size (secondsPerDollar 100000), while the sandbox runs. Published as a flat per-hour rate per size: small $0.018, default $0.036, large $0.072, xlarge $0.200. No size has a GPU.
- Billing starts
-
Not stated where the meter starts inside a create, resume or fork call. The usage record's seconds is the billed quantity, so the edge is Boat's own meter, not a call boundary.
- Billing ends
-
A stop ends machine billing: stopped time is never counted, and time past a refused stop is excluded. Auto-stop ends a sandbox after its deadline (1 hour by default).
- Rounding
-
Billed per second. The usage API returns whole billable machine-seconds and dollars to six decimals; no minimum duration or rounding increment is published.
- Idle and paused
-
There is no pause; an idle sandbox bills as running until it stops or auto-stops. A stopped sandbox costs no machine time and keeps its disk free for at least 14 days. After that it is eligible for automated retention cleanup. The provider currently documents the production cleanup job as reporting candidates without deleting them.
- Billed separately
-
Extra starts cost $0.03 to $0.07 each. Create, fork and resume count. The wallet pays first. An opted-in invoice can pay when the wallet is empty. Extra saved snapshots cost $0.056 each per day. The AI proxy costs $1 per enabled day plus $1 per 1,000 requests. Snapshot and proxy charges draw from the wallet. Egress is free.
- Left out
-
Plan commitments ($20/$100/$500/$2000 per month per seat, returned as VM time at list rates), included starts and concurrency limits, the wallet bonus of 2% to 25% on payments of $200 or more, the 7-day free trial's limits, the $100-plan requirement for xlarge, and taxes.
Rates checked 2026-11-01 Boat's sources, measurements and 6 open questions |
| boxd | Reported By Provider |
$0.0470 per vCPU-hour on active use
|
$0.0140 per GiB-hour on active use
|
$0.0000960 per GiB-hour on active use
|
—
|
|---|
Formula A complete USD machines.usage(id) record for this machine, with rates matching the stored list version, reports cost_micro divided by one million. Otherwise unknown; no calculated fallback.
- Billed on
-
$0.047 per vCPU-hour of CPU time used, $0.014 per GiB-hour of resident RAM while running or in standby, and $0.000096 per GiB-hour of written disk in every state; never provisioned size.
- Billing starts
-
Not stated where metering begins within create or resume calls; only the provider's usage record supplies cost.
- Billing ends
-
Hibernated and stopped machines still bill written disk; stopping alone does not end all charges. Exact deletion billing edges are not stated by the provider.
- Rounding
-
Metered every second, settled every 15 minutes, with no minimum per machine. Each organization settlement rounds each resource up to the next millionth of its currency; this is not per-machine rounding.
- Idle and paused
-
Idle CPU bills only time used; standby or suspend-to-RAM bills resident RAM and written disk. Hibernation and stopped machines bill written disk only; generic paused represents standby, not hibernation.
- Billed separately
-
State transitions cost nothing; separate snapshot and custom-domain fees are not stated by the provider on the checked pricing pages. Do not treat unpublished fees as zero.
- Left out
-
No monthly plan, paid-plan minimum or per-seat fee is published for pay as you go. Credits, taxes, custom pricing and annual self-host licences are outside the per-machine USD list cost.
Rates checked 2026-11-02 boxd's sources, measurements and 3 open questions |
| Daytona | Reported By Provider |
$0.0504 per vCPU-hour
|
$0.0162 per GiB-hour
|
$0.000108 per GiB-hour
|
—
|
|---|
Formula Daytona's own price for the sandbox. Check: billed seconds × (vCPUs × CPU rate + GiB of memory × memory rate + GiB of disk × disk rate).
- Billed on
-
CPU, memory and disk as reserved, not as used. Disk is charged in full; the pricing page says "after first 5 free", but the reported prices we measured deducted none.
- Billing starts
-
At create returned, measured on seven sandboxes. Daytona's first period began 14 to 86 ms earlier, within network and clock error.
- Billing ends
-
At destroy sent, measured on seven sandboxes. Daytona's last period ended 28 to 68 ms later.
- Rounding
-
Not stated beyond "calculated per second". Billed periods have millisecond edges, and a 247 ms period was priced at its exact length.
- Idle and paused
-
Stopped and paused (VM only) are billed for disk only. Archived (container only) and deleted are not billed. Creating, starting, stopping and pausing bill like started. Paused and archived were not measured.
- Billed separately
-
Not stated for network or creation. GPU is priced per GPU-hour (for example H100 $3.95 on-demand) and Windows at $0.0858 per vCPU-hour. Snapshots made from a sandbox stay billed after deletion, with no published rate.
- Left out
-
Free credit, plan or tier fees, taxes, discounts, GPU and Windows sandboxes, snapshot and image storage, and any network charge. Volumes are included at no extra cost.
Rates checked 2026-10-24 Daytona's sources, measurements and 6 open questions |
| E2B | Calculated |
$0.0504 per vCPU-hour
|
$0.0162 per GiB-hour
|
—
|
—
|
|---|
Formula For each running period, from a created or resumed event to the next paused or killed event: seconds × (vCPUs × CPU rate + GiB of memory × memory rate).
- Billed on
-
vCPU-seconds and GiB-seconds of memory as allocated, while running. Disk is included in the plan (10 GiB Hobby, 20 GiB Pro), not a meter. Sandboxes are CPU-only.
- Billing starts
-
Not stated. The calculator uses E2B's created event, which fell inside the create call on five sandboxes. This does not show E2B bills from it.
- Billing ends
-
Billing stops immediately on pause, kill or timeout. The calculator uses the killed event, which fell inside the destroy call on five sandboxes.
- Rounding
-
Billed per second. No minimum duration or rounding increment is published.
- Idle and paused
-
Only running time is billed. Paused sandboxes are kept with no time limit and are not billed. Whether pausing itself is billed has not been tested.
- Billed separately
-
None published: no creation fee, no paused-state or template storage charge. Network is not mentioned on the pricing or billing pages.
- Left out
-
Plan fees (Pro $150 per month, concurrency add-ons, Enterprise minimum), the one-time $100 Hobby credit and taxes. Plans cap vCPU and memory (8 each), and runtime (1 hour Hobby, 24 hours Pro).
Rates checked 2026-10-31 E2B's sources, measurements and 8 open questions |
| Modal | Reported By Provider |
$0.0710 per vCPU-hour billed per core (2 vCPUs), on request or use, whichever is larger
|
$0.0240 per GiB-hour on request or use, whichever is larger
|
—
|
Egress $0.04 per GiB Volumes $0.09 per GiB-month
|
|---|
Formula Modal's own bill for the App, when it held only this sandbox: the sum of hourly USD rows and covered empty hours, read at least 600 seconds after finished_at. An image preparation is priced the same way from its own stopped App. Otherwise unknown.
- Billed on
-
CPU (physical cores, 1 core = 2 vCPUs) and memory (GiB), each on the larger of requested and actual use. No sandbox cost is calculated from the request. Minimum request 0.125 cores and 128 MiB.
- Billing starts
-
Measured on 2026-10-11, not complete. Billing starts at about when Modal sets the sandbox's creation time, 20 to 70 ms before the create call returns. It does not start when the call is sent.
- Billing ends
-
At Modal's finished_at, measured on 325 one-sandbox Apps; each App's bill stopped growing then, and its final rows appeared within 315 seconds. The exact edge and rounding are unsettled, as the median bill was 2.22 seconds below created_at to finished_at at list rates.
- Rounding
-
Billed per second, and Modal's billing page lists no minimum time increment. How a partial second is rounded is not stated.
- Idle and paused
-
Not stated for sandboxes. The pricing page bills a 60-second default keep-alive for applications that take inputs, but does not say whether it applies to sandboxes. Sandboxes have a timeout (5 minutes by default, up to 24 hours) and an optional idle timeout, neither tied to billing. We have not measured this.
- Billed separately
-
Region multiplier on CPU, memory and GPU of 1.15 (broad region) or 1.75 (narrow region). Egress $0.04 per GiB above a workspace allowance, billed from 2026-10-01. Volumes $0.09 per GiB-month. GPUs per second by model. No snapshot or image storage price is stated.
- Left out
-
Plan fees (Starter $0, Team $250 per month), monthly free credits, credit programs, discounts, taxes, and the egress allowance. The list-price figure also leaves out volumes, snapshot retention and egress.
Rates checked 2026-11-05 Modal's sources, measurements and 6 open questions |
| Superserve | Calculated |
$0.0504 per vCPU-hour
|
$0.0162 per GiB-hour
|
—
|
—
|
|---|
Formula For each running period, from a started or resumed row to the first deleted, paused, idle_paused, timeout_paused or auto_deleted row: seconds × (vCPUs × CPU rate + GiB of memory × memory rate). With no end row the cost is unknown.
- Billed on
-
$0.000014 per vCPU-second and $0.0000045 per GiB-second of the memory the sandbox holds, while it runs. Storage on retained data is a separate resource that Superserve tracks but does not bill: a sandbox paused 11 min 18 s with 1 GiB written added no storage charge.
- Billing starts
-
Not stated. The calculator uses the started row (or resumed after a pause), which fell inside the create call on six sandboxes. The team's usage meter ran 0.09 to 0.38 s less than the rows on every period, so the rows are an upper bound.
- Billing ends
-
Compute and memory stop when the sandbox is paused. The calculator ends at the first deleted, paused, idle_paused, timeout_paused or auto_deleted row; the deleted row fell inside the destroy call on four sandboxes. The meter stopped before the idle_paused row (by 1.05 s) and before the timeout_paused row, which auto_deleted followed 0.24 s later.
- Rounding
-
Billed per second; no minimum or rounding increment is stated. The usage meter reports microsecond fractions.
- Idle and paused
-
An idle running sandbox bills its full compute and memory: one left idle 8 min stayed active at full size. Superserve pauses a sandbox only on a timeout it is given (idle_timeout_seconds, timeout_seconds), an explicit pause or a delete; both timeouts are unset by default. A paused sandbox bills nothing: the meter stayed flat for 43 s of idle pause.
- Billed separately
-
Storage on a shared template and retained sandbox changes is listed per GiB-hour but marked not billable, and a sandbox paused 11 min 18 s was charged 0 for it. The pricing page says its estimates exclude network and external model API charges; no network charge is published.
- Left out
-
Storage, plan fees, the included usage on paid plans, taxes, network and external model API charges.
Rates checked 2026-11-13 Superserve's sources, measurements and 8 open questions |
| Vercel | Calculated |
$0.128 per vCPU-hour on active use
|
$0.0212 per GiB-hour per GB, in whole minutes
|
—
|
Creations $0.60 per million Egress $0.15 per GB Snapshots $0.08 per GB-month
|
|---|
Formula GB of memory × run time in whole minutes × memory rate + active CPU hours × CPU rate + creations × creation fee + GB sent × egress rate + snapshot GB-months × storage rate.
- Billed on
-
Memory as provisioned (2 GB per vCPU), CPU as active use (I/O wait is not counted). Whether Active CPU is per vCPU or per sandbox, and whether GB is 1,000 or 1,024 MB, is not stated.
- Billing starts
-
Not stated. In five samples the session startedAt fell inside our create call; no bill was compared.
- Billing ends
-
Not stated. In five samples stoppedAt came before our destroy call and duration equalled stoppedAt minus startedAt; no bill was compared.
- Rounding
-
Provisioned memory is billed in 1-minute minimum increments. No rule is published for Active CPU. Creations are counted per call.
- Idle and paused
-
Not stated for starting, stopping or stopped sessions. A stopped persistent sandbox keeps a snapshot, billed as snapshot storage; deleting the sandbox does not delete it.
- Billed separately
-
Creation $0.60 per million. Network: data sent out and all exposed-port traffic, $0.15 per GB in iad1. Snapshots $0.08 per GB-month. Disk (64 GB) is included. Not stated: GPU.
- Left out
-
Plan fees and allowances, other regions than iad1, enterprise pricing, taxes, Drives, container registry storage and the snapshot kept after the last stop (30 days after last use by default).
Rates checked 2026-10-20 Vercel's sources, measurements and 8 open questions |
A dash means the price version has no rate for that meter. Each row opens to the provider's formula, billing rules and what is left out.
