Short answer. Modal vs Baseten is a packaging decision: Modal gives you Python-native containers and per-second billing at about $3.95 per H100 GPU-hour; Baseten gives you Truss packaging and managed model APIs at $6.50 per H100 GPU-hour. Choose RunPod for the lowest published H100 rate, Together or Fireworks for token serving plus reserved capacity, Lambda for straightforward GPU VMs, or Plugsky if you want a flat API and no GPU operations.
Modal vs Baseten: the short version
| Option | Deployment model | H100 list price | Billing unit | Best fit |
|---|---|---|---|---|
| Modal | Python functions and containers | About $3.95/GPU-hr | Per second | Python-native serverless and bursty traffic |
| Baseten | Truss packages and managed model APIs | $6.50/GPU-hr | Per minute | Packaged models with a managed control plane |
| RunPod | Pods, serverless workers and clusters | $4.39/GPU-hr Secure; from $2.69 Community | Per second | Lowest raw GPU rate and simple pods |
| Replicate | Cog models and a public marketplace | Per-second; check rate card | Per second | Demos and long-tail image/video models |
| Together AI | Serverless tokens, dedicated endpoints, clusters | $5.49 dedicated; $3.99 cluster | Per token or GPU-hour | Token serving plus reserved clusters |
| Fireworks | Serverless tokens, reserved throughput, GPUs | $8.00/GPU-hr | Per token or GPU-hour | Low-latency serving and training |
| Plugsky | OpenAI-compatible API | n/a (flat plans) | Monthly plan | No GPU operations; 39 models |
USD list prices checked 20 November 2026. H100 variants differ (PCIe, NVL, SXM); confirm the exact GPU, memory and interconnect before comparing. Prices exclude storage, egress and commitments.
The six alternatives
Baseten is the closest direct competitor. Both platforms run containers and scale to zero, but Baseten wraps the model in Truss and sells per-minute GPU time plus model APIs. If your team already uses Truss, switching to Modal means rebuilding the packaging and autoscaling layer. If your team writes Python functions, Modal is less ceremony.
RunPod is the price leader in the table. Its Secure Cloud H100 SXM is $4.39 per GPU-hour, and Community Cloud H100 PCIe starts at $1.99. The trade-off is operational: you choose the pod or worker, manage the runtime and accept that community capacity is not the same product as a managed enterprise platform. For a batch job or a simple endpoint, that can be the right trade.
Replicate is a marketplace and a per-second runtime. It is excellent for trying a model or shipping a demo, less so for a custom inference stack with strict latency and private networking. Together and Fireworks sell token-based serverless inference with a path to dedicated capacity; they are better compared on tokens per dollar than on GPU-hour rates. Lambda sells straightforward GPU instances and 1-Click Clusters, without the serverless abstraction. Plugsky removes GPUs from the equation entirely: a flat monthly API bill, 39 public models, and no custom weights.
Serverless GPU pricing is not one number
Modal's public rates are per second: H100 SXM $0.001097, B200 $0.001736, H200 $0.001261, A100 80 GB $0.000694, L40S $0.000542, L4 $0.000222. The monthly equivalent depends on utilization, not on a sticker hourly rate. A workload that runs 10 minutes a day is cheap even at a high hourly rate; a workload that runs all month is a reserved-capacity conversation.
Modal list rates (per second → per hour)
H100 SXM: $0.001097 × 3,600 = $3.95/hr
B200: $0.001736 × 3,600 = $6.25/hr
H200: $0.001261 × 3,600 = $4.54/hr
A100 80GB: $0.000694 × 3,600 = $2.50/hr
L40S: $0.000542 × 3,600 = $1.95/hr
Baseten H100: $6.50/hr, billed per minute
RunPod H100 SXM: $4.39/hr Secure Cloud
The bill also includes CPU, memory, volumes and egress. Modal lists CPU at $0.0000131 per core-second, memory at $0.00000222 per GiB-second, volumes at $0.09 per GiB-month and egress at $0.04 per GiB. Those lines are small for a GPU-heavy job and large for a data-movement-heavy pipeline.
Cold starts: measure the p95, not the claim
Cold start is image pull plus process start plus model load plus the first request's queue time. A platform can be fast on a small model and slow on a 70B model with a large image. The controls are similar across vendors: keep a warm floor, cache weights, shrink the image, and separate the model server from the request handler.
Modal, Baseten and RunPod all expose scale-to-zero and warm-capacity controls. The useful test is a controlled one: deploy the same container and model, send the same prompt after an idle period, and record time to first token at p50 and p95. Repeat with one warm replica. That tells you the cost of the floor and the benefit, which is the actual decision.
When reserved capacity is cheaper
Compare the reserved hourly rate with the serverless hourly rate at your sustained utilization. The formula is simple:
break_even_utilization = reserved_hourly / serverless_hourly
Modal H100: $3.95/hr
Together reserved H100 (91+ days): $3.45/hr
break-even = 3.45 / 3.95 = 0.873 → about 87%
At 100% utilization (730 hr/month):
Modal: $2,883.50
Reserved: $2,518.50 → saves $365/month
At 50% utilization:
Modal: $1,441.75
Reserved: $2,518.50 → reserved loses $1,076.75/month
That is the whole argument. Reserved capacity is a bet on utilization. It also buys certainty: a reservation can secure GPUs that serverless capacity cannot guarantee at peak. If your product has a hard latency SLO and unpredictable spikes, the reservation may be worth it below the mathematical break-even because the alternative is a failed request.
RunPod, Lambda and Fireworks also sell reserved or committed capacity, usually by quote. Get the effective hourly rate, the minimum term, the utilization commitment and the overage policy in writing. A "reserved" rate that requires 80% utilization is a different product from a pay-as-you-go discount.
Migration
- Containerise the model. Remove the Modal decorator from the critical path; keep the function logic.
- Reproduce the runtime. CUDA, Python, system libraries and model weights must match.
- Rebuild autoscaling. Concurrency, queue depth, warm floor and timeout are platform-specific.
- Move secrets and networking. Private endpoints, VPC peering and egress rules rarely port unchanged.
- Shadow traffic. Compare time to first token, tokens per second and error rate before cutover.
- Keep a rollback. Run both endpoints for a week; switch by route or tenant.
If you are moving to a managed API instead of another GPU platform, the migration is mostly a base URL and model ID change. See the Baseten alternatives for the packaging comparison and the GPU rental guide for contract terms.
Decision guide
- Modal: Python-native serverless, per-second billing, bursty traffic, custom containers.
- Baseten: Truss packaging, managed model APIs, per-minute billing, a polished deployment workflow.
- RunPod: the lowest published H100 rate and a simple pod or worker model.
- Replicate: a public model marketplace and fast demos.
- Together or Fireworks: token-based serving with a reserved-throughput path.
- Lambda: plain GPU VMs and short cluster reservations.
- Plugsky: a flat API bill and no GPU operations; see pricing.
For the wider market, see RunPod vs Vast.ai and the 2026 GPU rental market.
Sources
- Modal pricing — checked 20 November 2026.
- RunPod pricing — checked 20 November 2026.
- Baseten pricing — checked 20 November 2026.
FAQ
Is Modal cheaper than Baseten?
On published list prices, Modal's H100 SXM is about $3.95 per GPU-hour and Baseten's H100 80 GB is $6.50 per GPU-hour. Modal also bills per second; Baseten bills per minute. If the same model runs at the same throughput, Modal is cheaper on raw compute. Baseten's packaging and managed deployment may still justify its premium for some teams.
When is reserved GPU capacity cheaper than Modal?
Reserved capacity wins when sustained utilization is high enough that the lower hourly rate beats per-second billing. With Modal at $3.95 per GPU-hour and a reserved H100 at $3.45, the break-even is about 87% utilization: $3.45 ÷ $3.95 = 0.873. Below that, serverless is cheaper unless the reservation unlocks capacity or a support level you cannot get otherwise.
Does Modal support custom models?
Yes. Modal runs containers and Python functions, so you can serve custom weights and arbitrary inference code, not only a fixed model API. You are responsible for the image, dependencies, model loading, health checks and concurrency settings.
How do I migrate from Modal to another GPU platform?
Separate the application from the decorator. Containerise the model, reproduce the runtime and environment variables, rebuild the autoscaling and queueing policy, then shadow traffic on the new platform. The Python function is the easy part; secrets, warm pools, observability and cutover are the work.
What is the simplest Modal alternative?
If you do not need GPU control, an OpenAI-compatible API is simpler than any serverless GPU platform. Plugsky offers 39 models and flat plans from $8 per month, with no GPU operations. You give up custom weights and low-level runtime control.
Reviewed 20 November 2026. Modal, Baseten, RunPod, Together, Fireworks and Lambda list prices were checked against their public pricing pages on that date. Reserved-capacity math is illustrative and excludes commitments, storage and egress; confirm terms in the contract. This page is editorial and does not rank providers by payment.