The fastest first token in this data comes from one of the cheapest models on the board. DeepSeek V4 Flash reaches first token in 435 milliseconds at $0.24 in / $0.73 out per million — while a model costing thirty-four times more takes six times longer to start talking. OrcaRouter measures both across live traffic, and putting them in one llm pricing comparison kills an assumption that quietly shapes a lot of architecture decisions.
Prices and latency read 2026-09-09.
The data
| Model | Output /1M | p50 first token |
| DeepSeek V4 Flash | $0.73 | 435 ms |
| DeepSeek V4 Flash 0731 | $0.73 | 748 ms |
| DeepSeek V4 Pro | $2.18 | 831 ms |
| DeepSeek V4 Pro 0813 | $2.18 | 886 ms |
| Claude Opus 5 | $25.00 | 2.52 s |
| Qwen3.8 Max (0902) | $6.00 | 2.82 s |
| Muse Spark 1.2 | $4.25 | 2.88 s |
| Qwen3.8 Max | $6.00 | 4.09 s |
| Gemini 3.5 Flash | $9.00 | 4.06 s |
| Claude Fable 5.1 | $50.00 | 4.14 s |
| Claude Opus 4.8 | $25.00 | 4.38 s |
| GPT-5.5 Pro | $180.00 | 5.00 s |
| GPT-6 Astra | $50.00 | 5.79 s |
| Claude Fable 5 | $50.00 | 6.70 s |
| GLM 5.3 Flash | $0.25 | 6.97 s |
| GPT-5.6 Sol | $20.00 | 9.37 s |
| Qwen3.7 Flash | $0.13 | 9.79 s |
Sort that by price and the latency column is noise. Sort by latency and the price column is noise. The correlation people assume — pay more, wait less — is not there in either direction.
Two readings that both fail
“Cheap is slow.” Contradicted at the top of the table: the four DeepSeek entries occupy the four fastest positions and cost between $0.73 and $2.18 per million output. Every frontier model in the table is slower than all four.
“Expensive is fast.” Contradicted too. GPT-5.6 Sol at $20.00 reports 9.37 s. Claude Fable 5 at $50.00 reports 6.70 s. GPT-5.5 Pro at $180.00 — the most expensive model here by a factor of 3.6 — reports 5.00 s, slower than Claude Opus 5 at a seventh of the price.
What *is* visible is a family effect: DeepSeek’s models are fast, the GPT-5 generation is slow, and Claude sits in between with real spread inside it. That is a more useful prior than any price-based rule.
Where the same-price spread shows up
The clearest evidence that price is not buying speed is what happens *inside* a price point.
| Same price | p50 first token |
| Claude Opus 5 — $5 / $25 | 2.52 s |
| Claude Opus 4.8 — $5 / $25 | 4.38 s |
| Claude Fable 5.1 — $10 / $50 | 4.14 s |
| Claude Fable 5 — $10 / $50 | 6.70 s |
| Qwen3.8 Max (0902) — $2 / $6 | 2.82 s |
| Qwen3.8 Max — $2 / $6 | 4.09 s |
Three pairs, identical prices, and in each one the newer release is faster by 1.3 to 2.6 seconds. If you integrated a model string a couple of quarters ago and never revisited it, you are quite likely on the slow half of a pair — at exactly the same cost.
Two caveats, because this is one platform’s own data
Two figures are not measurements. Grok 4.6 and Gemini 3.6 Flash both report 10.00 s, which is a reporting ceiling rather than an observed value. Read those two as “not measured” rather than “slow” — I have left them out of the table above for that reason.
These are 7-day rolling windows and they drift daily. Claude Opus 5’s median moved 3.09 s → 2.82 s → 2.52 s across three consecutive reads. The ordering has been stable; the decimals have not. And latency is a property of a route under load — one platform’s traffic mix and regions — so a figure measured on someone else’s traffic, this table’s included, is a starting point rather than a specification.
What to do with it
If a person is waiting, put latency in the shortlist alongside price — and check the actual numbers rather than inferring them from cost. The assumption costs you either way: it talks you out of cheap models that are fast, and into expensive ones that are not.
If you are batching, ignore first-token latency entirely and optimise throughput and cost per piece. Time-to-first-token is a user-experience metric; a queue does not care.
Measure your own p95, not anyone’s p50. Median latency describes the request nobody complains about. Support tickets come from the tail, and the tail depends on your concurrency and your region — which no published figure can tell you.
Why price and latency are unrelated in the first place
The absence of correlation is not an accident of this data set; it follows from how the two numbers get set.
Price is a positioning decision. A vendor prices a model against its competitors and against the value of the capability, not against its serving cost. That is why three models can sit at exactly $10.00 / $50.00 with different architectures behind them, and why a flagship at $30.00 / $180.00 is signalling who it is for as much as what it costs to run.
Latency is an engineering outcome. Time to first token depends on model size and architecture, on how the provider has quantised and sharded it, on batching policy, on how much spare capacity is provisioned for current load, and on the physical distance between you and the nearest serving region. None of those is a pricing input.
The two are set by different teams on different timescales, and the price is the one that gets published. So the sensible prior is not “expect a trade-off” but “expect no relationship, and check”.
There is one indirect link worth naming: a cheap model is usually a small model, and small models genuinely can be faster. That is the mechanism behind DeepSeek V4 Flash’s 435 ms. But it is a weak tendency rather than a rule, and this data contains its own counterexample in Qwen3.7 Flash — cheapest on the board, and among the slowest.
Worth adding what this means for a shortlist in practice. Because the two properties are independent, the search space is bigger than people assume: you are not picking a point on a curve, you are picking from a scatter, and there are usually candidates that are both cheap and fast because nothing forces those to trade off. The teams that get the best results here are the ones who checked instead of reasoning from the price, and the check is one page view per candidate.
The takeaway
Across seventeen models spanning a 1,385x price range, output price and first-token latency are effectively uncorrelated: the four fastest entries cost between $0.73 and $2.18 per million, and the most expensive model in the table is slower than one costing a seventh as much. The pattern that does hold is by family, not by price. And the sharpest version of the point is the same-price pairs — three of them, each with the newer release 1.3 to 2.6 seconds faster at identical cost, which is a free upgrade sitting in a model string somebody has not looked at.
Sourcing note: Output rates are the list prices OrcaRouter passes through, read 2026-09-09. Median time-to-first-token figures are OrcaRouter production telemetry read the same day, not a controlled benchmark; they reflect its traffic mix, regions and live provider load, and each is a 7-day rolling window that moves daily. Grok 4.6 and Gemini 3.6 Flash report a 10.00 s ceiling rather than a measured value and are excluded from the latency table for that reason. Note on the DeepSeek rows: on 2026-09-10 DeepSeek published DeepSeek-V4.1-Flash under the identifier `deepseek-flash`, turned `deepseek-v4-flash` and `deepseek-v4-flash-vision-exp` into legacy aliases routed to it, and stated that requests to `deepseek-v4-pro` will all be routed to V4.1 Flash from 2026-09-14. The DeepSeek figures here are therefore a 2026-09-09 snapshot of a line the vendor is in the middle of consolidating.