Oct 25, 2026 - Last update: Nov 10, 2026 - 12 min read

For short or bursty fine-tuning written in Python, Modal is the smoother fit, and for long runs where you want SSH, a fixed machine and a lower hourly rate, RunPod usually costs less. If you want Modal’s Python API at close to RunPod’s price, Nodus is the third answer: it lists an NVIDIA H100 at $2.60/hr on the Nodus pricing page and restores your checkpoint on a new machine if capacity is reclaimed. Underneath, Modal runs your Python functions on GPUs it manages, while RunPod gives you a GPU machine (a Pod) that you keep running and control yourself.

We build Nodus, so we kept the head-to-head strictly to Modal’s and RunPod’s own pricing and docs pages, linked throughout. The Nodus part is one short section near the end.

How do Modal and RunPod compare at a glance?

The core difference is the unit you pay for. On Modal it is a function call that starts and stops with your code. On RunPod it is a machine that runs until you stop it.

	Modal	RunPod
What you run	Python functions decorated with @app.function	Pods (full containers with SSH and Jupyter), Serverless endpoints, Instant Clusters
Billing	Per second for GPU, plus CPU cores and memory billed separately	Per second; a Pod’s listed rate includes its vCPUs and RAM
Plans	Starter $0 with $30/month credit; Team $250/month with $100/month credit	Pay as you go; default spend limit of $80/hour
GPUs	T4 up to B300, up to 8 per container	RTX A5000 up to B300 on Pods, in Secure Cloud or Community Cloud
Cold starts	Containers boot in about a second, before imports and model loading	Pods have none once running; Serverless workers use FlashBoot
Interruption	GPU Functions are preemptible and cannot opt out	On-demand Pods cannot be displaced by other users
Longest single run	24 hours per Function call	Pods run until stopped; Serverless jobs up to 7 days
Multi-node	Up to 32 nodes and 256 GPUs, 3,200 Gbps RDMA (6,400 on B300)	Instant Clusters of 2 to 8 nodes (16 to 64 GPUs), larger through sales
Persistent storage	Volumes at $0.09/GiB/month, 1 TiB/month free	Network volumes at $0.07/GB/month under 1 TB
Coding agents	modal skills install adds Modal’s agent skills	Hosted MCP server at mcp.runpod.io

Sources: Modal pricing, Modal GPUs, cold starts, preemption, timeouts, multi-node clusters, modal skills; RunPod pricing, Pod pricing, Pods overview, Serverless endpoint settings, Instant Clusters, MCP servers. Checked November 10, 2026.

Which is cheaper for the same fine-tuning job?

RunPod is cheaper on listed rates for a plain multi-GPU run, and the gap depends on which RunPod tier you pick. To show it, we priced one job on public rates: a full fine-tune on 8 x NVIDIA H100 SXM for 10 hours, which is 80 GPU-hours.

Where it runs	Listed H100 rate	80 GPU-hours
Modal	$3.9492/hr	$315.94, plus CPU and memory
RunPod Pod, Secure Cloud	$3.99/hr	$319.20
RunPod Pod, Community Cloud	$2.69/hr	$215.20
RunPod Serverless (H100 PRO)	$5.39/hr	$431.20
Nodus	$2.60/hr	$208.00

Prices checked November 10, 2026: Modal’s $0.001097 per second converted to hourly from Modal pricing; RunPod’s per-GPU Pod and Serverless rates from RunPod pricing; the hourly rate listed on the Nodus pricing page.

Modal’s GPU rate does not include the CPU and RAM around it. If the job asks for 16 physical cores and 128 GiB of memory, Modal’s listed rates add (16 x $0.04716 + 128 x $0.007992) x 10 hours = $17.78, for $333.71 in total. A RunPod Pod’s rate already includes its listed vCPUs and RAM, so the Secure Cloud figure is close to the full bill apart from disk.

Once Modal’s CPU and memory are counted, it lands above RunPod Secure Cloud; the cheap end of the chart is RunPod Community Cloud and Nodus.

Two caveats change the picture. Secure Cloud and Modal land within a few dollars of each other, so the real RunPod saving comes from Community Cloud. RunPod describes Community Cloud as individual compute providers connected through a vetted peer-to-peer system (Pods overview).

A Pod also bills the whole time it runs, whether your script is training or you are reading logs. An idle 8 x H100 Pod at Secure Cloud rates costs $31.92 an hour. Modal’s pricing page says you pay only for compute time, never for idle resources (Modal pricing).

Do cold starts matter for training?

Barely, for a run measured in hours. A few seconds or even a minute of startup is noise against a 10-hour job. Cold starts matter when you run many short calls, such as a hyperparameter sweep of 200 five-minute trials.

Modal says its containers boot in about one second, and that the slow part is usually your imports and model loading (Modal cold starts). That makes Modal pleasant for sweeps, because each trial is a function call and nothing sits idle between them.

RunPod Pods have no per-call cold start because the machine stays up. You pay for that with idle time. RunPod Serverless does have cold starts, billed from when a worker starts until your handler is ready. Image pulls and cached model downloads normally happen while the worker is scaled down and are not billed, and FlashBoot is on by default for new endpoints (Serverless pricing).

What happens if the GPU is interrupted mid-run?

This is the biggest practical difference for training. Modal can interrupt a GPU function and restart it; a RunPod on-demand Pod is not displaced by other users.

Modal states that every Function is preemptible by default, that the chance rises with run length, and that the nonpreemptible flag is not supported for GPU Functions. When a preemption happens, Modal restarts the Function on the same input (Modal preemption). Its long-training example handles this with checkpoints written to a Volume and retries that resume from the latest one.

RunPod’s Pod pricing docs say on-demand resources are dedicated to your Pod and cannot be displaced by other users (Pod pricing). One thing to plan for: Pods stop when your account balance reaches $0, and a Pod without a network volume is terminated with its data unrecoverable.

On either platform, checkpoint. On 8 x H100 at Modal’s listed rate, losing 3 hours of work costs 3 x 8 x $3.9492 = $94.78. At RunPod Secure Cloud rates the same loss is $95.76, and at Community Cloud rates it is 3 x 8 x $2.69 = $64.56.

Three lost hours add 30% to the bill for a 10-hour run, so how often you checkpoint matters as much as the hourly rate.

Can a single run last longer than 24 hours?

On RunPod, yes, directly. On Modal, only through retries.

A Modal Function call has a maximum timeout of 24 hours, and each retry starts a fresh timeout (Modal timeouts). A three-day pretraining run on Modal is therefore a chain of calls that resume from checkpoints. It works, but your code has to be built for it.

A RunPod Pod has no run-length limit in its docs; it runs until you stop it or your balance hits zero. RunPod Serverless jobs have a default execution timeout of 10 minutes that you can raise to 7 days (endpoint settings).

Which handles storage and multi-node training better?

Modal is stronger for large multi-node jobs; RunPod is simpler when you want a disk that behaves like a disk.

For multi-node, Modal clusters go up to 32 nodes and 256 GPUs with RDMA at 3,200 Gbps, or 6,400 Gbps on B300. Nodes are gang-scheduled and colocated, and each node must use all of its GPUs (Modal multi-node clusters). RunPod Instant Clusters run 2 to 8 nodes (16 to 64 GPUs) at 1,600 to 3,200 Gbps, with up to 512 GPUs through sales (Instant Clusters). RunPod’s pricing page lists Instant Cluster GPUs at $4.79/GPU/hr for H100 SXM and $6.35/GPU/hr for H200 SXM (RunPod pricing).

For storage, Modal Volumes cost $0.09/GiB/month with 1 TiB/month included (Modal pricing), and writes must be committed to persist (Modal Volumes). RunPod network volumes cost $0.07/GB/month under 1 TB and attach to any Pod or Serverless endpoint (Pod pricing). Keeping 500 GB of checkpoints for a month is $35 on a RunPod network volume and fits inside Modal’s included terabyte. Modal charges $0.04/GiB for network egress past your plan’s allowance; RunPod Pods have no ingress or egress fees.

Is RunPod as Python-first as Modal now?

It is getting closer. RunPod’s runpod Python package now includes a decorator-based app SDK with .remote() calls and a local entrypoint, which looks a lot like Modal (RunPod Python SDK). It needs runpod 2.0 or later, and those functions run on RunPod Serverless.

Modal’s SDK is more mature for training work today: GPU strings like H100:8, Volumes, retries and clustered functions all live in one decorator. If you want to SSH into a box, run torchrun by hand and watch nvidia-smi, a RunPod Pod is the more natural tool.

Where is each one the better choice?

Pick Modal when your training is one part of a Python application. It fits sweeps of many short jobs, pipelines that call training from other functions, teams that want web endpoints next to training code, and multi-node runs larger than 8 nodes with guaranteed RDMA.

Pick RunPod when you want the cheapest plain machine and you are comfortable managing it. It fits interactive debugging over SSH or Jupyter, runs longer than 24 hours without retry plumbing, and budget work on Community Cloud.

Neither is the right choice if you never want to think about either problem: Modal leaves restart handling to your code, and RunPod leaves idle time and machine management to you.

Is there an option that combines both?

Yes. Nodus is an AI compute platform with Modal’s Python API. It places each run on the cheapest capacity that will finish it, and restores your checkpoint on a new machine if the old one is reclaimed. In practice that means Modal’s developer experience at a listed H100 SXM rate of $2.60/hr on the Nodus pricing page, close to RunPod Community Cloud, without managing a Pod.

Moving a Modal app is mostly an import change. App, .remote(), .map(), .spawn(), Image, Volume and Secret keep their names, and Nodus adds a few arguments Modal does not have (Nodus for Modal users):

@app.function(
    gpu="H100",
    checkpoint="/nodus/state",  # files here are saved and restored if capacity is reclaimed
    interruptible=True,      # allow cheaper interruptible capacity; progress is kept through the checkpoint
    region=["us", "eu"],     # region classes, not provider regions
)
def train(lr: float) -> dict: ...

print(train.estimate(3e-4))  # dry-run: expected cost, cold and warm start, the hold it needs

pip install nodus-compute
nodus login
nodus run app.py

A Function does not take a dollar cap yet: max_cost on a Function is refused when you deploy (Function spending controls). For a hard cap on a training run, launch the script as a Job instead, for example nodus run --gpu H100 --interruptible --max-cost 40 -d -- python train.py.

Your script writes its state to /nodus/state and loads it on start; Nodus decides when to checkpoint and restores that directory on the next attempt. Long training can run as a Job rather than a 24-hour function call.

We have measured this against Modal, not just priced it. In a small pilot with Qwen2.5-0.5B on one NVIDIA L4, Nodus produced byte-identical weights to Modal for 67% lower charges on the successful run. Counting a failed Nodus attempt, the saving was 24.7% (fine-tuning benchmark). That was one seed and one accepted run per platform, so treat it as a pilot, not a promise.

Nodus has real gaps. Multi-node training is in Beta and capped at 8 nodes, and Modal web endpoints, modal.Dict and modal.Queue have no Nodus equivalent. If you already have RunPod credit, the Nodus docs list RunPod among the cloud accounts you can connect so single-node work runs there first (Beta, an organization setting; see cloud accounts). The full head-to-head is in Nodus vs Modal.

FAQ

Does RunPod charge for an 8 x H100 Pod per GPU or per machine?

The rate on RunPod’s pricing page is per GPU, so an 8-GPU Pod costs eight times the listed rate. You also need at least one hour’s worth of credits for the configuration before an on-demand Pod will deploy (Pod pricing).

Will RunPod’s default spend limit block a large training run?

It can. RunPod sets a default limit of $80/hour across all resources, which is about 20 H100 SXM GPUs at Secure Cloud rates, and you contact support to raise it (Pod pricing).

Does Modal’s free tier cover a fine-tuning experiment?

A small one. The Starter plan includes $30 of compute each month and caps GPU concurrency at 10, which covers roughly 7.6 hours of one H100 at the listed rate (Modal pricing).

Does pinning a region change the price on Modal?

Yes. Modal’s pricing page lists region selection at 1.15x to 1.75x base prices, so pin only when data residency requires it (Modal pricing).

Can I train on Modal and serve on RunPod, or the other way round?

Yes. Trained weights are ordinary files, so push them to your own bucket or the Hugging Face Hub at the end of training and pull them from the serving side. Budget for egress if the training side charges for it.

Which is cheapest for an 8 x H100, 10-hour fine-tune?

On the listed rates we checked on November 10, 2026, Nodus was lowest at $208.00 for the 80 GPU-hours, then RunPod Community Cloud at $215.20, Modal at $315.94 plus CPU and memory, and RunPod Secure Cloud at $319.20. Our Nodus vs RunPod comparison and RunPod alternatives guide show how a lost machine changes that math.

Tags:

• pricing
• comparisons
• modal
• runpod
• training

What is GRPO, and how do you run GRPO training on GPUs?

Nodus vs CoreWeave: which fits your training workload?