Hidden LLM API costs nobody quotes (2026)

Every LLM comparison ranks models by two numbers: dollars per million input tokens, dollars per million output tokens. That’s the sticker. Your actual invoice has line items the sticker never mentions — a cache write that costs more than the input it replaces, a tokenizer that quietly inflates every request, reasoning tokens you’re billed for but never see. None of them are secret; most are in the vendor’s own docs. They’re just not on the comparison sites. Here are ten, each quoted from the source.

A note before the list

These aren’t scams. Anthropic, to its credit, documents nearly all of its surcharges on one pricing page. Google’s caching storage fee is in the caching docs. OpenAI’s reasoning-token billing is in the reasoning guide. The problem isn’t disclosure — it’s that the ecosystem quotes models by two numbers, so anyone comparing on the sticker is comparing the wrong thing. Every figure below links to the canonical source. Where the wording matters, it’s quoted verbatim.

1. The tokenizer tax

The price per token is honest. The number of tokens is the part nobody checks. The same sentence becomes a different token count on each model — and on the same family across versions. Anthropic states it plainly:

“Opus 4.7 and later use a new tokenizer compared to previous models… This new tokenizer may use up to 35% more tokens for the same fixed text.”

— Anthropic pricing docs

Read that again with your invoice in mind. Opus 4.8 and Opus 4.7 carry the same $5/M input sticker as Opus 4.5 — but if the newer tokenizer turns your prompt into up to 35% more tokens, your effective input price is up to 35% higher for identical text. A model that looks 10% cheaper per token can be more expensive per request.

2. Cache writes cost more than the input they replace

Prompt caching is sold as a discount. The cache read is — but the cache write is a premium. Anthropic’s multipliers:

Anthropic’s own note on when it pays off:

“A cache hit costs 10% of the standard input price, which means caching pays off after just one cache read for the 5-minute duration (1.25x write), or after two cache reads for the 1-hour duration (2x write).”

— Anthropic pricing docs

So caching is only a win once a cached prefix is reused enough. If your system prompt changes every call, or the 5-minute cache expires before the next request, you paid 1.25-2x base input for nothing. We walk the full break-even math in the cornerstone post on caching — the short version is that caching is a bet that you’ll reuse the prefix, and the house edge is the write premium.

3. Cache rent: Google charges you to store it

There’s a second caching cost that almost nobody models. On Google’s explicit context caching, the read discount is only half the bill — the other half is a per-hour storage fee for keeping the cache alive. From the pricing page, for both Gemini 2.5 Pro and 2.5 Flash:

“$1.00 / 1,000,000 tokens per hour (storage price)”

— Google Gemini pricing

Do the math on a Gemini 2.5 Pro cache holding a 200K-token document for an 8-hour workday: 0.2M tokens × $1.00/M/hr × 8 hr = $1.60 in storage alone, before you read it a single time. Hold a full 1M-token context cache for a day and that’s about $24 in pure storage. Cache something large, forget to expire it, and you’re paying rent on tokens you may never re-query — and check your specific model’s line, because some newer and larger Pro tiers carry a higher storage rate. The read discount is real; so is the meter running while the cache sits idle.

4. Crossing the context line reprices the whole request

Some models charge a higher rate above a context threshold — and it applies to the entire request, not just the overflow. Gemini 2.5 Pro is $1.25/M input and $10/M output at or below 200K tokens, and $2.50/M / $15/M above it (Google pricing). A 200K-token call runs about $0.26; push it to 250K and it doesn’t cost 25% more — it costs about $0.64, roughly 2.5x, because the whole prompt reprices at the higher tier.

Not every vendor does this, and the contrast is worth noting. Anthropic explicitly does not surcharge long context on its current models:

“Claude Opus 4.8, Opus 4.7, Opus 4.6, and Sonnet 4.6 include the full 1M token context window at standard pricing. (A 900k-token request is billed at the same per-token rate as a 9k-token request.)”

— Anthropic pricing docs

We flagged the Gemini line in the cheapest-by-use-case roundup too, because it’s the single easiest way to accidentally double a long-context bill. If you run near 200K on any model, confirm its tier policy before you scale.

5. Reasoning tokens you pay for but never see

Reasoning models generate a chain of thought before they answer. You don’t see it — but you’re billed for it. OpenAI’s docs are explicit:

“While reasoning tokens are not visible via the API, they still occupy space in the model’s context window and are billed as output tokens.”

— OpenAI reasoning guide

Output tokens are the expensive side of the bill — typically 4-8x input. A response that shows 200 visible tokens may have burned several thousand invisible reasoning tokens first, every one billed at the output rate. OpenAI recommends reserving at least 25,000 tokens for reasoning plus output when you start, which tells you how large the invisible part can get. If you’re costing a GPT-5.5-class reasoning workload on visible output alone, your estimate is low — sometimes by an order of magnitude.

6. One image is hundreds to thousands of tokens

“Vision input” sounds like a flat add-on. It isn’t — images are converted to tokens, and a single photo can dwarf your text prompt. Anthropic’s formula:

An image uses approximately (width px × height px) / 750 tokens.

— Anthropic vision docs

That makes a 1500×1000 image ~2,000 tokens and a 3000×2000 image ~8,000 tokens. On Opus 4.8 input at $5/M, that 8,000-token image is $0.04 — and ten of them in one prompt is 80,000 tokens, $0.40, before you’ve written a word of text.

OpenAI bills images differently but no more cheaply: high-detail images are scaled and split into 512px tiles at 170 tokens per tile plus an 85-token base, and image input is metered at $8/M tokens (OpenAI vision docs). Either way: a multi-image prompt is a large-prompt bill wearing a small-prompt disguise.

7. Video and audio explode the token count

If images are surprising, time-based media is a different order of magnitude. Google converts media to tokens at fixed rates:

Source: Google Gemini token docs. A ten-minute video is ~158,000 input tokens — most of a 200K context window, consumed by one clip. A one-hour video is ~947,000 tokens, brushing the 1M ceiling and costing real money on input alone. Audio input also runs several times the text rate per token on most Gemini tiers. If your product ingests media, model the bill on seconds of footage, not “number of files.”

8. Fast mode: paying 2-6x for the same model

Need lower latency? Some providers sell a faster path to the same model at a steep premium. Anthropic’s fast mode:

Source: Anthropic pricing docs. Fast mode can be the right call when latency is directly tied to revenue — but at 6x on Opus 4.7, it’s a line item that should be a deliberate decision, not a default someone flipped on. And it stacks: caching multipliers and the data-residency surcharge apply on top of fast-mode pricing.

9. The geography surcharge

If compliance forces you to pin inference to a region, you pay for it. On Anthropic’s first-party API, requesting US-only routing adds a flat multiplier across every token category:

“Specifying US-only inference through the inference_geo parameter incurs a 1.1x multiplier on all token pricing categories, including input tokens, output tokens, cache writes, and cache reads.”

— Anthropic pricing docs

On the partner clouds it’s similar: Bedrock and Vertex regional and multi-region endpoints carry a 10% premium over global endpoints for current models. A 10% tax on the entire bill is the kind of thing a data-residency requirement quietly adds — and it’s invisible until you compare a regulated deployment’s invoice against the sticker.

10. Tool use bills twice

Give a model tools and you pay on two axes the sticker never mentions. First, server-side tools carry their own usage charges on top of tokens — on Anthropic, web search is $10 per 1,000 searches and code execution is $0.05 per hour per container beyond a free monthly allowance (Anthropic pricing docs). Second, simply enabling tools injects a system prompt you didn’t write and are billed for every call:

Source: Anthropic pricing docs (range depends on tool_choice). It’s small per call — but an agent that makes thousands of tool-augmented calls a day is paying for a system prompt it never authored, every single turn, plus per-search and per-container-hour fees on the work the tools actually do.

How to not get surprised

None of this means any vendor is cheating you. It means the two-number sticker is the start of a cost estimate, not the end. A checklist that closes the gap between your estimate and your invoice:

1. Count tokens with the real tokenizer, not a rule of thumb — and re-count when you switch model families. The tokenizer tax (§1) can move the bill 20-35%.
2. Model cache reuse before enabling caching. If you won’t clear the write premium (§2) with enough reads, don’t cache. And set a TTL you’ll actually use, so you don’t pay storage rent (§3).
3. Know your context tier. If you run near 200K tokens, confirm whether the model reprices the whole request above it (§4).
4. Budget reasoning tokens as output. For o-series and extended-thinking models, the invisible chain of thought (§5) is the bill.
5. Meter media by the second and the pixel, not by the file (§6, §7). One video can fill a context window.
6. Treat fast mode and US-only routing as deliberate line items (§8, §9), not defaults.
7. Account for tool overhead — per-call system prompts plus per-use server-tool fees (§10).

Do that and your forecast will match your invoice. Skip it and you’ll learn these line items the expensive way — on the bill. For how we verify every price on this site against the vendor’s own page, see our methodology.

All figures in this post were verified on 2026-06-03 against the vendors’ own documentation: Anthropic pricing and vision docs, OpenAI reasoning and vision guides, and Google Gemini pricing, caching, and token docs. Where a number drives a decision, we link the source so you can check it yourself — see our methodology for the verification cadence.