LLM API pricing comparison: GPT-5, Claude, Gemini, DeepSeek and Llama (2026)

TL;DR

If you are comparing LLM API providers in 2026, the cheapest model on paper is rarely the cheapest in practice. The real cost depends on cache-hit rate, output verbosity, context window size, and whether your workload can use batch pricing.

Based on current rates (checked 2026-05-29):

|| Provider | Budget tier (/M input) | Workhorse tier (/M input) | Premium tier (/M input) | ||---|---|---|---| || DeepSeek | $0.14 (v4 Flash) | — | $0.435 (v4 Pro) | || Google | $0.15 (Gemini 2.0 Flash) | $1.25 (Gemini 2.5 Pro) | — | || Anthropic | — | $3.00 (Claude Sonnet 4.5) | $15.00 (Claude Opus) | || OpenAI | See note below | See note below | See note below | || Groq (Llama) | ~$0.10–$0.30 | ~$0.50–$1.20 | ~$2.00–$5.00 |

OpenAI pricing note: OpenAI pricing verified via third-party aggregator — verify directly at platform.openai.com before making procurement decisions.

The safest short answer: compare the full workload cost, not the headline input rate. A model that costs $3/M input but caches 80% of your prompts and produces concise outputs can be cheaper than a $0.15/M model that generates verbose responses and never hits cache.

The cross-provider comparison table

The table below shows cents-per-million-token rates for each provider’s current model lineup, checked from official documentation on 2026-05-29. All prices are USD unless otherwise stated.

*DeepSeek v4 Pro data from api-docs.deepseek.com/quick_start/pricing — currently at 75% off promotional pricing ending 2026-05-31 15:59 UTC. Post-promotion prices revert to 4× these rates.

†Anthropic’s batch FAQ mentions cache pricing can combine with batch discounts, but does not publish a simple batch row price in the current pricing table excerpt.

Input vs output asymmetry: Every provider charges significantly more for output tokens than input — typically 3–5× the input rate, and up to 10× for premium models. This is not incidental: generating text costs more compute than receiving it.

OpenAI rates (from third-party aggregator, verified 2026-05-29 via Artificial Analysis): GPT-5 series input rates range from ~$2/M (mid-tier) to ~$15/M (premium). Output rates range ~$10/M to ~$75/M. Cached input discounts are ~50% on standard input rates. Batch API: 50% discount on all rates. These are estimates — verify directly at platform.openai.com before committing to any OpenAI-based cost model.

How to read the table

Most columns are self-explanatory, but three deserve a closer look.

Cached input pricing: not a free lunch

Every provider now offers cheaper rates for reused prompt text. But the mechanics differ:

• DeepSeek offers the most dramatic cache discount: ~98% off input when the cache hits. A $0.14/M input drops to $0.0028/M — essentially free.
• Google offers ~90% cached input discount for Gemini 2.5 Pro (from $1.25 to $0.13 per M tokens within the 200K threshold).
• Anthropic has a two-part structure: cache writes cost more than standard input ($3.75/M vs $3.00/M for Sonnet 4.5), but cache hits cost $0.30/M — 90% off standard.

The implication: caching pays back only when the same prompt text is reused enough times. One-off queries get no benefit. Repeated system prompts, shared context documents, or frequent retrieval bundles can see huge savings.

Context window thresholds are real pricing cliffs

Google’s pricing page is the clearest example: Gemini 2.5 Pro costs $1.25/M input up to 200K tokens, then jumps to $2.50/M — a 2× increase for longer contexts. The output rate jumps from $10/M to $15/M above the same threshold.

This means a prompt that barely fits inside the threshold costs very differently from one that pushes past it. A 180K token RAG query costs half the input of a 250K token query on the same model.

Batch pricing availability

Batch pricing is for non-urgent work. If your task can wait — overnight classification, bulk embedding, weekly report generation — batch effectively doubles your dollar.

Real-world cost calculation examples

The table alone is misleading because nobody pays the headline rate for every token. Here are three worked examples showing the real cost of a complete workload.

Example 1: Document summarisation (low volume, no cache)

• Input: 4K tokens (prompt + document)
• Output: 500 tokens
• Volume: 1,000 runs/month
• Cache reuse: None (each document is different)

Key insight: For single-use queries without cache, budget models dominate. The cost spread is 20–30× between DeepSeek Flash and Claude Sonnet.

Example 2: RAG pipeline with heavy cache reuse

• Reusable context: 8K tokens (system prompt + fixed retrieval context)
• Unique input: 1K tokens per query
• Output: 1K tokens per response
• Volume: 50,000 queries/month
• Cache type: DeepSeek works best here (98% discount on cached tokens)

Key insight: At higher volumes, caching is not optional — it is the difference between affordable and unaffordable. The percentage savings are similar across providers, but the absolute dollar spread between budget and premium remains large.

Example 3: Batch classification (10K short inputs)

• Input: 10K short texts at 50 tokens each (500K total input tokens)
• Output: 1 token per classification (10K total output tokens)
• Batch available: Yes

Key insight: Batch classification is where budget models already seem cheap, and batch pricing halves it again. The absolute cost for 10K classifications on DeepSeek or Google Flash is less than a coffee.

Hidden costs that change the comparison

The comparison table is a starting point. These hidden factors often change which provider is actually cheapest for a specific workload.

1. Output verbosity differences

Models do not produce the same output length for the same task. A verbose model that generates 30% more output tokens effectively costs 30% more on the output side — regardless of the headline input rate. In practice, larger models (Claude Opus, GPT-5 premium) tend to produce longer, more detailed responses. Smaller models (Flash, Haiku) are terser.

Rule of thumb: When comparing providers, estimate output length per provider separately if you can. A $0.15/M input model that outputs 1,000 tokens costs as much as a $3.00/M input model that outputs 50 tokens.

2. Rate limit tiers and overage

Some providers charge different rates for burst usage beyond included quota. OpenAI’s platform, for example, has separate free/paid tiers. Most providers now publish rate limits by model tier, but overage costs are not always transparent.

Rule of thumb: If your workload has unpredictable spikes, factor in potential overage charges. The comparison table assumes standard pay-as-you-go rates within reasonable concurrency.

3. Provider update cadence

LLM pricing changes quarterly or faster. DeepSeek ran a 75% promotional discount throughout May 2026 that expires on 31 May. Google reduced rates on Gemini Flash twice in 2026. Anthropic has held steady since Q1.

Rule of thumb: Do not build a 12-month cost model from today’s pricing page. Plan for 10–20% annual price declines on most providers, with occasional promotions that make direct comparison unreliable during the promo window.

4. Multi-model routing overhead

If you use a model gateway (OpenRouter, LiteLLM) or a cloud AI platform (Bedrock, Vertex, Azure), add 5–20% margin on top of raw API pricing. The convenience of unified billing, fallback routing, and key management comes at a cost.

How to compare providers for your workload

Use this checklist before committing to any provider.

Action checklist

1. Count your real input tokens — not the tidy version you wish you had. Count system prompts, retrieval bundles, tool schemas, and conversation history.
2. Split input into one-off and reusable text. The reusable portion is where caching matters.
3. Estimate output length per task — and whether it varies by provider. A model that writes longer answers is not always better.
4. Check whether batch pricing applies. If the task can wait, half the cost is usually available.
5. Identify context window thresholds. Will your average prompt push past a pricing cliff?
6. Test cache-hit rate on a sample workload. The savings are real — but only if your prompts are actually repeated.
7. Add 20% buffer for retries, fallbacks, validation loops, and tool call overhead. These inflate token counts quietly.
8. Re-check every 90 days. Pricing changes. The cheapest provider this quarter may not be next quarter.

Simple formula

Total monthly cost = (fresh_input_tokens × fresh_input_rate)
  + (cached_input_tokens × cached_input_rate)
  + (output_tokens × output_rate)
  × batch_modifier_if_applicable

Build this as a low / likely / high range:

• Low: Short prompts, high cache reuse, batch available, concise outputs.
• Likely: Your current average workload with realistic estimates.
• High: Long prompts, low cache reuse, no batch, verbose outputs plus retries.

When to prioritise quality over price

The cheapest provider is not always the right choice. Price matters most when:

• The task is high-volume and repetitive — bulk classification, content extraction, embedding generation.
• The output quality is already acceptable from a budget model — no need to pay for power you will not use.
• Latency is not critical — batch pricing makes sense.

Price matters less when:

• The output is customer-facing — a budget model’s poorer reasoning or hallucination rate costs more in support or brand damage than the API savings.
• The task requires complex reasoning — legal analysis, medical triage, financial modelling, multi-step agent workflows.
• The output needs to be consistent and structured — JSON mode, tool calling, and instruction-following quality vary significantly between budget and premium models.

A practical rule: use the cheapest model that passes your evaluation threshold for the specific task, and route everything else up to a more capable (and more expensive) fallback. This is multi-model routing, and it is how cost-conscious teams deploy in production — not by picking one provider, but by matching workload to model tier.

Methodology

• Data checked: 2026-05-29
• Sources consulted: DeepSeek API docs, Google Vertex AI pricing, Anthropic Claude pricing, Groq pricing, Together AI pricing, Cohere pricing, Artificial Analysis (OpenAI aggregate)
• Directly verified at source (HTTP 200 from this server): DeepSeek, Groq, Together AI, Cohere
• Client-side rendered pages (pricing data extracted from page HTML but may differ from JS-rendered state): Anthropic, Google
• Blocked from server-side access: OpenAI pricing pages (HTTP 403) — rates estimated from third-party aggregator
• Assumptions: All currency values are USD. “M” means million tokens. Cache-hit rates are based on official published pricing; actual savings depend on workload patterns. Batch discount applies only when the workload is eligible for batch mode. Context threshold pricing (Google) is factored at the ≤200K rate unless otherwise stated. DeepSeek v4 Pro promotional pricing (75% off until 2026-05-31) is treated as the current rate; post-promotion rates will be 4× higher.
• Limitations: This article provides a pricing comparison snapshot, not live price quotes. Provider pricing changes frequently and account/volume tiers may differ between individual and enterprise contracts. It does not cover self-hosted model costs, fine-tuning economics, enterprise volume discounts, reserved-capacity pricing, or currency/regional pricing differences. Quality and capability differences between models are not captured in token pricing alone. It is not legal, financial or procurement advice.
• Jurisdiction: Global. All pricing referenced from publicly available API documentation.

Source list

• DeepSeek models and pricing — accessed 2026-05-29
• Google Vertex AI pricing — accessed 2026-05-29
• Anthropic Claude pricing — accessed 2026-05-29
• Groq pricing — accessed 2026-05-29
• Together AI pricing — accessed 2026-05-29
• Cohere pricing — accessed 2026-05-29
• Artificial Analysis model comparison — accessed 2026-05-29
• Anthropic model overview — accessed 2026-05-29

Related guides

• API model pricing: input, output, cache and batch costs
• What is a token, and why does it affect AI cost?
• Prompt caching explained: when repeated context becomes cheaper
• Batch APIs for LLMs: cheaper, slower and often underused
• The hidden cost of retries, fallbacks and validation loops
• Model routing: using cheap models first without breaking quality
• Hosted API vs self-hosted open model: the real cost comparison

Trust Stack

• Last checked: 2026-05-29
• Corrections: Contact us to report errors

Change log

• 2026-05-29: 16-gate editorial review: filled reviewedBy frontmatter, trimmed description to 118 chars, set Trust Stack review model label, removed internal ticket IDs from change log.
• 2026-05-29: First draft built from the content opportunity brief and researcher source pack. Cross-provider comparison table with current pricing checked against DeepSeek, Anthropic, Google, Groq, Together AI and Cohere official docs. OpenAI pricing sourced via third-party aggregator due to server-side request blocking. Three worked cost examples included. Methodology, sources and Trust Stack documented.