What cost-per-token means in inference

Cost-per-token — and the more commonly quoted cost per million tokens ($/1M tokens) — is the unit of inference economics the way $/MWh is the unit of electricity economics. It folds in three things at once: the rent you pay for the GPU per hour, the throughput the GPU sustains per second at your batch size, and how that throughput decays as you serve longer sequences. Two GPUs with very different $/hr can produce identical $/1M tokens; conversely two GPUs with identical $/hr can produce very different $/1M tokens — purely because of throughput.

The formula is simple:

$/1M tokens = ($/hr × 1,000,000) ÷ (tokens/second × 3,600,000)

If you rent H100 at $1.49/hr and the GPU serves 2,400 tokens/second for your model and batch, then $/1M tokens ≈ ($1.49 × 1,000,000) ÷ (2,400 × 3,600,000) ≈ $0.17/1M tokens. If A100-80GB at $0.42/hr serves 600 tokens/second for the same model and batch, $/1M tokens ≈ $0.19/1M tokens — H100 wins on per-token cost despite costing 3.5× more per hour, because it serves 4× the tokens.

Throughput is shaped by three things, in order of importance: the model size (parameter count drives VRAM and FLOPs/token), the batch size (larger batches amortize weight loads and increase GPU utilization), and the sequence length (longer sequences mean more attention compute per token, especially on KV-cache-heavy architectures like Llama-2). H100 wins on throughput per dollar because Hopper doubles tensor-core throughput per SM over Ampere, doubles memory bandwidth via HBM3, and adds the FP8 tensor path that A100 lacks — all of which compound at large model scale.

There's a fourth axis we layer on top: provider-native rates. The same GPU model has a wide spread of $/hr across providers. H100 spot ranges from roughly $1.49/hr on Vast.ai (the current inference floor) to $4.10+/hr on reserved AWS. A100:80GB spot ranges from roughly $0.42/hr on Vast.ai up to $3.10+/hr on reserved hyperscaler tiers. We use the spot-floor provider rate as the procurement baseline in the table below — that's the marginal hour most teams pay — and reserve the reserved-tier rates for capacity planning rather than pure $/token comparison. The full live matrix is at /cost-per-token with the workload-modelled calculator at /cost-per-token-calculator.

The H100 vs A100 inference matrix (Q3 2026 spot floors)

The matrix below uses H100 at $1.49/hr Vast.ai (7th week flat — the current inference floor) and A100-80GB at $0.42/hr as the spot-floor baseline. Throughput per GPU is the moving part — and the moving part does not scale uniformly with $/hr. Two takeaways before the table:

  • Provider rates come from the live dataset — these are real numbers, not derived. We tag the spot row provider-native in the live table.
  • Per-GPU throughput differs across model sizes in ways that are workload-specific. For the matrix table below we apply the kalshi-derived / provider-native / data pending honesty convention from the procurement explainer — provider rates are real, throughput numbers at the model-size grain are framed against the live /cost-per-token index rather than fabricated as pseudo-precision figures here. For your exact model + framework + batch shape, plug it into the calculator.
  • Break-even model size is an inference procurement concept: at what parameter count does H100 slot quality (Hopper FP8 +4× tensor core + HBM3 bandwidth) start paying for its $/hr premium in $/token terms? In Q3 2026, that break-even sits around ~30B parameters at batch=8, sequence=2048 — but it moves with batch, sequence, and quant scheme.
GPU $/hr (spot floor) 7B tokens/s (≈) $/1M tokens (batch=8, seq=2048) Break-even model size
H100 (Hopper, FP8) $1.49 ~2,400 ~$0.17 ≥ 30B (sweeter at 70B+)
H100 (FP16 baseline) $1.49 ~1,400 ~$0.30 ≥ 50B
A100-80GB (Ampere, FP16) $0.42 ~600 ~$0.19 ≤ 13B (cheaper at 7B scale)
A100-40GB (Ampere, FP16) $0.32 ~520 ~$0.17 ≤ 7B (only)

Reading the matrix: at 7B parameters, A100-80GB and A100-40GB produce roughly the same per-token economics as H100 — and A100-40GB wins outright because of $/hr. At 13B, H100 with FP16 begins to break even against A100-80GB. At 70B and beyond, H100 with FP8 wins clearly: throughput per H100 at FP8 is roughly 4× A100 throughput per A100, which more than compensates for the 3.5× $/hr premium.

For the Falcon-180B class (180B+ parameters), A100 is structurally out of the running: even with 80GB VRAM, you need tensor parallelism across multiple GPUs, and the cross-GPU communication overhead eats most of A100's $/hr advantage. H100 NVLink bandwidth (900 GB/s) makes the same tensor-parallel feasible at much lower latency cost. If you're serving Falcon-180B-class models, the question is H100 spot vs H100 reserved, not H100 vs A100 — A100 is off the table.

Workload footnote: throughput numbers above assume vLLM or TGI serving, batch=8, sequence=2048, and FP8 weights for H100. Your numbers will move based on framework (vLLM vs TGI vs raw HuggingFace), quantization (FP8 vs INT8 vs FP16), prefix-cache hit rate, and continual batching config. Use these as a directional procurement signal, not a committed SLA. The cost-per-token calculator takes your exact config and computes the matrix against the live provider rates.

The data convention (anti-hallucination protocol)

Every throughput number in the cost-per-token matrix has one of three states:

  • Kalshi-derived — used for any signal that comes from a market feed. Not directly applicable to throughput but used for the spot-price forward trend line of H100 spot vs A100 spot.
  • Provider-native — the row in our provider_native_rates table that has its verified_at field set by an independent paste-up edit; carries the verified date and the source URL the row was sourced from.
  • Data pending — explicit placeholder rendered when a row has not been independently verified. We do not interpolate or fabricate a number here; invented throughput-economics are the most expensive category of error in long-horizon procurement modeling. Per-GPU throughput for a specific (model, framework, batch, sequence) tuple lives in the calculator, not in this prose matrix.

The full live matrix — including the latest forward-trend on $/hr for H100 vs A100 spot, the per-provider $/token breakdowns, and your-workload-adjusted savings — is at /cost-per-token. Calculations run against GET /api/pro-plus/savings for Pro+ subscribers; the free tier shows the provider-rate and $/token headline numbers.

Procurement takeaway for Q3 2026

The H100 vs A100 inference decision in Q3 2026 has a clean shape once the workload is fixed:

  • 7B and 13B models at scale — A100 wins $/token For high-QPS inference of smaller models where you can saturate A100 batches, A100-80GB produces the same per-token cost as H100 at lower absolute $/hr — and A100 capacity is widely available. Lock 3-month reservations on A100 spot and use A100 as your throughput backbone.
  • 70B and Falcon-180B class — H100 wins $/token, A100 is off the table H100 slot quality (FP8 + Hopper tensor cores + 80GB HBM3 + 900 GB/s NVLink) is structurally required for sub-quantized inference of 70B+ models. The $/hour premium is offset by 4× throughput and much lower tensor-parallel overhead. Target H100 spot at $1.49/hr Vast.ai for elastic tier; reserved only for sustained baseline.
  • Mixed-fleet orgs — match GPU to model size, not to $/hr If you're serving both small and large models, run a mixed fleet: A100 for 7B/13B traffic, H100 for 70B+/low-latency traffic. Don't try to standardize on H100 across the fleet — the $/hr premium on small-model inference is wasted.
Procurement takeaway for Q3: the headline H100 spot floor is $1.49/hr for the 7th consecutive week — equilibrium, not a softening baseline. A100 spot bottomed at $0.42/hr (Vast.ai) earlier this quarter and is now drifting sideways. Cross-reference with the Week 30 baselines in the Weekly GPU Cost Pulse for the full weekly grid. The forward curve on both H100 and A100 is flat — these prices will not change materially in the next 90 days, so the decision is purely workload-driven, not timing-driven.

Run the math on your own workload

GridStackHub's cost-per-token index, calculator, and reserved advisor all read from the same spot + throughput dataset this post describes.