What is a context window and why does it change what a model can do?
A context window is the amount of text a model can hold in mind at once, measured in tokens. On the OpenAI, Anthropic and Google pages this guide reads, published windows run from 200,000 tokens up to just over a million. When a conversation outgrows the window, the model starts losing the beginning, which is why long chats drift.
US dollars per 1M input tokens
Data: our pricing ledgerverified Chart: AI Journey
Model announcements lean hard on this number: a million tokens of context, printed like a top speed. It is a real and useful figure, but it measures something narrower than the marketing suggests. This guide explains what the window actually holds, shows the sizes the vendors publish, read from their own pages and kept in our ledger, and covers the part the announcements skip: what filling a window costs, and what happens at the edge of it.
Tokens, the unit the window is measured in
A token is the chunk of text a model processes at a time: a short word, a piece of a longer one, a punctuation mark. English averages out near three quarters of a word per token, so 200,000 tokens is roughly the length of one long novel. A context window is the maximum count of tokens the model can consider in a single request: everything it reads and everything it writes back, together, inside one limit. It is working memory, not knowledge. The model’s training does not sit in the window; your conversation does.
What fills the window
The window holds more than your typing. Each request packs in the system prompt, the standing instructions the vendor or app developer wrote; the conversation so far, resent in full with every turn; anything you attached or pasted; whatever a search or file tool returned this turn; and the space the reply itself will occupy. A short question at the end of a long chat is not a short request, because the chat rides along with it.
That is why long conversations degrade. When the total no longer fits, the software in front of the model quietly drops or summarises the oldest turns. The model answers confidently without them, and the person on the other end experiences it as forgetting.
The published windows, from our ledger
These figures come from the vendors’ own model and pricing pages, each read on 6 September 2026 and recorded in our pricing ledger with its source. Not all of them sit on a price page. Google prints the Gemini window on the model’s own page rather than on its pricing table, Anthropic prints the Claude windows on its models overview, and the Grok figure comes from xAI’s model docs. Where a vendor splits the figure across a model page and a price page, the ledger records which of them each half came from.
| Model | Published window | Roughly |
|---|---|---|
| GPT-6 Astra (OpenAI) | 1,050,000 tokens | several novels |
| Gemini 3.8 Flash (Google) | 1,048,576 tokens | several novels |
| Claude Sonnet 5 (Anthropic) | 1,000,000 tokens | several novels |
| Grok 4.6 (xAI) | 500,000 tokens | a long shelf of documents |
| Claude Haiku 4.5 (Anthropic) | 200,000 tokens | one long novel |
The consumer products publish less. On the pages our plans ledger reads, Anthropic states a million token window on Claude’s paid plans, and Google states the same on its AI Pro and Ultra tiers but publishes no window for the cheaper AI Plus, while OpenAI publishes no per plan window for ChatGPT at all. Where a vendor prints nothing, our ledger records nothing rather than an estimate, which is why the same column is populated for one paid tier and empty for the tier below it.
A bigger window is not free
The window is billed by the token, at the input rates explained in our guide to how model pricing works. The headline rate is not the rate that applies at the top of the window, and this is the detail worth learning before you plan a bill around a big number. It sits on OpenAI’s own model page for GPT-6 Astra: a prompt of more than 272K input tokens is billed at twice the input and cache rates, and one and a half times the output, for the full request. The pricing table carries the matching long context columns, where the input line reads $20 per million against the short context $10.
Filling the 1,050,000 token window is by definition a long context request, so one filled window costs about $21 in input alone, before the model writes a word back. Multiplying the advertised window by the advertised price gets you half the bill. The chart above makes the same point from Anthropic’s list: the cheapest Claude is the one with the smallest window. Capacity is the product.
The second cost is subtler. A model can accept a million tokens without attending equally to all of them, and vendors know it: their long context documentation coaches developers on where to place important material. A window size is a limit, not a promise of perfect recall across the whole span. Treat “fits in the window” and “will be used well” as different claims.
What it means for you
For everyday chat, the practical rules are short. Start a fresh conversation for a fresh topic, because an old chat drags its whole history into every request and spends your allowance on it. When a long session starts contradicting itself, the window is the likely reason: ask the model to summarise the conversation, then carry the summary into a new one. And put the material that matters near your question rather than fifty pages up, whatever the advertised size.
When you compare plans or models, read the window the way you now read the price: as a published, dated figure that varies more inside a vendor’s lineup than the marketing admits, and that this site records with its source on the plans and pricing pages. The number changes what a model can do, but only when what you need is genuinely more text at once, and you are willing to pay by the token to use it.
Questions people also ask
- What is the context window of ChatGPT?
- OpenAI publishes window sizes for its API models, up to 1,050,000 tokens for GPT-6 Astra on the page we read on 6 September 2026, but publishes no per plan window for ChatGPT itself. We record the ChatGPT figure as unpublished rather than guessing one.
- How many words fit in a 200,000 token context window?
- Enough for a long novel. Anthropic's models overview does the conversion for its own lineup: it puts 200,000 tokens at roughly a 150,000 word novel, and a million tokens at roughly 555,000 on its current tokenizer, which is several novels, or one sizeable codebase, at once.
- Why does a chatbot forget the start of a long conversation?
- Because the whole conversation must fit into the window with every new message. Once it cannot, the software drops or compresses the oldest turns before the model reads the rest, so the model is not being forgetful: it was never shown the beginning again.
Where these numbers come from
Every figure on this page was read from the pages below on the dates shown, and nothing here is taken from another publisher's article. When a vendor changes a number on this page, the change is logged in what changed in AI and the page is corrected with a new date.
Primary sources
OpenAI API docs, where the GPT-6 Astra window and output caps are published
read
read
Anthropic's models overview, where the window for each Claude model is printed
read
Google's model page for Gemini 3.8 Flash, the source of its input token limit
read
xAI's model page for Grok 4.6, the source of its published window
read
Anthropic's Claude docs, the window and price for each Claude model here
read
Google's Gemini API docs, the source of the Gemini window and price figures here
read
Our own pricing ledger, where each window above is recorded with the page it was read from
read
read
Published by Kawsar. How this site collects and checks data.