# What are the best serverless GPU platforms in 2026? > Modal, RunPod, Baseten, Replicate, Cerebrium, Cloud Run and Nodus compared by workload, with list prices and one 10-hour H100 job priced on each. Source: https://www.nodus-compute.ai/blog/best-serverless-gpu-platforms-2026/ Build revision: 72a1aac0631976a73d4d18282842b803b7a96bac The best serverless GPU platform in 2026 depends on whether someone is waiting for the GPU: Modal or RunPod Serverless for endpoints a user waits on, and Nodus for training, fine-tuning and batch jobs that run for hours. Nodus lists an NVIDIA H100 at $2.60/hr on its [pricing page](https://www.nodus-compute.ai/pricing/) and restores your latest checkpoint on a new machine when capacity is reclaimed, so a long job costs less and survives an interruption. Baseten, Replicate, Cerebrium and Google Cloud Run GPUs each fit a narrower case, and the decision rules in this post say which. We build Nodus, so weigh that. Every outside number links to the company’s own page, and there is a section on where each of the others is the better pick. ## What makes a GPU platform serverless? A serverless GPU platform starts your container on a GPU when work arrives, bills while it runs and lets the GPU go when things are quiet. The platforms differ in the details that decide the bill: how fast a cold worker gets ready, how long an idle worker stays billed, and how long one run may last. Those details split the field in two. Endpoint platforms tune for start time, because a person is waiting on the first token or image. Job platforms tune for price per GPU-hour and for finishing, because a run that dies at hour eight wastes eight hours of GPU time. ## How do the main serverless GPU platforms compare? The table lists what each company publishes on its own pages. Start times are the vendor’s own claims, measured in different ways, so treat them as a guide rather than a benchmark. |Platform|Built for|NVIDIA H100|NVIDIA L4|Billing|Start time the vendor states| |-|-|-|-|-|-| |[Modal](https://modal.com/pricing)|Python functions, web endpoints, batch|$0.001097/s ($3.95/hr)|$0.000222/s ($0.80/hr)|Per second; idle containers billed for 60 s by default|Sub-second starts on large custom images ([homepage](https://modal.com/))| |[RunPod Serverless](https://www.runpod.io/serverless-gpu)|Container endpoints|$5.39/hr flex worker (H100 PRO)|$0.75/hr flex worker (24 GB class, includes L4)|Per second, rounded up; 5 s idle timeout by default ([docs](https://docs.runpod.io/serverless/pricing))|Under 200 ms with FlashBoot| |[Baseten](https://www.baseten.co/pricing/)|Production model serving and training|$0.10833/min ($6.50/hr)|$0.01414/min ($0.85/hr)|Per minute, including deploy and scaling time|“Fast cold starts”, no figure| |[Replicate](https://replicate.com/pricing)|Public models by API, custom models with Cog|$0.001525/s ($5.49/hr)|Not listed|Per second; most private models also pay for setup and idle time|Not stated| |[Cerebrium](https://www.cerebrium.ai/pricing)|LLM, voice and image apps|$0.000944/s ($3.40/hr)|$0.000222/s ($0.80/hr)|Per second; CPU and memory billed separately|Not stated| |[Google Cloud Run GPUs](https://cloud.google.com/run/docs/configuring/services/gpu)|Containers on Google Cloud|Not offered (L4 and RTX PRO 6000 only)|$0.0001867/s ($0.67/hr) ([pricing](https://cloud.google.com/run/pricing))|Per second, instance-based; an L4 needs at least 4 vCPU and 16 GiB|About 5 s| |[Nodus](https://www.nodus-compute.ai/pricing/)|Training, fine-tuning, batch, Python Functions|$2.60/hr|$0.43/hr|Prepaid credit; each run holds funds before it starts|A cold and warm start estimate per Function, before you run| Prices checked October 29, 2026. Hourly figures in brackets convert the listed per-second or per-minute rate; Modal, Cerebrium and Cloud Run bill CPU and memory on top of the GPU, and Cloud Run’s L4 rate is the non-zonal-redundancy price. RunPod’s endpoint docs show lower per-second rates for some tiers; we used the rates on its pricing page. ## Which serverless GPU platform should you pick for each workload? Match the platform to who is waiting and for how long. ### Someone is waiting on the response Pick RunPod Serverless or Modal. RunPod states sub-200 ms cold starts with FlashBoot, deploys any container, and by default keeps an idle worker for only 5 seconds before it scales down. Modal fits better when your service is Python: it states sub-second starts on large custom images and bills per second, with a 60-second keep-alive that you can change. Pick Baseten if you want a managed inference stack and per-minute billing is fine for your traffic. Pick Cloud Run if the rest of your app already lives on Google Cloud and an L4 or RTX PRO 6000 is enough. Google states instances start in about 5 seconds. ### Traffic is steady all day Skip scale-to-zero and pay for warm capacity on purpose. Serverless rates price in the freedom to drop to zero, which you never use if the GPU is busy around the clock. RunPod offers always-on active workers with discounts through sales, and a Nodus Function’s `min_workers` setting keeps workers warm at the Function’s worker rate. Compare that monthly bill with a reserved option before you commit. ### The job runs for hours Pick Nodus. For training, fine-tuning and continued pretraining, the price of a GPU-hour and what happens on an interruption matter far more than a fast first request. Your script writes its state to `/nodus/state`. Nodus checkpoints it at least four times over the expected run time and restores the latest copy into a new attempt if the machine is lost. The endpoint platforms can run long jobs too, within limits they publish. Modal caps one execution at [24 hours](https://modal.com/docs/guide/timeouts) and makes Functions [preemptible by default](https://modal.com/docs/guide/preemption), restarting an interrupted one on the same input. RunPod Serverless gives each endpoint a [10-minute execution timeout](https://docs.runpod.io/serverless/endpoints/endpoint-configurations) by default, configurable up to 7 days, and one GPU per worker unless you raise it. ### A batch job where nobody waits Embedding a corpus or scoring a dataset overnight has the same economics as training, so choose on price per GPU-hour and on resuming, not on cold starts. On Nodus, a Job with `Restartable` continuity keeps the progress counter you report, so a replacement attempt can skip the items already done. A Function’s `.map()` fans one function out over thousands of inputs. Modal is a good fit too if your code already runs there: its [batch processing guide](https://modal.com/docs/guide/batch-processing) scales functions to thousands of parallel containers. ### You only need to call an open model You may not need a GPU platform at all. Baseten’s Model APIs, Replicate’s public models and Nodus Inference (Beta), which speaks the OpenAI API format, charge per token or per prediction, so you never size a worker. ## What does the same GPU work cost on each platform? At list prices, a 10-hour job on one H100 ranges from $26.00 on Nodus to $65.00 on Baseten. We priced a LoRA fine-tune that needs 10 hours on one NVIDIA H100, which is 36,000 GPU-seconds or 600 GPU-minutes, at each platform’s listed H100 rate from the table: * Nodus: 10 h × $2.60 = $26.00 * Cerebrium: 36,000 s × $0.000944 = $33.98 * Modal: 36,000 s × $0.001097 = $39.49 * RunPod Serverless: 10 h × $5.39 = $53.90 * Replicate: 36,000 s × $0.001525 = $54.90 * Baseten: 600 min × $0.10833 = $65.00 ![Cost of 10 H100-hours at list GPU rates: Nodus $26.00, Cerebrium $33.98, Modal $39.49, RunPod Serverless $53.90, Replicate $54.90, Baseten $65.00.](https://www.nodus-compute.ai/blog-charts/best-serverless-gpu-platforms-2026/h100-10-hours.svg) *The same 10 H100-hours cost 34% less on Nodus than on Modal at list rates, before Modal adds CPU and memory.* This counts the GPU line only: Modal and Cerebrium add CPU and memory on top, and cold starts and idle windows are seconds on a 10-hour job. The ratios hold per GPU-hour, so eight GPUs scale the same way. For a small model served on an L4, the gap is smaller in dollars but similar in shape. Nodus lists the L4 at $0.43/hr, against $0.67 on Cloud Run before its required CPU and memory, $0.75 on RunPod Serverless, $0.80 on Modal and Cerebrium, and $0.85 on Baseten. ![Listed L4 rate per hour: Nodus $0.43, Cloud Run $0.67, RunPod Serverless $0.75, Modal $0.80, Cerebrium $0.80, Baseten $0.85.](https://www.nodus-compute.ai/blog-charts/best-serverless-gpu-platforms-2026/l4-hourly.svg) *On an L4 the price spread is cents per hour, so cold-start behavior usually decides an endpoint, not the rate.* ## What happens to the bill when a long run is interrupted? An interruption costs whatever work you have to redo, and that can outweigh any rate difference. Take the same 10-hour job, lose the machine at hour 8, and price every case at $2.60/hr so only the recovery changes: * No interruption: 10 GPU-hours = $26.00 * Checkpoint every 30 minutes: at most 0.5 hours redone, 10.5 GPU-hours = $27.30 * No checkpoint: 8 hours lost plus a 10-hour rerun, 18 GPU-hours = $46.80 ![Cost of a 10-hour H100 job at $2.60/hr: $26.00 with no interruption, $27.30 if lost at hour 8 with 30-minute checkpoints, $46.80 if lost at hour 8 with no checkpoint.](https://www.nodus-compute.ai/blog-charts/best-serverless-gpu-platforms-2026/interruption-cost.svg) *Without a checkpoint, one lost machine at hour 8 nearly doubles the bill.* Any platform here can resume if your code saves to persistent storage and reloads it on start, as [Modal’s preemption guide](https://modal.com/docs/guide/preemption) recommends for training; the difference is who does the plumbing. On a reclaim notice, Nodus asks your program for an urgent checkpoint and prepares a replacement machine. The replacement starts only once the old one is provably gone, so two copies never write the same checkpoint ([attempts and recovery](https://www.nodus-compute.ai/docs/concepts/attempts-and-recovery/)). If the old machine comes back first, the replacement is released and you are not charged for it. Our [guide to surviving spot preemption](https://www.nodus-compute.ai/blog/resume-training-after-spot-preemption/) walks through the checkpoint code. ## Can Nodus serve a latency-sensitive endpoint? Partly, and we would not pick it first for that today. Nodus Functions scale with demand: `min_workers` defaults to 0, so a Function scales to zero, and `max_workers` goes up to 1,000. An idle worker leaves after its `scaledown_window`, 1 minute by default and up to 20 ([scaling docs](https://www.nodus-compute.ai/docs/guides/functions/scaling/)). Before you deploy, `.estimate()` reports the expected cold and warm start bands for that Function. What Nodus does not publish is a fixed cold-start figure, and hosted Inference is still in Beta. If first-request latency is the metric your product lives or dies on, start with RunPod Serverless or Modal, which publish start times, and test Nodus against them with your own model. ## Where are Modal, RunPod and the others the better choice? Each of them beats Nodus somewhere specific. * Modal is the better choice for Python web endpoints that need quick container starts and per-second billing, and its Starter plan includes [$30 of compute credit a month](https://modal.com/pricing). * RunPod Serverless is the better choice when cold start is everything: it [states](https://www.runpod.io/serverless-gpu) sub-200 ms starts with FlashBoot, and deploys straight from GitHub with rollbacks. * Baseten is the better choice for teams that want a managed production inference platform; its [pricing page](https://www.baseten.co/pricing/) lists SOC 2 Type II and HIPAA compliance and a self-hosted option on Enterprise. * Replicate is the better choice for calling public models through an API without deploying anything, and its [fast-booting fine-tunes](https://replicate.com/pricing) bill only active time. * Cloud Run is the better choice if you already run on Google Cloud and an L4 or RTX PRO 6000 is enough, with [no GPU reservation](https://cloud.google.com/run/docs/configuring/services/gpu) to manage. * Cerebrium has the lowest per-second H100 rate among the endpoint platforms in our table, though [CPU and memory](https://www.cerebrium.ai/pricing) are billed on top. For a deeper head-to-head on the two most common picks, see [Modal vs RunPod](https://www.nodus-compute.ai/blog/modal-vs-runpod/). ## How do you move a long job from an endpoint platform to Nodus? Keep your training script and make it save to and load from `/nodus/state`. Then install the CLI, sign in, and run the same script with a spend cap. Add `--dry-run` first to see the estimate without starting paid compute. The commands are copied from the Nodus docs: Terminal window ```sh pip install nodus-compute nodus login nodus run --gpu H100 --image nodus/pytorch --checkpoint /nodus/state --max-cost 40 -d -- python train.py ``` The $40 cap leaves headroom over the $26.00 the job costs at the listed rate, and `nodus describe job/NAME` shows each attempt, the latest checkpoint and the cost so far. ## FAQ ### Is a serverless GPU cheaper than a dedicated one? Only when the GPU would otherwise sit idle. [Modal’s own pricing FAQ](https://modal.com/pricing) makes the same point: per-hour serverless rates can look higher, and the savings come from spiky or unpredictable traffic. If your GPU is busy most of the day, a lower hourly rate or reserved capacity wins. ### Do you pay for cold starts on serverless GPUs? Usually, yes, for the part where your code loads. [RunPod’s docs](https://docs.runpod.io/serverless/pricing) bill from worker start until your handler is ready, which is mostly loading the model into GPU memory, while image pulls and cached model downloads happen unbilled. [Modal](https://modal.com/pricing) bills application load time too, so smaller weights and lazy imports cut both latency and cost. ### Can you fine-tune a model on a serverless GPU platform? Yes. Nodus runs fine-tuning as a Job that resumes from its latest checkpoint, or through managed TrainingJobs (Beta) on the GPU you pick. Modal and RunPod Serverless also run training code, within the timeouts above. ### What happens on Nodus if credit runs out mid-run? Nodus is prepaid and renews a funded hold on your balance every 5 minutes while work runs. When a renewal cannot be funded, the run stops gracefully inside time already paid for, keeps what it saved, and can resume once you add credit.