Here's the shortest useful answer, up top, because that's what you came for. For bursty inference in August 2026 — an agent that fires a model call now and then, not a GPU pegged all day — serverless is the right model, and the cheapest per-hour serverless H100 is Modal (~$3.95/hr), then RunPod ($4.55/hr), with Baseten the premium at ~$6.50/hr. But the headline rate is not what decides your invoice. Billing granularity is. Modal bills per-second with no minimum; RunPod bills per-second rounded up; Baseten bills per-minute. On spiky traffic, that detail can outweigh the sticker price entirely.
Now the reasoning.
Why serverless, not a rented GPU#
If you've read our GPU-cloud head-to-head or the H100/H200/B200 price map, you already know how to rent a bare GPU by the hour. For a training run or a saturated production endpoint, that's the cheapest per-hour compute you'll find. But most early-stage products don't saturate a GPU — an agent calls a model in bursts, a side project gets traffic in spikes, a demo sits idle between clicks. Rent a bare H100 for that and you pay for every idle minute.
Serverless GPU fixes exactly that: the container scales to zero when idle and bills you only while a request runs. You trade a small per-hour premium for never paying for idle. The question stops being "which GPU is cheapest per hour" and becomes "which platform bills the way my traffic actually behaves."
The rates, side by side#
Approximate published rates as of early August 2026 (all subject to change — confirm on each vendor's pricing page, linked below):
| GPU | RunPod Serverless | Modal | Baseten (dedicated) |
|---|---|---|---|
| H100 (80GB) | $4.55/hr | ~$3.95/hr ($0.001097/s) | ~$6.50/hr ($0.10833/min) |
| H200 (141GB) | $5.93/hr | ~$4.54/hr ($0.001261/s) | — |
| A100 (80GB) | $2.72/hr | ~$2.50/hr ($0.000694/s) | ~$4.00/hr ($0.06667/min) |
| B200 | $8.64/hr | ~$6.25/hr ($0.001736/s) | ~$9.98/hr ($0.16633/min) |
On raw hourly rate, Modal wins and Baseten costs the most. If that were the whole story you'd stop here. It isn't.
The number that actually moves your invoice: granularity#
You pay for time the GPU is allocated to you, not time it's doing useful work. So how finely the platform slices time decides what a short call costs.
- Modal bills per-second with no minimum increment. A 3-second inference costs 3 seconds. This is the finest granularity of the three, and it's why Modal can beat a lower-looking rate on very spiky workloads — nothing rounds up.
- RunPod bills per-second, rounded up to the nearest second, from when a worker starts until it fully stops. Nearly as fine as Modal; the rounding rarely matters.
- Baseten bills per-minute, per replica. That same 3-second call rounds toward a full minute unless a replica is already warm and serving requests back-to-back. Per-minute billing is fine when traffic keeps replicas saturated — and quietly expensive when it doesn't.
For short, spiky bursts, per-second billing can beat a lower per-minute rate outright. For steady traffic that keeps replicas warm, the difference washes out. Match the billing clock to your traffic shape, not the sticker price to your spreadsheet.
Cold starts: the second axis#
Scale-to-zero has a tax: the first request after idle waits for a GPU to spin up and your model to load. Each platform attacks it differently.
- RunPod — FlashBoot: advertises sub-200ms cold starts on active endpoints, at no extra charge.
- Modal — memory snapshots: snapshots container (and GPU) memory so init-heavy models skip the expensive load on cold start.
- Baseten — fast cold starts: paired with scale-to-zero, but no published latency figure.
All three are best-case marketing numbers. If first-token latency after idle is load-bearing for your product, benchmark it on your model and your image before you commit.
Who each one is for#
The rates cluster; the operating model is what separates them.
- RunPod — cheapest H100/H200 serverless and the most knobs, but you package a Docker image and handler yourself. Best for bursty inference on a budget when you're comfortable owning the container. Its Flex (scale-to-zero) vs Active (always-on, discounted) worker split lets you tune for spiky or steady.
- Modal — the most developer-native: you write Python and Modal builds the container. Per-second-no-minimum billing and snapshot cold starts make it the pick for dev iteration and very spiky workloads where precision billing pays off.
- Baseten — the most managed: dedicated deployments on its optimized inference stack with autoscaling, the least infra you'll ever touch. Best for steady production traffic where replicas stay warm and per-minute billing stops mattering.
A note on scope: this is a cost cut. If your question is instead "which packaging format am I marrying for years," we compared the same platforms on that axis in Modal vs Replicate vs RunPod vs Baseten: where to deploy a custom model. And if your real question is "should I even self-host, or just call a managed inference API," that's a different fork — we mapped it in managed inference: Together vs Fireworks vs Baseten and where to rent a GPU to serve an open model. For everything in between — bursty, self-packaged, scale-to-zero — pick the platform whose billing clock matches how your traffic actually arrives.
Every price here is a published figure captured in early August 2026 and rounded for comparison. GPU pricing changes frequently — open the pricing pages in the sources below and confirm the live number before you budget.
