What It Costs to Fill a Context Window

By J. Wren · Published 2026-10-21

Rates as synced on 2026-10-20; see the change log for changes since.

Of the 13 models tracked on this site, 10 accept an input of 900,000 tokens or more. Fill one of them to the limit, once, and the bill for that single request runs from $0.2621 (Gemini 3.1 Flash-Lite) to $10.0000 (Claude Fable 5), a spread of 38.1×. That is input tokens only, for one request, with nothing cached and no answer generated yet.

The sticker prices leave something out. 4 of those 10 models charge a higher rate once the prompt passes a threshold: 272,000 tokens for the three GPT-5.6 models, 200,000 for Gemini 3.1 Pro. A prompt that fills half the window is already past both lines. This article works out what a full, a half-full and a one-tenth-full request cost on each model, shows where the higher rate bites, and publishes the script; re-run it when the rates move.

How this was computed

For each model on the site's price list I took the maximum input size, built three prompts from it, and priced each one. The arithmetic is deliberately plain:

tokens = round(max input * fraction)        fraction = 1, 0.5, 0.1
cost   = tokens * rate / 1,000,000          rate in USD per million input tokens

"Max input" is the max_input_tokens field in the LiteLLM dataset that this site's daily sync reads. It is an input limit. It says nothing about how long an answer can be. The labels differ from vendor to vendor: Gemini's "1M" is 1,048,576 tokens and Claude's "1M" is 1,000,000, a gap of 48,576 tokens, and the GPT-5.6 models stop at 922,000. I use each model's own number rather than rounding them all to a million. The figures for ratios and for the number of fills per $100 come from unrounded costs, which can move the last digit compared with dividing two rounded table cells.

The site's pricing file keeps one flat input rate per model. The long-context rates are not in it. I read them from the same LiteLLM dataset on 2026-10-13 and wrote them at the top of the script, with the field name beside each:

• GPT-5.6: input $4.00 → $8.00, output $20.00 → $30.00, above 272,000 tokens (input_cost_per_token_above_272k_tokens, output_cost_per_token_above_272k_tokens).
• GPT-5.6 Terra: input $2.00 → $4.00, output $12.00 → $18.00, same threshold.
• GPT-5.6 Luna: input $0.20 → $0.40, output $1.20 → $1.80, same threshold.
• Gemini 3.1 Pro: input $2.00 → $4.00, output $12.00 → $18.00, above 200,000 tokens (input_cost_per_token_above_200k_tokens and the matching output field).

LiteLLM's cost calculator bills the whole prompt at the higher rate once it is over the threshold, and switches the output rate for that request too. The rule is in litellm/litellm_core_utils/llm_cost_calc/utils.py (I read it at commit c2bc5ae), and the comparison is strictly "greater than". OpenAI's pricing page labels its tiers "Short context: ≤272K input tokens" and "Long context: >272K input tokens", and Google's labels them "prompts <= 200k tokens" and "prompts > 200k tokens". Both pages put a prompt of exactly 200k or 272K in the lower tier, which is also how the script treats it. Neither pricing page says in words whether the higher rate covers the whole prompt or only the part above the threshold; the vendor's bill is the authority, and this article follows LiteLLM's reading.

Filling the window: all 13 models

Figure 1 shows the full-window price of every model. Where a model has a higher rate, the solid part of the bar is what a single-rate calculation would give and the lighter part is what the higher rate adds.

Figure 1 — USD for one request that fills the whole input window, input side only

Table 1 — price of one request at 100%, 50% and 10% of the maximum input size (USD). † = higher rate applied above the threshold.

† The same fills at the single flat rate, for comparison: GPT-5.6 $3.6880 full and $1.8440 half; Gemini 3.1 Pro $2.0972 and $1.0486; GPT-5.6 Terra $1.8440 and $0.9220; GPT-5.6 Luna $0.1844 and $0.0922. The tenth column is the same either way.

Claude Fable 5 is at the top of the table with $10.0000 and GPT-5.4 nano at the bottom with $0.0544. Those two are not the same kind of request: nano's limit is 272,000 tokens, Fable's is 1,000,000. For a comparison that holds the kind of request fixed, look at the long-context models in Table 2, or at the fixed prompt size further down.

Half a window still pays the higher rate, for four models

The threshold sits low enough that the middle column is not spared. Half of GPT-5.6's 922,000 is 461,000 tokens, well past 272,000; under that rule the whole prompt is priced at $8.00: $3.6880, where a single-rate calculation says $1.8440. Half of Gemini 3.1 Pro's 1,048,576 is 524,288, past 200,000, and costs $2.0972 instead of $1.0486. Terra and Luna behave the same way.

The tenth column is the only one where all 13 models are billed at their ordinary rate. A tenth of the GPT-5.6 models' window is 92,200 tokens and a tenth of Gemini 3.1 Pro's is 104,858, both under their thresholds. The step shows up as a ratio of full to tenth. For GPT-5.6 a full fill is $7.3760 and a tenth is $0.3688, a ratio of 20.0×; for Claude Opus 5 the same ratio is 10.0×.

One more detail about the 1M labels. The Gemini window runs 48,576 tokens past a round million, and on Gemini 3.1 Pro every one of those tokens is priced at the higher rate, $4.00 per million: $0.1943 for the overhang alone.

Fits, at a dollar or more a fill

"It fits" and "it is cheap to fill" are different questions. I made the second one explicit. The test is a formula, and the script computes it for every model:

long_context    = max input >= 900,000 tokens
pricey          = one full fill, higher rate included, >= $1.00
fits_but_pricey = long_context and pricey

The word "pricey" is mine, and the $1.00 line is mine too; no vendor defines either, and the line says nothing about whether any particular fill is worth its price. Here is where the line falls. Sort the 10 long-context models by full-fill price and look at the ratio between neighbours. The largest step is between Gemini 3.6 Flash at $0.7864 and Claude Sonnet 5 at $2.0000, a factor of 2.5×. The next largest is between GPT-5.6 Luna at $0.3688 and Gemini 3.6 Flash at $0.7864, a factor of 2.1×. A line of $1.00 sits inside the first of those steps. A line at or below $0.7864 would add Gemini 3.6 Flash to the list. I put it in the biggest gap, and you can move it: the constant is at the top of the script.

With the line at $1.00, 6 models are in: Claude Fable 5, GPT-5.6, Claude Opus 5, Gemini 3.1 Pro, GPT-5.6 Terra and Claude Sonnet 5. 4 are out: Gemini 3.6 Flash, GPT-5.6 Luna, Gemini 3.5 Flash-Lite and Gemini 3.1 Flash-Lite. Table 2 gives the numbers, plus how many full fills a budget of $100 covers and what a 200,000-token prompt costs on each model.

Table 2 — the 10 long-context models: price of one full fill (USD), full fills per $100, and price of a 200,000-token prompt (USD).

The last column uses the base rate for Gemini 3.1 Pro: a prompt of exactly 200,000 tokens is not above its 200,000-token threshold.

The same 200,000 tokens on every model

A tenth of a window is not a fixed amount of text. A tenth of Claude Haiku 4.5's window is 20,000 tokens and costs $0.0200; a tenth of GPT-5.6 Luna's is 92,200 tokens and costs $0.0184. In that pair, the cheaper fill is the one with the bigger prompt.

To compare like with like, use a prompt every model can take. 200,000 tokens is the largest such size: it is Haiku 4.5's limit, and the other twelve models accept at least that much. At that size the prices run from $0.0400 (GPT-5.6 Luna and GPT-5.4 nano, tied) to $2.0000 (Claude Fable 5), a factor of 50.0×. For comparison, full fills across all 13 models differ by 183.8×, but those fills range from 200,000 to 1,048,576 tokens each, and among the 10 long-context models alone they differ by 38.1×. Three different questions, three different numbers; I would not quote one of them without saying which.

What this does not show

Everything above is the input side of one request. Output tokens, and any reasoning tokens billed as output, are not in the numbers. On the four models with a higher rate, the output rate for the request also moves up once the prompt is over the threshold (GPT-5.6 from $20.00 to $30.00 per million, Gemini 3.1 Pro from $12.00 to $18.00). An estimate that includes the answer will come out higher than the figures here.

The prices are standard global rates. Prompt caching (LiteLLM also counts cached tokens toward the threshold), batch, priority and flex pricing are left out, as is any surcharge for processing in a particular region, which can cost more. The 13 models are the ones this site tracks, not a survey of the market: the four Claude models tracked here have no long-context rate in the LiteLLM dataset, which is a statement about those four. It is not a claim about every Anthropic model.

Rates move. Google's pricing page lists Gemini 3.6 Flash's current rate as running through December 31, 2026 (checked 2026-10-13), and the figures here may need re-running after that date. Last, none of this says a model will do good work on a full-size prompt; that is a separate question, and the context window calculator has a section on it, "Fitting is not the same as working well".

How to reproduce this

The script and its output are published next to the earlier ones: context_fill_cost.py and context_fill_cost.results.json. It uses only the Python standard library and reads ../pricing.json (the same file the calculators use); keep it in a folder whose parent holds that file.

python context_fill_cost.py
python context_fill_cost.py --html    # also prints Table 1, Table 2 and Figure 1 as HTML

The long-context rates are constants at the top of the file, each with its LiteLLM field name and the date it was read. The script checks that the base rates recorded there still match pricing.json; if one has changed it stops without writing anything, which is the signal to read the dataset again. The results file also carries every number used in the prose above as a ready-made string under display.

To work out a monthly figure instead of a single request, use the LLM API cost calculator. To see whether a given amount of text fits a window in the first place, use the context window calculator. The same text can be a different number of tokens on a different tokenizer, which the Gemini vs GPT token-count guide measures. For changes to the rates themselves, see the pricing change log.