AI Token Costs Compared Across Every Major Provider (2026)

Run the same AI assistant on two different models and the monthly bill can swing from under $700 to more than $25,000, with nothing else about the product or its traffic changing. The number that moves is the price per token, and in 2026 the gap between the cheapest and the most expensive credible model is wider than it has ever been.

We build AI features into web and mobile products, so this is a number we price before writing a line of code. The rate printed on a provider's pricing page rarely matches what lands on the invoice, because a few mechanics that never appear in the headline number quietly do most of the damage.

Here is a current, side-by-side look at what every major provider charges per token, and the cost structure underneath those numbers that decides what you pay.

How token pricing works before you compare anything

Every major provider bills the same way, per million tokens, split into input and output. Input is everything you send the model, which means your prompt, the conversation history, and any documents you retrieve and paste in. Output is what the model writes back. A token is roughly four characters of English, so 1 million tokens is about 750,000 words.

The part founders miss is that output almost always costs several times more than input. Claude Opus 5 charges $5 per million input tokens and $25 per million output. GPT-5.6 Sol charges $5 in and $30 out. That four-to-six-times gap matters because it flips the math depending on what your product does. A summarizer that reads long documents and returns a short answer is input-heavy and stays cheap. A chatbot or an agent that writes long, reasoned replies is output-heavy, and the output rate is what sets your ceiling.

There is a reason output is dearer. Input tokens are read in parallel in a single pass, while output tokens are generated one at a time, each one depending on the last, which is far more expensive compute. That mechanic is why every provider lists two rates instead of one, and why a small change in how long your answers run moves the bill more than a change in prompt length.

So the right comparison is never a single price. It is two prices weighted by the shape of your own traffic.

The 2026 price comparison, tier by tier

We group the models into three tiers by capability and price, because that is how the buying decision breaks down in practice. Prices below are the public list rates per million tokens as of September 2026, taken from each provider's own pricing page.

Frontier tier: the most capable models

These are the models you reach for when the task is genuinely hard, such as multi-step reasoning, tricky code, or judgment calls where a wrong answer is expensive. Grok 4.6 and Gemini 3.1 Pro sit noticeably below OpenAI and Anthropic on the headline rate, which has pulled a lot of frontier workloads toward Google and xAI over the past year. On raw price, OpenAI and Anthropic are now the premium options in this tier rather than the default.

Workhorse tier: what runs most production features

This tier does the heavy lifting in real products. It is capable enough for retrieval-augmented answers, structured extraction, classification, and most agent steps, at a quarter to a half of frontier cost. DeepSeek V4-Pro is the outlier, priced well below the American labs, with an off-peak discount that cuts the rate further during set overnight windows. For a workload you can schedule rather than serve live, that timing discount is real money.

Value tier: high-volume and background work

This is where cost per request falls to a fraction of a cent, which is what makes high-volume features viable at all. Amazon Nova Micro and Nova Lite are the cheapest credible options from a major cloud, and they fit workloads like tagging, routing, and short classifications where you do not need a frontier brain. DeepSeek Flash goes lower again, with a cache-hit input price that rounds close to zero. The tradeoff across this tier is capability, so these models earn their place on narrow, well-defined tasks rather than open-ended reasoning.

The costs that never appear on the pricing page

The headline rate is the start of the calculation, not the end. Four mechanics move the real bill more than the sticker price does, and all four are easy to miss until the invoice arrives.

The first is prompt caching. When part of your input repeats across requests, such as a long system prompt or a set of retrieved documents, most providers let you cache it and charge a fraction of the input rate to reuse it. Claude Sonnet 5 reads a cached token at $0.20 against a $2.00 input rate, a ninety percent cut on the repeated portion. DeepSeek pushes cache-hit input close to a hundredth of the miss rate. For a chatbot that sends the same 2,000-token system prompt on every turn, caching is often the single biggest lever on the whole bill.

The second is batch processing. If a job does not need an answer in real time, OpenAI, Anthropic and Google all run it through a batch API at roughly half price. Nightly report generation, bulk content classification, and backfills are all natural fits. The work is identical, the turnaround is slower, and the rate is cut in half.

The third is reasoning tokens, and this is the one that surprises founders most. Modern reasoning models think before they answer, and that thinking is emitted as tokens you pay for at the output rate, even though your user never sees them. A single answer that shows 200 words can bill for 2,000 tokens of hidden reasoning behind it. Google flags these thinking tokens on its own pricing pages precisely because so many teams budget for the visible output and get a bill several times larger. If you run reasoning models, model your output tokens on what the model generates, not on what it displays.

The fourth is context-length pricing. A few providers charge more once your input crosses a threshold. Gemini 3.1 Pro roughly doubles both its input and output rates above 200,000 tokens. Stuff an entire knowledge base into every prompt and you can quietly cross into the expensive tier on every call, which is one more reason retrieval plus caching beats brute-forcing a giant context.

DeepSeek adds a fifth wrinkle with time-of-day pricing, halving rates during off-peak overnight windows. It only helps workloads you can defer, but for those it stacks on top of the already-low base rate.

Working out a real monthly cost

Numbers on a table do not tell you what your product costs, so here is a concrete workload run across the tiers. Take a customer-facing assistant handling one million messages a month. Each message carries about 3,000 input tokens, which is the system prompt plus retrieved context plus a little history, and returns about 400 output tokens. That comes to 3 billion input tokens and 400 million output tokens a month.

At list prices, the same product costs the following per month:

• Claude Opus 5: about $25,000 ($15,000 input, $10,000 output)
• Claude Sonnet 5: about $10,000 ($6,000 input, $4,000 output)
• Gemini 3.5 Flash-Lite: about $1,900 ($900 input, $1,000 output)
• GPT-5.6 Luna: about $1,080 ($600 input, $480 output)
• DeepSeek Flash: about $690 ($450 input, $240 output)

That is a thirty-six-times spread on one product, driven entirely by model choice. A frontier model can still be the right call for this workload, as long as it earns the premium in answers a cheaper model cannot match, because at this volume the gap between tiers funds an engineer.

Now apply one optimization. If 2,500 of those 3,000 input tokens are a static system prompt and retrieved documents that repeat every turn, caching that portion on Claude Sonnet 5 drops its cost from roughly $10,000 to around $5,500 a month, a cut of almost half from a single change. The lesson holds across every provider. The model you pick sets the order of magnitude, and caching, batching and prompt design decide how much of that headline rate you end up paying.

What we weigh before choosing a model

Price is one input into the decision, and rarely the first one. A model that is cheaper per token but needs three tries to get a usable answer is not cheaper. The workflow to get this right is short and holds up across projects.

Start from the shape of the task and the traffic. Estimate input and output tokens per request and multiply by real volume before looking at any pricing page, because an input-heavy workload and an output-heavy one rank the models completely differently. Then match the tier to the difficulty. Reserve the frontier tier for the small share of requests that genuinely need it, route the routine majority to the workhorse tier, and push high-volume background work down to the value tier. Many production systems we build do exactly this with a router, sending the hard requests to a capable model and everything else to a cheap one.

From there, quality is the gate, not the ledger. We test candidate models on the real task with real evals before price enters the conversation, because a wrong answer that reaches a customer costs more than any token rate. The models that clear the quality bar then compete on total cost after caching and batching, not on the headline number. Portability matters too. Prompts and retrieval move between providers with modest effort, so the model you choose today is a decision you can revisit next quarter when the prices shift again, which in this market they will.

The providers will keep leapfrogging each other on price, and a table like this one is a snapshot rather than a settled answer. What does not change is the method. Size the workload, match the tier to the difficulty, prove quality first, then let caching and batching decide the real bill. If you want an AI feature built to that standard from the first commit, with the cost modeled before the code, see how we work.

Prices cited are public list rates as of September 2026, taken from each provider's own pricing pages. Rates change often, so confirm against the live pricing page before you commit a budget.