Yes, it matters which host you call an open-weight model from. The same model name arrives at different quantizations and often with less context than the model advertises: two hosts serve GLM-5.3 at a quarter of its published window, one host caps DeepSeek V4 Pro’s output at 4.3% of the vendor’s documented maximum, and DeepInfra serves Qwen3.8’s open flagship at fp4 — a 4-bit precision format — with 262,144 tokens of context, 26% of its extended ceiling.
Almost nobody self-hosts a model this size, so “open weights” means, in practice, a rental decision across competing hosts. The census in §04 is the fast path: each row is a model-times-provider pair, setting what a host serves — quantization, context, price — beside the vendor’s advertised figures, with every field this pull did not capture marked rather than dropped.
- 01The model name does not specify the product.Hosts serving identical weights differ on quantization, context, output caps, price and speed. The name tells you the checkpoint; the endpoint listing tells you what you are buying.
- 02Served context can be a quarter of the advertised figure.io.net and Reka serve GLM-5.3 at 262,144 tokens against 1,048,576 advertised.
- 03The price tag does not signal the cut.DeepInfra charges $2.00/$6.00 for the native-window Qwen3.8 flagship — the same rate structure it charges elsewhere for full million-token windows. Only the spec fields reveal the difference.
- 04Identical price can hide a 5× speed gap.At the same $1.40/$4.40, GLM-5.3 runs at 29 tokens/sec on GMICloud and 149 on Together. Throughput is a per-host property the price sheet never mentions.
01 — The findingSame name, different product.
We made this argument once before for a single model — the Qwen3.8 Flash weights-vs-hosted split showed that the checkpoint on Hugging Face and the API sold under the same name are not the same thing. This page is the class-level version of that finding, with numbers, across four model families and every provider endpoint OpenRouter lists for them. It is also deliberately narrower than our catalog-literacy guide: that post teaches how to read a catalog row — prices, dates, surfaces. This one measures what the row actually delivers once a host serves it.
The data source that makes the measurement possible is OpenRouter’s public endpoints API, which reports a structured quantization, context-length and price field for every provider serving a given model — what each provider reports to OpenRouter, published per endpoint. Cross-reference those fields against each vendor’s own model card and the gaps appear immediately.
DeepInfra's Qwen3.8 flagship window
Qwen's open flagship advertises 262,144 tokens natively, extensible to 1,010,000. DeepInfra serves the native window at fp4 — about 26% of the extended ceiling — while Together serves the full 1,010,000. Both are legitimate servings of the same weights. Only one fits a long-context workload.
DeepInfra's DeepSeek V4 Pro output cap
DeepSeek documents a 384,000-token maximum output for the V4 line. DeepInfra's V4 Pro endpoint publishes a 16,384-token output ceiling — the most severe output truncation in this census. A summarisation or codegen pipeline sized to the vendor's number stops mid-answer here.
None of this is hidden. The figures come from published fields — endpoint listings, vendor model cards, first-party docs pages — with derived cells marked where they appear. What does not exist anywhere we could find among the sources reviewed for this pull is the cross-referenced view: the served figure next to the advertised one, per host, per model, in one table. That is the gap this page exists to close.
02 — MethodWhat was collected, and how.
A serving census is only as good as its denominators. Every percentage on this page is scoped to its named model and computed from figures quoted in the same row, and every undisclosed field is kept visible rather than dropped.
- What was collected
- For each provider endpoint serving Kimi K3, GLM-5.3, DeepSeek V4 Pro, DeepSeek V4 Flash and Qwen3.8’s open flagship: the quantization disclosed where stated, the context length served where the endpoint publishes one, the maximum completion tokens published, and input/output price per million tokens where published. Vendor-advertised baselines come from each model’s own card or docs.
- Sources
- OpenRouter’s public per-model endpoints API for quantization, context and price; each vendor’s Hugging Face model card and first-party docs for advertised figures; Together, Fireworks, DeepInfra and Groq’s own model pages where cited. Throughput comes from OpenRouter’s rendered provider tables, matched to API price rows to confirm identity.
- Collected
- 2026-09-01, in a single pass. All serving facts on this page describe the state of the listings in that one pull, pinned to this single collection stamp.
- Units
- Token figures quote the source’s exact value — 1,048,576, not “1M”. Where a vendor advertises “1M”, percentages use 1,048,576 as the denominator. Qwen flagship percentages use its 1,010,000 extended ceiling; the Qwen3.8-27B row uses 1,000,000. Prices are USD per million tokens, input/output.
- Exclusions
- Self-hosting economics are out of scope — this is a rental census. Closed-weight models appear only as the Qwen3.8 Max control row. Uptime, rate limits and data-retention terms were not collected. Release dates are deliberately absent; this page records current-state serving, not launch history.
- Known limitations
- “Undisclosed” quantization means the host did not report the field — it is not evidence of full precision. Published max-completion values are API parameter ceilings, not benchmarked generation capability. Throughput figures are OpenRouter’s rolling site-side averages, not fixed specs. Prices and fields move; treat every cell as a snapshot.
03 — The vocabularyThree terms that decide what you are buying.
Quantization is the numeric precision a model’s weights are stored and served at — bf16 at the heavy end, fp8, then 4-bit formats like fp4 and mxfp4. Lower precision means cheaper, faster serving, and potentially different outputs from the same weights. The twist this census surfaces: for two of the four families, low precision is not a downgrade — it is the factory setting. Moonshot trained Kimi K3 natively at MXFP4 weights with MXFP8 activations, per its own model card, and DeepSeek V4 ships at a native “FP4 + FP8 Mixed” precision. “Full precision” for these models is already a 4-bit-class format, and Alibaba goes a step further: it publishes its own pre-quantized FP8 checkpoint of the Qwen3.8 flagship rather than leaving quantization entirely to hosts.
Served context vs advertised context is the gap between the window on the model card and the window a specific endpoint accepts. A host serving less than the advertised figure is not lying — it is making a capacity decision — but nothing on the price sheet announces it. Distill vs full model is the third check: a distill is a smaller model trained to imitate a larger one’s outputs, sold under a confusingly similar name. The naming trap in this census takes a different form — sibling models sharing one family name, which §07 takes apart for Qwen.
Serving the native format
Together's own model page states it serves Kimi K3 with MXFP4 weights and MXFP8 activations — exactly the format Moonshot trained. A host serving the native format is not down-quantizing anything; you are getting the checkpoint as the lab built it.
Recasting above or below native
Four of GLM-5.3's hosts disclose fp4 — below the fp8 the vendor's own endpoint serves. DeepInfra, alone among Kimi K3's 17 endpoints, discloses bf16 — heavier than the model's native MXFP4, implying an upcast. Different arithmetic, same model name.
Not disclosing at all
For Kimi K3, hosts including Together, Fireworks and DigitalOcean carry no quantization field on their OpenRouter listings; for GLM-5.3 it is nine of 21 hosts. Undisclosed is not full precision — it is a blank you are being asked to price.
Quality varies by provider, mainly because quantization differences across hosts can change the model's responses.OpenRouter blog, July 2026
04 — The censusThe serving census: served vs advertised, per host.
Rows are grouped by model family. Each group header carries the vendor’s advertised context — the denominator for that group’s percentage column — and the endpoint count from the full pull. Rows shown are the census’s curated cut from that pull: price extremes, throughput extremes, context truncations and vendors’ own listings, where this pull captured them. Undisclosed fields are kept in as “undisclosed” — deleting them would turn a host’s silence into our omission.
| Provider | Quantization served | Context served | % of advertised | Price in / out ($/M) | Note |
|---|---|---|---|---|---|
| Kimi K3 — advertised 1,048,576 ctx (Moonshot) · 17 endpoints in pull, 7 shown | |||||
| Moonshot AI | mxfp4 (native) | 1,048,576 | 100% | — | The vendor’s own listing; output defaults to 131,072, settable to the full window per Moonshot’s docs |
| Makora | undisclosed | 1,048,576 | 100% | $2.55 / $12.75 | Cheapest of the 17 endpoints |
| Together | mxfp4 (per its own page) | 1,048,576 | 100% | $3.00 / $15.00 | OpenRouter field blank; Together’s own page states MXFP4 weights / MXFP8 activations — the native format |
| Fireworks | undisclosed | 1,048,576 | 100% | $3.00 / $15.00 | Its own model page lists “1040k tokens” — slightly under the advertised figure |
| DeepInfra | bf16 | 1,048,576 | 100% | — | Only endpoint claiming bf16 — heavier than the native MXFP4 checkpoint, implying an upcast |
| Sail Research | fp4 | 974,842 | 93% | — | The only host in the pull truncating Kimi K3’s context |
| Morph (Fast tier) | fp4 | 1,048,576 | 100% | $6.00 / $22.50 | Most expensive of the 17 — 2.35× Makora’s input price |
| GLM-5.3 — advertised 1,048,576 ctx (Z.ai states 1M) · 21 endpoints in pull, 9 shown | |||||
| Z.ai | fp8 | 1,048,576 | 100% | — | The vendor’s own listing; publishes a 131,072 output ceiling, matching its documented 128K maximum |
| AkashML | fp8 | 1,048,576 | 100% | $1.17 / $3.96 | Price floor of the 21 endpoints |
| Together | undisclosed | 1,048,576 | 100% | $1.40 / $4.40 | 149 tok/s — fastest at the cluster price |
| GMICloud | fp8 | 1,048,576 | 100% | $1.40 / $4.40 | 29 tok/s — same price as Together, 5.1× slower |
| DeepInfra | fp4 | 1,048,576 | 100% | — | One of four hosts disclosing fp4 — below the vendor endpoint’s fp8 |
| io.net | fp8 | 262,144 | 25% | — | A quarter of the advertised window |
| Reka | fp8 | 262,144 | 25% | — | The other quarter-context host for this model |
| Cloudflare | undisclosed | 1,310,720 | 125% | — | Reports more context than the model advertises — an open discrepancy; see the callout below |
| Venice | undisclosed | 1,048,576 | 100% | $1.75 / $5.50 | Price ceiling of the 21 endpoints |
| DeepSeek V4 Pro — advertised 1M ctx · 384,000 max output (DeepSeek docs) · 17 endpoints in pull, 5 shown | |||||
| DigitalOcean | undisclosed | — | — | $0.87 / — | Cheapest input price of the 17 |
| Azure (US) | undisclosed | — | — | $1.91 / — | Most expensive input price — 2.2× DigitalOcean’s |
| DeepInfra | fp8 | — | — | — | Output capped at 16,384 tokens — 4.3% of the vendor’s documented 384,000, the deepest output cut in this census |
| CoreWeave | fp8 | — | — | — | 65 tok/s — fastest of the 17 |
| Ionstream | fp4 | — | — | — | 15 tok/s — slowest, a 4.3× spread |
| DeepSeek V4 Flash — advertised 1M ctx (DeepSeek docs), normalised 1,048,576 · 17 endpoints in pull, 2 shown | |||||
| DigitalOcean | undisclosed | — | — | $0.068 / — | Floor of the census’s widest input-price spread: 6.5× |
| Cloudflare | undisclosed | 384,000 | 37% | $0.44 / — | Highest input price of the 17 — and just over a third of the advertised context |
| Qwen3.8-2.4T-A95B (open flagship) — advertised 262,144 native / 1,010,000 extended (Qwen card); denominator 1,010,000 · 7 endpoints in pull, 5 shown | |||||
| DeepInfra | fp4 (per its own page) | 262,144 | 26% | $2.00 / $6.00 | The native, un-extended window — at DeepInfra’s standard rate; the price gives no warning |
| SiliconFlow | fp8 | 1,048,576 | 104% | — | Reports more than the vendor’s 1,010,000 ceiling — a reported field, not independently corroborated |
| Together | undisclosed | 1,010,000 | 100% | $2.50 / $6.25 | Matches the vendor’s stated extended ceiling exactly |
| Alibaba | undisclosed | 1,000,000 | 99% | — | The weights’ own vendor, hosting its open flagship |
| Venice | undisclosed | 262,144 | 26% | $2.50 / $7.50 | Native window at a higher price than Together’s full window |
| Qwen3.8 Max (closed-weight control) — 1 endpoint in pull | |||||
| Alibaba Cloud Intl | n/a — closed weight | 1,000,000 | n/a | $2.00 / $6.00 | Single host, so no advertised-vs-served spread to measure; 131,072 max output, ~37 tok/s |
| Qwen3.8-27B (open dense) — advertised 262,144 native / 1,000,000 extended (Qwen card); denominator 1,000,000 · first-party Groq spotlight | |||||
| Groq | undisclosed | 131,042 | 13% | — | Roughly half of even the native 262,144 window; from Groq’s own model docs, not OpenRouter |
Cloudflare’s GLM-5.3 endpoint reports a context length of 1,310,720 tokens — more than the 1,048,576 the model advertises. No primary source we reviewed explains it, and it could be a padded or rounded field rather than genuine extra window. We record it as an open discrepancy, not as a claim that Cloudflare gives you bonus context. Surfacing exactly this kind of unexplained gap between reported and advertised figures is what this census is for.
05 — The context split“Advertised” context is often the extended figure.
The Qwen rows expose a mechanism most coverage flattens into one number. Qwen’s own model card states context two ways: “262,144 natively and extensible up to 1,010,000 tokens” — a native window the model was trained at, and an extended ceiling reached through scaling techniques. A headline “1M context” for this model is the extended figure. A host serving 262,144 is not lying; it is quietly serving the un-extended model. The census’s job is to tell you which one your endpoint is.
| Model | Native context | Extended (advertised) | Host serving native only | Host serving the extended figure |
|---|---|---|---|---|
| Qwen3.8-2.4T-A95B | 262,144 | 1,010,000 | DeepInfra ($2.00/$6.00) · Venice ($2.50/$7.50) | Together — 1,010,000 at $2.50/$6.25 |
| Qwen3.8-27B | 262,144 | 1,000,000 | Groq serves 131,042 — below even the native window | — (none captured in this pull) |
DeepInfra charges $2.00/$6.00 for the Qwen3.8 flagship at its native 262,144-token window — the same rate structure it charges elsewhere for full million-token windows on other models, and fifty cents an input-million less than Together charges for the full 1,010,000. The spec sheet is the only place the difference shows up. If your workload needs the long window, the cheapest listing can be the one that cannot run it.
06 — The spreadsSame weights, different bill.
Even where a host serves the full model at the full window, the commercial terms scatter. Kimi K3’s input price runs from $2.55 to $6.00 per million across its 17 endpoints — a 2.35× spread for identical weights. DeepSeek V4 Flash spans $0.068 to $0.44, a 6.5× spread, the widest in this census. GLM-5.3 is the counterexample that proves price and speed are separate axes: 14 of its 21 hosts converge on $1.40/$4.40, and at that single price point throughput still spans 5.1×. Our frontier-model price index tracks list prices across vendors; this page is the reminder that for open weights, the list price is only one of the fields that varies.
Throughput for identical weights, fastest vs slowest host
OpenRouter provider tables, matched to API price rows · single collection pass (§02)OpenRouter itself published the single-model version of this finding in July, for DeepSeek — and its July snapshot counted 16 providers where our later pull found 17, a reminder that even the host count is a moving figure. The two numbers are different snapshots, not a contradiction.
'DeepSeek' is one model served by 16 different companies, at prices that vary by about 4x and throughput ranging from 4 to 57 tokens per second.OpenRouter blog, July 2026
One caution on the output column of any endpoint listing: a published max-completion figure is the number the API will accept, not a benchmarked promise of what the model reliably generates in one turn. Twelve of GLM-5.3’s third-party endpoints publish an output ceiling of 943,718 tokens — more than seven times the 128K maximum Z.ai itself documents. Only the vendor’s own listing is directly tied to a vendor-stated limit. Read high ceilings as generous parameter defaults; read low ones — like the 16,384-token DeepSeek V4 Pro cap — as the binding constraint they are. What a usage aggregator’s charts can and cannot tell you about any of this is its own topic — see what OpenRouter’s usage charts actually measure.
07 — The name trapOne name, three Qwens.
“Qwen3.8” is not one product. It is at least three distinct models with three different serving postures. Qwen3.8 Max is closed-weight and single-host — exactly one provider, Alibaba Cloud International, serves it. That is the census’s control case: with no open weights there is no host choice, no quantization spread and no context-truncation risk to shop around; the entire renting-not-running problem collapses to a single row. Qwen3.8-2.4T-A95B is the open flagship — 2.4T total parameters, 95B active — described by Alibaba as the open-weight variant of Max, served by seven hosts with the full spread of cuts documented above. And Qwen3.8-27B is a small open dense model, the one Groq serves at 131,042 tokens.
The licences split the same three ways, and the split broke a pattern. Every earlier Apache-licensed Qwen open release used Apache-2.0; the Max-class flagship instead ships under a bespoke “qwen3.8-max” licence — the first Qwen open weight to do so — while the 27B keeps Apache-2.0, the only Apache licence anywhere in this census. Kimi K3 ships under its own bespoke licence, GLM-5.3 under a bespoke licence that is not MIT, and DeepSeek V4 under MIT. Four families, four different answers to what you may do with the weights you are nominally free to run.
The catalog-side consequence is visible at Groq: its documented model catalog, in this census’s collection pass, listed no Kimi K3, no GLM-5.3 and no DeepSeek V4 of any variant — its open-weight lineup at this size class is Llama, GPT-OSS, MiniMax-M2.7 and two dense Qwen3.x models. That is a claim about one documentation page in one pull, not about Groq’s roadmap; but it means the fastest-inference host many builders reach for first simply does not carry three of these four families. This generation’s spread also has precedent: the same host-by-host variance was visible for GLM-5.2 in our provider price comparison and its companion on what self-hosting actually takes — the hardware reality that makes this whole census a rental decision in the first place.
08 — Using itFour checks before you commit to a host.
The census supports a short pre-flight routine. None of it requires tooling beyond the endpoint listing and the vendor’s model card.
Compare served context to the vendor's figure, not the headline
Pull the endpoint's context field and divide by the model card's advertised number. Anything under 100% is a different product from the one the launch post described — and for models with a native/extended split, check which of the two figures you are getting.
Know the native format before judging the served one
fp4 sounds like a downgrade until you learn Kimi K3 was trained at MXFP4 and DeepSeek V4 at FP4+FP8 mixed. Judge a host's format against the model's native precision, and treat an undisclosed field as a question to ask, never as full precision.
Check the completion ceiling against your longest response
Output caps vary far more than context. A 16,384-token cap on a model documented at 384,000 will truncate a long generation silently. Low published ceilings bind; very high ones are parameter defaults, not promises.
Treat price as the tiebreaker, not the signal
The census's most actionable finding is that price does not encode any of the above: native-window servings and 5×-slower endpoints bill like their full-fat neighbours. Shop the spec fields first; then let price decide between hosts that pass.
The limitation to hold onto: this is a census of published serving fields, not a probe of live endpoints. We did not measure quality deltas between quantizations here, and the fields themselves move — hosts join, reprice and requantize continuously. If model selection and host selection sit between your team and a workload that has to ship — an agent pipeline sized to a context window that one candidate host quietly does not serve — that is the kind of decision our AI transformation engagements exist to de-risk.
09 — ConclusionRent the spec sheet, not the name.
Open weights make the model portable. They do not make the product uniform.
The promise of open weights is choice, and the choice is real — 17 hosts for Kimi K3, 21 for GLM-5.3, 17 for each DeepSeek V4 variant. What this census adds is that the choice is wider than the price column suggests: hosts differ on the quantization they serve, the context they actually offer, the output they will return, and the speed they deliver it at — and several of those differences carry no price signal at all.
The control case makes the point from the other side. Qwen3.8 Max, closed-weight, has exactly one host, one price, one context figure. Nothing to shop, nothing to mis-buy. Open weights turn a product into a market, and markets reward the buyer who reads the listing.
The gaps stay in the table — the undisclosed quantizations, the uncaptured cells, and one genuinely unexplained figure in Cloudflare’s GLM-5.3 row. A serving census that resolved every discrepancy into a tidy claim would be describing a market that does not exist.