
Qwen 4 vs Grok 4.7: The 200,000-Token Line Decides This Matchup
- GoogleNEWGoogle: Gemini 4 Carbon2026-11-10$2.00 / $10.00 per 1M tokens · 90 tok/s
- AnthropicNEWAnthropic: Claude Fable 5.22026-11-09$8.00 / $40.00 per 1M tokens · 97 tok/s
- orcaNEWOrca: OrcaC2 1.02026-11-0717 tok/s
- OrcaNEWOrcaCyber: GLM 5.3 Abliterated / Uncensored2026-11-04$3.00 / $5.00 per 1M tokens · 87 tok/s
- OrcaNEWOrcaCyber: Hy4 Abliterated / Uncensored2026-11-04$0.80 / $1.60 per 1M tokens · 133 tok/s
- OrcaNEWOrcaCyber: Kimi K3.1 Pro Abliterated / Uncensored2026-11-04$4.00 / $20.00 per 1M tokens · 72 tok/s
- OrcaOrcaCyber: MiniMax M3.1 Flash Abliterated / Uncensored2026-10-29$0.80 / $1.60 per 1M tokens · 127 tok/s
- OrcaOrcaCyber: GLM 5.3 Flash Abliterated / Uncensored2026-10-27$0.80 / $1.60 per 1M tokens · 65 tok/s
- OrcaOrcaCyber: Qwen3.8 Flash Next Abliterated / Uncensored2026-10-26$0.80 / $1.60 per 1M tokens · 92 tok/s
- OrcaOrcaCyber: MiMo V2.6 Flash Abliterated / Uncensored2026-10-26$0.80 / $1.60 per 1M tokens · 44 tok/s
- MoonshotMoonshotAI: Kimi K3.1 Pro2026-10-2447Intelligence
- OrcaOrcaCyber: DeepSeek V4.1 Flash Abliterated / Uncensored2026-10-23$0.80 / $1.60 per 1M tokens · 193 tok/s
- minimaxMiniMax: M3.1 Flash2026-10-1929Intelligence
- OrcaOrca: OrcaCyber Ultra 1.02026-10-17$5.00 / $10.00 per 1M tokens · 148 tok/s
- deepseekDeepSeek: DeepSeek V4.1 Flash 10172026-10-1733Intelligence
- DeepSeekDeepSeek: DeepSeek V4.1 Flash2026-10-1740Intelligence
- OrcaOrca: OrcaCyber Zero 1.52026-10-10$3.00 / $7.50 per 1M tokens · 123 tok/s
- openaiOpenAI: GPT-6.1 Sol2026-09-2955Intelligence
- anthropicAnthropic: Claude Sonnet 5.52026-09-2855Intelligence
- typesafeTypeSafe: Jev 1.132026-09-24$0.04 / $0.00 per 1M tokens · 219 tok/s
Grok 4.7 and Qwen4-Max are both billed at two dollars in and six dollars out per million tokens — but only Grok 4.7 stays there. Our own catalogue record for Grok 4.7 carries two input tiers, $2.00/$6.00 up to a 200,000-token prompt and $4.00/$12.00 past it, while Qwen4-Max sits at $1.50 input and $4.50 output per million across its full 1,000,000-token window. That single structural difference is worth more than the eight index points that separate them on paper, because long-context work is precisely the work both models are sold for. A note on names before anything else, since the two get conflated constantly: Qwen 4 is the generation name Alibaba uses, and Qwen4-Max is the only member of it you can call today — released 16 November 2026, with smaller tiers promised for open source and no date attached. Grok 4.7 has been shipping since 21 September 2026. This is a pricing and evidence comparison, not a launch report on either.
The shape of the two models, briefly
Qwen4-Max is Alibaba's fourth-generation flagship, a sparse mixture-of-experts model with a 2.4-trillion-parameter backbone, 71 billion parameters active per token, and a further 328 billion parameters of N-gram embedding. It accepts text, images and video, returns text, and carries a one-million-token context window. Thinking is on by default, and the model shares a 262,144-token budget between its reasoning and its final answer — so a 131,072-token answer is only available if the thinking fits in the other half.
Grok 4.7 is SpaceXAI's current text flagship. It is a reasoning model with a 500,000-token context, up to 450,000 output tokens, text and image input, and three selectable reasoning levels. SpaceXAI publishes no parameter count for it and describes the release as a larger base model with a longer reinforcement-learning run rather than a new architecture.
On the dimensions that decide a purchase:
• Context — Qwen4-Max 1,000,000 tokens vs Grok 4.7 500,000
• Max output — Qwen4-Max 262,144 shared with thinking, or 131,072 with thinking suppressed, vs Grok 4.7 450,000
• Input price to 200K — Qwen4-Max $1.50 vs Grok 4.7 $2.00 per 1M
• Output price to 200K — Qwen4-Max $4.50 vs Grok 4.7 $6.00 per 1M
• Input price past 200K — Qwen4-Max still $1.50 vs Grok 4.7 $4.00; output $4.50 vs $12.00
• Cached read — Qwen4-Max $0.075 vs Grok 4.7 $0.50 below 200K, $1.00 above
• Modality — Qwen4-Max text, image and video in vs Grok 4.7 text and image in
• Independent score — Qwen4-Max 43 on the Artificial Analysis Intelligence Index, rank 38 of 81, vs Grok 4.7 at 35, rank 46 of 81
• Weights — neither vendor publishes any
What a 400,000-token request actually costs
Take the workload both models invite: read a large repository or a long evidence bundle, then write a substantial patch or report. 400,000 input tokens, 20,000 output tokens, no cache reuse.
On Qwen4-Max at the international rate of $1.413 per million in and $4.24 out, that is $0.565 of input and $0.085 of output, about $0.65. At the Singapore rate of $1.50/$4.50 it is $0.69.
On Grok 4.7, the same request never touches the cheap tier, because 400,000 is twice the boundary. It bills $1.60 of input and $0.24 of output: $1.84. The ratio is 2.7 to one, and it is not a rounding artefact — it is the difference between a flat card and a card with a step in it.
Drop the request to 150,000 input and 15,000 output and the picture changes character. Qwen4-Max Singapore: $0.225 plus $0.0675, about $0.29. Grok 4.7 at tier one: $0.30 plus $0.09, about $0.39. A 25 per cent gap, unremarkable, roughly what the headline prices imply. The two cards only separate violently on the workloads where one of them changes tier.
That is the arithmetic the marketing pages skip. When a vendor advertises a price and then adds a long-context tier, the honest comparison is per workload, not per token, because the tier boundary lands right where the product is supposed to be useful.
The agent loop is where the cache design matters more than the price
Long-context readers rarely make one call; they make ten against a stable prefix. Consider a 200,000-token prompt of which 180,000 is cacheable, 10,000 fresh input, 10,000 output, across ten turns.
Qwen4-Max bills, per turn, $0.027 of fresh input, $0.0135 of cache reads at $0.075, and $0.045 of output — $0.0855, so $0.855 for the run. The cache write itself is charged once, at $1.875 per million for a five-minute store, and is small enough at this size to ignore.
Grok 4.7 bills $0.04 of fresh input, $0.09 of cache reads at $0.50, and $0.06 of output — $0.19 per turn, $1.90 for the run. The cache-read rate alone is nearly seven times Qwen4-Max's, which is why the gap more than doubles even though neither model is in its expensive tier here.
If you run this through one endpoint rather than two vendor contracts, the routing layer does not change any of those numbers — 0 per cent markup means the provider's list price passes through untouched, so a vendor price cut lands on your bill the same day it is published rather than at the next contract renewal. That is the argument for keeping a mix of models behind a single key, and it is the only argument in this article that is about our product rather than theirs.
Where Grok 4.7 still wins outright
Two places, and neither is small.
The first is output length. Grok 4.7 publishes a 450,000-token output ceiling. Qwen4-Max publishes no separate output cap; it has a 262,144-token budget shared with its own thinking, and with thinking suppressed the ceiling is 131,072. For work that produces a long artefact rather than a short answer — a generated codebase, a long legal draft, a transcribed-and-analysed corpus — the difference is not about quality. It is about whether the job completes in one call or has to be chunked.
The second is measured evidence at the top end. Grok 4.7 has been on the Artificial Analysis Intelligence Index since September and has three reasoning-effort readings: 35 at xhigh, 35 at high, 31 at low, with time to first answer token moving from 52.9 seconds at the top setting to 10.6 seconds at the bottom. Qwen4-Max has a single published index score of 43 and, as of writing, no output speed or per-task timing on the same board. A 43 against a 35 is a real lead, but a score without a speed reading tells you nothing about whether the model is practical at your latency budget.
There is a third asymmetry that is easy to miss: Grok 4.7's effort control is a cost lever you can pull per request, and its published timings show what each setting costs you in wait. Qwen4-Max exposes reasoning effort too, but Alibaba describes the saving only in relative terms — token usage down 24 per cent at xhigh and 35 per cent at high on its Work360 suite, 48 and 49 per cent on Terminal-Bench 4.0, all measured against Qwen3.8-Max rather than published as a rate card per effort level. Vendor-reported, unreproduced, and relative to a different model: useful as a direction, useless as a budget input.
Where Qwen4-Max wins outright
Context and the shape of the meter.
A million tokens against half a million is not a doubling of a specification; it changes which jobs fit. Three that sit between the two numbers: a monorepo-wide refactor where the relevant slice is 600,000 tokens of dependency graph and history; a discovery exercise over a document set that must be read whole rather than retrieved; and a 24/7 agent that accumulates state across a working day without summarising. Qwen4-Max fits all three. Grok 4.7 fits none of them in one call, and pushing 600,000 tokens into it means either retrieval or the $4/$12 tier — priced at exactly the point where the 2.7× gap becomes hard to defend.
The flat card also makes forecasting possible. A budget owner can multiply tokens by one rate and be right. A stepped card means the finance model has to guess the prompt-length distribution, which in practice means the estimate is wrong in the expensive direction.
And the independent score, such as it is, favours Qwen4-Max: 43 against 35 on the same board. The caveat is real — a model days old has had far less scrutiny, and a single index aggregate hides enormous per-task variance — but the direction is not ambiguous.

What neither model tells you
Neither vendor publishes weights, so neither can be self-hosted, audited, or pinned to a version you control. SpaceXAI publishes no parameter count at all for Grok 4.7. Alibaba publishes an architecture description for Qwen4-Max — gated DeltaNet layers interleaved with a sparse attention mechanism, four parallel residual branches with dynamic gates, an N-gram embedding table — but no weights.
Neither vendor's benchmark numbers are independently audited in the way the index is. Alibaba's Work360 figure of 52.69 against Qwen3.8-Max's 47.74, its claim that average cost per task fell from $4.43 to $1.67, and its 5-to-13-per-cent lower bits-per-byte across five base checkpoints are all first-party and unreproduced. Grok 4.7's advantages are equally undocumented beyond the index: there is no published per-task cost from SpaceXAI, only a token price.
The one independent cost figure that exists cuts against the cheaper card. Artificial Analysis puts Qwen4-Max at $3.27 per Intelligence Index task, and its Grok 4.7 profile does not list a comparable figure at all. Read that carefully: the cheapest-looking model here is the one with a documented per-task bill, and the other is simply unmeasured. It is not evidence that Qwen4-Max is expensive. It is evidence that only one of these two has been costed end to end by anyone.
How to choose
If your prompts routinely exceed 200,000 tokens, Qwen4-Max is the cheaper model by a factor that grows with length, and Grok 4.7's tiering means the usual "just send more context" instinct gets expensive fast. Route long-context work to Qwen4-Max.
If your job is to emit a very long artefact in a single call, Grok 4.7's 450,000-token output ceiling is the deciding number and Qwen4-Max's shared 262,144 budget is the disqualifier. Chunking a generation is not a neutral workaround; it costs you coherence at the seams.
If you need a latency number before you commit, Grok 4.7 has published ones at three effort levels and Qwen4-Max does not. That asymmetry will close as independent testing catches up, but today it is a reason to pilot rather than standardise.
If you already run Grok 4.7 and the question is whether to add Qwen4-Max, the honest answer is to add it selectively: long-context reads, video input, and cost-sensitive batch work, while leaving long-form generation on the model with a documented output ceiling. Two models behind one key costs you a routing rule, not a migration, and it means a bad week at either vendor is a failover rather than an outage.

The scoreboard, with its sourcing attached
The single number that most cleanly separates these models is not the index score — it is the price at 400,000 tokens. Qwen4-Max $0.69, Grok 4.7 $1.84, on each vendor's published international rate. Everything else in this comparison is a judgement about evidence and headroom.
A word on the index scores, because they will be quoted out of context. The 43 and the 35 come from the same Artificial Analysis board, read on 17 November 2026. They are comparable to each other. They are not comparable to the 55 that Kimi K3.1 Pro carried on an earlier rubric, and any article that puts those two figures in the same sentence is comparing two different tests. The vendor figures — Work360, the token reductions, the bits-per-byte deltas — are Alibaba's own and carry no third-party check at all.
One more thing worth knowing before you plan a bill around the 43: the score is a single effort setting. Alibaba ships thinking on by default with a 131,072-token budget and effort set to high, and independent testing has not yet published what the model scores at low effort or what that would save. Until it does, treat the 43 as the price of the model's default posture rather than a dial you can trade down.
Both cards, on one route
Worth stating the operational difference between reading two rate cards and running two models, because it is smaller than the price gap suggests. grok/grok-4.7 is one of the 215 identifiers we serve, at the provider's list price with nothing added, so its tier boundary and its cache rate are whatever SpaceXAI publishes on the day. Qwen4-Max is not one of them; it routes through Alibaba's own Model Studio API. The practical consequence is that the mixed strategy argued for above — long-context reading on Qwen4-Max, long-form generation on Grok 4.7 — needs one vendor relationship for each side, and a routing rule is only as good as the two endpoints underneath it.

Compared in this article1
Detected from this article · Benchmarks: Artificial Analysis · updated daily
