AI API pricing, compared honestly

The headline “dollars per million tokens” rarely predicts your actual bill. Your input/output ratio, prompt caching, and batch usage move the number more than the sticker rate does — two providers with near-identical headline prices can produce a 3× difference on your invoice. This page compares OpenAI and Anthropic on the things that actually show up on the bill — and benchmarks Google Gemini and DeepSeek alongside them — with worked math you can copy.

The cost model: input, output, cache, batch

Four numbers determine your spend per request:

1. Input price — per million input tokens (prompt, context, system message).
2. Output price — per million generated tokens, usually 3–5× the input price.
3. Cached input price — a steep discount for repeated prefixes you mark cacheable.
4. Batch discount — typically ~50% off for non-realtime work via batch endpoints.

The single biggest mistake is comparing on input price alone. Output is the expensive half, so a chatbot that reads long context but answers briefly (input-bound) behaves completely differently from an agent that writes long completions (output-bound).

Per-model rates — all four providers

Below are the current standard list rates across OpenAI, Anthropic, Google, and DeepSeek — the same data that powers our cost calculator. Don’t rank on the headline input price; rank on your input/output mix.

Two things to notice: output costs 3–5× input at every provider, and cached-input rates vary wildly — Anthropic and DeepSeek discount cached reads by ~90%, which can flip the cheapest pick for prompt-heavy, cache-friendly workloads. The mini/flash tiers (GPT‑5.4 mini, Gemini Flash) and DeepSeek run an order of magnitude cheaper than the flagships.

Worked example: an output-light vs output-heavy app

Take 1,000,000 requests/month. Compare two shapes:

• Support bot (input-heavy): 2,000 input tokens, 200 output tokens each.
• Drafting agent (output-heavy): 1,000 input tokens, 1,500 output tokens each.

Monthly token volume:

Now cost both workloads across every model (no caching), using tokens ÷ 1,000,000 × rate, sorted cheapest-first by the support-bot bill:

Two patterns jump out. First, the mini/flash tiers and DeepSeek run 10–50× cheaper than the flagships at the same traffic. Second, rankings flip between workloads — a model that’s cheap for the read-heavy support bot can fall behind for the output-heavy agent, because output dominates that bill. So don’t crown one “cheapest model”; pick per workload. Want this math at your own traffic? The cost calculator does it live across all 11 models.

How caching and batching change the answer

The support bot above reuses a large system prompt on every call. If 1,800 of its 2,000 input tokens are a cacheable prefix, Anthropic’s cheap cached-input rate ($0.30/1M vs $3.00 base) erases much of its input cost — narrowing or reversing the gap with OpenAI. Caching helps input-bound apps the most; it does nothing for output cost.

For offline jobs (bulk classification, embeddings backfills, nightly summarization), routing through each provider’s batch API roughly halves the bill and uses separate, higher rate limits — a double win that’s independent of which provider is cheaper at sticker price.

A quick cost estimator

def monthly_cost(requests, in_tok, out_tok, in_rate, out_rate,
               cached_in_tok=0, cached_rate=0.0, batch_discount=0.0):
  billable_in = (in_tok - cached_in_tok) * in_rate + cached_in_tok * cached_rate
  per_req = (billable_in + out_tok * out_rate) / 1_000_000
  total = per_req * requests
  return total * (1 - batch_discount)

# Support bot on Anthropic Sonnet, 1.8k of 2k input cached, realtime (no batch):
print(monthly_cost(
  requests=1_000_000, in_tok=2000, out_tok=200,
  in_rate=3.00, out_rate=15.00,
  cached_in_tok=1800, cached_rate=0.30,
))  # -> dramatically lower than the no-cache $9,000 above

When to switch, when to split

• Switch if one provider is meaningfully cheaper for your specific input/output ratio and quality is acceptable for the task. Confirm with the estimator on real token counts, not headline rates.
• Split by routing cheap, tolerant tasks to a mini/Haiku model and reserving flagship/Sonnet for hard ones. This usually saves more than picking a single provider, and a thin abstraction makes it easy — see the wrapper in the OpenAI → Anthropic migration guide.
• Factor in non-token costs: rate-limit headroom (a cheaper provider you constantly 429 against isn’t cheaper), latency, and quality on your eval set.

What to do next

1. Plug your real token counts into the estimator above — separate input from output.
2. Turn on caching and batching in the model before deciding; they often change the winner.
3. Validate quality on your own eval set, not vendor benchmarks.
4. Ready to move workloads? Follow the OpenAI → Anthropic migration guide, and size throughput with the OpenAI and Anthropic Claude rate-limit references.