What an LLM API Call Actually Costs in October 2026 (GPT-6 vs Claude 5.5 vs Gemini 3.8)

Every LLM pricing page gives you the same thing: two numbers per model, dollars per million input tokens and dollars per million output tokens. That looks simple, and the simple version is a fine starting point. But the price per million tokens is not the price of your call. Reasoning tokens, cache writes, long-context tiers and promo end dates all sit between those two numbers and your invoice, and any one of them can reorder the “cheapest model” ranking.

Here’s the arithmetic, done properly, at October 2026 list prices.

The prices (as of 2026-10-06)

Standard (non-batch) rates in USD per million tokens. “Cached” means the cache-read rate.

Model	Input	Output	Cached read
GPT-6 Astra	$10.00	$50.00	$1.00
GPT-6.1 Sol	$2.00	$10.00	$0.10
GPT-6 Luna	$0.10	$0.50	$0.01
Claude Opus 5.5	$4.00	$20.00	$0.20
Claude Sonnet 5.5	$2.00	$10.00	$0.20
Claude Haiku 4.5	$1.00	$5.00	$0.10
Gemini 3.1 Pro (preview)	$2.00	$12.00	$0.20
Gemini 3.8 Flash (promo)	$0.75	$3.75	$0.075
Gemini 3.1 Flash-Lite	$0.25	$1.50	$0.025

Two things stand out before any math. First, output costs five times input on almost every row, and six times on Gemini 3.1 Pro and Flash-Lite. Second, Sonnet 5.5 and GPT-6.1 Sol have identical list prices, which, as we’ll see, does not mean they cost the same.

The formula

One call costs:

cost = (input_tokens / 1,000,000) × input_price
     + (output_tokens / 1,000,000) × output_price

Multiply by 1,000 for per-1,000-call cost. That’s the whole model the pricing pages imply, and it’s what most back-of-envelope estimates use.

Scenario 1: a typical chat call

A 2,000-token prompt (system prompt plus user message plus a bit of context) and a 500-token reply. Worked for Sol:

input:  2,000 / 1,000,000 × $2.00  = $0.004
output:   500 / 1,000,000 × $10.00 = $0.005
total:                              $0.009 per call → $9.00 per 1,000 calls

Across the board:

Model	Input cost	Output cost	Per call	Per 1,000 calls
GPT-6 Luna	$0.0002	$0.00025	$0.00045	$0.45
Gemini 3.1 Flash-Lite	$0.0005	$0.00075	$0.00125	$1.25
Gemini 3.8 Flash (promo)	$0.0015	$0.001875	$0.003375	$3.38
Claude Haiku 4.5	$0.002	$0.0025	$0.0045	$4.50
GPT-6.1 Sol	$0.004	$0.005	$0.009	$9.00
Claude Sonnet 5.5	$0.004	$0.005	$0.009	$9.00
Gemini 3.1 Pro	$0.004	$0.006	$0.010	$10.00
Claude Opus 5.5	$0.008	$0.010	$0.018	$18.00
GPT-6 Astra	$0.020	$0.025	$0.045	$45.00

Notice that the reply is only 20% of the tokens but more than half the cost on every row. On Sol, $0.005 of the $0.009 is output.

The spread is the real headline: the same call is $0.45 or $45 per thousand depending on the model. A 100× range means “which model” matters far more than “which provider.”

Scenario 2: long context flips the ranking

Now a retrieval-heavy call: 300,000 input tokens (a big document dump or a long agent transcript) and a 1,000-token answer. This is where tier rules come in:

OpenAI: prompts over 272K input tokens bill at long-context rates. Sol goes from $2/$10 to $4/$15, Astra from $10/$50 to $20/$75.
Google: Gemini 3.1 Pro prompts over 200K tokens go from $2/$12 to $4/$18.
Anthropic: no long-context tier. Claude 4.6 and later include the full 1M context window at standard pricing; Anthropic’s own example is that a 900K-token request bills at the same per-token rate as a 9K one.

Sol, 300K prompt:   300,000 / 1M × $4  + 1,000 / 1M × $15 = $1.200 + $0.015 = $1.215
Sonnet, 300K prompt: 300,000 / 1M × $2 + 1,000 / 1M × $10 = $0.600 + $0.010 = $0.610

Model	Per call	Per 1,000 calls
Claude Sonnet 5.5	$0.610	$610
GPT-6.1 Sol (long-context rate)	$1.215	$1,215
Gemini 3.1 Pro (long-context rate)	$1.218	$1,218
Claude Opus 5.5	$1.220	$1,220
GPT-6 Astra (long-context rate)	$6.075	$6,075

In Scenario 1, Opus 5.5 cost twice what Sol did. Here they’re within a cent of each other, and Sonnet, Sol’s price twin, is half the price. The long-context tier is priced by prompt size, so crossing 272K moves the whole request to the higher rate. Keep your prompt at 271K and you never see it.

Trap 1: reasoning tokens are output tokens

Thinking models think in tokens, and you pay for them at the output rate, even when you never see them. OpenAI’s reasoning guide says it directly: reasoning tokens “are not visible via the API” but “are billed as output tokens.” Anthropic reports how many of your billed output tokens were reasoning in usage.output_tokens_details.thinking_tokens. Google’s pricing page lists Gemini output prices as “including thinking tokens.”

So a request that shows you a 500-token answer may have generated 3,500 tokens of reasoning first. Same 500-token prompt, 4,000 billed output tokens:

Model	Per call	Per 1,000 calls
Gemini 3.8 Flash (promo)	$0.0154	$15.38
Claude Haiku 4.5	$0.0205	$20.50
GPT-6.1 Sol	$0.041	$41.00
Gemini 3.1 Pro	$0.049	$49.00
Claude Opus 5.5	$0.082	$82.00

Output is now over 97% of every bill, so the input price barely matters. When you estimate output, don’t size it by the visible reply. Look at the reasoning count in the usage object of a real response.

Trap 2: the same text is a different number of tokens

Prices are per token, but a token isn’t the same unit across providers. Each vendor trains its own tokenizer (how that works), and the same paragraph gets a different count on each. Anthropic’s pricing page is unusually frank about this: Claude 4.7 and later models use a newer tokenizer that “produces approximately 30% more tokens for the same text.”

That’s why the Sonnet-equals-Sol tie in Scenario 1 is misleading. Identical per-token prices with a tokenizer that emits more tokens means a higher per-call bill for the same prompt. Compare per call on your own text, not per million tokens on a pricing page.

Trap 3: caching can lose money

Cache reads are cheap: 0.1× base input on most Claude models, 0.05× on Opus 5.5, $0.10 vs $2.00 on Sol. Cache writes cost extra, though. Anthropic charges 1.25× base input for a 5-minute cache write and 2× for a 1-hour write (Opus 5.5: $5 and $8 per MTok vs $4 base). OpenAI’s pricing page now lists cache-write rates too: $12.50 on Astra, $2.50 on Sol, $0.125 on Luna, all 1.25× their input price. Gemini charges a per-hour storage fee on top of the cached rate ($4.50 per million tokens per hour on 3.1 Pro).

Take a 10,000-token system prompt on Sonnet 5.5:

uncached:          10,000 / 1M × $2.00 = $0.020 per call
5-min cache write: 10,000 / 1M × $2.50 = $0.025
cache read:        10,000 / 1M × $0.20 = $0.002

At steady traffic, 1,000 calls cost $0.025 + 999 × $0.002 ≈ $2.02 instead of $20. But if requests arrive every ten minutes, the 5-minute cache expires between them and every call is a write: $25 instead of $20, 25% worse than not caching at all. A 1-hour write ($0.040) only pays off once it’s been read twice. Caching rewards bursty, repetitive traffic. For sparse traffic it’s a surcharge.

Gemini 3.8 Flash costs $0.75/$3.75 through 2026-12-31. Starting 2027-01-01 it’s $1.50/$7.50. In Scenario 1 that moves it from $3.38 per 1,000 calls (cheaper than Haiku’s $4.50) to $6.75 (half again more than Haiku). If you choose a model on a promo price, put the end date in your budget spreadsheet next to it.

On the upside, Anthropic cancelled a scheduled increase. The page now says Sonnet 5’s $2/$10 introductory pricing “is now the standard price” and the planned move to $3/$15 on 2026-09-01 “will not occur.” Sonnet 5.5 lists the same $2/$10.

Trap 5 (in your favor): batch is half price

If your work can wait, all three providers’ batch tiers cut prices in half. Anthropic states a 50% discount on input and output. OpenAI’s batch table lists Sol at $1/$5 and Luna at $0.05/$0.25. Google lists Gemini batch rates at half of standard, e.g. 3.8 Flash at $0.375/$1.875 during the promo. For overnight classification or backfills, that’s the single largest discount available.

How our calculator handles this

The cost calculator built into the Token Counter runs the Scenario 1 formula against every model above, per call and per 1,000 calls, sorted cheapest first. Here’s what it does and doesn’t model:

Exact counts come from OpenAI’s open-source encodings (o200k_base and cl100k_base, via the gpt-tokenizer library), running in your browser. Your prompt never leaves the page.
Claude rows use characters ÷ 3.5, raised 1.3× for Claude 4.7+ models because Anthropic doesn’t ship a browser tokenizer — the 1.3× follows the 30% tokenizer note above (Haiku 4.5 keeps the older tokenizer, so it gets the plain estimate). They’re marked ≈; treat them as ballpark figures.
Gemini rows reuse the GPT token count with Google’s prices, so they’re estimates too.
Override the input count to price a prompt you’ve measured elsewhere. The override replaces the count for every row, Claude included.
It uses standard rates only. Long-context tiers appear as notes on the affected rows but aren’t applied, and caching, reasoning tokens and batch discounts aren’t modeled. For reasoning models, enter your expected output including thinking tokens.

For exact numbers, every provider has a count-tokens API. Use it before you commit to volume.

Prices change, so check the source

Everything here is as of 2026-10-06, taken from the official pages:

OpenAI: https://developers.openai.com/api/docs/pricing
Anthropic: https://platform.claude.com/docs/en/about-claude/pricing
Google: https://ai.google.dev/gemini-api/docs/pricing

These pages change without notice, and the promo dates above will pass. Check them before signing anything.

Try it

Token Counter: paste your real prompt, set expected output tokens and call volume, and see the per-call and per-1,000-call cost across GPT, Claude and Gemini, side by side.
How LLM tokenization works: why your token count depends on which model is counting.
JSON Formatter: minify structured context before it goes into a prompt, since every brace is billed.