Cheapest LLM API: the honest list, by capability class

Cheapest by capability class

Comparing a 9B model to a frontier model on price is like comparing a bicycle to a truck on fuel economy. Sort into classes first. All rates per million tokens, verified on the vendor pages in August 2026.

Frontier class

Models you would trust with an ambiguous, multi-step task. These are single-source: no shopping around, so the only decision left is which one, and the cards for Claude Opus 5 and gpt-5.6-sol carry the published benchmark rows behind it.

Mid class

The workhorse tier: good enough for the large majority of production and agent traffic. This is where price competition actually exists.

Small and cheap class

Classification, extraction, routing, summarization, mechanical edits. This is where the truly low numbers live.

Five traps that make a cheap API expensive

1. Tokenizers are not comparable

This is the trap nobody accounts for. Anthropic documents that Claude 4.7 and later models use a newer tokenizer producing roughly 30 percent more tokens for the same text than earlier models. That means a per-million-token price is a price for a unit that differs between models. A model at $2 per million that tokenizes your text 30 percent more finely is effectively $2.60 against a model at $2 with a coarser tokenizer. Any price table, including the ones above, understates this. The only fix is to measure your own corpus.

2. Long-context surcharges

OpenAI applies a long-context multiplier on the GPT-5.6 family past 272K tokens: input doubles and output rises 50 percent, so gpt-5.6-sol goes from $5.00 / $30.00 to $10.00 / $45.00. Anthropic does the opposite, pricing the full 1M-token context window at the standard rate on Claude 4.6 and later, so a 900k-token request costs the same per token as a 9k one. For a coding agent that accumulates context across a long session, this single difference can outweigh the headline rate.

3. Cache pricing varies more than base pricing

Cache read rates are where the spread actually is, and for agent workloads (which resend the same system prompt and repo context every turn) cache is most of the input.

At 80 percent cache hit rate, a 10 percent cache ratio and a 20 percent cache ratio produce a 9 percent difference in the total input bill on identical base rates. Note also that Anthropic charges to write the cache: 1.25x base for a 5-minute TTL, 2x for an hour. A 5-minute cache pays for itself after one read; a 1-hour cache after two.

4. Free-tier rate limits are the actual product

Free tiers exist to stop you evaluating properly. OpenRouter grants 50 free-model requests per day, rising to 1,000 only after you have purchased at least $10 in credits. Fireworks grants $1 once. Together publishes nothing. Groq offers a rate-limited free tier. Modal is the exception with $30 renewed monthly. If a "free" plan caps you below your evaluation set, its price is not zero, it is the cost of a bad decision made on insufficient data.

5. The fees that are not per token

OpenRouter charges no inference markup and instead takes 5.5 percent on Stripe credit purchases with a $0.80 minimum, or 5 percent on crypto. Anthropic charges a 1.1x multiplier if you pin inference to US-only geography, and $10 per 1,000 web searches for the server-side search tool. None of these appear in a $/Mtok comparison and all of them appear on the invoice.

The discount nearly everyone leaves on the table

Every major provider discounts asynchronous work by 50 percent, and it requires no model change, no prompt change, and no quality tradeoff. It requires only that you can wait.

When a flat plan beats every per-token price

For coding agents specifically, the cheapest per-token rate is often not the cheapest way to buy inference at all, because subscriptions bundle a large allowance at a fixed price. The arithmetic is simple and almost nobody does it.

Workload: 880 agent turns/month, 25k input + 1.5k output per turn,
          80% of input served from cache.
          = 22M input tokens, 1.32M output tokens

On Claude Sonnet 5 ($2 / $0.20 cached / $10):
  uncached input   4.4M x $2.00  = $ 8.80
  cached input    17.6M x $0.20  = $ 3.52
  output           1.32M x $10   = $13.20
                                   -------
  metered total                    $25.52 / month

  -> A $25 flat plan is roughly break-even at ONE developer.

Same workload, 6 developers on one team:
  metered total                   $153.12 / month
  Continuum Max 100 ($100, $100/wk allowance)
                                  $100.00 / month
  -> Flat wins by ~35%, and the allowance still has headroom.

Same workload but heavy (3x turns) on Claude Opus 5 ($5 / $0.50 / $25):
  uncached input  13.2M x $5.00   = $ 66.00
  cached input    52.8M x $0.50   = $ 26.40
  output           3.96M x $25    = $ 99.00
                                    --------
  metered total                     $191.40 / month per developer
  -> Well past the crossover. Flat plans win decisively at frontier
     models and high turn counts.

Questions people ask

Keep reading

Continue through Inference providers with Serverless inference: three different things with one name.