If you read one line: "serverless GPU" means two different products, and buying the wrong one is the expensive mistake. Genuinely serverless scales to zero and charges you nothing when idle (Azure Container Apps, Cloud Run, Modal, RunPod Serverless, Baseten). "Rent a GPU by the hour" (RunPod Pods, Lambda Labs, CoreWeave) bills even while the box sits idle. Pick serverless for spiky or low-volume work; pick rent-by-the-hour only when a GPU runs hot most of the day.

Here's the whole decision in one screen:

One caveat before the detail: every dollar figure here is approximate. GPU prices move month to month, and the numbers below come from 2026 pricing guides and vendor docs, not a live quote — confirm on each platform's own pricing page before you commit, and never sign a long inference contract at today's rates.

The test that decides everything: does it scale to zero?#

Before you compare a single price, ask one question of any "serverless GPU" product: when no request is running, am I billed? If the answer is no, it's genuinely serverless. If the answer is yes — an idle pod keeps charging — it's a rented box wearing a serverless label.

This is the distinction that quietly wrecks budgets. A founder running an inference endpoint that's busy 10% of the day will pay roughly 10× less on a scale-to-zero platform than on an always-on pod of the same GPU, because the pod bills the other 90% for doing nothing. Flip it around: a training job or a serving endpoint pinned at 80% utilization all day will often be cheaper on a dedicated hourly box, because you're paying a serverless premium (RunPod Serverless runs roughly 2–3× a comparable Pod) for a scale-to-zero benefit you're not using.

The rough break-even is your utilization. Below ~40–50% busy, scale-to-zero usually wins. Above it, a dedicated GPU — the kind we mapped in what it costs to rent an H100/H200/B200 and in the CoreWeave vs Lambda vs Nebius GPU-cloud comparison — is often the better deal. Know which side of that line your workload sits on before you shop.

The question isn't "what's the cheapest GPU per hour." It's "what am I paying for the hours I'm not using it." Scale-to-zero answers that with a zero.

The genuinely serverless options, and who each is for#

Modal is the one most small teams should try first, because the developer experience is the best in the category: you decorate a Python function with @app.function(gpu="H100") and it runs serverless, per-second, scaling to zero. It's commercially GA and mature — not a preview. Cold starts used to be the knock on serverless GPU; Modal's CPU memory snapshots (GA) cut a standard container from ~5s to ~1s, and community reports put ComfyUI-style workloads under 3s. Prices are roughly H100 ~$3.95/hr, A100 80GB ~$2.50/hr, L4 ~$0.80/hr — but pinning to a broad region multiplies the rate (×1.5 for a wide US/EU/AP selection, ×1.75 for a narrow one), which is the easy way to overpay without noticing.

Pick Modal if: you're a Python team shipping bursty or batch custom inference and you value shipping speed and clean abstractions over squeezing the last cent.

RunPod Serverless — cheapest and widest, if you'll tolerate rougher edges

RunPod Serverless (distinct from RunPod Pods, which are the rent-by-the-hour product) scales to zero, bills per second, and has the category's most aggressive cold-start story: FlashBoot, advertised at sub-200ms, by keeping a pool of pre-warmed workers. It also has the widest GPU menu — 30+ SKUs including consumer RTX 4090s — so it's the place to run something on a cheap card. The trade-off is that serverless runs roughly 2–3× the equivalent Pod rate (that premium buys FlashBoot and orchestration), and the tooling is more infrastructure-flavored and less polished than Modal or Baseten.

Pick RunPod Serverless if: you're cost-sensitive, want the broadest hardware choice, and can live with a rougher platform.

Baseten — production serving, not idle savings

Baseten is a production model-serving platform: autoscaling, observability, reliability. It scales to zero (replicas at zero aren't billed), but two details matter. Billing is per GPU-minute per replica — coarser than per-second — and cold starts for large models can take minutes, during which you're billed while the model wakes. Baseten's own docs recommend keeping at least two replicas warm for production, which means you're not really using scale-to-zero in anger; you're paying for dependable serving. That's a feature, not a bug, for the right team.

Pick Baseten if: you're shipping a few custom models as reliable APIs and will happily keep a warm floor for latency. (If you mostly want the quickest path to share a model or a big public-model catalog, Replicate is the adjacent choice — see our Modal vs Replicate vs RunPod vs Baseten deep-dive.)

The hyperscaler serverless options

AWS: the gotcha worth stating plainly

If you're on AWS and assumed the serverless primitives would cover GPU, they don't. Lambda has no GPU. SageMaker Serverless Inference is CPU-only. For GPU you use SageMaker real-time or async endpoints (which can scale to zero but aren't pay-per-second serverless), or you leave AWS for Modal/RunPod/Replicate. Don't architect around a SEO blog post claiming otherwise — AWS's own docs are the source of truth here.

Cold starts: the number that decides if serverless is even viable#

For an interactive product, the cold start — the time from "request arrives at a scaled-to-zero service" to "model is serving" — is the make-or-break metric, and it's where these platforms genuinely differ. RunPod's FlashBoot (<200ms) and Modal's snapshots (~1s) are built to make scale-to-zero feel warm; Cloud Run's <5s is fine for many APIs; Baseten and big-model loads on Azure/Databricks can take minutes, which is why they push you toward a warm floor. If your traffic is steady enough that cold starts rarely fire, any of these works. If it's spiky and latency-sensitive, the cold-start column is the one to optimize — and it's worth reading our dedicated breakdown of scale-to-zero LLM inference and how to beat GPU cold starts before you commit.

The founder's read#

There is no single best serverless GPU — there's the one that fits your workload's shape. Start with the scale-to-zero test (are you billed while idle?) and your utilization (below ~40–50% busy favors serverless). Then match the platform to your situation with the one-screen list up top: Modal for Python DX, RunPod for cheap-and-wide, Baseten for dependable serving, Cloud Run for L4-on-GCP, ACA for Azure governance, Databricks only if you're already there. Put a thin abstraction in front of your model calls so you can move when prices shift — because they will — and for the serving side specifically, our Together vs Fireworks vs Baseten comparison picks up where this leaves off. Confirm today's prices on the vendor's own page before you sign anything longer than a month.