AI Token Pricing 2026: Cost Per Query, Updated

The token math you learned in 2024 does not hold in late 2026. The model you were pricing last spring has been renamed, repriced, or replaced, and two structural changes have rewritten the bill: off-peak surcharges and near-free cache reads. If you are still estimating cost from a clipboard of 2024 per-million-token numbers, you are probably off by a factor of two or more in either direction.

This is a ground-up refresh of the original cost-per-query guide, recomputed against the October 2026 lineup. Same approach: what a token is, why the shape of a query matters more than its size, and what five realistic queries actually cost today. What changed is every number, plus a new section on the billing mechanics that quietly dominate real spend.

The 2026 lineup, in one table

Prices below are list rates per million tokens (MTok), input and output, for the models that matter to most users. Think of this as the cheat sheet, then we will use it.

Model	Input	Output	Notes
Claude Fable 5	$10	$50	Frontier, gated access
Claude Opus 5	$5	$25	The workhorse flagship
Claude Opus 5 Fast	$10	$50	About 2.5x speed
Claude Sonnet 5.5	$2	$10	Cache reads $0.20
GPT-5.6 Sol	$5	$30	OpenAI top tier
GPT-5.6 Terra	$2.50	$15	Mid tier
GPT-5.6 Luna	$0.20	$1.20	After the 80 percent cut
Gemini 4 Argon	$2	$10	Intro rate, doubles to $4/$20
DeepSeek V4-Flash	$0.14	$0.28	2x peak surcharge
DeepSeek V4 Pro	$0.435	$0.87	Cache hits near free

Two things jump out. First, the spread between the cheapest and most expensive output token is now roughly 170x, far wider than the 60x of two years ago. Second, the flagship tiers have compressed: Claude Opus 5 at $5/$25 and Gemini 4 Argon at $2/$10 sit well below where frontier pricing used to be, while the budget tier has collapsed entirely. The middle of the market is being squeezed from both ends.

What a token is, briefly

A token is about three quarters of an English word, or roughly 4 characters. That rule of thumb still holds across Claude, GPT, and Gemini in 2026. The reference points:

1 token is about 4 characters of English.
100 tokens is about 75 words.
1,000 tokens is about 750 words, or a page and a half of single-spaced text.

Code, numbers, and non-English text tokenize less efficiently. A dense Python file can run 20 to 30 percent more tokens than the equivalent prose. Japanese or Chinese text commonly runs 2x to 3x more tokens per visible character than English. Every model bills by tokens, not words and not queries, so this conversion is the first thing to get right.

Why input and output are not priced the same

Output tokens cost more, usually 3x to 5x more, than input tokens on the same model. Generation is sequential: to produce 1,000 output tokens the model runs 1,000 forward passes, each re-attending over the whole context so far. Reading the input happens once. Output is where the compute burns.

The practical consequence for you: the shape of a query, not just its size, sets the bill. A workflow that stuffs in a 50,000-token document and asks for a 200-token summary pays almost entirely for input. A workflow that generates a 5,000-token essay from a 100-token prompt pays almost entirely for output. Same total tokens, very different price.

What a single query costs in October 2026

Five realistic queries, priced across the current lineup. Rounded to the nearest tenth of a cent, using the table above and assuming no caching and no reasoning unless stated.

Query 1: “Explain quantum entanglement in two paragraphs”

Input: about 10 tokens.
Output: about 300 tokens.

Model	Cost
DeepSeek V4-Flash	$0.0001
GPT-5.6 Luna	$0.0004
Gemini 4 Argon	$0.003
Claude Opus 5	$0.008
Claude Fable 5	$0.015

The spread here is now over 100x for the same question. On the cheap end this is a rounding error you will never see on a statement. On the frontier end it is still trivial per query, which is exactly why routing simple lookups to a small model is the highest-leverage cost decision most people never make.

Query 2: Reviewing a 5,000-line code file for bugs

Input: about 45,000 tokens (file plus system prompt and instructions).
Output: about 800 tokens (a list of findings).

Model	Cost
DeepSeek V4-Flash	$0.007
GPT-5.6 Luna	$0.010
GPT-5.6 Terra	$0.124
Claude Opus 5	$0.245
Claude Fable 5	$0.490

Run this review ten times a day on Fable 5 and you are at $4.90 per day, about $147 per month, for one task. On Opus 5 it is half that. On Terra it is a quarter. This is the query shape where model choice starts to matter at the monthly level.

Query 3: Summarizing a 200-page PDF

Input: about 180,000 tokens.
Output: about 1,500 tokens.

Model	Cost
DeepSeek V4-Flash	$0.026
GPT-5.6 Luna	$0.038
Gemini 4 Argon	$0.375
Claude Opus 5	$0.938
Claude Fable 5	$1.875

A 200-page PDF on Fable 5 is nearly $1.88 per pass. Refinement loops pass the same document through the model several times, so the same summary can cost five times the single-pass figure before you are happy with it. This is also the query shape where prompt caching transforms the economics, which we will get to.

Query 4: A short chat reply (“rephrase this email to sound less aggressive”)

Input: about 200 tokens.
Output: about 200 tokens.

Model	Cost
DeepSeek V4-Flash	$0.0001
GPT-5.6 Luna	$0.0003
Gemini 4 Argon	$0.0024
Claude Opus 5	$0.006
Claude Fable 5	$0.012

Negligible everywhere. Most casual chat lives in this zone, which is how flat subscriptions stay profitable. The provider is betting most of your queries look like query 1 or query 4, not query 2 or 3. When you break that bet, the rate limits and nerfs arrive.

Query 5: Generating a 4,000-word article from a brief

Input: about 500 tokens.
Output: about 5,500 tokens.

Model	Cost
DeepSeek V4-Flash	$0.002
GPT-5.6 Luna	$0.007
GPT-5.6 Terra	$0.084
Claude Opus 5	$0.140
Claude Fable 5	$0.280

Output dominates. Doubling the length roughly doubles the cost, and halving it almost halves the cost. This is the lever bulk content teams pull first: cap the output, route the draft to a mid-tier model, and reserve the frontier tier for editing passes where judgment actually matters.

Cache reads are now the biggest lever

Every provider shipped prompt caching years ago, but the 2026 discounts are deeper and the failures more expensive. The idea is unchanged: keep sending the same long system prompt, document, or codebase, and the provider stores the intermediate state so you can re-read it cheaply instead of paying full input every turn.

Current cache-read rates as a share of normal input price:

Claude Sonnet 5.5: cache reads at $0.20 per MTok, a 90 percent discount against the $2 input rate.
Gemini 4 Argon: cached input discounted 95 percent, down to $0.10 per MTok at the intro price.
DeepSeek V4 Pro: cache hits at a small fraction of the $0.435 miss rate, which can push effective input cost under a cent per million on warm workloads.

There is a catch that trips people up: cache writes are billed at a premium over standard input, not a discount. You pay more on the first turn to write the cache, then read it back cheaply. On a long session this amortizes fast. On a short one you pay the write premium without collecting enough reads to break even.

The other catch is that caches are keyed on an exact byte prefix. A timestamp in your system prompt, a reordered tool list, or re-sending reasoning content between turns breaks the cache on every call. In practice, a stable system prompt and a stable tool definition are worth more than a model downgrade. If you want the full mechanics, we broke down the cross-provider pattern in how prompt caching saves money across providers.

Off-peak pricing and the new surcharges

The newest wrinkle in 2026 is time-based pricing. DeepSeek introduced peak and off-peak rates, with peak hours charged at 2x the regular price across input, output, and cached tokens. Peak is defined as 9:00 to 12:00 and 14:00 to 18:00 Beijing time (UTC+8). For a developer in North America running nightly batch jobs, the arithmetic is simple: shift the work a few hours and pay half, or keep it in the Beijing workday and pay double.

This is the cloud provider playbook arriving in AI. Expect more of it. Any workload you can schedule is now a workload you can discount, and the discount is often larger than a model swap.

Reasoning tokens, tracked or invisible

Reasoning modes are standard across the frontier tiers now: Claude’s extended thinking, Gemini’s deep think, OpenAI’s reasoning settings. The model spends tokens thinking before it produces the visible answer, and those thinking tokens bill at output rates.

On a hard reasoning query, hidden reasoning commonly outnumbers visible output by 5x to 20x. A reply that shows you 500 tokens can burn 7,000 tokens of reasoning behind it. At Opus 5 output rates of $25 per MTok, that is about $0.18 of invisible tokens behind a visible half-cent reply. On Fable 5 at $50 per MTok it doubles.

The fix is not to avoid reasoning. It is to track the reasoning_tokens field in the API response, which most providers report separately from output_tokens, and to disable extended thinking on tasks that do not need it. Writing, translation, and simple lookups are pure cost with reasoning on and no benefit.

Where API math meets subscription math

Most people never see a token bill. They pay a flat monthly fee for Claude Pro, ChatGPT, or Gemini, and the token math hides behind a fair-use curtain. It still matters, because the subscription is a token bucket with a paywall on top.

The providers size those buckets so average users never touch the ceiling and heavy users hit it constantly. If your usage priced at API rates is roughly twice your subscription fee, you are a mild net loss for the provider and probably fine. If it is ten times your subscription fee, you are the user the rate limits are built to clip, and the next nerf is aimed at you. Knowing which side of that line you sit on tells you whether to lean on the subscription, move to API billing, or split work across providers.

This is the part most cost guides skip. When we looked at hard budget caps for AI spending, the same pattern showed up: the users who get surprised are the ones who never computed their own break-even point.

How to estimate any query in your head

Once you have done this a few times, you can eyeball most queries to within a cent:

Estimate input in words, divide by 0.75, round to the nearest thousand tokens.
Do the same for output.
Multiply each by the model’s per-million rate and divide by 1,000,000.
If reasoning is on, multiply output by 5 to 10 for a rough total.
If caching applies, cut cached input by 90 to 95 percent.

Worked example on Claude Sonnet 5.5: 4,000 input tokens at $2 per MTok is $0.008, and 800 output tokens at $10 per MTok is $0.008, for about $0.016 per call. If 3,000 of those input tokens are cache reads at $0.20 per MTok, the input side collapses to near nothing and the real cost is under a cent.

Tracking the meter

Eyeballing is fine for casual use. For agents, products, or anything that runs the same query ten thousand times, you need instrumentation. Three fields to log on every call:

input_tokens, output_tokens, cached_input_tokens, and reasoning_tokens, broken out separately.
The model name and a timestamp, so cost spikes correlate to behavior changes.
A task tag, so you can answer which feature in your product burned the budget this month.

Most providers hand you the first piece in the response. The other two are on you. That gap is what tokenkarma fills: unified per-call accounting across Claude, OpenAI, Gemini, and DeepSeek, with cached and reasoning tokens broken out so you can see what is actually driving the bill instead of inferring it from a monthly summary. For users running several providers at once, that unified view is the difference between a bill you control and a meter you watch in horror at month end.

The takeaway

Token pricing is not complicated, it is just under-explained, and the ground shifted hard in 2026. Four things to carry forward:

The budget tier is nearly free and the frontier tier is wide. Route by task shape, not by habit.
Cache reads are the single biggest lever on repeat-prefix workloads, if you keep the prefix stable.
Off-peak scheduling is now a real discount, and it will spread to more providers.
Reasoning and image tokens add to the bill silently. Track the fields or get surprised.

Recompute the cost of the three queries you run most, against the October 2026 table. The number is smaller than you fear for chat and larger than you fear for agents. Either way, knowing it is the difference between a tool you run and a meter that runs you.