The models behind ChatGPT carry a 1,050,000 token context window and can produce up to 128,000 tokens in a single response. OpenAI’s model documentation lists that figure for GPT-6 Astra and for GPT-5.6 Sol, Terra and Luna alike. What you get inside the ChatGPT product itself depends on your plan, and OpenAI documents those limits separately from the API specifications.
The number is easy to look up. The useful part is understanding what occupies that space, and why filling it degrades results rather than improving them.
Key points
- The underlying models hold 1,050,000 tokens, with a 128,000 token maximum output per response.
- ChatGPT the product applies its own plan-based limits, which differ from the raw API figures.
- Everything in the conversation counts, including uploaded files, images, prior turns and the model’s own output.
- A token is roughly three quarters of a word in English, so a million tokens is very approximately 750,000 words.
- Longer context is not better context. Retrieval from a very large window is measurably less reliable than from a focused one.
What the context window actually is
The context window is the working memory available while the model produces a response. It holds everything the model can refer to for that turn, and it is entirely separate from the data the model was trained on.
That distinction causes most of the confusion people have with it. A model knows a great deal that is not in the context window, from training. It knows nothing about your specific documents, your earlier conversation or your uploaded spreadsheet unless those things are in the window. Training data is what the model learned; context is what it can currently see.
Every turn of a conversation adds to the total. Your message goes in, the model’s reply goes in, and the next turn starts with all of it. A long conversation accumulates steadily even when each individual exchange is short.
What occupies the space
Several things consume context that people do not usually count.
Uploaded files. A PDF is converted to text and that text enters the window. A long document can consume a substantial share of the available space by itself.
Images. These are converted into tokens too, and a high resolution image costs more than a small one.
Prior turns. The whole conversation history, not a summary of it.
Custom instructions and memory. Anything configured to be included automatically is present on every turn.
The model’s own output. Responses become part of the input for the following turn.
Reasoning tokens. On models that reason before answering, that internal work occupies space in the turn that produces it.
Tool definitions and search results. When a conversation uses web search or file search, what comes back enters the window in full. A search returning several long pages consumes far more than the question that triggered it.
Where the space actually goes in a long chat
A worked example makes this concrete, because the intuitive accounting is usually wrong.
Someone opens a conversation to analyse a report. They upload a sixty page PDF, which converts to perhaps forty thousand tokens. They ask five questions, each producing a detailed answer of a thousand tokens or so. Then they upload a second document for comparison, another thirty thousand tokens. Then they paste in a spreadsheet extract.
By this point the conversation holds both documents in full, every question, every answer, and the spreadsheet. The current question, the thing they actually want answered, is a few dozen tokens at the very end of all that.
Nothing here is a mistake exactly. Each individual step was reasonable. But the useful signal is now a tiny fraction of what the model is looking at, and the first document has been sitting there since long after it stopped being relevant.
The pattern generalises. Context fills through accumulation rather than through any single large item, which is why it tends to surprise people. Each addition seems small, and the total is not visible until answers start degrading.
Why more context does not mean better answers
This is the part that matters practically and it is the opposite of most people’s intuition.
Retrieval accuracy degrades as a context grows. A model with a very large window does not attend equally well to everything inside it, and material buried in the middle of a long context is recalled less reliably than the same material in a short one. Anthropic documents this effect explicitly for Claude’s context window, calling it context rot, and the underlying behaviour is common across models of this generation rather than specific to one vendor.
The practical implication is that pasting everything you have is a poor strategy. A focused prompt containing the three relevant documents usually outperforms one containing thirty documents of which three are relevant, and it costs a fraction as much on the API.
This reframes what a large window is for. It is headroom that stops a task failing outright when the material genuinely is large. It is not permission to stop deciding what matters.
There is a diagnostic worth knowing that follows from this. If a model gives a good answer about something near the end of a long conversation but misses something you provided much earlier, that is not a capability problem and a stronger model will not reliably fix it. It is a retrieval problem caused by distance and clutter, and the fix is to bring the relevant material closer to the question.
What to know before deciding
Several practical points follow from how the window behaves.
Output is capped separately. A 128,000 token maximum output means the model cannot produce an arbitrarily long document in one response regardless of how much input room exists. Long outputs need to be structured across multiple requests.
Long prompts cost more per token on the API. Requests above 272,000 input tokens are repriced at double the input rate for the whole request, which makes that boundary worth designing around rather than drifting across.
Caching changes cost, not occupancy. Cached input is far cheaper but still fills the same space.
Plans differ inside ChatGPT. The product applies limits that are not the same as the raw model specification, and those change often enough that checking the current plan page is more reliable than any figure quoted in an article.
Knowledge cutoffs are separate. GPT-6 Astra’s training data ends 30 April 2026. Context window size has no bearing on what the model knows about events after that date.
Practical ways to work within it
- Start a new conversation for a new topic. Carrying an unrelated hour of history forward costs space and degrades retrieval.
- Upload the relevant pages, not the whole document. Extracting the section you need beats attaching a four hundred page report.
- Put instructions at the start or end. Recall is strongest at the edges of a long context and weakest in the middle.
- Summarise deliberately at natural breaks. Asking for a summary and starting fresh with it works better than letting history accumulate.
- Check whether the model actually has what you think. If an answer ignores something you provided, the material may have fallen outside the window or been buried.
- Reduce before you upgrade. A cluttered context on a stronger model frequently performs worse than a clean context on a cheaper one.
How the window relates to what you pay
For anyone using the API rather than the chat product, context size and cost are tied together in ways worth understanding before designing a system.
Input tokens are billed on every request, and a conversation resends its entire history each turn. That means a long chat is not billed once for the history; it is billed for it repeatedly, growing with every exchange. A fifty turn conversation with a large uploaded document has paid for that document fifty times.
Prompt caching addresses exactly this. A stable prefix, typically the system prompt and any fixed reference material, can be cached and served at a small fraction of the standard input rate. It does not reduce how much of the window is occupied, but it changes the economics of occupying it substantially.
Batch processing is the other lever. Work that does not need an immediate answer runs at half the standard rate, which for high volume document processing is usually a larger saving than any prompt optimisation.
None of this applies inside the ChatGPT product, where you pay a subscription rather than per token. But if a workflow ever moves from the chat interface to the API, these are the mechanics that decide whether it is affordable.
Decision framework
Five questions when context feels like the constraint.
- Is the window full, or is retrieval failing? These present identically and need opposite fixes. A shorter, better-organised prompt tests the second cheaply.
- How much of your conversation is still relevant? In long sessions the answer is usually a small fraction, and the rest is actively harming recall.
- Are you uploading more than you need? Whole documents where a section would do is the most common source of unnecessary consumption.
- Does your task need long output or long input? They are different limits, and only one is a million tokens.
- Would starting over work better? Frequently yes, and it takes thirty seconds.
Understanding how these systems consume and retrieve from context is a transferable skill rather than a product detail, and it applies whichever assistant you use. If you want a structured route in, explore Coursiv AI lessons and check current plan details on the official site.
Your next step
Next time a long conversation starts producing worse answers, do not assume you need a bigger window or a stronger model. Ask for a summary of what matters so far, start a fresh conversation, and paste the summary in.
That single habit fixes the majority of context problems people encounter, it costs nothing, and it works because the issue is almost never the size of the window. It is how much irrelevant material is competing for the model’s attention inside it.