What a 250K prompt costs on Grok 4.7, GPT-6 Sol and Opus 5.5: the 200K and 272K price cliffs

A 250,000-token prompt with 8,000 tokens of output costs $1.10 on Grok 4.7, $0.71 on GPT-6 Sol and $1.16 on Claude Opus 5.5. Each of the first two has a price cliff: a prompt size at which the whole request is repriced, not just the tokens past it. Grok 4.7’s is at 200K and this prompt is already over it. GPT-6 Sol’s is at 272K; Sol’s $0.71 is its default setting, and turning off the caching OpenAI switches on for you brings it to $0.58. Opus 5.5 has no cliff below its 1M context window, and that flat rate wins in two places: single calls above 500K while Sol runs at its default, and repeated calls over a fixed context above 272K, if OpenAI counts cached tokens toward its threshold. OpenAI’s docs do not say.

All rates are the standard, synchronous list prices on each vendor’s own pages, read on 2026-09-23. Every bill below shows its formula, so you can put in your own prompt sizes and re-run it when the sheets change. They will.

Where are the 200K and 272K price cliffs on Grok 4.7, GPT-6 Sol, Opus 5.5 and Gemini 3.8 Flash?

Two vendors put a threshold on the prompt, two do not. Three rates per model matter here: the input rate for new prompt tokens, the cached input rate for prompt tokens the provider reuses from an earlier request with the same beginning, and the cache write rate for storing that beginning so it can be reused.

Cache writes: GPT-6 Sol $2.50, or $5.00 above 272K. Opus 5.5 $5.00 for a 5-minute cache, $8.00 for 1 hour. xAI lists no cache-write rate. Sources: xAI Pricing, OpenAI API Pricing, Claude API pricing, Claude Opus 5.5 overview, Gemini Developer API pricing, Gemini 3.8 Flash model page.

The wording decides the bill. xAI: long-context models “bill the long context rates for all tokens in a request once its prompt reaches the model’s long context threshold.” OpenAI, on the GPT-6 Sol model page: “Prompts with more than 272K input tokens are priced at 2x input and cache rates and 1.5x output for the full request.” Anthropic: “Claude 4.6 and later models … include the full 1M token context window at standard pricing. (A 900k-token request is billed at the same per-token rate as a 9k-token request.)” Opus 5.5 shipped on 22 September, so it is covered.

Read the “Above” column again. Past its threshold Grok 4.7 charges $4.00 per million input tokens. So does GPT-6 Sol. So does Opus 5.5, at every size. For long prompts the three input rates are the same; the differences sit in output ($12, $15, $20), cached input ($1.00, $0.40, $0.20) and cache writes, and which of those decides your bill depends on how often the same long prompt is sent.

GPT-6 Luna carries the identical 272K rule and the same default caching at one twentieth of Sol’s rates; everything said about Sol below applies to it in proportion. Gemini 3.8 Flash is here as a reference point: no threshold, and the same 250K request costs $0.22 (0.25M × $0.75 + 0.008M × $3.75). It is a smaller class of model, so read it as a floor rather than a substitute. Its introductory rates are scheduled to double on 1 January 2027, and its context caching carries an hourly storage fee on top of the cached rate.

Why 2,000 extra tokens double a Grok 4.7 or GPT-6 Sol bill

Because the threshold reprices the request. Two prompts 2,000 tokens apart, same 8K of output, GPT-6 Sol shown both at its default (prompt written to cache at $2.50 or $5.00) and with caching off:

Grok 4.7           199,000 in:  0.199M × $2.00 + 0.008M × $6.00  = $0.446
                   201,000 in:  0.201M × $4.00 + 0.008M × $12.00 = $0.900   (+101.8%)

GPT-6 Sol default  271,000 in:  0.271M × $2.50 + 0.008M × $10.00 = $0.7575
                   273,000 in:  0.273M × $5.00 + 0.008M × $15.00 = $1.485   (+96.0%)

GPT-6 Sol off      271,000 in:  0.271M × $2.00 + 0.008M × $10.00 = $0.622
                   273,000 in:  0.273M × $4.00 + 0.008M × $15.00 = $1.212   (+94.9%)

Opus 5.5           199,000 in:  0.199M × $4.00 + 0.008M × $20.00 = $0.956
                   201,000 in:  0.201M × $4.00 + 0.008M × $20.00 = $0.964   (+0.8%)

If Grok charged the higher rate only on the 1,000 tokens over the threshold, the 201K request would cost $0.452. It costs $0.900, because the first 200,000 tokens and all of the output move to the higher rate as well.

Three details decide which side of the threshold your traffic lands on.

The threshold counts the whole prompt, not the output. System prompt, tool definitions, conversation history and the new message all count. Output does not: a 190K prompt with 30K of output stays on the lower rates, and a 205K prompt with a one-word answer does not.

Cached tokens count on Grok, and probably on Sol. xAI says so outright on its prompt caching usage and pricing page: long context pricing “applies when total prompt tokens (including cached tokens) exceed the model’s long context threshold.” OpenAI does not say. The evidence is indirect: the rule is written on “input tokens”, and in the usage example in OpenAI’s Prompt caching guide, input_tokens is 15,000 with cached_tokens 12,000 inside it. Cached tokens are part of the number the rule is written on. That is our reading, not OpenAI’s statement, and one conclusion further down depends on it.

The exact boundary is loosely worded. xAI’s pricing page says ”≥ 200k” and “reaches”, while the grok-4.7 model page and the caching page both say “exceed”. Which side exactly 200,000 tokens falls on depends on the page you read. OpenAI’s “more than 272K” does not say whether K is 1,000 or 1,024. Keep your guard a few thousand tokens clear of both and neither question matters.

Where you call the model changes how you meet the threshold. A Zenn write-up on the Grok 4.7 500k row notes that in Cursor the 500K context is a separate row you pick, at $4 / $1 / $12, while on the xAI API the same rates switch on by themselves at 200K. The author works from the docs on the API side and says so. In an editor you choose to pay double. On the API a conversation grows past 200K and you find out from the invoice.

The 272K rule is the one already on GPT-6 Astra, OpenAI’s flagship, which we priced in the Astra and Fable 5.1 bill. Grok’s threshold sits 72,000 tokens lower.

GPT-6 Sol’s default caching adds 25% to a single call

OpenAI’s Prompt caching guide says “Prompt caching is enabled by default”, and in the default implicit mode “OpenAI places a breakpoint at the end of the latest eligible message.” For GPT-5.6 and later, “cache writes cost 1.25× the standard, uncached input-token rate.” The guide’s own first-request example reports cache_write_tokens equal to input_tokens. So a single 250K call on GPT-6 Sol writes the whole prompt to cache at $2.50 per million instead of paying $2.00 as plain input, even if nothing will ever read it back:

GPT-6 Sol, 250K in / 8K out
default (implicit)      0.25M × $2.50 + 0.008M × $10.00 = $0.705
caching off             0.25M × $2.00 + 0.008M × $10.00 = $0.580

The same guide gives the way out: in explicit mode, “When no explicit breakpoints are placed, the request does not use prompt caching or create cache writes.” For a call you know is one-off:

{
  "model": "gpt-6-sol",
  "prompt_cache_options": { "mode": "explicit" },
  "input": "…your 250K document and question…"
}

The guide puts the break-even at a single reuse: one write plus one full read costs 1.35× the plain input cost, against 2× for sending the prefix twice uncached. If there is any chance the prompt comes back within the 30-minute lifetime, leave caching on. If there is none, turn it off.

With both settings for Sol, single calls at 8K output look like this:

Grok 4.7 is cheapest below 200K, where it matches Sol on input and charges $6 for output against $10. Sol is cheapest from 200K to 272K, at roughly half of Grok’s price with caching off and about two-thirds of it by default. Above 272K Grok is cheapest while it fits: at 300K it is 1.9% under Sol with caching off and 4.9% under Opus. Grok’s 500K window has to hold the prompt and the output together.

Above 500K it comes down to that one setting. With Sol at its default, Opus 5.5 is the cheapest, and Sol costs 21.9% more than Opus at 600K. With caching off, Sol is back in front by 1.6%. A setting most teams have never touched decides which vendor is cheapest for long single calls.

Repeated calls over a fixed long context: when Opus 5.5’s flat rate wins

The second workload is one long context asked many questions: document Q&A over a contract set, a pinned slice of a codebase, a knowledge base loaded once per session. Model it as 20 calls, each sending a prompt of P tokens, of which P − 10K is the fixed context (written to cache on call 1 and read from cache after that) and 10K is the new question, with 2K of output per call:

call 1      = context × cache_write + 10K × input + 2K × output
calls 2..20 = context × cached      + 10K × input + 2K × output   (each)
total       = call 1 + 19 × call 2

For GPT-6 Sol this assumes an explicit breakpoint at the end of the fixed context, so only the context is written. Left on implicit mode, Sol also writes each 10K question at the cache-write rate; that adds $0.10 over 20 calls below 272K and $0.20 above. Opus 5.5 caches only when you ask it to, using cache_control; its default cache lives 5 minutes, and a 1-hour cache costs $8.00 to write instead of $5.00 (Anthropic’s prompt caching docs). OpenAI’s GPT-6 cache lasts at least 30 minutes after its last use.

By hand, Opus 5.5 at 300K: call 1 is 0.29M × $5 + 0.01M × $4 + 0.002M × $20 = $1.53; each later call is 0.29M × $0.20 + $0.04 + $0.04 = $0.138; $1.53 + 19 × $0.138 = $4.152.

Below 272K GPT-6 Sol is cheapest, because its $0.20 cached rate matches Opus’s and every other rate is lower. Above 272K, on the assumption that cached tokens count, Sol’s cached rate doubles to $0.40, Grok’s is $1.00, and Opus stays at $0.20. On repeated calls the cached rate carries most of the bill, and it is the one rate where Opus is strictly the cheapest.

That result has two conditions, and both are visible in the table.

• The calls come less than 5 minutes apart. If a person reads each answer before asking the next question, you need the 1-hour cache, and at 300K Opus’s $5.022 and Sol’s $5.054 are level.
• OpenAI counts cached tokens toward 272K. If it does not, each later Sol call at 300K is billed on its 10K of new tokens at the lower rates, and Sol costs $3.382 against Opus’s $4.152: cheapest at every size in the table. xAI states the rule; OpenAI does not, so this column is the range of honest answers, not an edge case.

It also takes a few calls. At 300K, two calls are cheapest on Grok ($1.578 against $1.706 and $1.668); Opus leads from the third call. And the model is a lower bound for agent sessions, whose context grows every turn and usually crosses a threshold partway through rather than starting over it. That case needs the next section.

Switching providers mid-session means rebuilding the cache

A cache lives with one provider. Move a session from GPT-6 Sol to Opus 5.5 at a 300K context and the first call on Opus has to write the 290K context again: 0.29M × $5 = $1.45 of the $1.53 that call costs. After that, each call saves $0.048 (Sol $0.186, Opus $0.138).

switch premium   = Opus first call − Sol call = $1.530 − $0.186 = $1.344
saving per call  = $0.186 − $0.138            = $0.048
break-even       = $1.344 ÷ $0.048            = 28 further calls

With 20 calls left, staying on Sol costs $3.534 and switching costs $4.014. The two meet at 29 calls left; only at 40 does switching come out ahead, $6.912 against $7.440. And if OpenAI does not count cached tokens toward the threshold, a later Sol call costs $0.098, less than Opus’s $0.138, and the switch never pays at all.

So the provider for a long session is a decision made at its start, from the context size you expect it to reach. Moving it partway is worth it only when a long run of calls is still ahead.

Routing by prompt size: which provider for which request

Price first, with a warning on top. The three models are not interchangeable on quality or behaviour, and a model that needs fewer calls beats all of this arithmetic. Before routing a workload on price, re-run a sample of it on the cheaper model and check the answers still find what they need in the long context.

Standard tier, synchronous, 8K output for single calls; repeated calls as modelled above, with the context already over the threshold when the session starts:

Off the synchronous tier the tables shift. OpenAI prices Batch and Flex at 50% of standard, Anthropic’s Batch API halves Opus 5.5 to $2 / $10, and grok-4.7 has no batch discount; its model page lists the Batch API as not supported. Each vendor’s regional or US-only processing adds 10% to every rate.

The guard in front of the call is small:

# Long-context thresholds, standard tier, read 2026-09-23. Config, not code: they move.
THRESHOLDS = {
    "grok-4.7": 200_000,   # higher rates once the prompt reaches 200K
    "gpt-6-sol": 272_000,  # higher rates when input is more than 272K
    "gpt-6-luna": 272_000,
}
MARGIN = 0.05  # a starting point; set it from your own counts, see below

def in_repricing_zone(model: str, prompt_tokens: int) -> bool:
    # Flags requests in the repricing zone; routing itself uses the table above.
    limit = THRESHOLDS.get(model)
    return limit is not None and prompt_tokens >= limit * (1 - MARGIN)

prompt_tokens has to be the full prompt: system prompt, tool definitions, history and the new message. Each vendor gives you a way to count it before you send:

• OpenAI: client.responses.input_tokens.count() takes the same payload as a request and returns the count the model will receive (Counting tokens).
• Anthropic: the token counting endpoint takes a Messages payload and returns an estimate, which “might differ by a small amount” (Token counting).
• xAI: POST /v1/tokenize-text tokenizes plain text only (API reference), and xAI notes that inference endpoints add pre-defined tokens on top of it (Billing FAQ). Treat it as a floor.

The same document is a different number of tokens at each vendor. A 5% margin is a starting point. The right one comes from your own logs: compare the count before the call with the total the provider reports after it, per provider, on your own documents. That total is usage.input_tokens on OpenAI’s Responses API and usage.prompt_tokens on xAI’s Chat Completions. On Anthropic it is three fields added together: input_tokens + cache_creation_input_tokens + cache_read_input_tokens, because input_tokens alone excludes anything cached.

When the guard fires, each option has a price:

• Trim. A Grok prompt cut from 201K to 185K, under the 190K the guard fires at, goes from $0.900 to $0.418. The cost is whatever you cut: boilerplate is free money, the clause the answer depended on is a wrong answer at half the price.
• Split, for extraction only. A 250K document as two 125K Grok calls costs 2 × (0.125M × $2 + 0.008M × $6) = $0.596, against $1.096 in one call. Neither call sees the whole document, which is fine for pulling fields out and wrong for anything that needs cross-references.
• Choose the provider when the session starts, from the size it will reach, using the table. The cost is a second provider in your stack, with its own tokenizer, errors and quality profile.
• Pay it. Sometimes the right call. With the guard in place you at least know you did.

This is the layer we build, so here is the bias stated plainly. Deciding the provider from prompt size and caching pattern is awkward in application code, where every service ends up holding its own copy of these price sheets and tokenizers. A router sees the request size and the price table in the same place. PiRouter is designed to make that choice a routing rule between the models it carries. Grok 4.7 and Opus 5.5 are not among them today; the model list shows what is.

Are your one-off GPT-6 calls paying for a cache nobody reads?

The first thing to pull from your logs is not the threshold traffic. It is the one-off calls. Take 30 days of requests to GPT-5.6 and later OpenAI models, keep the ones whose prompt beginning never appears again, and check whether they ran with caching at its default. Each of them paid 1.25× input on its whole prompt to store something no later request read. On a 250K call that is $0.125 of a $0.705 bill, it applies below the threshold as well as above it, and the fix is one field in the request.