Modal Pricing in 2026: What a Serverless GPU Bill Actually Costs

Modal sells GPU compute by the second, and that one fact decides your whole bill. There are no instances to reserve and, in theory, no idle server to forget about: when your code is not running, the meter stops. The catch is that "not running" is a setting you control, and the most expensive mistake on Modal is paying for a GPU to sit warm while it does nothing. This teardown walks the 2026 rate card, the single trap that turns a $200 bill into a $5,700 bill, and the utilization point where a plain rented GPU gets cheaper.

Quick answer: Modal pricing in 2026

Modal (modal.com) has three plans in 2026: Starter at $0 a month with $30 of free compute credit, Team at $250 a month with $100 of free credit, and custom Enterprise. Everything on top is metered per second with scale-to-zero. GPU rates work out to about $3.95 an hour for an H100, $2.50 for an A100 80GB, $1.95 for an L40S, $1.10 for an A10, and $0.80 for an L4. CPU is $0.047 per physical core-hour, memory is $0.008 per GiB-hour, and storage volumes are $0.09 per GiB a month with the first 1 TiB free. Your real invoice is almost entirely GPU-seconds, and the number that decides it is how long your containers stay warm, not how many requests you serve.

Modal GPU rates, 2026 (billed per second)

Modal quotes GPU compute per second. The per-hour column below is that per-second rate multiplied by 3,600 and rounded, so you can sanity-check a bill against a wall clock.

Source: modal.com/pricing, July 2026.

Modal plans and non-GPU meters, 2026

The only meter that matters is GPU-seconds

On almost every Modal bill, GPU-seconds are the whole story. CPU and memory are rounding errors next to a GPU rate, and storage is usually free because a few cached model weights sit well under the 1 TiB free tier. The mental model is one line:

bill (approximately) = GPU dollars-per-second x seconds your GPU containers are alive.

The word doing all the work is "alive." A container is alive during cold-start warmup and during any keep-warm or idle-timeout window you configure, not only while it is actively serving a request. That is where the surprises live.

The keep-warm trap: paying for a GPU to do nothing

To avoid cold starts, it is tempting to keep a GPU container warm. Do the arithmetic before you do that. One H100 held warm around the clock for 30 days is:

$0.001097 x 86,400 seconds x 30 days = $2,843 a month, at zero traffic.

Set keep_warm=2 with a generous container_idle_timeout and you have quietly rented two full-time H100s, whether anyone calls your endpoint or not. Scale-to-zero is the default that makes Modal cheap; keep-warm is the setting that turns it back into a server you forgot to switch off.

Three 30-day Modal bills, same platform

Here is the same platform producing three very different invoices, driven entirely by how the containers are configured.

Bill A, weekend project, scale-to-zero. An image-generation endpoint on an A10: 3,000 generations a month at 8 seconds each is 24,000 GPU-seconds. That is 24,000 x $0.000306 = $7.34, plus about $0.75 of CPU and memory, plus a 7 GiB model cached on a Volume (free, under 1 TiB). Total near $8, which the $30 Starter credit swallows whole. Invoice: $0.

Bill B, production endpoint, keep-warm on. A chat model on an H100 serving 50,000 requests a month at 3 seconds each is 150,000 GPU-seconds of actual inference, worth $165. But keep_warm=2 keeps two H100s alive for the entire month: 2 x 2,592,000 seconds x $0.001097 = $5,687 in GPU alone. Only $165 of that is inference. About 97% of the bill is idle time.

Bill C, same workload, fixed. Drop to keep_warm=0, lean on memory snapshots to keep cold starts to a few seconds, and you bill roughly the active seconds plus short spin-up tails, near 180,000 GPU-seconds, or about $200. Same requests, same users, one configuration change.

The one lever: match warm containers to real concurrency

The fix for Bill B is not a discount, it is a measurement. Pull your P95 concurrent requests and set the warm-container count to that number, not to "2 to be safe." Set container_idle_timeout in the tens of seconds, not minutes. Use memory snapshots so cold starts are cheap enough that you can run keep_warm=0 on everything but your hottest path. That sequence is what collapses $5,687 to about $200, at the cost of a few seconds of extra latency on the first request after a quiet spell.

The GPU-selection lever

The second-biggest lever is not renting the biggest card. Plenty of 7B to 13B models run comfortably on an L40S (48GB) or an A10, and an L40S at $1.95 an hour is 51% cheaper than an H100 at $3.95 an hour. If your model fits and your latency budget allows it, moving Bill C from an H100 to an L40S takes it from about $200 to about $98 a month for identical throughput. Reach for an H100 or H200 when the model genuinely needs the memory or the tokens-per-second, not by reflex.

Modal versus a rented pod: the 73% crossover

Modal charges a premium for doing the ops for you, and it is worth pricing that premium honestly. Modal's H100 is about $3.95 an hour; a rented H100 PCIe pod on RunPod (2026) is $2.89 an hour on-demand, and an A100 80GB pod is $1.39. But a pod bills for every hour it is switched on, while Modal bills only the seconds it actually runs.

Suppose a single H100 is genuinely busy a fraction U of the month:

• Modal: $2,844 x U
• A RunPod pod left on 24/7: $2,081, flat

They cross where 2,844 x U = 2,081, so U = 0.73. Below roughly 73% GPU utilization, Modal's scale-to-zero beats a pod you leave running; above it, the always-on pod is cheaper per delivered GPU-hour. If you diligently stop and start the pod to track traffic, the lower rate tips further toward RunPod, but that scheduling is ops you now own.

When managed serverless GPU is worth paying for

Modal, and managed-inference platforms like Baseten, earn their premium when traffic is bursty, you want per-second billing, and you would rather not babysit autoscaling or remember to turn boxes off. A rented pod or a reserved instance wins when a GPU is busy most of the month and someone owns the operations. The same build-versus-rent crossover shows up across every usage-metered service; we walk the general version in when DIY beats SaaS at scale. And if the model itself is your cost center rather than the hardware, routing to a hosted API can undercut self-hosting weights entirely, which is the math in our OpenRouter pricing teardown.

One plan note before you upgrade: the $250 Team plan includes $100 of credit versus Starter's $30, so the plan costs about $180 a month net of that credit. Upgrade for SSO, more developer seats, and support, not for the credit arithmetic.

Math check: on Modal your bill is GPU-seconds, not requests. One H100 left warm all month is about $2,843 whether it serves a million calls or none, so the cheapest lever is almost always cutting idle warm time first, then right-sizing the GPU, in that order.