AI API Pricing Comparison 2026: OpenAI vs Claude vs Gemini vs DeepSeek vs Qwen

Verdict First

You want the answer without scrolling. Here it is, by workload shape.

Cheapest usable model, full stop: Qwen3.8-Flash at $0.11 in / $0.375 out. If you're doing classification or extraction and quality bar is "better than regex," stop reading and use this.

Best price-to-quality ratio: deepseek-v4-flash at $0.22 / $0.66 off-peak. Frontier-adjacent quality for roughly 2% of what GPT-6 Astra charges. The catch is real though. Rates double during peak hours (01:00–04:00 and 06:00–10:00 UTC, Mon–Fri), so US-daytime traffic pays $0.44 / $1.32.

Best for anything agentic or code-heavy: Claude Sonnet 5 at $2 / $10, with cache hits at $0.20. Not the cheapest. The cache economics on repeated system prompts are what make it work.

Cheapest reasoning: grok-4.6 at $2 / $6. That 3x output-to-input ratio is the lowest on any flagship, and reasoning workloads are output-dominated.

When budget genuinely doesn't matter: gpt-6-astra at $10 / $50, cache $1, 1.05M context.

The spread between the top and bottom of that list is roughly 450x on input. Same token, same count, wildly different invoice.

The 2026 Master Pricing Table

Standard tier, ≤200K context unless the context column says otherwise. Cached column is the rate you pay on a prefix cache hit. Blank means the provider doesn't publish one.

Two things worth staring at.

Qwen3.7-Max is billed in RMB, not dollars: ¥12 input, ¥36 output per 1M on Alibaba's Model Studio console. The $1.67/$5.00 above is a conversion at ×0.1389, so your actual invoice moves with FX. Alibaba has also been running a 50%-off promo (¥6/¥18). Don't plan a budget around promo pricing.

And Llama 4 Scout ships a 10M context window at $0.17 input. Nobody else is close on that axis. Whether you can usefully fill 10M tokens is a different question, but the pricing is not the constraint.

The Long-Context Pricing Trap

Here's what bites people. Most providers switch to a higher rate above a context threshold, and this is the part that surprises everyone: the higher rate applies to the entire prompt, not just the tokens above the line. Send 201K tokens to Gemini 2.5 Pro and all 201K bill at the long-context rate. Not just the extra 1K.

GPT-6 Astra is the odd one. Its long-context tier bills output cheaper than standard, $37.50 against $50. That's not a typo in our data; it's how the 1.05M-context flagship is positioned. If you're running genuinely long prompts, Astra's premium over Gemini shrinks a lot.

Anthropic is the quiet winner here. The 500K-context Claude models publish no long-context surcharge at all. Sonnet 5 costs $2/$10 at 10K tokens and $2/$10 at 400K tokens. For document workloads that hover around the 200K line, that predictability is worth more than a marginally lower headline rate.

I got this wrong when I first built our price table. I'd assumed the surcharge applied only to overflow tokens and modeled a document-QA workload at about $340/month. Actual: $680. The whole-prompt rule doubled it.

Decision Tree: Which Model for Your Workload

Chatbot (customer support, tier-1)

Shape: 50K input / 5K output per request, heavy system-prompt reuse, latency matters.

Pick Claude Haiku 4.5 ($1 / $5, cache $0.10). Not DeepSeek, and here's why. Your traffic peaks during business hours, which is exactly when DeepSeek's 2x peak multiplier kicks in. Haiku's cache hit at $0.10 covers a repeated 40K system prompt for almost nothing.

At 200K requests/month with a 40K cached prefix and 10K fresh input: roughly $1,050/month. Same volume on Sonnet 5 runs about $2,100. Route the 15% of conversations that actually need reasoning to Sonnet and you land near $1,200 total.

Document RAG

Shape: 200K input / 4K output, ~95% prefix cache hit, low request volume.

Pick Gemini 3.6 Flash ($1.50 / $7.50, cache $0.15) if your documents fit under 200K. Above that line, switch to Claude Sonnet 5 specifically because of the no-surcharge thing above.

5,000 requests/month at 95% cache hit: Gemini 3.6 Flash lands around $300/month. Sonnet 5, same workload, roughly $400. But it stays $400 when your contracts grow past 200K, where Gemini jumps to a different tier entirely.

Anthropic charges a cache write fee that people forget: $2.50/M for the 5-minute TTL, $4/M for the 1-hour. On a 200K prefix that's $0.80 per write on the 1-hour tier. Fine when you're reusing it 50 times. Terrible if your prefix churns every request.

Code Agent

Shape: 10K input / 8K output, most of that output being reasoning tokens, long multi-turn sessions.

Pick grok-4.6 ($2 / $6) if cost dominates, Claude Sonnet 5 ($2 / $10) if quality does.

The math on 50K requests/month: Grok runs $3,400/month, Sonnet 5 $5,000/month, Opus 5 $12,500/month. Grok's 3x output multiplier against Anthropic's 5x is the entire difference.

But I'd still pay the $1,600 gap for Sonnet on a code agent. Agent workloads fail expensively. A wrong edit costs a human 20 minutes of review, which is worth more than the token delta. The cheap-model math only works if the cheap model doesn't generate rework.

One more thing about code agents that doesn't show up in any pricing table: multi-turn sessions re-send the entire conversation on every turn. Turn 20 of a debugging session might carry 80K tokens of accumulated context. That means your effective input cost scales quadratically with session length, not linearly. A 30-turn session isn't 30x a single call. It's closer to 200x. Cap your context window or summarize aggressively, or the input column becomes your whole bill.

Caching & Batch Savings

Caching is the biggest lever nobody pulls hard enough.

The jump from 50% to 90% hit rate is where the money is. On Sonnet 5 that's $1.10 down to $0.38 per 1M input, a 65% cut from nothing but prompt ordering. Put your stable content (system prompt, retrieved docs, few-shot examples) at the front and the volatile content (user message) at the end. That single change moves most apps from roughly 50% to above 85%.

Watch the TTL, though. Anthropic's default cache lives 5 minutes. If your traffic is bursty, with quiet gaps between clusters of requests, you'll pay the write fee over and over and never collect the hit-rate savings. The 1-hour TTL costs more up front ($4/M against $2.50/M on Sonnet 5) and is usually the better deal for anything below roughly one request per minute. DeepSeek and Google skip the write fee entirely, so they start saving on request two instead of request three or four.

Batch is the second lever: OpenAI, Anthropic, Google, and Mistral all cut rates 50% for async jobs. Gemini 3.6 Flash Batch is $0.75/$3.75. Llama 4 Scout on Bedrock Batch drops to $0.085/$0.33. Anything overnight, whether that's embeddings, labeling, or backfills, should be running batch. Stacking batch on top of caching is how a $3,000 bill becomes $400.

My Picks for Common Budgets

$10/month: side project

Qwen3.8-Flash ($0.11 / $0.375) or Mistral Small 4 ($0.15 / $0.60). At $10 you get roughly 30M input tokens on Qwen. That is a genuinely large amount of classification. Skip anything with "Pro" or "Opus" in the name.

$50/month: indie tool with real users

deepseek-v4-flash off-peak ($0.22 / $0.66) as the default, Claude Haiku 4.5 for anything user-facing where a bad answer costs you the customer. Roughly 90/10 split. If your users are US-based, budget for the peak multiplier. Call it $65 to be safe.

$200/month: small SaaS feature

Gemini 3.6 Flash ($1.50 / $7.50) with caching on. At 90% cache hit your effective input rate is $0.29, which stretches $200 much further than the headline suggests. Add Claude Sonnet 5 on a 10% escalation path.

$500/month: production feature, quality matters

Claude Sonnet 5 ($2 / $10) as the primary. Batch anything async. At 85%+ cache hit and 50% of volume on batch, $500 covers a meaningful production workload, on the order of 100M+ cached input tokens.

$2,000/month: core product

Two models, not one. Claude Sonnet 5 for the 80% path, Claude Opus 5 ($5 / $25) or gpt-6-astra ($10 / $50) for the 20% that needs frontier reasoning. Don't run Astra on everything — at $50/M output it burns $2,000 in about 40M output tokens, which a busy product hits in under a week.

The pattern at every tier is the same: one cheap model doing volume, one expensive model on an escalation path, caching turned on. Single-model architectures either overpay or underdeliver.

What none of these budgets account for is retries. Every production system re-runs some percentage of calls because of timeouts, rate limits, malformed JSON, or a validation step rejecting the output. On our own workloads that runs 8-12% of total volume, and it bills at full rate every time. Whatever number you land on above, add 20% before you promise it to anyone holding the credit card.

Run your actual token counts through the Token Calculator before committing. Average tokens per request is the number that decides everything above, and most people's estimate is off by 2-3x.

Sources

1. OpenAI Platform Pricing. platform.openai.com/docs/pricing. verified 2026-09-06 (gpt-6-astra, gpt-5.6 family)
2. Anthropic Claude Pricing. docs.claude.com/en/docs/about-claude/pricing. verified 2026-09-02 (Sonnet 5, Opus 5, Haiku 4.5, cache write tiers)
3. Google Gemini API Pricing. ai.google.dev/gemini-api/docs/pricing. verified 2026-09-02 (Gemini 2.5/3.x, long-context tiers)
4. DeepSeek API Pricing. api-docs.deepseek.com/quick_start/pricing. verified 2026-09-02 (V4 Flash/Pro, peak-hour multiplier)
5. Mistral API Pricing. mistral.ai/pricing/api. verified 2026-09-02 (Medium 3.5, Small 4)
6. AWS Bedrock Pricing. aws.amazon.com/bedrock/pricing. verified 2026-08-28 (Llama 4 Maverick/Scout, batch rates)

Cross-checked against data/models.json, last regenerated 2026-09-06. All rates per 1M tokens, USD.