Comparison · Serverless GPUs

Modal alternative: serverless GPU options compared

Modal is the default recommendation for Python teams that want per-second GPU billing and a clean deploy story. The alternatives matter when you need a cheaper raw rate, a different packaging model, or no GPU operations at all. Here is the price and cold-start comparison, including the reserved-capacity break-even.

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

OptionDeployment modelH100 list priceBilling unitBest fit
ModalPython functions and containersAbout $3.95/GPU-hrPer secondPython-native serverless and bursty traffic
BasetenTruss packages and managed model APIs$6.50/GPU-hrPer minutePackaged models with a managed control plane
RunPodPods, serverless workers and clusters$4.39/GPU-hr Secure; from $2.69 CommunityPer secondLowest raw GPU rate and simple pods
ReplicateCog models and a public marketplacePer-second; check rate cardPer secondDemos and long-tail image/video models
Together AIServerless tokens, dedicated endpoints, clusters$5.49 dedicated; $3.99 clusterPer token or GPU-hourToken serving plus reserved clusters
FireworksServerless tokens, reserved throughput, GPUs$8.00/GPU-hrPer token or GPU-hourLow-latency serving and training
PlugskyOpenAI-compatible APIn/a (flat plans)Monthly planNo 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

  1. Containerise the model. Remove the Modal decorator from the critical path; keep the function logic.
  2. Reproduce the runtime. CUDA, Python, system libraries and model weights must match.
  3. Rebuild autoscaling. Concurrency, queue depth, warm floor and timeout are platform-specific.
  4. Move secrets and networking. Private endpoints, VPC peering and egress rules rarely port unchanged.
  5. Shadow traffic. Compare time to first token, tokens per second and error rate before cutover.
  6. 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

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.