Every AI provider splits the bill in two. Input and output tokens are metered separately and priced separately, and the output side is usually the pricier one, often four to five times more per token. That single fact decides which workloads are cheap, which are expensive, and sometimes which provider you should use at all. Summarizing a long report (heavy input, light output) and drafting a long report from a short brief (light input, heavy output) can cost wildly different amounts on the same model.
This post answers a practical question: if you have a certain number of tokens or a certain budget, what does that actually buy you? How much can you feed in, how much comes back out, and how do Claude, Gemini, and ChatGPT compare on the same job? We are not redefining tokens here. For that, start with our pillar on what tokens are and how AI models break text down. The one-line recap: a token is a small chunk of text, roughly 3 to 4 characters or about three-quarters of an English word, so 1,000 tokens is around 750 words, a page and a half. From there, everything is about the split.
The input and output token split, in plain terms
Two counters run on every request you send to a large language model.
- Input tokens: everything you send in. Your prompt, the system instructions, any documents or chat history you attach, and the tool definitions. The model reads all of it at once.
- Output tokens: everything the model generates back. The visible response, plus, on reasoning models, the internal “thinking” tokens that are usually billed at the output rate even though you never see them.
Providers meter these two separately because they cost different amounts to produce. Input is processed in parallel: the model ingests the whole prompt in one pass, which uses the hardware efficiently. Output is generated one token at a time, each new token depending on the ones before it. That serial generation is slower and uses the hardware less efficiently, so providers charge more for it. Anthropic’s published rates put Claude output at exactly five times the input price. Google and OpenAI use similar multipliers on their comparable tiers.
The practical upshot is that the shape of your workload, not just its size, drives the cost.
Why the split flips which workloads are cheap
Because output costs several times more per token than input, two jobs that move the same total amount of text can land at very different prices.
Consider a heavy-input, light-output job: feeding a 20-page contract to a model and asking for a three-sentence risk summary. You send a lot of tokens and get few back. Almost all the cost is on the cheap side of the meter. Summarization, classification, extraction, and search-and-answer over long documents all live here, and they are cheap relative to their apparent size.
Now consider a light-input, heavy-output job: giving a model a one-paragraph brief and asking it to draft a 2,000-word article. You send few tokens and get many back. Almost all the cost is on the expensive side. Long-form drafting, code generation, and anything with reasoning turned on live here, and they cost more than their input size suggests.
This is also why "reasoning" or "thinking" modes deserve a second look before you switch them on for everything. Those hidden reasoning tokens count as output. A model that thinks for 3,000 tokens before writing a 200-token answer bills you for 3,200 output tokens, not 200. The feature is often worth it for hard problems and wasteful for simple ones.
What X tokens actually gets you
Tokens are abstract until you tie them to real things you send and receive. Using the pillar’s convention (about 750 words per 1,000 tokens), here is what common chunks of text cost in tokens.
| Text | Rough size | Approx. tokens |
|---|---|---|
| A single chat message or question | 15–40 words | 20–50 |
| A detailed prompt with instructions | 150–300 words | 200–400 |
| A long, detailed email | 500 words | ~650 |
| A 5-page memo or blog post | 2,000 words | ~2,700 |
| A 25-page research paper | 9,000 words | ~12,000 |
| A 300-page book | 90,000 words | ~120,000 |
| A medium codebase (50 files) | varies | ~200,000–400,000 |
Read this table in both directions. On the input side, it tells you what you can feed a model: a flagship model with a 1,000,000-token context window can hold roughly eight full-length books, or a good chunk of a real codebase, in a single request. On the output side, it tells you what you get back: 1,000 output tokens is about a page and a half of finished writing, so a 4,000-word article is roughly 5,300 output tokens, and a full working code file might be 1,500 to 4,000.
Two cautions carry over from the pillar. Code and structured data (JSON, CSV, tables) tokenize more densely than prose, often 1.2 to 1.5 times as many tokens for the same character count, so a codebase eats more of your budget than its word count implies. And the exact counts differ by tokenizer, so treat every number here as an estimate, not a guarantee.
Claude vs Gemini vs ChatGPT: context, input, and output
Here is where the three providers stand in mid-2026 across a flagship tier and a cheaper, faster tier. Prices are per million tokens (per MTok) and are representative of published list rates at the time of writing. Vendors adjust pricing often and run promotions, so treat these as ballpark and confirm the current numbers on each provider’s pricing page before you budget a real workload.
| Model | Tier | Context window | Input / MTok | Output / MTok |
|---|---|---|---|---|
| Claude Opus 4.8 | Flagship | 1,000,000 | ~$5 | ~$25 |
| Claude Sonnet 5 | Default | 1,000,000 | ~$3 | ~$15 |
| Claude Haiku 4.5 | Cheap / fast | 200,000 | ~$1 | ~$5 |
| Gemini 3.1 Pro | Flagship | ~1,000,000+ | ~$2 | ~$12 |
| Gemini 3 Flash | Cheap / fast | ~1,000,000 | ~$0.30 | ~$2.50 |
| GPT-5.5 | Flagship | ~256,000+ | ~$4 | ~$20 |
| GPT-5.5 mini | Cheap / fast | ~256,000 | ~$0.50 | ~$4 |
Three patterns are worth naming. First, every tier keeps output several times more expensive than input, so the workload-shape logic above applies no matter which provider you pick. Second, the cheap tiers are not marginally cheaper, they are an order of magnitude cheaper: Gemini 3 Flash input at roughly $0.30 per MTok is more than fifteen times cheaper than Claude Opus 4.8 input. Third, context windows have converged at the top. The flagships all hold enough for whole-codebase or whole-book workloads, so context size is rarely the thing that separates them anymore. Capability and price are.
Anthropic publishes its Claude tiers and rates directly; the Claude Opus 4.8 overview covers where the flagship fits, and our look at GPT-5.5 does the same for OpenAI’s line.
What N tokens or $X buys on each
Numbers make the split concrete. Take a common summarization job: a 100,000-token input document (roughly a short book) and a 1,000-token summary out.
- Claude Opus 4.8: 100,000 input at ~$5/MTok is ~$0.50, plus 1,000 output at ~$25/MTok is ~$0.025. Total: ~$0.53.
- Gemini 3.1 Pro: ~$0.20 input plus ~$0.012 output. Total: ~$0.21.
- GPT-5.5: ~$0.40 input plus ~$0.02 output. Total: ~$0.42.
The input dominates, so the ranking follows input price, and the tiny output barely registers.
Now flip it to a drafting job: a 1,000-token brief in, a 10,000-token long-form draft out (heavy output).
- Claude Opus 4.8: ~$0.005 input plus 10,000 output at ~$25/MTok is ~$0.25. Total: ~$0.255.
- Gemini 3.1 Pro: ~$0.002 input plus ~$0.12 output. Total: ~$0.122.
- GPT-5.5: ~$0.004 input plus ~$0.20 output. Total: ~$0.204.
Here the output dominates, so the ranking follows output price. The same three models, the same order of magnitude of total text, but the cost driver flips completely between the two jobs.
The other way to read it is by budget. One dollar on Gemini 3 Flash buys roughly 3.3 million input tokens (about four full books) or 400,000 output tokens (about 300,000 words of finished writing). The same dollar on Claude Opus 4.8 buys about 200,000 input tokens or 40,000 output tokens. Same dollar, an order of magnitude difference in what it holds, which is exactly why tier selection matters as much as provider selection.
Turning the split into decisions
A few levers follow directly from all of this.
- Match the tier to the job, not the brand. A heavy-input job like document summarization is dominated by input price, so route it to whichever tier has cheap input and enough context. A heavy-output job like drafting is dominated by output price, so the output rate is what to shop on.
- Send simple work to the cheap tier. The cheap tiers cost roughly a tenth to a twentieth of the flagships. Classification, extraction, routing, and short replies rarely need flagship reasoning. Reserve the expensive tier for genuinely hard tasks.
- Use prompt caching on repeated input. If you send the same long context repeatedly (a fixed system prompt, a reference document, a knowledge base), all major providers now cache it and bill the cached portion at a fraction of the input rate, often around a tenth. For heavy-input workloads, this is one of the largest single savings available.
- Cap and shape the output. Because output is the pricey side, an explicit maximum-length setting and a “be concise” instruction directly cut cost. Turn reasoning modes on deliberately, not by default, since their hidden thinking tokens bill at the output rate.
The overall picture is simple once the split is in view. Tokens are not one meter, they are two, and the cheaper meter runs on what you send while the pricier one runs on what you get back. Estimate the two separately, pick the tier that is cheap on whichever side your workload leans, and confirm the live rates before you commit real volume.
Frequently asked questions
Why do output tokens cost more than input tokens?
Input is processed in parallel: the model reads your whole prompt in a single pass, which uses the hardware efficiently. Output is generated one token at a time, each token depending on the previous ones, which is slower and less efficient. Providers pass that higher generation cost through as a higher per-token output rate, commonly four to five times the input rate on the same model.
Do input and output tokens share one budget or two?
For pricing, they are metered separately and billed at different rates, so think of them as two counters. For the context window, they share one limit: the window caps input plus output combined. A model with a 200,000-token window that receives a 195,000-token prompt has only about 5,000 tokens left for its response.
Do “thinking” or reasoning tokens count as input or output?
As output. On reasoning models, the internal reasoning the model does before answering is generated the same way as visible output and is generally billed at the output rate, even though you never see those tokens. A model that reasons for 3,000 tokens to produce a 200-token answer bills roughly 3,200 output tokens. Enable reasoning modes deliberately, since they can multiply output cost on otherwise small responses.
Is the cheapest provider always the cheapest for my workload?
No, because it depends on whether your workload leans on input or output. A heavy-input job (summarization) is ranked mostly by input price; a heavy-output job (drafting) is ranked mostly by output price. A provider that is cheapest on input may not be cheapest on output. Estimate both sides for your actual input-to-output ratio before deciding.
How do token counts differ across Claude, Gemini, and ChatGPT?
Each provider uses its own tokenizer, so the same text produces slightly different token counts on each. That means per-token prices are not perfectly comparable, and the most reliable comparison is by equivalent input content rather than by raw token count. The pillar on what tokens are covers the tokenizer differences in detail.
