Input vs Output Token Pricing Across Major Providers

Every AI provider charges two different prices for the same model: one rate for what you send in, another for what comes back out. That second number, the output rate, usually runs 2 to 8 times higher than the input rate, and the gap between them shapes a monthly bill far more than the sticker price ever suggests. Understanding that ratio, model by model, is the difference between a forecast that holds and one that blows past budget by the third week of the month.

The reason comes down to how the compute actually works. Input tokens get processed together, in one pass across the whole sequence the model reads at once. Output tokens don't work that way. The model writes one token, feeds it back in, writes the next one, and repeats that cycle until it's done. Each output token costs its own full pass through the model. That sequential grind is why generation costs more than reading, and every provider's rate card reflects it, even if the ratio they land on varies wildly.

What the current rate cards say, model by model

At the cheap end of the mainstream market, OpenAI's GPT-5.6 Luna is $0.20 per million input tokens and $1.20 output, a 6x ratio, after a price cut on July 30, 2026. That's the floor for a model most teams would still call production-grade.

Move up to the $2-input tier and two models sit almost side by side. Claude Sonnet 5 runs $2.00 in, $10.00 out, a 5x ratio. Anthropic made that rate permanent on August 11, 2026, canceling a price hike to $3.00/$15.00 that had been scheduled for September 1. GPT-5.6 Terra charges the same $2.00 for input but $12.00 for output, a 6x ratio. Same entry price, different exit price, and that gap widens fast once a workload runs heavy on generation.

Flagship pricing tells a similar story. GPT-5.6 Sol runs $4.00/$20.00 (a promotional rate through at least November 21, 2026, down from $5.00/$30.00 at launch). Claude Opus 5 costs $5.00/$25.00, and Claude Fable 5 tops Anthropic's lineup at $10.00/$50.00, both holding a 5x ratio. Opus 5 and Sol's original launch price both start at $5.00 on the input side, yet the output rates diverge by $5, a 17% spread. On a workload that's mostly output, agentic loops, long documents, that 17% compounds fast, because it's hitting the priciest tokens purchased.

Down at the budget tier, the numbers get almost absurd by comparison. Qwen3.7 Flash charges $0.03 in, $0.13 out per million tokens, the cheapest paid API tracked anywhere as of September 15, 2026 (benchlm.ai puts the tracked market at 156 paid models across 27 providers). Gemini 3.7 Flash, at $0.75/$3.75, is the cheapest model that still scores 70 or above on quality benchmarks, which is the rough line for "production-grade." DeepSeek V3.2 stands out for a different reason: at $0.28/$0.42, it holds a 2x ratio, the narrowest of any mainstream model on the market.

Zoom out and the spread across the whole market covers four orders of magnitude, cheapest to most expensive. Even within one provider's own lineup, the range is enormous: Anthropic runs 10x top to bottom ($1 Haiku to $10 Fable), OpenAI runs 150x ($0.05 GPT-5 nano to $30 GPT-5.5 Pro). There's no such thing as a standard multiplier here. Each model sets its own ratio, and that ratio is a design choice, not a market convention.

How the ratio changes the shape of a real bill, not just the headline rate

Most teams budget off the input rate, because that's the number on the pricing page. That is backwards from how most teams budget, since output is what does the damage. Output is what does the damage.

In most real applications, the prompt itself, system message, context, chat history, makes up the bulk of total tokens sent. But the output rate per token runs so much higher that output cost still ends up dominating the bill, even at lower volume.

Run the math on a modest workload: 20,000 requests a day, 200 output tokens per response. That works out to a substantial number of output tokens a day, scaling to a much larger monthly total. At Claude Sonnet 4's $15 per million output rate, that's $1,800 a month, just for output, on top of whatever input costs. Swap in Gemini Flash at $0.40 per million output, and the exact same volume costs $48 a month. Same request count, same output length, same input tokens. The only variable that changed is which model handled it, and the bill moved by a factor of nearly 40.

That's the ratio doing its work. A model like DeepSeek V3.2, with its narrow output ratio, scales very differently as output volume climbs than a model like GPT-5.6 Terra, at 6x, even if their input prices look similar on paper.

Input isn't free from surprises either. A system prompt that grows from 500 tokens to 2,000 tokens quadruples the input cost of every single request that carries it. Teams often treat prompt length as fixed once it's written, but it's a live cost lever, and it moves in one direction if nobody's watching it.

Workload shape decides which side of the ratio matters more. Agentic loops, long-form writing, document drafting: all output-heavy, so the output multiplier drives the bill. Classification, extraction, short-answer tasks: read-heavy, write-light, so the input rate carries more weight in the total.

The discount layers that sit beneath the headline ratio, caching, batching, and what they change

The advertised ratio isn't the real ratio once discounts enter the picture. Every major provider offers some version of the same three levers: cached input, batch processing, and cheaper model tiers, each with its own fine print.

Prompt caching cuts the cost of repeated input tokens down to roughly 10% of the standard input rate, across most providers. Anthropic's version claims savings up to 90% on cached tokens. Take that 2,000-token system prompt from earlier: if it's shared across every request instead of resent and paid for in full each time, the savings on a high-volume Sonnet 4 deployment aren't a rounding error, they're large enough that caching has to be decided as part of the architecture on day one, not layered in later as a tweak. OpenAI runs a comparable caching mechanism; other providers offer similar features, though exact savings rates vary by provider.

Batch processing works differently. Both OpenAI and Anthropic offer batch APIs at half the synchronous rate, with results returned asynchronously within 24 hours. Any workload that doesn't need a response in real time, bulk classification, overnight report runs, annotation jobs, should default to batch, not treat it as a nice-to-have. Cutting every token price in half changes the whole shape of a budget, not just the total at the bottom.

Stack all three, caching, batching, and routing simple tasks to cheaper tiers, and the effective price a team pays can look nothing like the number on the rate card. This is also where head-to-head comparisons between providers quietly get decided. Two models can advertise the same ratio and still produce very different real bills, depending on how strict the cache-eligibility rules are or how much latency a team can tolerate for batch discounts.

The reasoning-token problem: when the listed ratio understates your actual bill

Thinking models, o1, o3, and their counterparts elsewhere, generate internal reasoning tokens before producing a visible answer. Those reasoning tokens get billed as output, even though the user never sees them.

That means a model with a modest advertised ratio can behave like a much pricier one once it's handed a genuinely hard problem, because the real output volume includes all that invisible reasoning work. Teams running reasoning-heavy tasks routinely report bills several times higher than what a simple token-count estimate predicted.

Part of the problem is visibility. Provider dashboards often don't break reasoning tokens out from the rest of a request, so reconciling a bill after the fact takes more than just reading the invoice. It takes an outside tool watching token flow in real time.

Pricing history shows how far this category has moved and how far it still has to go. o1-pro peaked at $262.50 per million tokens in March 2025. OpenAI's 2026 Pro launches hold at $67.50. That's a steep drop, but reasoning models still sit in a cost class of their own. Forecasting for them means characterizing the task, reasoning-heavy versus simple completion, not just counting expected tokens. The ratio a team plans against and the ratio it actually pays can come apart sharply here.

How dramatically the market has shifted, and why budgets set last quarter are already wrong

Flagship pricing has fallen hard over the past few years. GPT-4 launched in March 2023 at a blended $37.50 per million tokens. Claude Opus 5 launched in July 2026 at $5.00 input, $25.00 output. That's not a gradual decline, that's a collapse in flagship pricing over three years.

The mid-tier has followed a similar path. Closed mid-tier launches in 2026 cost 38% less than their 2024 counterparts, with the median dropping from $6.00 in 2024 to $4.38 in 2025 to $3.75 in 2026.

And the pace inside a single quarter can undo a budget on its own. On July 30, 2026, OpenAI cut GPT-5.6 Luna by 80% and Terra by 20% in the same announcement. A budget built in August was already stale by September. Claude Sonnet 5 tells a similar story from the other direction: it launched at an introductory $2.00/$10.00, with a hike to $3.00/$15.00 scheduled for September 1, and Anthropic scrapped that increase permanently on August 10. Teams that built forecasts around the increase happening ended up over-budgeting. Teams that assumed it would happen and never revisited their model routing left savings on the table without realizing it.

Not every segment is moving uniformly, either. Some small closed models now launch above $1.00 where a similar model would have priced under it a year earlier. Any cost forecast locked in without a way to track these changes is going to drift out of date within a single quarter. That's not a hypothetical, that's the pattern the last two years have already shown.

What intelligent model selection requires once the ratio is understood

A workable routing pattern looks something like this: send high-volume, simple work to the $0.20-$1 input tier, use $2-input models as the production default for standard tasks, and reserve flagship models for cases where evaluation shows a real, measurable quality gain worth paying for.

The output ratio, not the input rate, decides which tier choice matters most for verbose or agentic work. The gap between a flagship's output rate ($25-$50 per million) and a mid-tier model's output rate ($10 per million) swamps whatever difference exists on the input side.

Routing itself is a cost strategy, not just an engineering nicety. Sending easy queries to cheaper models and escalating only the hard ones to a flagship model can cut costs by 40-70% with barely any quality loss on the easy tier, and the routing decision, usually handled by an embedding similarity classifier, adds only 1-2 milliseconds of latency.

The lowest list price doesn't guarantee the lowest bill. Output volume, cache hit rate, retry rates, and the actual quality of responses can flip the ranking between two models that look nearly identical on paper. Before picking a model, a team needs to know its own workload: output-heavy tasks favor models with a low output ratio, input-heavy tasks favor models with a low input rate. Running everything through the most expensive model "just in case" almost never beats routing the bulk of traffic to a cheaper model and saving the flagship for the minority of requests that actually need it.

Token budgets belong in code review, not just in a finance spreadsheet. System prompt length, how much conversation history gets kept, max_tokens caps, these are direct levers on cost. That 500-to-2,000-token prompt creep from earlier isn't a one-time event. It happens gradually, one added instruction at a time, until someone notices the input bill has quadrupled.

Why managing this across providers requires centralized visibility, not per-provider dashboards

Enterprise spend on LLM APIs hit $12.5 billion in 2025, and 53% of AI teams report their costs exceeded forecasts by 40% or more while scaling. That's not a rounding problem. That's a forecasting failure happening at scale, across the industry.

Part of the reason is structural. Each provider's dashboard reports its own tokens in its own format. Reasoning tokens are often absent from per-request breakdowns entirely. The input/output split rarely gets surfaced per team or per project without some outside tool pulling it together. A per-provider dashboard can tell a team what it used. It can't tell a team what it should have used, or which model tier would have hit the same quality bar for less money.

Observability itself isn't free, either. Logging, monitoring, and auditing spend adds meaningfully to total LLM operating cost. That's before anyone even gets to the model bill.

An AI gateway addresses the structural half of this problem. It sits as a reverse proxy between an application and every model provider it talks to: the app sends requests to one endpoint, and the gateway handles provider selection, authentication, and policy enforcement behind the scenes. Switching models becomes a routing policy change, not an engineering project that touches application code. The capabilities that matter most here are per-request cost attribution by model and provider, real-time spend visibility broken out by team or project, routing rules that can act on the ratio directly, and automatic fallback if a provider goes down. Industry projections put the share of software engineering teams building multi-model applications that will run an AI gateway at 70% by 2028, up from roughly 25% in 2025.

The alternative, reconstructing costs from end-of-month invoices, gives a team no signal until the budget's already gone. More than half of AI teams report exceeding their cost forecasts significantly during scaling. Centralized visibility is what lets a team see the effective ratio across every provider at once, catch which teams are quietly running expensive output-heavy workloads on high-ratio models, and spot a mid-quarter price change before it shows up as a surprise on the invoice instead of a line item someone already planned for.