Replicate
Run and fine-tune thousands of open-source AI models with one line of code via a cloud API, billed per second of GPU or CPU compute
Python-first serverless platform for running, deploying, and fine-tuning AI models on GPUs, billed per second with scale-to-zero and no idle charges
Modal is a Python-first serverless platform for running AI and GPU workloads, billed per second with no charge while idle. The Starter plan is free with $30 per month in compute credits; an Nvidia H100 runs $0.001097/sec (about $3.95/hour) and an A100 80GB $0.000694/sec. The Team plan adds a $250/month base fee plus $100 in credits. Best for developers deploying model inference, fine-tuning, or batch jobs without managing GPUs.
Modal is a serverless cloud platform for running AI and GPU workloads from Python. Instead of provisioning servers, writing Dockerfiles, or managing a Kubernetes cluster, you write ordinary Python functions locally, annotate them to declare the hardware and dependencies they need, and deploy them to the cloud with a single command. Modal handles the container build, scheduling, autoscaling, and networking, spinning containers up on demand and scaling them back to zero when traffic stops. The catalog of hardware spans CPU-only containers up through Nvidia T4, L4, A10, L40S, A100, H100, H200, and Blackwell B200 and B300 GPUs, all available on-demand with no reservations.
Billing is usage-based and granular. You pay per second for the CPU ($0.0000131/core/sec), memory ($0.00000222/GiB/sec), and GPU your code actually uses — an H100 is $0.001097/sec (about $3.95/hour) and an A100 80GB is $0.000694/sec — plus $0.09/GiB/month for storage volumes, with the first 1 TiB each month free. The Starter plan is free and includes $30/month in compute credits; the Team plan is $250/month with $100 in credits and higher concurrency limits; Enterprise is custom. Because functions scale to zero, workloads that receive no traffic cost nothing, and the platform advertises sub-second cold starts and scaling from zero to 1000+ GPUs.
Modal suits developers and ML teams who want to run production AI workloads — inference, training, or batch jobs — without becoming infrastructure engineers, and who are comfortable working entirely in Python. It trades the lowest-possible raw compute cost and language flexibility for a fast path from local code to autoscaling GPU deployment.
Starting price: Free + usage · Free tier: yes · Model: usage-based
Price history tracked from June 2026
| Plan | Price | Includes |
|---|---|---|
| Starter | Free + compute | $30/month in free compute credits · Pay-per-second billing; functions scale to zero when idle · Up to 100 containers and 10 concurrent GPUs · No capacity reservations or long-term commitments |
| GPU (per second) | $0.000164–$0.001972/sec | Nvidia T4 $0.000164/sec, L4 $0.000222/sec, A10 $0.000306/sec · A100 40GB $0.000583/sec; A100 80GB $0.000694/sec (about $2.50/hr) · H100 $0.001097/sec (about $3.95/hr); H200, B200, B300 also available |
| CPU & memory | from $0.0000131/core/sec | CPU $0.0000131/core/sec (minimum 0.125 cores per container) · Memory $0.00000222/GiB/sec · Storage volumes $0.09/GiB/mo with 1 TiB/month free |
| Team | $250/mo | $100/month in free compute credits · Up to 1000 containers and 50 concurrent GPUs · Team workspaces and role-based access · Per-second compute billed on top of the base fee |
| Enterprise | Custom | Custom container and GPU concurrency limits · Volume discounts and dedicated support · SSO, security reviews, and compliance controls |
| Pros | Cons |
|---|---|
| Python-native workflow — no Dockerfiles or Kubernetes to run GPU serving | Python-only SDK — no first-class support for other languages |
| Granular per-second billing with true scale-to-zero, so idle workloads cost nothing | Per-second, per-resource pricing (compute plus memory plus GPU) makes total cost hard to predict for variable workloads |
| Broad, current GPU selection including H100, H200, and Blackwell B200/B300, on-demand with no reservations | The Team plan carries a $250/month base fee on top of usage, a step up from pay-as-you-go-only rivals |
| Free Starter plan includes $30/month of compute credits to evaluate real workloads | Serverless model means you build on Modal's runtime and primitives rather than portable infrastructure |
| Transparent per-second CPU, memory, and GPU rates published on the pricing page |
Run and fine-tune thousands of open-source AI models with one line of code via a cloud API, billed per second of GPU or CPU compute
Usage-based inference cloud for generative media — 1,000+ image, video, and audio model APIs (FLUX, Kling, Veo) plus serverless GPUs from $1.89/hour
AI cloud for running, fine-tuning, and deploying open-source models via serverless inference and on-demand GPU clusters
Ultra-fast, low-cost inference for open models on custom LPU chips (groq.com — not xAI's Grok)
Modal's Starter plan is free to join and includes $30 per month in compute credits. Beyond the credits you pay per second for the CPU, memory, and GPU your code actually uses, and idle functions scale to zero and cost nothing.
An Nvidia H100 is $0.001097 per second, about $3.95 per hour. Billing is per second, so a job that runs 14 seconds is billed for 14 seconds with no idle charges.
Modal offers Nvidia T4 ($0.000164/sec), L4, A10, L40S, A100 40GB, A100 80GB ($0.000694/sec), H100 ($0.001097/sec), H200, and Blackwell B200 and B300, all on-demand with no reservations.
It is usage-based. You pay per second for CPU ($0.0000131/core/sec), memory ($0.00000222/GiB/sec), and GPU by type, plus $0.09/GiB/month for storage volumes. The Team plan adds a $250/month base fee, and Enterprise is custom.
Modal is Python-first. You write ordinary Python functions locally, decorate them to define hardware and dependencies, and deploy to the cloud via the CLI or SDK. There is no first-class SDK for other languages.
The Starter plan is free with $30/month in credits, up to 100 containers and 10 concurrent GPUs. The Team plan is $250/month with $100 in credits, up to 1000 containers and 50 concurrent GPUs, plus team workspaces and role-based access.
Common uses are deploying model inference endpoints, fine-tuning and training models, running GPU batch jobs like embeddings or document parsing, and spinning up isolated sandboxes for AI-agent or untrusted code.