Token Limits: What They Mean for Your Prompts

TL;DR: Token limits explained: a token is roughly four characters or three-quarters of a word, and every model has two ceilings, a context window for the whole request and an output cap for what it generates. ChatGPT, Claude and Gemini publish different numbers, and reasoning even eats into the cap on two of the three.

What is a token, actually?

A token is the unit a model reads and writes internally. It is not a word, and it is not a character, though it is closer to the second.

OpenAI's own guidance on the subject puts it plainly: "A token can represent a character, part of a word, a whole word, or punctuation." Spacing changes the split too, so red, Red, and red (with a leading space) can all tokenize differently even though a human reader treats them as the same word or a trivial variant of it. The same source is direct about the practical consequence: "A token count is not the same as a word count."

That last sentence is the one worth sitting with. Every "how long can my prompt be" question people ask about ChatGPT, Claude, or Gemini is really a question about tokens, and word count is only ever a proxy for it, never the real unit being measured.

Tokens also come in more than one flavor once you're inside an actual request. OpenAI's token-counting guide names four categories that matter for a single exchange: input tokens (what you send), output tokens (what the model generates), cached input tokens (input reused through prompt caching, priced differently), and reasoning tokens (internal thinking that "are not visible as answer text, but they count toward output usage and are billed as output tokens"). Keep that fourth category in mind. It is the one that causes the most confusing failures later in this post.

How many tokens is my prompt, really?

Close enough for planning purposes, using English prose as the baseline. OpenAI's help center gives three interchangeable estimates for English text, each its own short sentence: "1 token is approximately 4 characters." "1 token is approximately three-quarters of a word." "100 tokens are approximately 75 words." All three describe the same ratio from different angles, and the same page is upfront that they are exactly that: "These are estimates, not exact counts."

The ratio also isn't fixed across vendors, which is the part most "1 token = 4 characters" explainers skip entirely. Anthropic documents its own current tokenizer's efficiency directly, and the number is meaningfully different from OpenAI's: "1M tokens is roughly 555k words or 2.5M Unicode characters on the current tokenizer... 200k tokens is roughly 150k words." Do the arithmetic and that is about 0.555 words per token, versus OpenAI's 0.75. The same 400-word paragraph can cost noticeably more tokens on one vendor's tokenizer than another's, before you write a single extra sentence.

Neither number is wrong. They describe different tokenizers built by different companies, and Anthropic's own page even notes its older tokenizer was closer to OpenAI's ratio: "models before it fit about 750k words in 1M tokens." A vendor can change this ratio when it ships a new tokenizer, with no change to your prompt at all.

Is a token limit the same thing as a context window?

No, and conflating them is the single most common source of confusion in this whole topic.

A context window is the total token budget for one request: your prompt, the running conversation history, any system instructions, and the model's own answer, all drawing from the same pool. An output cap, called max_tokens or max_output_tokens depending on the API, limits only what the model is allowed to generate. It never limits what you send.

ChatGPT's own pricing page makes the shared-pool part concrete, in a footnote about why a long chat degrades before a short one does: the context window has to cover "system instructions (including tools and personality), memories (if enabled), and internal processing (reviewing information, reasoning, and response generation)" in addition to your visible messages. Your prompt is competing for room with things you never typed. Context window math, not vibes, is why the twentieth message in a long thread gets cut short when the second one didn't. The system-versus-user split those instructions create is its own topic, covered fully in system prompt vs user prompt.

If you want the full field-by-field breakdown of max_tokens, max_output_tokens, and max_completion_tokens across OpenAI, Anthropic, and Google, including which one is required and which one is optional, max tokens vs max output tokens covers that parameter in depth. This post stays one level up: what the numbers mean for the prompt you're about to write, not the API field you'd set to enforce them.

How big is each model's context window right now?

Checked directly against each vendor's own page on September 3, 2026. Treat every number below as perishable; vendors change these often, sometimes within the same week.

ChatGPT, from OpenAI's pricing page, splits into two separate windows depending on which model answers:

Claude, from Anthropic's model reference, is simpler on paper: three of its four current models share one number.

Gemini Apps, from Google's own support page, ties the window directly to your subscription plan:

Google's own explanation of why this matters is worth quoting directly, because it puts an abstract number into something you can picture: "with a 1M token context window, Gemini can understand up to 1,500 pages of text or 30,000 lines of code." Its Deep Think feature is called out separately: "If you use Deep Think, there is a 192 thousand token window." That figure is smaller than the base Pro/Ultra number above it, despite running on the same subscription tier.

Three vendors, three different ways of slicing the same underlying idea, and none of the three numbers above are interchangeable with each other. If you're choosing which chat interface to paste a genuinely large document into, ChatGPT vs Claude covers more of that decision than the raw token counts alone can.

Why did I get a short or empty answer even though the model "thought" for a while?

Because reasoning tokens are billed against the same ceiling as your visible answer, on two of the three vendors covered here, and that ceiling can run out before any visible text is written.

I need to correct something here rather than repeat a common shorthand: describing OpenAI's output cap as covering visible output tokens and reasoning tokens alone. That description is incomplete, and it is one I have used myself before. OpenAI's own reasoning guide names a third category explicitly: "you can limit the total number of tokens the model generates, including reasoning tokens, visible output tokens, and non-visible formatting tokens, by using the max_output_tokens parameter." Three categories, not two. OpenAI's separate token-counting guide explains where that third one comes from: "Some models, including GPT-5 models, generate tokens used to format or delimit response channels, tool calls, and other message structure." These formatting tokens "don't appear in message content or logprobs" at all. They're real, billed tokens you cannot see in the response text.

The failure mode that follows is blunt. OpenAI's reasoning guide states it directly: hitting the cap "might occur before any visible output tokens are produced, meaning you could incur costs for input and reasoning tokens without receiving a visible response." A hard multi-step task can spend its entire budget thinking, with the visible answer arriving empty or truncated. Why does ChatGPT cut off mid-answer walks through this exact failure alongside four other unrelated causes of truncation, and how to tell them apart in under thirty seconds.

OpenAI's practical guidance for sizing around this is a concrete number, not a vague "set it high": "OpenAI recommends reserving at least 25,000 tokens for reasoning and outputs when you start experimenting with these models." Adjust from there once you know how much a given prompt actually needs.

Does a longer prompt actually cost more?

Sometimes, and in a way most token-limit explainers never mention: not just more tokens, but a higher price per token.

If you never touch an API directly, this section still matters, because it explains why some tools (including any prompt manager or extension that calls a model on your behalf) get noticeably pricier on long documents. OpenAI's help center states the basic asymmetry plainly: "Input, cached input, and output tokens can have different prices." Across every vendor covered in this post, output tokens are consistently priced higher per token than input tokens, and a cached input token (one your prompt has already sent before, reused via prompt caching) is cheaper again than a fresh one.

What's less well known is that length itself can move the price. OpenAI's published API rates for GPT-5.6 Sol split into two tiers for the identical model: a "Short context" rate that applies up to 272,000 input tokens, and a higher "Long context" rate above that threshold. Concretely, GPT-5.6 Sol's standard-tier input price roughly doubles, from $4.00 to $8.00 per million tokens, and its output price rises from $20.00 to $30.00 per million tokens, once a request crosses that line.

Anthropic makes the opposite design choice, and says so explicitly. Its pricing documentation states: "Claude 4.6 and later models and Claude Mythos Preview include the full 1M token context window at standard pricing." It gives a concrete example in the same breath: "A 900k-token request is billed at the same per-token rate as a 9k-token request." Same model, wildly different prompt sizes, identical per-token cost.

Neither approach is more "correct." They are two real, current, and opposite pricing philosophies from the two vendors, which is exactly why a token-limit conversation that stops at "how many tokens fit" and never asks "at what rate" is missing half the practical picture for anyone paying per token, directly or through a tool built on top of one.

How do I stay within my token limit?

Five habits, roughly in the order they're worth doing.

Quick token-budget check before pasting a large block into any chat:

1. Estimate tokens: words ÷ 0.75 (rough, English prose), or characters ÷ 4.
2. Add your expected answer length in tokens on top of that estimate.
3. Compare the total to the MODEL's context window, not its output cap alone.
4. If you're within ~10% of the ceiling, cut conversation history or
   attachments first. Never trim the actual question or your instructions.
5. For a reasoning model, leave real headroom (thousands of tokens, not
   dozens) for thinking before the visible answer even starts.

OpenAI's own recommendations for an oversized input match that instinct, and are worth following in this order: "Shorten or rephrase the prompt." "Remove unnecessary or repeated context." "Divide large inputs into smaller parts." "Summarize or preprocess text before sending it." Note what's missing from that list: nowhere does it say to compress your actual instructions. Trim the ballast, not the ask.

The single highest-leverage habit for a long-running chat is the one people resist most: starting over. A brand-new conversation with a short, deliberate brief (goal, constraints, the two or three facts that matter, the last good output) almost always beats scrolling fifty messages deep into a thread that is already competing with your next answer for room. If your prompt's own wording is the harder problem, Prompt Architects' generation tool does that shortening and de-duplication work for you before the token count ever becomes the bottleneck.

Sources and access dates

Every figure above traces to a vendor's own page, accessed September 3, 2026:

• OpenAI: Understanding and counting tokens, the reasoning models guide, the token-counting guide, the ChatGPT pricing page, and the API pricing page.
• Anthropic: the models overview, the pricing page, and the extended thinking guide.
• Google: Gemini Apps limits & upgrades for Google AI subscribers and Upload & analyze files in Gemini Apps.

Context windows, output caps, and per-token pricing all move faster than most reference content admits. Check the vendor's own current page before sizing a real prompt against any specific number here, this one included.