This review is built from Modal’s published pricing and documentation, plus third-party analyses and comparisons, rather than a formal test of our own. Prices are attributed with their dates; Modal changes rates from time to time, so check its pricing page.
Modal is a serverless GPU platform for Python developers. You write a function, add a decorator that says which GPU it needs, and Modal runs it in the cloud, scaling from zero to many containers and back. You pay by the second for the GPU, CPU and memory your code actually uses. AI Coolies called it the default serverless GPU platform for Python-first AI teams in 2026, and that matches its reputation.
The honest verdict: Modal serverless is excellent for bursty work and expensive for steady work. If your GPU sits idle most of the day, per-second billing and scale-to-zero can make it far cheaper than renting a machine. If your GPU is busy most of the day, Modal’s hourly-equivalent rates are well above dedicated GPU rentals. Beam’s analysis put it bluntly: simple to read and punishing at sustained scale. Know your utilisation before you choose.
Table of Contents
- What Modal Serverless Is
- Modal Serverless GPU Prices
- Modal Serverless Plans and Free Tier
- Modal Serverless CPU and Memory Costs
- When Modal Serverless Beats Renting
- Modal Serverless Developer Experience
- Modal Serverless Cold Starts
- A Worked Cost Example
- Serving an Open LLM on Modal Serverless
- Good Uses for Modal Serverless
- Modal Serverless vs RunPod, Vast.ai and Token APIs
- Modal Serverless Lock-In
- Modal Serverless vs Local Hardware
- Modal Serverless for Teams
- Who Should Use What
- FAQ
- Getting Started With Modal
- Verdict
- Sources and Further Reading

What Modal Serverless Is
Most GPU clouds rent you a machine by the hour. You start it, use it, and pay until you stop it, whether or not it is doing anything. Modal works differently. It runs your Python code in containers that start on demand when a request or job arrives, and stop when the work is done.
AI Coolies summarised the appeal: Python developers deploy inference, training and batch jobs with decorators instead of Dockerfiles or Kubernetes. Spheron described the same thing from a competitor’s angle: Modal solved a real problem because developers hated managing GPU infrastructure, so it abstracted it away with decorators and per-second billing.
In practice you get a web endpoint for a model, a scheduled job, or a function you can call from your own code, all without managing servers.
Modal Serverless GPU Prices
Modal publishes per-second rates. Dupple listed them from Modal’s pricing page on October 30, 2026, along with hourly equivalents.
| GPU | Per second | Per busy hour |
|---|---|---|
| NVIDIA B300 | $0.001972 | About $7.10 |
| NVIDIA B200 | $0.001736 | About $6.25 |
| NVIDIA H200 | $0.001261 | About $4.54 |
| NVIDIA H100 | $0.001097 | About $3.95 |
| NVIDIA RTX Pro 6000 | $0.000842 | About $3.03 |
| NVIDIA A100 80GB | $0.000694 | About $2.50 |
| NVIDIA L40S | $0.000542 | About $1.95 |
| NVIDIA A10 | $0.000306 | About $1.10 |
| NVIDIA L4 | $0.000222 | About $0.80 |
| NVIDIA T4 | $0.000164 | About $0.59 |
Beam’s June analysis and Tech Insider’s coverage list the same H100 figure. Activepieces put it in daily terms: an H100 kept running for a full day costs $94.80, but Modal does not charge for idle resources. That last part is the whole point.
Modal Serverless Plans and Free Tier
Modal’s Starter plan is free and includes $30 of compute each month, which Tech Insider noted at a time when some rivals, such as Nebius, had suspended free trials. That is enough to experiment meaningfully: dozens of hours on a T4 or L4, or several hours on an H100.
The Team plan costs $250 a month according to Dupple and CostBench, adding more seats, higher concurrency and team features. Enterprise plans are custom. For most individuals and small projects, Starter is enough until real traffic arrives.
Modal Serverless CPU and Memory Costs
GPU time is not the whole bill. Dupple and ThunderCompute both point out that a GPU container also bills CPU cores and memory on top of the GPU rate. For a typical inference container with a couple of cores and 16GB of RAM, that adds a noticeable percentage.
Doolpa scored Modal 86 out of 100, docking points for opaque multiplier pricing and the lack of any self-hosting option. Spheron’s breakdown also describes multipliers that change what you pay. Read the pricing page carefully for the options you choose, and model the full cost, not just the GPU line.
When Modal Serverless Beats Renting
The key number is utilisation: the fraction of time your GPU is actually working. GPU Per Hour’s guide on serverless pricing makes the method clear. Take Modal’s per-second rate, convert it to a busy-hour price, and compare it with a dedicated rental at the same GPU.
Take the H100. Modal costs about $3.95 per busy hour. ThunderCompute listed RunPod’s on-demand H100 at $3.49 an hour in September, and Spheron listed H100 PCIe rentals around $2 to $2.64 an hour during 2026. If your H100 is busy all day, a rental at $2.50 an hour is far cheaper than Modal at $3.95.
Flip the usage pattern and the answer flips. If the GPU is busy only 20% of the time, a dedicated rental still bills 24 hours a day, while Modal bills only the busy hours. At that level, Modal costs roughly a fifth of what an always-on H100 rental would, even at a higher hourly rate. The break-even point sits where Modal’s busy-hour price times your utilisation equals the rental’s hourly price, which for an H100 is somewhere around 60 to 70% utilisation at current rates.
Modal Serverless Developer Experience
This is where Modal earns its premium. You describe the container environment in Python, mark functions with decorators that specify the GPU, and deploy from your terminal. Logs, metrics and a web dashboard come built in. There is no Kubernetes to manage and no instance to remember to shut down.
For small teams without dedicated infrastructure engineers, that time saving is often worth more than the price difference. An engineer who would spend days setting up autoscaling on raw cloud instances can have a working endpoint in an afternoon.
Modal Serverless Cold Starts
Scale-to-zero has a cost: when a request arrives and no container is running, one must start and load the model before answering. That cold start can take seconds or longer for large models.
ThunderCompute’s comparison credited Modal with sub-second starts using snapshots, and noted that RunPod advertises starts as low as 500ms with its FlashBoot feature. In practice, cold start time depends heavily on model size and how you package it. You can also keep a minimum number of containers warm, but then you pay for idle time again, which erodes the serverless advantage.
For user-facing chat, plan for warm containers during busy hours. For batch jobs and background tasks, cold starts rarely matter.
A Worked Cost Example
Numbers make this concrete. Imagine an internal document assistant used by a 30-person company. It handles about 600 requests on a working day, each needing around eight seconds of H100 time, and almost nothing at night or at weekends.
That is 4,800 GPU seconds a day, or roughly 1.3 busy hours. At $0.001097 a second, the GPU cost is about $5.30 a day. Across 22 working days, that is around $115 a month, plus CPU and memory, and plus whatever it costs to keep a container warm during office hours if cold starts bother your users.
A dedicated H100 rental at $2.50 an hour, left running around the clock, would cost about $1,800 a month for the same work. Even a rental that you remember to stop every evening would cost several hundred dollars. In this pattern, Modal serverless wins easily.
Now change one thing: the assistant becomes popular and handles requests all day and night at high volume, keeping the GPU busy 80% of the time. The Modal bill rises to roughly $2,300 a month, while the always-on rental stays near $1,800. The crossover is real, and it arrives sooner than many teams expect.
Serving an Open LLM on Modal Serverless
A common use is serving an open model with vLLM or a similar engine behind a web endpoint. Modal publishes examples for exactly this. The pattern is to bake model weights into the container image or a persistent volume, so cold starts do not download gigabytes each time, then expose an OpenAI-compatible endpoint.
Choose the GPU by model size. An L4 or L40S handles small and mid-sized models cheaply. An H100 or H200 suits 70B-class models at FP8. For the largest open models, multiple GPUs per container are possible, at multiplied cost.
If the model is a popular open release, compare against a token API first. Providers already run it at scale, and per-token pricing may undercut running your own endpoint unless you need custom weights or fine-tunes.
Keeping the Bill Under Control
A few habits keep serverless costs predictable. Use the smallest GPU that meets your latency target; an L4 at $0.80 per busy hour handles many small-model tasks that people send to an H100 by default. Set scale-down timeouts short, so containers stop soon after the last request. Cache model weights in volumes rather than downloading them on every start, which cuts both cold-start time and billed seconds.
Batch where you can. Sending documents for embedding in groups of hundreds rather than one at a time keeps the GPU busy for fewer, fuller seconds. And review the usage dashboard weekly for the first month, because the first surprise bill usually comes from a forgotten warm container or a retry loop, not from real traffic.
Good Uses for Modal Serverless
- Bursty inference. An internal tool used a few hundred times a day, or a product feature with uneven traffic.
- Batch jobs. Embedding a document collection overnight, transcribing a backlog of audio or running evaluations across many prompts, fanned out across many GPUs for a short time.
- Prototypes and demos. A model endpoint you can share without leaving a GPU running.
- Short fine-tuning runs. Jobs that need a large GPU for hours, not weeks.
Poor fits are steady, high-volume inference that keeps GPUs busy all day, and long training runs where reserved capacity is much cheaper.
Modal Serverless vs RunPod, Vast.ai and Token APIs
| Option | Billing | Best for |
|---|---|---|
| Modal | Per second, scale to zero, CPU and RAM extra | Bursty Python workloads |
| RunPod | Per-second serverless plus hourly pods | Mixed serverless and dedicated |
| Vast.ai | Hourly marketplace | Cheapest raw GPU hours |
| Token APIs | Per token | Standard open models, no GPU management |
ThunderCompute’s comparison noted that RunPod covers both halves of the Modal use case: serverless endpoints that scale to zero and bill per second, plus persistent pods. Vast.ai is usually cheapest for raw hours. And if you only need a popular open model, ThunderCompute pointed out that providers like Together AI replace GPU-second maths with per-token pricing, which is often simplest of all.
Modal Serverless Lock-In
Modal’s decorators and container definitions are its own. Code written for it does not run unchanged on other platforms. Spheron’s alternatives guide pitches exactly this point, offering serverless GPU without the lock-in.
The practical mitigation is to keep your model code separate from the platform code. Put inference logic in normal Python modules, and keep the Modal-specific wrapper thin. Then moving to another provider, or to your own hardware, means rewriting the wrapper rather than the application.
Modal Serverless vs Local Hardware
For readers of this site, the other alternative is your own hardware. A local GPU has no hourly bill at all once bought, and your data never leaves your premises.
The calculation is similar to the cloud one. If you need a GPU a few hours a week, Modal’s free tier or a small monthly bill beats buying hardware. If you run models all day, a local card such as an RTX 5090 or a used RTX 3090 pays for itself within months. Many teams use both: local hardware for steady work and Modal for occasional bursts that need bigger GPUs.
Modal Serverless for Teams
For teams, the Team plan adds seats and concurrency, and the dashboard shows who is spending what. Set budget alerts early. Serverless platforms make it easy to launch a hundred GPUs with one line of code, and equally easy to forget a warm container that runs all weekend.
Check data handling for your use case too. Your code and data run on Modal’s infrastructure, so confirm its security and compliance documentation meets your requirements before sending sensitive workloads.
Who Should Use What
| If you are | Start with | Why | Link |
|---|---|---|---|
| A Python team with bursty GPU workloads | Modal | Scale to zero, per-second billing, great tooling | Try it |
| Running GPUs busy most of the day | RunPod pods or Vast.ai | Much cheaper per hour | Check price |
| Serving a standard open model | Token API provider | No GPU maths at all | Check price |
| Running models all day on private data | Local GPU | No hourly bill, data stays local | Check price |
Frequently Asked Questions About Modal Serverless
How much does an H100 cost on Modal?
$0.001097 per second, about $3.95 per busy hour, plus CPU and memory.
Is there a free tier?
Yes. The Starter plan includes $30 of compute each month.
When is Modal cheaper than renting a GPU?
When your GPU is idle most of the time. Above roughly 60 to 70% utilisation on an H100, dedicated rentals usually win.
Does Modal have cold starts?
Yes, when scaling from zero. Snapshots shorten them, and you can keep containers warm at extra cost.
Can I self-host Modal?
No. It runs only on Modal’s infrastructure.
Is it good for training?
For short runs, yes. Long training runs are usually cheaper on reserved or dedicated GPUs.
Getting Started With Modal
Install the Python client, authenticate, and run one of Modal’s example inference apps on a small GPU such as an L4. Watch the dashboard to see how billing accrues per second.
Then measure your real workload. Log how many requests arrive per hour and how long each takes. Multiply out the busy GPU seconds per month and compare against a dedicated rental before you commit.
Set a budget alert before you share any endpoint publicly.
Verdict
Use Modal serverless if your GPU work is bursty, your team writes Python, and you value shipping quickly over squeezing every cent from GPU hours. For prototypes, internal tools, batch jobs and uneven traffic, it is one of the best options available.
The honest caveat is sustained cost. At about $3.95 per busy H100 hour plus CPU and memory, steady workloads cost far more than dedicated rentals or your own hardware, and the platform-specific code adds some lock-in.
Next step: measure your GPU utilisation for a typical week. If it is low, start on Modal’s free tier. If it is high, compare RunPod pods, Vast.ai and a local GPU instead.
Sources and Further Reading
- Dupple: Modal pricing 2026, for the full per-second rate table and plans.
- Beam: Modal pricing explained, for a competitor’s view of sustained costs.
- GPU Per Hour: when per-second beats renting, for the break-even method.
- ThunderCompute: Modal alternatives, for RunPod and Together AI comparisons.
- AI Coolies: Modal review, for the developer experience.
On this site: compare GPU clouds in our RunPod and Vast.ai reviews, see token pricing in AI inference API providers, and cut costs with LLM API cost optimisation.




