AI Model Providers Compared: What the Same Workload Actually Costs

The question that matters isn't "which is smartest"

Developers comparing model providers usually start with benchmarks and end up picking on price, context window, or which rate limit tier they can actually live inside. Those three numbers move monthly, vendors quote them inconsistently (per-1K vs per-1M tokens, cached vs uncached, short-context vs long-context), and the gap between the cheapest and most expensive way to run the same job is routinely 40x. This page prices one realistic workload — 10 million input tokens and 2 million output tokens a month, roughly what a mid-volume support bot or coding assistant burns — against every major provider's own published rate card, checked today.

The frontier three, side by side

If you want a top-tier general-purpose model, it's a three-way race: OpenAI's GPT-5.5, Anthropic's Claude Opus 5, and Google's Gemini 3.1 Pro Preview. All three now sit around a 1M-token context window, which used to be the differentiator and no longer is.

Sources: OpenAI GPT-5.5 pricing, Claude Opus 5 pricing, Gemini 3.1 Pro pricing.

Two things worth knowing before you pick one:

• Anthropic is the only one of the three with no long-context surcharge. If your workload regularly stuffs large documents or long conversation histories into the prompt, that's a real cost difference, not a rounding error — a 300K-token prompt costs the same per token on Claude as a 3K-token one, while OpenAI and Google both double the price past their thresholds.
• Claude's prompt-cache reads cost 10% of the base input price and don't count against Anthropic's per-minute input-token rate limit at all — only fresh, uncached tokens do. For any workload that resends a large system prompt or document repeatedly, that changes both your bill and your effective throughput ceiling. OpenAI's cached input is 10% too, but it does count toward the rate limit.

What the same month actually costs, everywhere

Here's 10M input + 2M output tokens priced against each provider's current published rate, cheapest to most expensive:

Sources: Groq model pricing, MiniMax M2.7 via OpenRouter, Mistral API pricing, DeepSeek pricing, Cohere Command A via OpenRouter, other sources as above.

The spread is the finding, not any single number: the same job costs $2.70 on Groq's hosted open-weight models and $110 on GPT-5.5 — a 40x range for one workload. That doesn't mean the cheap end is the right call; GPT-OSS 120B and Claude Opus 5 are not interchangeable on capability. But most teams paying frontier prices for a workload that a $0.15/$0.60 open-weight model handles fine are doing it by default, not by decision. DeepSeek in particular is worth a second look for cost-sensitive coding and agent work: V4 Pro's off-peak pricing (01:00–04:00 and 06:00–10:00 UTC, Monday–Friday, half the peak rate) is a genuine lever if your batch jobs can be scheduled around it.

Note what's missing from a pure per-token table: Replicate and RunPod don't sell tokens, they rent GPU-seconds — Replicate's cheapest listed instance is $0.000025/sec for a small CPU box, scaling to $0.0014/sec for an A100. That model only pencils out if you're running your own weights or bursty batch jobs; for a steady chat workload, per-token pricing from a hosted API is almost always cheaper once you count idle GPU time.

The rate limits that actually bite

Price comparisons assume you can hit the price. New accounts usually can't, and the gap between "published rate card" and "what a new org gets on day one" is where most production incidents start.

• OpenAI's Tier 1 (unlocked at $5 paid) caps GPT-5.5 at 500 requests/minute and 500,000 tokens/minute — and prompts over 272K tokens draw from a separate, stricter long-context pool: 200 RPM / 400,000 TPM. A team building on long documents can hit the long-context ceiling well before the headline TPM number suggests trouble. (OpenAI rate limits)
• Anthropic's Start tier gives Claude Opus 5 and Sonnet 5 their own 2,000,000-input-token-per-minute pool each, separate from older Opus/Sonnet 4.x models, which share a combined bucket. Migrating from Opus 4.8 to Opus 5 effectively doubles your available throughput rather than competing for the same limit. (Anthropic rate limits)
• Gemini enforces a spend-based rate limit on top of RPM/TPM: Tier 1 accounts are capped at $10 of API spend per rolling 10-minute window, Tier 2 at $50, Tier 3 at $200. A burst of expensive Gemini 3.1 Pro calls can trip a 429 from the spend cap even when your request and token counts look fine. (Gemini rate limits)
• Groq's headline speed doesn't come with headline throughput. The Developer plan's base limit for GPT-OSS 120B is 30 requests/minute and 8,000 tokens/minute — fine for a demo, tight for anything with concurrent users, regardless of how fast each individual response streams. (Groq rate limits)
• Together AI publishes no fixed limits at all. Its rate limiting is dynamic, scaling with your own recent successful traffic; the only way to learn your actual ceiling is to watch for x-ratelimit-reset headers on a 429, which makes capacity planning a live experiment rather than a lookup. (Together AI rate limits)
• Cohere's trial keys are capped at 1,000 API calls a month, full stop — not a per-minute throttle but a hard monthly ceiling, and newer models like Command A Reasoning stay trial-only until you contact sales for a production key. (Cohere rate limits)

Going through an aggregator instead of direct

OpenRouter is worth a specific mention because its economics are unusual: it charges no markup on per-token inference pricing — you pay the same rate you'd pay the provider directly — and instead takes a 5.5% fee (minimum $0.80) only when you purchase credits by card. Free rate limits are simple and separate from provider limits: 50 requests/day on free models with no credits purchased, rising to 1,000/day once you've bought at least $10. The tradeoff for routing everything through one API key and getting automatic provider fallback is that 5.5% top-up fee plus, if you bring your own provider keys (BYOK), a 5% fee on usage above a $25,000/month free allowance. For a team already spending five figures a month with a single provider, that's real money; for anyone who values not rewriting integration code every time a new model ships, it's a small tax. (OpenRouter FAQ)

The verdict

• Building something that needs to reason over long documents or hold long conversations: Claude, because it's the only frontier option with no long-context price penalty, and its cache-read discount plus rate-limit exemption reward exactly that pattern.
• Cost-sensitive, high-volume, and the task doesn't need frontier reasoning: start with Groq's hosted GPT-OSS 120B or DeepSeek V4 Pro scheduled into its off-peak window before reaching for a name-brand flagship — the same job is 10-40x cheaper and the rate limits, while tight on Groq specifically, are enough for most non-consumer-facing workloads.
• Multi-provider fallback matters more than shaving the last cent off inference cost: OpenRouter, accepting the 5.5% credit fee as the price of one integration and automatic failover across providers.
• Running your own fine-tuned weights or bursty batch jobs rather than a steady API-shaped workload: GPU-second rental (Replicate, RunPod) instead of any per-token API — the pricing model matches the usage pattern better.

Whichever you pick, verify the number yourself before committing budget: every price and limit above shifts on vendor timelines, not yours, and several providers (Google, OpenAI) already have scheduled price increases baked into their published tables for January 2027.