Grok 4.20 Guide: One Model Name, Three Different Endpoints

"Grok 4.20" sounds like a single model. On xAI's API it is three: a reasoning model, a non-reasoning model, and a multi-agent variant, all published under the same 0309 snapshot and all billed at the same per-token rates. Which one you are actually calling depends on the exact model string, and a generic alias can hide that from you.

A note on names: xAI, the company behind Grok, was renamed SpaceXAI in July 2026 after SpaceX acquired it. This guide uses the xAI name throughout.

That matters more than it used to, because Grok 4.20 is no longer the newest thing in the family. Grok 4.3, 4.5, 4.6 and 4.7 have all followed it. This guide covers what 4.20 is, what it costs, and the narrower set of jobs where it is still the sensible pick.

What Grok 4.20 actually is

xAI's release notes record Grok 4.20 and Grok 4.20 Multi-agent going live on the API in March 2026. The model page describes it as a high-performance model with "industry-leading speed and agentic tool calling capabilities", and also stresses low hallucination rates and strict prompt adherence. Those are vendor descriptions, not measurements, so treat them as a statement of intent.

The facts you can rely on are on the model pages themselves:

• Context window: 1,000,000 tokens. Some catalogues list 2M for this model; xAI's own page says 1M, and that is the figure to plan around.
• Modalities: text and image in, text out.
• Capabilities: function calling and structured outputs on both single-model variants; reasoning on the reasoning variant only.
• Rate limits: 37 requests per second and 10 million tokens per minute on the single-model variants, at the time of writing.

xAI does not publish a parameter count or architecture for it, and there are no open weights. It is an API-only model.

Reasoning or non-reasoning: choose per call

The split into grok-4.20-0309-reasoning and grok-4.20-0309-non-reasoning is the most useful thing about this release, and it is easy to overlook. Rather than one model with an effort dial, you get two endpoints with identical prices, and the difference is whether the model spends hidden tokens thinking before it answers.

That makes routing simple. Extraction, classification, reformatting and short tool-dispatch turns rarely benefit from reasoning, and reasoning tokens are billed as output. Send those to the non-reasoning endpoint. Multi-step planning, debugging and anything with a chain of dependent decisions goes to the reasoning one. Reasoning models explained covers which task shapes actually gain from thinking longer.

Note the alias trap: plain grok-4.20 is an alias of the reasoning snapshot. If you assumed it was a neutral default, you have been paying for reasoning on every call.

The third variant, grok-4.20-multi-agent-0309, runs several agents in parallel and returns a synthesised answer. It behaves differently enough, with different API support and different tool rules, that it has its own article: Grok 4.20 Multi-Agent guide.

The 200K pricing cliff

xAI lists Grok 4.20 at $1.25 per million input tokens, $0.20 per million cached input and $2.50 per million output, for prompts under 200K tokens. OpenRouter lists the same base rates at the time of writing. Prices move, so check before you budget.

The detail that catches people is the second tier. Once a prompt reaches 200K tokens, every rate doubles, to $2.50 input, $0.40 cached and $5.00 output, and xAI's wording is that the higher rate applies to all tokens in that request, not just the ones above the threshold. A 199K-token prompt and a 201K-token prompt differ by far more than 2K tokens' worth of cost.

For anything that grows a transcript, such as an agent loop or a long chat, this turns 200K into a soft ceiling. Compacting context before you cross it is usually cheaper than paying double on every subsequent turn. Context window cost trade-offs walks through the arithmetic.

Aliases, snapshots and reproducibility

The reasoning snapshot carries more than a dozen aliases, including grok-4.20-beta, grok-4.20-0309 and several experimental names from the March beta period. xAI's convention is that a -latest alias follows the newest version while a dated name such as -0309 stays fixed.

If you are running evaluations or anything where behaviour drift is a bug, use the dated name. You will then know that a change in output came from your prompt, not from a silent model update. Batch requests are supported on both single-model variants at a 20% discount, which suits offline evaluation and bulk processing.

One small migration gotcha: xAI states that logprobs and top_logprobs are not supported on Grok 4.20 and newer, and the fields are silently ignored rather than rejected. Code that relies on token probabilities for confidence scoring will quietly receive nothing.

Where it sits in the family now

Grok 4.3 is listed at exactly the same rates, with the same 1M window, and adds a five-level reasoning effort control. Grok 4.5 and later move to $2 input and $6 output with a 500K window, aimed at coding and longer agent work.

So the honest comparison for 4.20 is with 4.3, not with the flagship. Price is identical, so the decision comes down entirely to behaviour on your tasks. Reasons to stay on 4.20:

• You have a pipeline validated against the 0309 snapshot and no reason to re-validate.
• You want a hard guarantee of no reasoning tokens, which the separate non-reasoning endpoint gives you by construction.
• You want the multi-agent variant, which only exists on 4.20.

For new work, start by evaluating Grok 4.3 alongside it, and only step up to the 4.5-and-later tier if the cheaper models measurably fail your tasks.

A short evaluation plan

1. Take twenty real requests from your logs, split between simple and multi-step.
2. Run the simple half on the non-reasoning endpoint and the reasoning endpoint. If quality is indistinguishable, you have found free savings.
3. Run the multi-step half on Grok 4.20 reasoning and Grok 4.3 at its default effort, same prompts, same tools.
4. Record output tokens per task and whether you would accept the result unedited. Cost per accepted answer is the number that decides it.

Keep the prompts and results. When xAI ships the next snapshot, re-running the same twenty requests tells you in an afternoon whether to move.