Grok 4.6 API Pricing: The 200K Cliff and When 4.5 Wins

Grok 4.6 costs $2.00 per million input tokens and $6.00 output, which is exactly what Grok 4.5 costs. The two model cards are otherwise identical down to the rate limits. One number differs, cached input, and it is the newer model that is more expensive there.

The bigger number is the one that is not a difference between models at all: at 200,000 prompt tokens, every rate doubles, and it doubles for the whole request.

Model IDs:     grok-4.6 / grok-4.5  (x-ai/grok-4.6 on gateways)
Context:       500K tokens, both
Under 200K:    $2.00 in / $6.00 out    both models
                $0.50 cached on 4.6, $0.30 cached on 4.5
200K and over: $4.00 in / $12.00 out   both models
                $1.00 cached on 4.6, $0.60 cached on 4.5
Threshold:     applies to ALL tokens in the request, not the excess
Measured:      fixed per-request overhead 206 tokens on 4.6, 494 on 4.5
Break-even:    ~575 cached tokens; below it 4.6 is cheaper per call
Snapshot:      2026-08-19

How Much Does the Grok 4.6 API Cost?

$2.00 in, $0.50 cached in, $6.00 out per million tokens, until the prompt reaches 200K. Straight from xAI’s model list, which its own documentation site now brands SpaceXAI:

Grok 4.3 is in that table for a reason. It is 38% cheaper on input and 58% cheaper on output than either 4.x flagship, and it carries a 1M context instead of 500K. If your workload does not need the newest model, the tier below is not a small saving.

Gateways pass the headline rate through unchanged. OpenRouter and ofox both list x-ai/grok-4.6 at $2.00 and $6.00 with a 500,000-token context. What neither catalog exposes is the second row. Gateway model listings tend to carry a single price pair per model, so the doubling above 200K is invisible until it lands on your invoice. Read it off xAI’s table, not off a catalog field.

What Happens When Your Prompt Crosses 200K Tokens?

The whole request reprices, not the overflow. xAI’s wording is unambiguous: requests whose prompt reaches the threshold are billed at the higher rate for all tokens in the request.

Two requests, 2,000 tokens apart, both with 2,000 tokens of output:

A 1% larger prompt for a 102% larger bill. There is no gradual slope here, and no partial credit for the tokens below the line.

The practical consequence is that 200K is a hard ceiling for cost-sensitive work, not a soft one, even though the context window runs to 500K. Anything past 40% of the window is on the expensive tier.

Two things make that line easier to cross than it looks. First, the threshold counts the prompt, so a long conversation walks toward it one turn at a time and crosses it without any single message being large. Second, your prompt is not the only thing in the prompt, which is the subject of the next section.

If you are batching, the fix is to split before the line rather than after it. Two 150K requests at the low tier cost $0.60 in input; one 300K request costs $1.20 for the same tokens.

What Is the Difference Between Grok 4.6 and Grok 4.5?

One number on the published cards. We pulled both model cards and put every field side by side:

Cached input is 67% more expensive on the newer model. That is the opposite of the usual direction and it is the entire published basis for keeping 4.5 around.

The alias row is worth a second look if you use Grok Build: grok-build-latest resolves to Grok 4.5, not 4.6. If you assumed the Build tier tracks the flagship, it does not. Our Grok Build versus API cost breakdown covers where the subscription beats metered billing.

Why Does the Same Prompt Cost More on Grok 4.5?

Because a fixed block of input tokens rides along with every request, and it is more than twice as large on 4.5.

We sent identical bodies of 1, 50 and 200 repeated words to four models through an OpenAI-compatible gateway on 2026-08-19 and fit the line. Every model tokenized the body at exactly 1.00 token per word. The intercepts did not match:

Four and twelve tokens are an ordinary chat template. Two hundred and four hundred and ninety-four are a preamble. Adding your own system message raised both figures by exactly the size of that message, 7 tokens, so this sits underneath anything you send rather than replacing it.

We could not test a second route to attribute it, so treat the source as unproven: the overhead travels with the model rather than with the gateway, since 4.3 and a non-xAI model on the same endpoint show none of it, but confirming whether it originates upstream would take a direct key. Either way it is on your invoice, so price it.

Priced at the published rates, before you send a single token of your own:

The cheaper cache rate on 4.5 is real, and on short calls the larger preamble more than eats it.

It also eats your headroom. On 4.5 you reach the 200K cliff 494 tokens earlier than your own token count suggests, and 206 tokens earlier on 4.6. If you are budgeting a prompt at exactly 199,800 tokens, you are already over.

Which One Is Cheaper for Your Workload?

Around 575 cached tokens, the answer flips.

The arithmetic is small enough to check by hand. Grok 4.5 saves $0.20 per million cached tokens, which is $0.0000002 per cached token. It loses $0.000115 per request on the larger preamble. Divide one by the other and you get 575 tokens.

• Cached prefix under ~575 tokens: Grok 4.6 costs less per call
• Cached prefix over ~575 tokens: Grok 4.5 costs less, and the gap widens linearly
• A 100K-token cached system prompt and tool schema saves $0.02 per request on 4.5, which is roughly 170 times the preamble penalty

The 200K threshold does not move that line. Above it every rate doubles on both models, the cache advantage doubles to $0.40 per million and the preamble penalty doubles too, so the break-even stays at about 575 tokens.

That covers input. Output is where the two models genuinely diverge, and it does not follow the cache logic at all. We ran the same code-generation prompt through both, 8 runs each:

That last row is the only one in the table that is not an output-side number, so here is its basis. It is output at $6.00 per million plus the full input at $2.00 per million, and the input side includes the fixed per-request overhead from the previous section: 244 input tokens on 4.6, 532 on 4.5. Output alone would be $5.69 and $1.58. We did not record cache hits on these particular runs, so the input is priced entirely at the uncached rate, which makes the all-in figure an upper bound; if the preamble was served from cache it lands nearer $5.98 and $1.99. The ordering does not move either way.

All 16 responses contained a function definition and a docstring, which is a structural check rather than a quality judgement; we did not grade the code. What is not in doubt is the spend. On this task Grok 4.6 billed 3.6x the output tokens and took 3.2x the wall clock for a job both models completed.

Watch the field names there. completion_tokens excludes reasoning tokens on these models: a response reporting 216 completion tokens had 723 reasoning tokens alongside it, and total_tokens was the sum of prompt, completion and reasoning. Any cost estimator built on prompt_tokens × input + completion_tokens × output undercounts the billed output on this workload by 77%, and the call as a whole by about 71%. That single field is a bigger error than every pricing difference on this page.

So the short version: 4.5 for long cached prefixes and for short deterministic work where you do not want to pay for deliberation, 4.6 when the extra reasoning is the point.

How Do I Call Grok 4.6?

OpenAI-compatible, so it is a base URL and a model string.

from openai import OpenAI

client = OpenAI(api_key="YOUR_KEY", base_url="https://api.ofox.io/v1")

r = client.chat.completions.create(
    model="x-ai/grok-4.6",          # x-ai/grok-4.5 for the cheaper cache tier
    messages=[{"role": "user", "content": "Refactor this module and run the tests."}],
)
u = r.usage
billed_output = u.completion_tokens + u.completion_tokens_details.reasoning_tokens
print(u.prompt_tokens, billed_output)

Three things that bite people on the way in:

• The ID is namespaced on gateways. grok-4.6 works against xAI directly; on OpenRouter and ofox it is x-ai/grok-4.6. The hyphen matters.
• logprobs fails silently. xAI documents it as unsupported on grok-4.20 and newer and says the field is ignored. We sent logprobs: true with top_logprobs: 3 to both models: HTTP 200, no error, and no logprobs object in the response. Nothing tells you it did not work.
• Both models are in us-east-1 and us-west-2 only. If you have data-residency constraints outside the US, this pair is not the answer regardless of price.

15% off top-ups through 2026-08-31 at ofox puts x-ai/grok-4.6 and x-ai/grok-4.5 on the same key and the same endpoint as roughly 130 other models, which is what makes the A/B above a one-string change. The live catalog specs are on the Grok 4.6 and Grok 4.5 model pages.

For rate limits across providers, our LLM API rate limits comparison has the numbers side by side. For the older Grok lineup and key setup end to end, the Grok API pricing and setup guide still covers the basics.

References

• xAI developer docs: models and pricing
• xAI developer docs: Grok 4.6 model card
• xAI developer docs: Grok 4.5 model card
• OpenRouter: x-ai/grok-4.6
• ofox model page: Grok 4.6
• ofox model page: Grok 4.5