Halflight Price Index

Price per unit of work, by model

Median across providers (dot), interquartile range (thick) and full range (thin) for every model with at least 3 providers. The blended view prices one reference request, 1,000 input and 250 output tokens, per unit of its total work; the mix control in the table below recomputes the blended columns and tile but not this chart. The number at the right is the median the dot marks; hover for the provider count and range. Per token, qwen/qwen3-next-80b-a3b-instruct at ~$1.10/M and mistralai/mistral-nemo at ~$0.03/M look a few times apart; per unit of work they are 156× apart.

Who sells the same work cheaper

Each provider’s blended price divided by the market median for that model, then the median over the models the provider serves (providers with at least 4 models that have 3 or more sellers). Left of 1× is cheaper than the market for the same work. The widest spread on one model today is deepseek/deepseek-v3.2: 15× between the dearest and cheapest of its 12 providers.

All models

Click a column to sort. “Count source” says where the active-parameter figure comes from: config, verified means the formula and the vendor’s stated count agree within 20%; config means the formula alone, with no stated count to check it against; vendor-stated † means the formula was not used. Dollar-per-PPT columns are medians across providers; $/PB is the precision-adjusted decode figure (bytes read, so fp4 builds count as less work).

Every listing

One row per provider per model, including batch variants. This is the raw material; the model table above summarises it.

Units

Param-token

The work of pushing one token through one parameter. A model with 5.1 billion active parameters does 5.1 billion param-tokens of work for every token it processes. It is the unit of prefill work in ADR-014, and the precision-agnostic unit of decode work on this page.

PPT, peta-param-token

10¹⁵ param-tokens. The scale falls out of the prices: dollars per million tokens divided by active parameters in billions is dollars per 10⁶ × 10⁹ param-tokens. At $0.60 per million output tokens on a 5.1B-active model, decode work costs $0.60 ÷ 5.1 = $0.118 per PPT, so a dollar buys about 8.5 PPT, which is roughly 1.7 million output tokens of that model.

PB, petabyte of weights read

10¹⁵ bytes. Decode is memory-bound, so ADR-014 measures decode work in bytes of weights read per output token: active parameters × bytes per parameter for the served precision (0.5625 at 4-bit, 1.0625 at 8-bit, 2.0 at bf16, scale overhead included). An fp4 build reads about a quarter of the bytes an fp16 build does for the same token, so the same list price counts as more dollars per PB. The same model at $0.60 per million output tokens served at fp4 reads 5.1 × 0.5625 = 2.9 GB per token and costs $0.209 per PB.

Which to read

Dollars per PPT compares models and providers on the work the architecture implies, whatever precision it is served at. Dollars per PB credits a provider for serving a cheaper precision, so it sits closer to their cost. The page leads with PPT because it applies to prefill and decode alike.

Method

The unit is the normalised inference unit from Halflight’s ADR-014: two quantities, never combined.

I(t) = I(t−1) × exp( Σ wᵢ · ln( pᵢ(t) / pᵢ(t−1) ) / Σ wᵢ )     wᵢ = 7-day spend, pᵢ = model’s median $/PPT

prefill work per input token  = N_active                      [param-tokens]
decode work per output token  = N_active × bytes_per_param     [bytes]

prefill $/PPT = ($ per M input tokens)  ÷ N_active[B]           → $ per 10¹⁵ param-tokens
decode  $/PPT = ($ per M output tokens) ÷ N_active[B]           → precision-agnostic
decode  $/PB  = ($ per M output tokens) ÷ (N_active[B] × bytes) → $ per 10¹⁵ bytes of weights read

blended $/PPT = (S_in × $/M in + S_out × $/M out) ÷ (N_active[B] × (S_in + S_out))   default S_in = 1,000, S_out = 250

• Prices are OpenRouter’s public per-provider endpoint listings for every model that has a Hugging Face ID, fetched the day of the snapshot. Free tiers are excluded; batch variants are listed but kept out of the model medians.
• Active parameters are estimated from each model’s public config.json (attention, dense or routed MLP, one output head; the input embedding lookup is not counted, which reproduces vendors’ own figures, e.g. gpt-oss-120b → 5.1B). The estimate is checked against the count in the model name or vendor description; where they disagree by more than 20% the stated figure wins and the row is flagged, following ADR-014’s override rule. Gated repositories use figures from the model card.
• Bytes per parameter come from the listing’s declared quantization (fp4/int4 → 0.5625, fp8/int8 → 1.0625, bf16/fp16 → 2.0, including scale overhead); unknown listings fall back to the checkpoint’s native precision.
• Short context. The prefill figure omits the attention term that grows with input length; it is the short-context value, as ADR-014 §2 publishes it.
• Blended prices one reference request per unit of its total work, both terms in param-tokens, so no constant is needed to add them: the market’s own input-to-output price ratio is the exchange rate. The mix is a stated choice, not a measurement; change it to your own traffic.
• Level (the dollar figure) is the median over all standard listings today. It answers “what does the market charge for a unit of work” and moves when listings join or leave, so it is not the series.
• Index (the number beside it) is chain-linked: each day it is multiplied by the expenditure-weighted geometric mean of every basket model’s price relative, its median today over its median the day before. Only price changes move it; a model joining or leaving never produces a jump. First snapshot = 100.
• Weights are expenditure: each model’s prompt and completion tokens over the seven full days before the basket was fixed, from the daily totals on its OpenRouter page, priced at the model’s own median listing. Today’s basket v2026-10 has 150 models; the five largest carry 69% of the weight, which is the shape of open-model demand, not a choice.
• Equal-weighted index is the same chain with every basket model counted once. It measures the typical model’s price change rather than the price of the work people buy; when the two diverge, the gap shows whether cheapening is happening among the heavily used models or in the long tail. Published beside the spend-weighted figure from day 2.
• Basket membership and weights are fixed at the first snapshot of each month and published; changes between versions are chain-linked on the day they take effect.

What this does not measure

• Quality. A token from a stronger model is worth more. The index prices the machine time behind a token and says nothing about what the token is worth. A model that sits high here is either earning a quality premium or carrying margin; the index cannot tell which.
• Serving conditions. Hybrid and linear-attention architectures (Mamba, Qwen-Next, DeepSeek V4) are estimated with a plain-transformer formula and lean on the vendor’s stated count. Speculative decoding, batching depth, KV-cache pricing and context tiers are invisible in a list price.
• Throughput or latency. Dollars per unit of work, not seconds.
• A hardware floor. The next step is a cost floor per unit of work from GPU-hour price × measured throughput, so the gap between floor and market is visible.

Skipped today: 4 models with no usable parameter count (inference-net/schematron-v2-small, inference-net/schematron-v2-turbo, prism-ml/ternary-bonsai-2-27b, stepfun/step-3.7-flash), 16 free tiers.