Major

LLM API Pricing in 2026: The Rate Card Is Not the Bill

Every LLM pricing table shows input and output. Your invoice has a dozen more columns: cached reads, cache writes, context tiers, batch discounts and reasoning tokens. Here is what the rate cards actually charge.

Jason BaoUpdated
Hands holding tax forms beside a calculator and laptop, reviewing the real cost of LLM API usage

How are LLM APIs priced?

LLM APIs bill per million tokens, with input and output counted separately and output priced four to five times higher. That is the rate card. Your invoice also reflects cached reads, cache writes, context-length tiers, batch discounts, reasoning tokens and tool fees, and those usually move the total more than the choice between two similarly priced models.

If you run agents in production, the useful question is how many model calls you pay for, not just what each one costs. Major attacks that second number: when an agent works out a repeatable step, it builds a deterministic app for it, and the step stops spending tokens. The section on building this on Major below shows how.

Current rates from the three major providers

Prices below were verified on 17 September 2026 against each provider's own pricing page. They change often, so check the provider page before you put a forecast in front of finance. Each bullet lists input, cached input and output per million tokens.

  • Anthropic Claude Opus 5: $5.00 / $0.50 / $25.00. The 1M window bills at the standard rate.
  • Anthropic Claude Sonnet 5: $2.00 / $0.20 / $10.00. No context tier.
  • Anthropic Claude Haiku 4.5: $1.00 / $0.10 / $5.00.
  • OpenAI gpt-6-astra: $10.00 / $1.00 / $50.00. Long context: $20.00 / $2.00 / $75.00.
  • OpenAI gpt-5.6-terra: $2.00 / $0.20 / $12.00. Long context: $4.00 / $0.40 / $18.00.
  • OpenAI gpt-5.4: $2.50 / $0.25 / $15.00. Above 272k tokens: $5.00 / $0.50 / $22.50.
  • OpenAI gpt-5-nano: $0.05 / $0.005 / $0.40.
  • Google Gemini 3.1 Pro Preview: $2.00 / $0.20 / $12.00. Above 200k tokens: $4.00 / $0.40 / $18.00.
  • Google Gemini 2.5 Pro: $1.25 / $0.125 / $10.00. Above 200k tokens: $2.50 / $0.25 / $15.00.
  • Google Gemini 3.5 Flash-Lite: $0.30 / $0.03 / $2.50.

Read the context tier before anything else. gpt-5.6-terra and Gemini 3.1 Pro Preview both list $2.00 input. On a 300k-token prompt one of them charges $4.00 and the other still charges $2.00, because the boundaries sit in different places. Claude Sonnet 5 stays at $2.00 to a million tokens.

The pricing dimensions most tables leave out

Output is expensive because generation runs one token at a time, each needing its own pass through the model, while input tokens are processed in parallel. Beyond that ratio, nine things change the bill.

  • Cached input reads: about 0.1x base input at Anthropic and OpenAI, roughly the same at Google. This is the largest lever on any workload with a stable prefix such as a system prompt, policy document or schema.
  • Cache writes: Anthropic charges 1.25x base input for a 5-minute cache and 2x for a one-hour cache. The 5-minute cache pays for itself after one read, the one-hour cache after two. Bursty traffic that writes and then goes quiet pays the premium for nothing.
  • Cache storage: Google rents cached context by the hour, from $0.50 to $8.10 per million tokens depending on model and tier, so idle context accrues charges overnight.
  • Context-length tiers: OpenAI and Google roughly double input above a threshold (272k and 200k in the examples above). Anthropic states that Claude 4.6 and later bill a 900k-token request at the same per-token rate as a 9k one.
  • Batch: 50% off input and output at all three providers. It is the cheapest optimization for anything asynchronous.
  • Fast and priority tiers: 2x standard at OpenAI and Anthropic, about 1.8x at Google. These multiply with cache rates.
  • Reasoning tokens: billed at the output rate. An agent that thinks for 4,000 tokens before a 200-token answer pays for 4,200 output tokens.
  • Tokenizer density: Anthropic notes Claude 4.7 and later produce roughly 30% more tokens for the same text than Sonnet 4.6 and earlier. The rate card does not change; your effective price does.
  • Tools and residency: web search runs $10 per 1,000 calls at OpenAI and Anthropic. Anthropic applies a 1.1x multiplier for US-pinned inference.

What a real workload costs

Take a support triage agent handling 2,000 tickets a day, or 60,000 runs a month on Claude Sonnet 5. Each run sends a 12,000-token stable prefix (triage policy, product taxonomy, response templates), 3,000 tokens of ticket and history, and generates 700 tokens.

  • Standard: 15,000 input tokens at $2 per million is $0.030, plus 700 output tokens at $10 per million is $0.007. That is $0.037 per run, about $2,220 a month.
  • With caching: the prefix reads at $0.20 per million ($0.0024), uncached input costs $0.006, output stays $0.007. That is $0.0154 per run, plus roughly 720 cache writes a month at $0.03 each. About $946 a month.
  • Batch plus caching: every figure halves. About $473 a month.

Same model, same output quality, $2,220 or $473 depending on two configuration choices. Configuration decides more of this bill than model selection does.

How to estimate your own bill

  1. Count tokens on ten real requests with the provider's token counting endpoint. Never reuse a count from another model's tokenizer.
  2. Split input into the stable prefix and the variable part. The ratio tells you what caching is worth before you build it.
  3. Check whether your typical prompt crosses a tier boundary. If it sits near 200k or 272k, model both sides.
  4. Add measured reasoning tokens to your output estimate.
  5. Price the job, not the token. A cheap model that needs two attempts can cost more per finished task than a mid-tier model that gets it right once.

This guide does not cover self-hosting or fine-tuning economics, which need their own calculation.

Cut the number of calls: build the triage agent on Major

Every lever above makes a single call cheaper. None makes fewer calls. In the triage workload, most of the 60,000 monthly tickets fall into four or five shapes the agent has already figured out, yet the system pays full price each time it reasons to a conclusion it reached last Tuesday.

Major is the enterprise platform where agents build the software they run on. Here is how the triage workload would run there.

  • Connectors: Zendesk supplies tickets and customer history, Slack carries escalations to a human owner. Credentials are scoped per connector, not pasted into a prompt.
  • The app: a triage app with managed database tables for ticket category, routing rule and resolution history. Classification rules for the known shapes run as deterministic code and write to those tables.
  • The agent: it handles only the tickets the app cannot place, such as a new failure pattern or an angry enterprise customer, and builds a new rule into the app when it solves one.
  • The trigger: a workflow fires on each new Zendesk ticket, runs the app first, and calls the agent only on a miss.
  • State: history lives in the app database instead of being re-sent in a 12,000-token prefix on every run.
  • Governance: role-based access decides who can edit rules, and every action is logged, so you can attribute any routing decision.

Token cost becomes front-loaded and then flat. The agent spends tokens once to work out each repeatable step, and later runs of that step cost code execution rather than inference. The model still handles judgment calls; it just stops carrying work that code does better. Reason once, run forever.

Caching and batching still apply to the calls that remain, so everything in this guide keeps paying off on the smaller bill.

Start building on Major

Point an agent at your triage queue, let it build the app for the parts that repeat, and price the workload again in a month. You will see which calls stopped happening.

Related articles

Frequently asked questions

How are LLM APIs priced?
Per million tokens, counted separately for input and output, with output priced roughly four to five times input on the same model. Two further dimensions carry real weight. Cached input reads bill at about a tenth of the standard input rate, and OpenAI and Google both charge more for input once a prompt crosses a context-length threshold. Anthropic charges one rate across its full context window.
Why is output more expensive than input?
Input tokens are processed together in a single pass over the prompt. Output tokens are produced one at a time, each requiring its own pass through the model, so generation consumes far more compute per token than reading does. Providers price that difference directly, which is why output sits at four to five times the input rate across Anthropic, OpenAI and Google.
What is the cheapest LLM API?
The lowest per-token tier is not the cheapest per finished job. gpt-5-nano lists at $0.05 per million input and $0.40 output as of 17 September 2026, but a small model that needs two attempts, longer reasoning, or a retry on a malformed response can cost more per completed task than a mid-tier model that answers correctly the first time. Price the job, not the token.
Does prompt caching actually save money?
Yes, once you read the cache. Anthropic charges 1.25x the base input rate to write a five-minute cache and 2x for a one-hour cache, against a read price of 0.1x. That means the five-minute cache pays for itself after a single read and the one-hour cache after two. Bursty traffic that writes a cache and then goes quiet pays the write premium for nothing.
Are LLM API prices going up or down?
Both, depending on the model. Per-token rates on comparable capability have generally fallen as newer tiers launch, and Anthropic cancelled a scheduled increase on Claude Sonnet 5, keeping it at $2 and $10. Google has published the opposite: Gemini 3.8, 3.7 and 3.6 Flash double on 1 January 2027, from $0.75 to $1.50 input and $3.75 to $7.50 output.