Claude vs. GPT vs. Gemini: Real Cost Per Task, Not Per Token

Last updated 19 September 2026. List prices below were checked against Anthropic’s Claude API pricing docs, OpenAI’s API pricing page, and Google’s Gemini Developer API pricing page on that date. Rates and model IDs change; confirm on each provider’s own docs before you budget. [VERIFY: 2026-09-19]

Not affiliated with Anthropic, OpenAI, or Google. Claude Token Optimization is an independent site and audit service. Claude® and related names are trademarks of Anthropic PBC. GPT® / ChatGPT® are trademarks of OpenAI. Gemini® is a trademark of Google. Always confirm live rates on each provider’s docs. [VERIFY: 2026-09-19]

If you searched llm cost comparison, llm api cost comparison, or chatgpt vs claude api cost, you have probably seen a table of dollars per million tokens. That table is necessary and not sufficient. The unit that matters for a product budget is cost per finished task — including retries, tool chatter, and the standing context you send every turn.

This page does three things: (1) frames why per-token rankings flip once tasks differ, (2) posts a verified mid-tier rate card for Claude, GPT, and Gemini, and (3) walks illustrative scenarios with fixed, labeled token shapes so you can re-run the math. It is not a live quality bake-off. We did not claim that model X “won” a blind eval here. Tokenizers, thinking tokens, and retry rates differ in production — that is exactly why you measure your own tasks inside the LLM cost framework.

For Claude-only list prices, keep Claude API pricing open. To estimate a Claude call before you send, use the cost calculator.

Why “cheapest per million” lies

Two models can have the same list price and different bills for the same product job:

• Retries. A cheaper model that fails acceptance 30% of the time can cost more than a mid-tier model that passes once.
• Context shape. A fat system prompt taxes every turn. See hidden system prompt costs.
• Thinking / reasoning tokens. Some providers bill extended thinking as output. That changes the effective cost of a “short” answer.
• Tokenizer differences. Anthropic notes that Claude 4.7+ tokenizers can produce roughly 30% more tokens for the same text than earlier Claude tokenizers — exact uplift depends on content. Cross-provider token counts for identical prose will not match 1:1. [VERIFY: 2026-09-19]
• Tool loops. Agents multiply input. Cost-per-task must include every tool result stuffed back into context.

So the comparison method is: define the task, measure tokens (and retries) on each model, multiply by that model’s rates, then divide by accepted completions. List prices alone are step zero.

Verified rate card (API, standard tiers)

Mid-tier workhorses and cheap defaults teams actually compare. All figures are USD per million tokens (MTok) on standard first-party APIs unless noted. [VERIFY: 2026-09-19]

OpenAI also publishes long-context rates and Fast mode uplifts; Google publishes Batch / Flex / Priority tiers and over-200k surcharges on Pro. Claude publishes cache write/read multipliers and a 50% Batch discount. Those modifiers change cost-per-task for agent loops — see prompt caching for Claude’s cache math.[VERIFY: 2026-09-19]

How to run a real cost-per-task comparison

1. Define the finished task. Example: “triage ticket to one of five labels with ≥90% agreement to golden set.”
2. Freeze the prompt pack. Same system instructions, same tools, same retrieval chunk policy. Changing the pack mid-test invalidates the comparison.
3. Sample ≥30 real items (more if variance is high). Synthetic toy prompts understate production context.
4. Log usage fields from each provider response (input, output, cache, thinking). Do not estimate from character counts alone when APIs report tokens.
5. Count retries and human overrides toward the task until acceptance.
6. Cost = Σ(tokens × rates) / accepted tasks. Report median and p90, not only the mean.

That loop is Stage 1–3 of the Measure → Attribute → Reduce framework applied to model choice. Model routing details will deepen on the planned model routing page.

Illustrative scenarios (labeled math, not a bake-off)

Below we hold token shapes fixed across models and multiply by the rate card above. That isolates list-price effects. In production, token shapes will not match across providers — treat these as worksheets, not winners. All dollars are USD. [VERIFY: 2026-09-19]

Scenario A — Short classify (800 input / 50 output)

At this shape, cheap defaults dominate — as expected. The decision is quality and latency, not pennies, until volume hits millions of calls.

Scenario B — Support reply with docs (4,000 input / 400 output)

Here mid-tier Claude Sonnet 5 and GPT-5.6 Terra / Gemini 3.1 Pro land in the same ballpark under identical token assumptions. A 20% retry rate on the cheaper model erases that gap fast — which is why acceptance rate belongs in the denominator.

Scenario C — Coding turn (12,000 input / 1,500 output)

Coding agents rarely stop at one turn. Multiply by turns per merged PR, then by retry factor. Claude Code seat economics are a different meter — see Claude Code costs and reducing Claude Code tokens.

Scenario D — Agent loop (25,000 input / 3,000 output across 5 turns)

Caching changes this table more than swapping mid-tier brands. On Claude, cache reads are 0.1× base input on most models after a write — see prompt caching pricing. OpenAI and Gemini publish their own cached-input rates; apply those before you declare a winner. [VERIFY: 2026-09-19]

When the “expensive” model is cheaper

Worked intuition (still illustrative): suppose Scenario B must hit 95% acceptance. Model Cheap passes 70% on first try and needs a second full call otherwise. Model Mid passes 95% once.

• Expected calls for Cheap ≈ 0.70×1 + 0.30×2 = 1.3 calls → 1.3 × $0.00220 ≈ $0.00286 if Cheap were Gemini 2.5 Flash’s illustrative unit cost.
• Mid at Claude Sonnet 5’s illustrative $0.01200 still looks higher here — until Cheap needs human review at $2/ticket or a third model escalation. Add those line items.

The point is not the specific dollars. It is the formula: cost per accepted task = (Σ API $ + human $) / accepted tasks. List-price rankings ignore the denominator.

Claude-specific notes for fair comparisons

• Seat plans vs API. Pro / Max / Team are capacity bars, not per-token invoices. Do not mix seat MSRP into an API cost-per-task table — see Pro vs the API.
• Prompt caching. Stable prefixes on agent loops should be compared with cache hits enabled after the prefix is short.
• Batch API. 50% off input and output when latency allows. [VERIFY: 2026-09-19]
• How tokens are counted. How Claude tokens work and the context window page.

What to do Monday

1. Pick one production task and write the acceptance test.
2. Log tokens + retries on your current default model for 50 items.
3. Re-run the same pack on one cheaper and one stronger model.
4. Compute cost per accepted task; put the winner behind a router (planned: model routing).
5. If the waste is prompt structure rather than brand choice, cut token usage first — or have the prompts reviewed.

Building a fair task pack

Most published “model comparisons” fail before the first API call because the task pack is either toy-sized or secretly optimized for one vendor’s strengths. A fair pack for llm api cost comparison work looks like this:

• Production residue. Pull real tickets, PRs, or support threads (redacted). Synthetic one-liners understate standing context and tool results.
• Fixed retrieval. If you use RAG, freeze the chunker and top-k. Letting each model retrieve differently turns the test into a retrieval bake-off.
• Same tool surface. Identical tool schemas and identical max-iteration caps. A model that “wins” by calling tools 40 times is not cheaper just because output looked fluent.
• Blind scoring where it matters. For quality gates, score without seeing the model name. For cost, always keep the usage logs attached.
• Separate latency SLOs. Cost-per-task and p95 latency are different decisions. A Batch-discounted job can win on dollars and lose on product UX.

Write the acceptance rubric before you look at costs. If you invent the rubric after seeing which model was cheapest, you will rationalize the table you already wanted.

Where ChatGPT vs Claude API cost searches go wrong

Searchers typing chatgpt vs claude api cost often mix three different meters:

1. ChatGPT consumer seats vs Claude Pro / Max seats.
2. OpenAI API vs Claude API list prices.
3. Hosted agent products that wrap either API with their own markup.

Only meter (2) belongs on this page. Meter (1) is a capacity-bar decision — see Pro vs the API. Meter (3) needs the vendor’s invoice line items, not a public rate card. Conflating them produces LinkedIn charts that compare a $20 seat to a $2 / MTok API line and call it research.

When your team is Claude-heavy on seats and API-curious for automation, run two cost-per-task sheets: one for human chat / Claude Code workflows, one for product inference. Mixing them in one average hides the automation opportunity.

Modifiers that move the ranking more than brand choice

Before you switch providers, check whether these modifiers already flip your bill inside one ecosystem:

• Caching. Repeated system prompts and tool schemas should hit cache. On Claude, reads are typically 0.1× base input after a write. OpenAI and Gemini publish their own cached-input columns — apply them in Scenario D before declaring Terra “tied” with Sonnet. [VERIFY: 2026-09-19]
• Batch. Claude Batch is 50% off input and output when you can wait. Gemini and OpenAI also publish batch tiers. Async eval jobs and offline classification should almost never pay interactive rates. [VERIFY: 2026-09-19]
• Long-context surcharges. Gemini 2.5 Pro and 3.1 Pro raise rates above 200k input tokens. A “cheap” Pro call with a 250k dump is not the ≤200k row on the card. [VERIFY: 2026-09-19]
• Thinking tokens. Gemini bills thinking inside output on several SKUs. OpenAI reasoning models and Claude adaptive / extended thinking change output volume. Log the fields the API returns; do not assume output ≈ visible answer length.
• Regional / Fast uplifts. Several providers charge premiums for data residency or faster tiers. Those belong in the spreadsheet as separate columns, not as footnotes you forget when finance asks why March spiked.

A minimal spreadsheet schema

Roll up with sum(api_usd + human_usd) / count(accepted) per model. Publish p50 and p90. If leadership only sees the mean, one pathological agent loop will own the narrative.

Connecting this page to the rest of the site

Cost-per-task is the pricing-hub expression of Cluster 6 (reduction and cost ops). Use it with:

• LLM cost framework — process spine.
• Claude API pricing — Claude-only depth.
• Eleven ways to cut usage — reduce tokens before you swap brands.
• Planned model routing — automate the decision once the sheet is stable.
• Team spend tracking — attribution so the sheet has owners.

Three decision rules after you have numbers

Once you have cost per accepted task for at least two models on one pack, most teams still stall. Use these rules:

1. If the gap is under ~15% and quality is tied, keep the model your team already debugs well. Switching costs (evals, prompt ports, observability) eat thin savings.
2. If the cheap model wins on dollars but fails the rubric, do not “fix it later.” Either raise the cheap model with better prompts / retrieval, or route only the easy slice to it. Shipping a failing default to save $40/month is not optimization.
3. If the expensive model wins on accepted-task cost, check whether structure — not IQ — caused it. Bloated prefixes and unbounded tool loops inflate every model; fix those with cut token usage tactics, then re-measure. Brand loyalty should not survive a second Measure pass.

Finance partners care about forecastability. A slightly higher unit cost with low variance often beats a bargain model with wild p90 agent loops. Report both.

Worked monthly sketch (illustrative)

Assume 50,000 Scenario B support completions per month, 92% first-pass acceptance on Sonnet 5, and 75% on Flash with one full retry for failures. Using the illustrative unit costs above:

• Sonnet 5 path: 50,000 × $0.01200 ≈ $600 API (ignoring cache), with fewer retries in the happy path.
• Flash path: expected calls ≈ 50,000 × (0.75×1 + 0.25×2) = 62,500 calls × $0.00220 ≈ $137.50 API — until you price human review on the 8% that still fail both attempts.

If each residual failure needs five minutes of specialist time at a $60/hour loaded cost, that is $5 per failure. Eight percent of 50,000 is 4,000 failures → $20,000 human. The “cheap” API line was never the bill. Your numbers will differ; the accounting shape will not.

That is why this site pushes audits toward prompt structure and routing, not toward a single universal model winner. When the sample already shows the waste, start an audit.

FAQ

Is ChatGPT vs Claude API cost the same as ChatGPT Plus vs Claude Pro?

No. Consumer seats and API meters are different products. This page is API cost-per-task. Seat comparisons belong on Pro vs API and plan pages.

Should I always pick the cheapest list-price model?

No. Pick the lowest cost per accepted task after measuring retries and human overrides. Cheap defaults win many classification jobs; they lose many agentic coding jobs.

Why don’t you publish a single winner?

Because a honest winner requires your task distribution. Publishing a fake bake-off would rank for clicks and mislead budgets. The rate card and worksheets are the durable asset.

How often should rates be re-checked?

Whenever you re-budget, and at least when providers announce model or price changes. This page is dated 2026-09-19 with [VERIFY] markers for that reason.

Next steps

Keep Claude API pricing for the Claude-only card, use the calculator for quick Claude estimates, and run decisions through the cost optimization framework. When your sample already shows structural waste in the prompts themselves, start an audit — pricing lives only on that checkout page.