How to Read an LLM Pricing Page: Every Line Item Explained

A modern LLM pricing page is no longer two numbers. It's a dozen line items — input, output, cached, batch, context tiers, thinking tokens, tool fees — and misreading any of them can double your real cost. Here's a field guide to every line, and which ones actually move your bill.

The Two That Everyone Knows

• Input (prompt) tokens. Everything you send: system prompt, conversation history, codebase context, the user's message. Priced per million tokens. In coding, input usually dominates volume because you re-send context every turn.
• Output (completion) tokens. Everything the model generates. Priced per million, and almost always more expensive than input — often 3–5x. This is why verbose models cost more even at the same "price."

The Discounts That Cut the Bill

• Cached input. A repeated prefix read from cache instead of reprocessed, typically ~10% of the base input rate (sometimes lower). Huge for multi-turn agents with a stable system prompt. Watch for a separate "cache write" premium on the first turn.
• Batch pricing. Roughly 50% off for async jobs processed within a window (e.g., 24 hours). Applies to queued, non-interactive work.
• Off-peak pricing. Some providers now charge less during low-demand UTC hours. The headline rate may be the off-peak one — peak can be 2x.

The Traps That Inflate It

• Context-length tiers. Many models charge more once a prompt crosses a threshold (e.g., 128K or 200K tokens). Some double all rates for the entire request past that line. A long-context task can silently cost 2x — check for ">200K" or "long context" rows.
• Thinking / reasoning tokens billed as output. Reasoning models generate internal thinking you pay for at the output rate, even though you never see most of it. A 500-token answer can bill 5,000 output tokens. Estimate agentic output at total generation, not the visible result.
• Tool / built-in feature fees. Web search, code execution, and grounding are often billed separately — e.g., "$X per 1,000 search queries" — on top of tokens. Easy to overlook until they show up on the invoice.
• Introductory rates. "Through December 31" or "limited-time" flags mean the number isn't durable. Budget at the post-promo rate.

Which Line Items Actually Matter?

Not all lines deserve equal attention. For a typical coding workload, weight them like this:

• Dominant: input and output rates, and cached input if you run multi-turn agents. These set 80%+ of your bill.
• Big if applicable: context-length tiers (long-context work) and thinking tokens (reasoning models). These are the surprise doublings.
• Situational: batch and off-peak (only if you have flexible workloads), tool fees (only if you use those features).

A Five-Step Reading Routine

1. Find the base input and output rates.
2. Check whether that headline rate is off-peak, introductory, or a third-party price — is it durable?
3. Scan for context-length tiers and note the threshold that doubles your cost.
4. If it's a reasoning model, confirm thinking tokens are billed as output and inflate your output estimate.
5. List any per-use tool fees for features you'll actually call.

Do that and the "cheap" model that's secretly expensive — and the "premium" model that's cheaper than it looks once you cache — stop surprising you. The headline number is a starting point, not the answer.

Skip the manual math: our AI Cost Calculator applies real per-token rates across models to your project size, so you compare true total cost instead of headline prices.