RunPod vs Vast.ai (2026): Real H100 & A100 Effective Cost After Cold-Start, NVMe Storage & Bandwidth Billing

Posted on Oct 19 • Originally published at gpu.mybskm.top

On the sticker, Vast.ai rents H100 SXM capacity about 25% below RunPod's Community Cloud ($2.01 against $2.69) and A100 80GB about 26% below its Secure tier ($1.319 against $1.79). On the invoice, a two-hour model test is 63% more expensive on Vast and a 7×24 production node flips to RunPod above 5.4 TB/month of transfer — while a 72-hour preemptible fine-tune is still 52.8% cheaper on Vast. Same two providers, three different winners.

Affiliate disclosure (FTC): this article contains affiliate links for RunPod and Vast.ai. If you rent capacity through them, this site may earn a commission at no extra cost to you. That has no effect on the arithmetic, the ordering of the tables or which provider wins a scenario — the two links are worth the same, and one scenario below is deliberately won by each provider. Rates are a planning baseline captured from the providers' own APIs on 2026-10-18T16:37:25Z, not a quote; GPU markets move daily and host-set network rates vary per machine.

A pricing page shows one number per GPU: dollars per GPU-hour. Renting an H100 80GB looks like a comparison of $2.01 against $2.69, and the decision looks like arithmetic in one dimension. It is not, because the hourly rate is the only line item that both providers bill the same way.

The metric that reconciles all three is dollars per useful GPU-hour: the total invoice for a workload divided by the GPU-hours that actually produced work. It is the only number comparable across the two providers, and it moves in opposite directions depending on the workload shape.

effective $/useful GPU-hour = (gpu_hours_billed * hourly_rate + ingress_gb * in_rate + egress_gb * out_rate + storage_gb_month * storage_rate + reserve_for_interruption) / useful_gpu_hours Enter fullscreen mode Exit fullscreen mode Six dimensions, one table Dimension RunPod Vast.ai 1. H100 80GB / A100 80GB hourly rate H100 SXM $2.69 Community / $3.99 Secure. H100 PCIe $1.99 / $2.89.

A100 80GB SXM $1.39 / $1.79. A100 80GB PCIe $1.19 / $1.79. H100 SXM $2.01 verified on-demand sample.

H100 PCIe $2.002. A100 80GB SXM $1.319. A100 80GB PCIe $0.935.

Interruptible bids clear far lower, around 55–60% of on-demand. 2. Billing granularity & cold start Per-second billing.

FlashBoot serves a cached container image in roughly a minute when the image is already on the host, so a restart is cheap. Stopping a pod frees the GPU but keeps the volume. Per-second billing.

No cross-host image cache: a new host pulls the container from the registry again, and any weights not on a persistent volume are re-downloaded. Restarts land on a different physical machine by design. 3.

Network bandwidth billing $0 for pod ingress and egress. A 150 GB weight download and an API serving 6 TB a month cost nothing extra. Host-set, typically $0.01–$0.08/GB, and it applies to pulls as well as serving.

150 GB at $0.02/GB is $3.00 before the GPU does any work. 4. Persistent storage Network volume around $0.10/GB-month.

A 500 GB volume is $50/month whether the pod runs or is stopped, and it follows you between GPUs. Host local disk billed per GB-month at the host's rate, commonly $0.10–$0.20. Cheaper for short jobs, riskier for long ones: if the host reclaims the instance, the data is gone.

5. Preemption & physical reliability Secure Cloud runs in tier 3/4 datacenters with an uptime commitment; Community Cloud is shared inventory but still a single operator with a support path. A peer-to-peer marketplace of independent hosts.

Verified hosts are screened, unverified hosts are cheaper and less predictable. There is no SLA on a rented desktop, and a host can go offline mid-run. 6.

Best workload fit Anything that repeats: interactive notebooks, short tests, 24/7 inference, anything where a cold start is a tax you pay repeatedly. Anything that is long, batch, checkpointed and preemptible: fine-tunes, distillation, synthetic data generation, offline evaluation sweeps. Rates captured from the RunPod GraphQL catalog and the Vast.ai bundles API on 2026-10-18T16:37:25Z (HTTP 200 on both).

Vast figures are the lowest verified rentable single-GPU offers sampled, before host network and storage charges. Interruptible pricing and storage rates are vendor and host list values, not a quote.

This is the workload that produces the most misleading price comparison in the ecosystem, because the sticker says Vast is 25% cheaper and the invoice says the opposite.

Vast is cheaper on the only line most people compare — $4.02 against $5.38 of GPU time — and then loses $3.44 on transfer and cold start. The effective rate is 63% higher ($4.43 against $2.71) for a job that took two hours. If your test takes twenty minutes instead of two hours, the distortion gets worse: the transfer, image pull and cold start are fixed costs that do not shrink with job length, so the same 20-minute test carries $4.84 of overhead against $0.67 of GPU time.

The rule this scenario produces: if the job does not amortise a 150 GB transfer, the hourly rate is the wrong number to optimise. Rent the platform that already has the weights.

Now the same two providers for 730 hours a month, one H100 SXM, 500 GB of persistent data, and a serving surface that moves 6 TB a month. This is where RunPod's zero-rated network starts paying for the higher hourly rate, and where a peer-to-peer marketplace needs an availability reserve that a datacenter contract does not.

RunPod wins by $30.90 a month — a thin margin that exists only because of the reserve. Drop the 15% interruption reserve and Vast wins at $1,824.50 against $2,013.70. That is the honest version of this comparison: the two providers are within 2% of each other for a 24/7 node, and which one is cheaper depends on two inputs you control, not on the sticker.

The first input is transfer volume. Hold the other assumptions fixed and solve for the egress at which the two bills cross:

crossover_gb = (runpod_total - vast_fixed_costs) / vast_egress_rate = ($2,013.70 - $1,737.40) / $0.05 = 5,526 GB (~5.4 TB per month) Enter fullscreen mode Exit fullscreen mode Below about 5.4 TB a month, Vast's hourly discount survives the bandwidth bill. Above it, RunPod is cheaper — and the curve keeps diverging, because RunPod's marginal cost per extra terabyte is zero. A text-only vLLM endpoint moving a few hundred GB a month sits comfortably below the crossover and should probably stay on Vast if it can accept the availability risk. An endpoint that also distributes model artifacts, serves a public demo, streams large outputs, or hosts multimodal traffic crosses it quickly.

The second input is how much you are willing to pay for not being evicted. If a host disappears at 03:00 and your clients see 502s for forty minutes while you migrate a pod and re-pull weights, that event has a cost that no rate card contains. A 15% reserve is a crude way to price it. Teams with paying customers usually price it higher, and at that point RunPod Secure at $3.99 becomes the rational choice even though it is the most expensive hourly rate in this article.

The mirror image. Long, checkpointed, tolerant of a restart, and utterly indifferent to a cold start that happens twice in three days. This is the workload peer-to-peer GPU markets were built for.

Vast saves $314.52 on a single three-day run, and the saving is not a rounding error on the transfer bill: the transfer, storage and restart charges together add $24.63, which is 8.7% of Vast's total and still leaves it 52.8% cheaper. Two evictions costing twelve minutes each are priced in at $0.48, because a checkpointed batch job only loses the work since the last checkpoint.

One honest caveat. RunPod also sells preemptible capacity, and at roughly $1.50/GPU-hour the gap narrows to about $57.48 for this run. The wide margin in the table reflects the practical reality that three H100s of interruptible capacity are not always available on RunPod when you want to start, while a marketplace has thousands of independent sellers. If you can get RunPod spot immediately, the premium you are paying for a managed platform is small.

The A100 80GB version of the same job is cheaper again on both sides: at $1.319 on-demand and around $0.78 interruptible, 216 A100 GPU-hours for 72 hours cost $168.48 of GPU time and about $177 including weight transfer, and the gap to RunPod's $1.39 Community rate stays in the same proportion. For LoRA-scale fine-tuning of models that fit in 80 GB, A100 capacity is the value tier — H100 only pays when you need FP8 or the extra memory bandwidth.

Three costs are real, recurring, and absent from every line item above.

There is also a correctness risk that shows up as a performance mystery: a "verified" marketplace host can have a degraded interconnect, PCIe lanes shared with other tenants, or a thermal limit that quietly halves sustained throughput. The cure is measurement, not a rate card.

Warm up, time a fixed workload, and divide dollars by useful work. The script below is the same shape used to fill the tables in this article.

import time, subprocess, json start = time. time () # pod clocks in at this moment subprocess. run ([ " python ", " -m ", " pip ", " install ", " -q ", " transformers " ]) load_start = time. time () #... download weights and build the engine here... load_seconds = time. time () - load_start work_start = time. time () #... run the fixed 200-prompt evaluation here... work_seconds = time. time () - work_start print ( json. dumps ({ " billed_seconds ": round ( time. time () - start, 1 ), " load_seconds ": round ( load_seconds, 1 ), " work_seconds ": round ( work_seconds, 1 ), " overhead_ratio ": round (( load_seconds ) / max ( work_seconds, 1e-9 ), 3 ), })) Enter fullscreen mode Exit fullscreen mode If overhead_ratio is above 0.2, you are renting cold-start time and should be on a platform with a cached image and free ingress. If it is below 0.05 and the job is checkpointed, you are the workload a marketplace is built for and the hourly discount is yours to keep.

The calculator takes GPU model, hours, utilisation, egress and storage and returns the effective dollars per useful GPU-hour, so you can put your own numbers into the tables above.

Both links below are affiliate links carrying the same tracking parameter, and both providers win a scenario in this article. Pick with the tables, not the discounts.

Affiliate links: a commission may be paid at no extra cost to you. Rates change daily; verify the current price and the host's network terms before renting.

Hourly rates were pulled directly from each provider's catalog API on 2026-10-18T16:37:25Z, both returning HTTP 200: the RunPod GraphQL catalog for Community and Secure tiers, and the Vast.ai bundles endpoint for the lowest verified rentable single-GPU offers. Every dollar figure in the scenario tables is a multiplication of those rates by the stated quantities, plus the stated network, storage and reserve assumptions. Nothing is a vendor quote and nothing is a promotion.

Assumptions worth restating: Vast ingress and egress at $0.02/GB for weights and $0.05/GB for serving traffic, both inside the commonly quoted $0.01–$0.08 band; persistent storage at $0.10/GB-month for both providers; a 15% interruption reserve for the marketplace in a production scenario; interruptible Vast capacity at $1.19/GPU-hour, approximately 59% of the verified on-demand sample. Change any of them and the tables change; the method does not.

Related research: The H100 Rental Trap, and the live rate index that feeds these tables.