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

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.

The two prices on every GPU page, and the third one that decides the bill

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 three charges that differ:

• Wall-clock time that is not GPU time. A pod that spends 40 minutes pulling a 150 GB set of weights and a 25 GB container image is still renting the GPU. If that pull happens on every fresh host — as it does on a peer-to-peer marketplace without a shared image cache — the overhead is billed at the full hourly rate and produces nothing.
• Network transfer. RunPod does not meter pod traffic. Vast.ai hosts set their own inbound and outbound rates, commonly quoted in the $0.01–$0.08 per GB band, and both directions can appear on the invoice. For a text LLM endpoint that is noise. For a workload that pulls 150 GB of weights per cold start, or serves a public demo, it is a real second line item.
• Storage that survives the pod. A stopped pod still owns its disk. Network volumes and container disks are billed per GB-month in both ecosystems, but on a marketplace the instance can also disappear when the host needs the machine back, which turns "storage cost" into "storage cost plus re-provisioning".

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

Six dimensions, one table

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.

Scenario A — pull a 150 GB model and run a two-hour test

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.

Scenario B — a 7×24 vLLM inference node

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)

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.

Scenario C — a 72-hour LoRA / distillation batch on three H100s

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.

What none of these tables price

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

• Re-provisioning time. A cold start on a new Vast host is 25–40 minutes for a large model. If your team does that four times a week, it is a working day per month spent watching a progress bar.
• Data loss on eviction. Local disk on a rented machine is not durable storage. Checkpoints belong on a volume, an object store or the host you control, and that replication has its own cost.
• Prepaid credit and billing friction. Marketplaces run on prepaid balances; a card decline mid-run stops a pod. Managed platforms invoice. Neither is wrong, but a finance team will price the difference at more than zero.

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.

Measure your own effective rate in ten minutes

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),
}))

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 three-line decision

1. Short and interactive, or 24/7 serving: RunPod. The hourly premium is smaller than the transfer, cold-start and failover costs it removes. The crossover for a serving node is about 5.4 TB/month of egress; below that the difference is under $31 a month either way.
2. Long, checkpointed and preemptible: Vast.ai. A 72-hour three-GPU batch run saves $314.52 against RunPod Community rates, or roughly $57 against RunPod spot if spot is available.
3. Unsure: price the transfer first. At $0.02/GB, 150 GB of weights is $3.00 per cold start. Multiply that by the number of cold starts you will actually have, and the answer usually appears before you finish the multiplication.

Price your own workload

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.

• Open the GPU cost calculator →
• Run it on Hugging Face Spaces →
• Read the full teardown with every table and source note →

Rent the capacity, if the arithmetic says so

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.

• Rent H100 on RunPod ↗
• Rent H100 on Vast.ai ↗

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.

Method and sources

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.