Modal GPU Pricing 2026: Per-Second Billing Cost vs Spheron

Modal advertises H100 access at $0.001097 per second. Do the multiplication and you get roughly $3.95/hr, the number most comparison posts, including some of ours, cite as "Modal's H100 price." That number is accurate. It's also the floor, not what a real production deployment typically pays. Region selection and preemption rules move the real cost before you've written a line of GPU code, and the break-even point against a dedicated hourly rental sits closer to half your day than most serverless pitches imply.

This post breaks down Modal's actual per-second rates for every GPU it offers, the two multipliers that change what you pay, and the utilization math for when that per-second billing model beats a flat hourly H100 rental. If you're weighing Modal against a bare-metal alternative on architecture rather than just cost, see our Spheron vs Modal comparison for the fuller picture on cold starts, multi-node training, and persistent storage.

Modal's Actual GPU Pricing in 2026 (Per-Second Rates, Not the Marketing Number)

Modal's GPU pricing model is genuinely per-second, with no minimum billing increment published on its pricing page. You pay for exactly the wall-clock seconds your function holds a GPU, and the meter stops the instant the container scales to zero. That's the real advantage of the model. The complication is that the headline rate for each GPU (the number that gets rounded to "$3.95/hr for an H100") only holds if you don't specify a region and never trip the preemption behavior that applies to every GPU function by default.

The Full Per-Second Rate Table (H100, H200, B200, A100, L40S, A10, L4, T4)

Source: Modal's pricing page. These are base rates: no region multiplier, no preemption discount, GPU held for the full hour. Modal also lists B300 at $0.001972/sec (~$7.10/hr) and RTX PRO 6000 at $0.000842/sec (~$3.03/hr) for teams evaluating the newest silicon.

The "effective $/hr" column matters more than the raw per-second number for planning purposes, because nobody budgets in fractions of a cent per second. Multiply the per-second rate by 3,600 and you get the number to compare against any hourly-billed provider, which is exactly what the break-even section below does for H100.

The Hidden Multipliers: Region and Preemption Change What You Actually Pay

Two things move the real cost away from the table above: where you tell Modal to run the function, and whether Modal decides to preempt it. Neither shows up in the headline rate, and both apply specifically to GPU workloads in ways worth understanding before you commit a production deployment to Modal.

Region Selection Multiplier (1.5x-1.75x, Up to 2.5x Depending on Source)

Modal's own documentation is specific: a broad region selection (us, eu, ap) applies a 1.5x multiplier, and a narrower region (us-west, eu-north) applies 1.75x, on top of the base usage price for whatever combination of GPU, CPU, and memory the function consumes. Modal's docs give the formula directly: "the cost to run it for 1 hour would be ((GPU hourly cost) + (CPU hourly cost) + (memory hourly cost)) x 1.75" for a narrow region pin. If you don't specify a region at all, no multiplier applies and Modal schedules the function wherever capacity exists.

That's the gap that catches teams off guard. If your workload has a data residency requirement, a latency target tied to a specific coast, or a compliance reason to pin execution to eu, you're not paying the base H100 rate anymore. You're paying $3.95 x 1.5 = $5.93/hr for a broad region, or $3.95 x 1.75 = $6.91/hr for a narrow one.

Blaxel's Modal pricing breakdown describes a wider range, 1.25x up to 2.5x for region selection, and a combined figure of 3.75x when region selection stacks with Modal's non-preemptible surcharge. Read that combined figure carefully: Modal's non-preemptible option (the 3x multiplier) applies only to CPU and memory usage. It's explicitly not available for GPU Functions, covered next, so the 3.75x combined multiplier describes a CPU/memory-only workload, not GPU cost. For a GPU function, region selection at 1.5x-1.75x, per Modal's own docs, is the only multiplier in play.

Preemption on Modal: GPU Functions Are Preempted by Default (No Non-Preemptible Opt-Out)

Every Modal Function is subject to preemption by default. When Modal preempts a function, it gracefully terminates it and restarts it on the same input, so the work isn't lost, but the container does stop and cold-start again mid-job. For a CPU or memory-bound function, you can pay your way out of this: Modal's nonpreemptible parameter guarantees protection from interruption, at a 3x price multiplier on CPU and memory usage.

For GPU Functions, that opt-out doesn't exist. Modal's own guide states it plainly: the nonpreemptible parameter "is not supported for GPU Functions." Every GPU workload on Modal, regardless of how much you're willing to pay, remains preemptible. Modal Sandboxes get a partial exception: sandboxes are generally not subject to preemption, except when a GPU requirement is specified, in which case the GPU sandbox is preemptible too, for the same availability and scheduling reasons.

Practically, this means a long-running GPU inference server on Modal can be interrupted at any point, restart on the same input, and eat a fresh cold start, with no paid tier that removes that risk. If your workload can tolerate a restart mid-request (batch jobs, async pipelines), this is a non-issue. If it can't (a synchronous, latency-sensitive API), it's a real constraint that per-second billing alone doesn't fix.

What a 'Guaranteed Availability' Workload Really Costs When You Stack Multipliers

Say you need an H100 pinned to us-west for latency reasons, running a production inference endpoint. You're now paying the 1.75x region multiplier: $3.95 x 1.75 = $6.91/hr. You cannot additionally pay for non-preemption, because that option doesn't exist for GPU Functions. So the workload costs nearly double the headline rate, and it can still be preempted and restarted at any time.

Compare that to Spheron's on-demand tier, which is not preempted by definition. The DEDICATED instance type holds the GPU for as long as you're running it, with no scheduling interruption; only the separate SPOT tier trades that guarantee for a lower price. At $2.01/hr for H100 PCIe on-demand (live rate, see the pricing note below), you're paying less than a third of the region-pinned Modal rate, for a workload that doesn't restart mid-request. Even Spheron's H100 spot tier at $2.91/hr, which can be reclaimed, undercuts the region-pinned Modal price while being explicit about the trade-off rather than bundling it into a "guaranteed availability" framing that doesn't actually guarantee availability.

The Break-Even Point: When Per-Second Billing Beats Dedicated Hourly (and When It Doesn't)

Per-second billing is a genuine advantage at low utilization and a genuine cost the moment utilization climbs. There's a specific crossover point, and it's lower than most people assume, sitting just past half of a 24-hour day rather than somewhere near constant use.

The Utilization Math: Modal $3.95/hr Effective vs Spheron H100 On-Demand

Spheron's live H100 pricing, fetched from its GPU rental catalog on 14 Jul 2026: $2.01/hr on-demand for H100 PCIe, $4.41/hr on-demand for H100 SXM5, and $2.91/hr spot for H100 SXM5. Most single-GPU inference deployments run on the PCIe variant, so that's the number to compare against Modal's base rate; the pricier SXM5 tier matters mainly for multi-GPU training where NVLink bandwidth is the point, not raw per-hour cost.

That PCIe-vs-SXM5 distinction is also why this post's crossover point differs from the one in our earlier Spheron vs Modal comparison, which put break-even near 61% utilization using SXM5 at $2.40/hr. That was a different GPU tier at an earlier snapshot in time, not a contradiction: Spheron's marketplace rates move with live availability, and SXM5 has since repriced to $4.41/hr, above Modal's own $3.95/hr base rate, which makes SXM5 the wrong comparator for a single-GPU serverless function in the first place. Modal's GPU Functions allocate single GPUs without NVLink, so PCIe on-demand, without the NVLink premium, is the apples-to-apples match, and that's the rate this section uses throughout.

Spheron bills a flat hourly rate whether the GPU is processing requests or sitting idle. Modal bills only for the seconds a function actually runs. The break-even is where those two costs meet: 2.01 / 3.95 = 0.509, or about 51% utilization, roughly 12.2 hours of active GPU time in a 24-hour day.

Pin Modal to a region and the crossover shifts hard in Spheron's favor. At the 1.5x broad-region rate ($5.93/hr), break-even drops to 2.01 / 5.93 = 0.339, about 34% utilization. At the 1.75x narrow-region rate ($6.91/hr), it drops to 2.01 / 6.91 = 0.291, about 29% utilization, or roughly seven hours a day.

Pricing fluctuates based on GPU availability. The prices above are based on 14 Jul 2026 and may have changed. Check current GPU pricing → for live rates.

Worked Example: Bursty Inference (2hrs/day) vs Sustained Inference (24/7)

Bursty inference, 2 hours/day, 30 days/month. Modal: $3.95 x 2 x 30 = $237/month. Spheron on-demand, left running continuously so it's ready whenever the 2-hour window hits: $2.01 x 24 x 30 = $1,447.20/month. Modal wins by a wide margin here, which is exactly the workload pattern per-second billing is built for.

There's a nuance worth stating plainly: Spheron bills per minute with no minimum, so if that 2-hour window is predictable, you could stop the instance for the other 22 hours and pay only $2.01 x 2 x 30 = $120.60/month, cheaper than Modal. The catch is that stopping and restarting a dedicated instance means reloading model weights into VRAM yourself, which is functionally the same cold start Modal charges you to avoid managing. Modal's value here isn't the per-second rate, it's not having to build and operate that stop/start logic yourself. For genuinely unpredictable bursty traffic, that automation is worth paying for. For a fixed, known daily window, a manually scheduled Spheron instance can beat both numbers above.

Sustained inference, 24/7, 30 days/month. Modal: $3.95 x 24 x 30 = $2,844/month. Spheron on-demand: $2.01 x 24 x 30 = $1,447.20/month. Spheron saves about $1,396.80/month, roughly 49% cheaper, and that gap widens further if the workload is pinned to a specific Modal region. This is the case per-second billing was never meant to win, and the math confirms it.

For the underlying utilization economics behind these numbers, including how utilization percentage translates into cost-per-token for LLM serving, see our AI inference cost economics guide.

Modal vs Spheron GPU Rental: Side-by-Side Cost for Bursty vs Sustained Workloads

The two platforms solve different problems, and the pricing model reflects that. Modal optimizes for zero idle cost at the price of cold starts and mandatory preemption. Spheron optimizes for predictable, always-on capacity at a flat hourly rate with no cold starts and a non-preemptible on-demand tier.

Full Comparison Table (Billing Model, Cold Starts, Multi-GPU, Preemption)

For a deeper look at RunPod's own per-second serverless tier as a second data point on billing granularity, see RunPod H100 pricing 2026, and for a provider that bills strictly by the hour with no serverless tier at all, see Lambda Cloud H100 pricing 2026. For rates across a wider set of providers beyond just Modal and Spheron, our GPU cloud pricing comparison for 2026 covers AWS, Azure, RunPod, Lambda, and CoreWeave alongside Spheron.

Which Workloads Actually Belong on Serverless GPUs

The billing model question comes down to utilization and latency tolerance, not which platform has the lower headline number. Our serverless vs on-demand vs reserved GPU guide covers the general framework across all three billing models; here's how Modal specifically lands on it.

When Modal Wins on Cost

• Async batch jobs and scheduled pipelines with long idle gaps between runs.
• Bursty inference APIs running below roughly 50% daily utilization, where the crossover math above hasn't flipped yet.
• Prototyping and low-volume endpoints where you'd otherwise be paying for an idle dedicated GPU most of the day.
• Teams that explicitly want to avoid building stop/start automation and are willing to pay for that convenience.

When Dedicated Hourly Rental Wins on Cost

• Sustained inference serving above roughly 51% utilization on a single H100, where Modal's per-second meter has already crossed the flat hourly rate.
• Any workload pinned to a specific Modal region, since the 1.5x-1.75x multiplier drops the crossover point to somewhere between 29% and 34% utilization.
• Synchronous, latency-sensitive APIs that can't tolerate a mid-request preemption and restart, since Modal has no paid non-preemptible tier for GPU Functions.
• Multi-node distributed training, where Modal's multi-node support remains in private beta and Spheron's InfiniBand-based multi-node setup is production-ready. Our best GPU for AI inference guide covers GPU selection once you've settled on a dedicated rental path.

If you're evaluating Modal against a longer list of serverless and bare-metal options rather than just Spheron, our 10 best Modal alternatives roundup covers nine other platforms across the same cost and architecture trade-offs. For deployment details and API reference once you've picked a path, Spheron's docs cover provisioning an on-demand instance end to end.

If your H100 utilization is climbing past half your day, per-second billing has already stopped paying for itself. Rent H100 GPU →