Serverless GPU Pricing: Modal Has the Cheapest H100 Hour, Not the Cheapest Job

Modal lists an H100 at $0.001097 a second, about $3.95 an hour, the lowest serverless GPU price of the four platforms compared here. Price one ordinary 90-second inference job under each platform's default billing rules, and Modal comes out more expensive than RunPod. The hourly rate is the number everyone compares. The idle window is the number that decides your bill.

The comparison matters more this month than it did last quarter. Modal raised $750 million at a $15.75 billion valuation on 14 October 2026, led by Accel, and said it now earns more than $1 billion a year. Serverless GPU pricing has become a line item finance teams ask about, so it is worth getting the arithmetic right.

What serverless GPU pricing actually bills you for

Serverless GPU pricing means you rent an accelerator by the second and the platform turns it off when traffic stops. You do not pick an instance and leave it running. The platform starts a container when a request arrives and shuts it down when the queue empties.

That sounds like you pay only for work. You do not. Every platform bills for some time when the GPU is doing nothing useful for you, and each one draws that line in a different place. The per-second rate is the price of a second. The billing rules decide how many seconds you buy.

There are three phases in any serverless request. Load is the time to get model weights into GPU memory. Execution is the time spent on your request. Idle is the time a warm container waits for the next request before it scales down. Your bill is the rate multiplied by whichever of those three phases the platform counts.

On a long training run, a minute of idle time is noise. On a 60-second inference request, a minute of idle time doubles the bill. Short, bursty jobs are exactly the workload serverless GPU platforms are sold for, so the billing rules matter most where the marketing is loudest.

H100 and A100 per-hour rates, side by side

Here are the published H100 and A100 rates at each platform, converted to an hourly figure where the page lists per-second prices. Every number comes from the vendor's own page, fetched on 31 October 2026. None of these pages carried a "last updated" date except RunPod's, which said 8 October 2026.

Modal bills CPU at $0.0000131 per physical core per second and memory at $0.00000222 per GiB per second on top of the GPU rate. RunPod, Replicate and Lambda list one rate per GPU tier. Lambda is included as the always-on baseline, not as a serverless product.

The A100 ranking is different

On the A100 80 GB, Modal ($2.50), RunPod ($2.72) and Lambda ($2.79) sit within 30 cents of each other. Replicate is the outlier at $5.04, roughly double. If your model fits on an A100, the hourly gap between the three cheapest is small enough that billing rules dominate completely.

"H100" is not one product

Modal names the H100 SXM5 and Lambda separates SXM from PCIe, which it prices at $3.29. RunPod's serverless tier says "H100 PRO" and Replicate says "H100" without a form factor. SXM parts run faster than PCIe parts, so a lower price on an unnamed variant may buy less throughput per second. Ask before you compare.

The billing rules that set the real serverless GPU price

This is the part of serverless GPU pricing that vendor comparison pages skip. Each platform publishes its rules, usually on a docs page rather than the pricing page. Read together, they explain almost all of the gap between the hourly ranking and the job ranking.

Sources: Modal pricing FAQ; RunPod Serverless pricing docs; Replicate billing docs; Lambda billing docs. All fetched 31 October 2026.

Modal bills the warm-down

Modal's pricing FAQ says it bills "during application load time and during the time your container is processing inputs". It then adds that containers stay alive for 60 seconds after the last input, "which we also bill for". That 60-second default is a sensible latency choice, because the next request finds a warm container. It is also a cost you did not ask for.

Replicate splits public and private

Replicate's billing docs say that for public models "setup and idle time for the model is free". For private models and deployments you pay "the time they spend setting up; the time they spend idle, waiting for requests; and the time they spend active". The same H100 at the same rate has two very different effective prices depending on whose weights it runs.

One standard inference job, priced on four platforms

To turn rules into dollars, we priced one job everywhere. It is a deliberately ordinary shape: a cold container, 30 seconds to load model weights into GPU memory, 60 seconds of execution, then whatever idle time each platform bills by default. No request arrives during the idle window, so the container scales down afterwards.

The load and execution times are our assumptions, not measurements. They are held constant across platforms so the only variables are the published rate and the published billing rule. Modal's figure includes 2 CPU cores and 16 GiB of memory, because Modal bills those separately and the others do not.

Modal's per-second figure is $0.001097 GPU plus $0.0000262 CPU plus $0.0000355 memory. RunPod's is $5.39 divided by 3,600. Lambda's is $4.29 divided by 60, billed per started minute. Replicate does not publish its private idle window, so 180 seconds is our reading of "a few minutes".

The ranking inverts

Sorted by hourly rate, the order is Modal, Lambda, RunPod, Replicate. Sorted by the cost of this job on default settings, it is Replicate public, RunPod, Lambda, Modal, Replicate private. The platform with the cheapest H100 hour finished fourth of five. The platform with the most expensive hour finished both first and last.

That is the whole argument of this post in one table. I would not choose a serverless GPU vendor from its pricing page, because the pricing page is the least informative document it publishes.

Modal vs RunPod: the idle window decides the comparison

On default settings, 60 of Modal's 150 billed seconds are idle. That is 40% of the job's cost spent waiting for a request that never came. On RunPod the idle share is 5 of 95 seconds, about 5%. The 36% hourly rate advantage Modal holds over RunPod's serverless H100 is consumed by that difference and then some.

Change one setting and the result flips. Modal lets you set scaledown_window anywhere from 2 seconds to 20 minutes, according to its cold-start guide. At 2 seconds, the same job bills 92 seconds and costs $0.107. That is 25% cheaper than RunPod's default and the cheapest option on this list for running your own weights.

The trade you are actually making

A short idle window is not free. If requests arrive every 30 seconds, a 2-second window means every request pays a fresh 30-second load. A 60-second window would have kept one container warm and billed 30 seconds of idle between jobs instead of 30 seconds of load. The right setting is a function of your traffic gaps, not a universal number.

My position is that most teams should start short and lengthen the window only when latency complaints arrive. A default chosen by the vendor optimises for the vendor's latency story. A setting chosen from your own request logs optimises for your bill. The broader version of this argument, that cheap unit prices hide rising totals, is made in the analysis of why cheaper tokens still produce larger AI bills.

Multipliers the headline serverless GPU rate leaves out

Modal's $3.95 is a list price for preemptible capacity in an unpinned region. Its pricing page lists two multipliers that apply on every plan. Region selection costs "1.15 to 1.75x base prices." Non-preemptible execution costs "3x base prices."

Those are not small adjustments. A region-pinned H100 at the lowest multiplier is about $4.54 an hour of GPU time, above Lambda's $4.29. At the top of the regional range it is about $6.91. A non-preemptible H100 is about $11.85. If your data residency rules require a region, the cheapest-hourly claim disappears before you run a single job.

Modal Sandboxes, the container product behind much of the company's recent growth, are billed at the 3x non-preemptible rate by default. That product and its competitors are compared in the agent sandbox pricing breakdown, so this post stays on GPU inference.

Modal's free Starter plan includes $30 of monthly credit and caps you at 10 concurrent GPUs. The Team plan costs $250 a month, includes $100 of credit and raises the cap to 50 GPUs. RunPod's docs set a default spend limit of $80 an hour across all resources. Neither is a price, but both shape what a bursty workload can actually do on day one.

When an always-on H100 beats serverless GPU pricing

Serverless pricing is a bet that your GPU would otherwise sit idle. If it would not, a plain instance is cheaper. Lambda's single H100 SXM at $4.29 an hour costs $102.96 a day whether you send it one request or ten thousand.

The break-even is easiest to see as a share of the day. RunPod's serverless H100 costs $5.39 an hour, so an always-on Lambda H100 wins once your workers would be billed for more than about 80% of the day. For Replicate's $5.49 rate the line sits near 78%. For Modal at its base rate with our CPU and memory allowance, $4.17 an hour, serverless stays cheaper at every utilization. Pin a region at 1.15x and the line drops to about 89%.

The utilization you actually have

Most inference endpoints outside a large consumer product run well below 80% utilization, because traffic follows working hours. That is the honest case for serverless. Whether owning hardware beats renting it at higher utilization is a separate calculation, worked through in the GPU break-even utilization model. And if the job does not need an H100 at all, the cost per task of small language models is the cheaper question to ask first.

Where this comparison is weakest

The job in this post is a model, not a measurement. The 30-second load and 60-second execution are our assumptions, and real numbers vary by an order of magnitude with model size, image caching and the platform's own snapshot features. RunPod advertises sub-200-millisecond FlashBoot cold starts and Modal advertises containers that boot in about a second. If either holds for your model, the load segment shrinks and the ranking moves.

Throughput is not held constant either. We priced seconds, not tokens or images. If one platform's H100 finishes the same request in 45 seconds rather than 60, its job cost falls by a quarter. A fair comparison on your workload needs a benchmark run on each platform, which this post did not do.

RunPod publishes two H100 numbers

RunPod's pricing page, dated 8 October 2026, lists the 80 GB H100 PRO serverless tier at $5.39 an hour. Its endpoint configuration docs list the same tier at $0.00116 a second, about $4.18 an hour. Neither is labelled flex or active. At the docs rate, our RunPod job falls from $0.142 to $0.110, nearly level with a tuned Modal. We used the dated pricing page and flag the conflict here rather than pick the friendlier number.

List prices are not contract prices

Every figure here is a public list price. RunPod discounts active workers through sales, Replicate offers committed-spend contracts, and Modal has an Enterprise tier with custom terms. A team spending six figures a year on GPUs is not paying these rates, and the comparison between negotiated prices may look nothing like this one.

Frequently asked questions

How to price your own serverless GPU job this week

Pull one day of request logs for the endpoint you want to move. Write down three numbers: median model load time, median execution time, and the median gap between requests. Those three numbers, multiplied through the billing rules table above, will tell you more than any vendor's pricing page.

Then check the idle setting before you check the rate. If you are on Modal, read your current scaledown_window and compare it with your median request gap. If the window is longer than the gap, you are paying to keep a container warm that rarely serves anyone. For the wider question of where inference cost lands in your margins, start with the breakdown of inference costs and AI gross margins.

Related reading