Nov 6, 2026 - 9 min read

Modal bills a training run per second across three meters, GPU, CPU cores and memory, and multiplies the sum by 1.15x or 1.75x if you pin a region. Nodus lists the same NVIDIA H100 at $2.60/hr on its pricing page, against $3.95/hr for Modal’s GPU meter alone, and restores your checkpoint when a machine is reclaimed. On Modal, a preempted run that starts over is billed again, so checkpointing is part of the price.

This post breaks a Modal training bill into its parts, prices two ordinary fine-tuning runs line by line, and shows which settings move the total. Every Modal number comes from Modal’s pricing page or its docs, and the arithmetic is shown once so you can redo it with your own job.

What does Modal charge for while a training job runs?

Modal bills each running container for three things at once. The GPU meter is the big one, and CPU and memory are charged on top of it, per second, at the amounts you request or actually use, whichever is higher.

Meter	Modal list rate	Per hour
NVIDIA H100 SXM	$0.001097 / sec	$3.9492
NVIDIA B200	$0.001736 / sec	$6.2496
NVIDIA A100 80 GB	$0.000694 / sec	$2.4984
CPU, per physical core (2 vCPU)	$0.0000131 / sec	$0.04716
Memory, per GiB	$0.00000222 / sec	$0.007992
Volumes	$0.09 per GiB-month, first 1 TiB free
Network egress	$0.04 per GiB beyond the plan’s included amount

Prices checked November 6, 2026, from modal.com/pricing. Hourly figures are the per-second rates times 3,600.

Two details on that page are easy to miss. Each container has a minimum request of 0.125 cores and 128 MiB, and you pay for the higher of what you request and what you use. Modal also says it may run a gpu="H100" request on an H200, or a gpu="A100" request on an 80 GB A100, without changing the price. A gpu="B200+" request is billed as B200 even when it lands on a B300 (GPU guide).

What does a full Modal bill look like for a fine-tuning run?

A single-GPU LoRA fine-tune shows how the meters add up. We priced one H100 for 8 hours with 8 physical cores and 64 GiB of memory, an assumed shape for a 7B to 13B model with a data loader running alongside.

Line	Arithmetic	Cost
GPU	$3.9492 x 8 h	$31.59
CPU	8 cores x $0.04716 x 8 h	$3.02
Memory	64 GiB x $0.007992 x 8 h	$4.09
Modal total, no region set		$38.70
Same run pinned to us (1.15x)	$38.70 x 1.15	$44.51
Same run pinned to us-west (1.75x)	$38.70 x 1.75	$67.73

The CPU and memory lines add more than a fifth to the GPU line here. They grow with the request, not the GPU count, so a job that asks for 32 cores “to be safe” pays for 32.

A narrow region pin turns a $38.70 run into $67.73 before anything goes wrong, more than three times the Nodus listed rate.

The region multiplier is the line that surprises people. Modal’s region selection guide applies 1.15x to broad regions like us and 1.75x to narrow ones like us-west, on the GPU, CPU and memory together. With no region set there is no multiplier, so only pin a region when data residency or latency actually needs it.

How does a multi-GPU fine-tune scale on Modal?

The meters scale linearly, so a full fine-tune on 8 B200s is the same formula with bigger inputs. We used 8 x B200 for 12 hours, 64 cores and 512 GiB of memory.

• GPU: $6.2496 x 8 GPUs x 12 h = $599.96
• CPU: 64 cores x $0.04716 x 12 h = $36.22
• Memory: 512 GiB x $0.007992 x 12 h = $49.10
• Total with no region: $685.28; pinned to us: $788.08; pinned to us-west: $1,199.25

On the Starter plan, that one job also uses 8 of your 10 concurrent GPUs, so a second experiment waits. The Team plan raises the limit to 50 GPUs for $250 a month, which includes $100 of compute credit, so the plan costs $150 a month net before you train anything.

What happens to the bill when a Modal run is preempted?

You pay for the lost work again. Modal’s preemption guide says all Functions are preemptible by default, that the non-preemptible option is not supported for GPU Functions, and that an interrupted Function restarts on the same input. Unless your code saved a checkpoint and reloads it, the restart begins at step zero.

Take the 8-hour H100 run above and interrupt it at hour 5. Without a checkpoint, the 5 hours rerun at the same $4.84/hr ($38.70 / 8 h), which adds $24.19 and brings the job to $62.89. If your code saves every 30 minutes and reloads on start, you lose at most half an hour, or $2.42, for $41.12 in total.

Checkpointing is a billing decision on Modal, not only a reliability one.

The guide also warns that the chance of interruption grows with run length. Our decision rule: if a Modal training run lasts more than an hour, write a checkpoint to a Volume at least every 30 minutes and load it on start. Checkpoint storage is cheap next to the rerun: the first 1 TiB of Volumes is free, and 2 TiB of checkpoints costs 1,024 GiB x $0.09, or $92.16 a month.

Is there a time limit on a single Modal training call?

Yes, 24 hours per execution attempt. Modal’s timeouts guide sets a default of 5 minutes and allows up to 24 hours, so a training Function must set timeout explicitly. A longer run continues through modal.Retries, and each retry is a new attempt with its own timeout and its own billed time.

That matters for pricing because a stuck job is billed until the timeout ends it. An infinite loop with a 24-hour timeout on 8 B200s costs 24 x 8 x $6.2496, or $1,199.92 in GPU time alone. Set the timeout close to the run’s expected length, and set a workspace budget as the monthly backstop.

How does the same run price on Nodus?

Nodus quotes compute per machine instead of per meter, so a GPU’s hourly rate already includes the CPU and memory that come with it. The H100 SXM is listed at $2.60/hr on the Nodus pricing page and the B200 at $5.50/hr, and our docs say the rate is frozen when capacity is acquired (usage and costs).

On Blackwell the list-rate gap is smaller, but CPU, memory and region still sit on top of Modal’s GPU meter.

Run	Modal (GPU + CPU + memory, no region)	Nodus (listed machine rate)
1 x H100, 8 h	$38.70	$2.60 x 8 = $20.80
8 x B200, 12 h	$685.28	$5.50 x 8 x 12 = $528.00

Nodus also records boot and teardown segments in each run’s cost, so the final bill is not the bare rate times hours. The honest way to compare is to price your exact job first. A dry run returns the estimate and any blockers without starting anything (GPU guide):

nodus run --name lora-h100 --gpu H100-SXM --image nodus/pytorch \
  --max-cost 25 --timeout 9h --checkpoint /nodus/state --dry-run \
  -- python train.py

The checkpoint behaves differently too. When the capacity under a Nodus Job is reclaimed, the next attempt starts with the job’s state directory restored. By default Nodus takes at least four checkpoints over the expected run time (checkpoints guide). A --max-cost cap checkpoints and suspends the job at the limit instead of killing it, and raising the cap resumes it (Budgets).

When is Modal’s pricing the better deal?

Modal is the better deal for bursty work. Its per-second billing and fast container starts mean short jobs, evaluation fan-outs and inference endpoints that scale to zero pay for very little idle time. If your training calls are minutes long and sit next to Modal web endpoints, the free $30 a month on Starter can cover real experiments.

Modal also wins when you want its plan features: environment-level budgets and deployment rollbacks on Team, and paying with committed cloud spend on Enterprise. For long, GPU-bound runs where the hourly rate dominates, the meters above add up faster, and that is where we built Nodus to be cheaper. Our Nodus vs Modal comparison covers the feature side, and the fine-tuning benchmark shows one measured run on both.

FAQ

Does Modal charge for cold starts?

Modal bills per second while a container is running, and its pricing page contrasts its 1 to 2 second container starts with the 10+ minute provisioning of fixed instances. Time spent loading your model and importing libraries inside the container is running time, so it is billed.

Is Modal’s free tier enough to fine-tune a model?

Sometimes. Starter includes $30 of compute a month, which covers about 7.6 hours of one H100 at the GPU rate alone, before CPU and memory. New Nodus organizations get a one-time $30 starter credit that expires after 30 days (credits).

Are Modal Sandboxes priced like Functions?

No. Sandboxes bill CPU and memory at Modal’s non-preemptible rates, three times the list price, according to the pricing page. That matters for coding agents that run training inside a Sandbox instead of a Function.

Does Modal charge for downloading checkpoints after training?

Only past your plan’s included egress: 1 TiB a month on Starter, 10 TiB on Team, then $0.04 per GiB (pricing page). Pulling 2 TiB of checkpoints off Modal in a month on Starter costs 1,024 GiB x $0.04, or $40.96.

Which Modal alternatives are cheaper for long runs?

We compared the main options, with one 80 GPU-hour run priced on each, in the best Modal alternatives in 2026. Nodus is the closest swap for Python training jobs.

Tags:

• pricing
• modal
• fine-tuning
• training

How do coding agents run jobs that take hours, not minutes?

What is an MCP server, and how can it give agents GPUs?