ChatGPT vs Claude vs DeepSeek in 2026: The Numbers, Checked at the Source

Claude had “200K tokens” of memory. DeepSeek cost “$0.27 per million input tokens” and ran on “V3.2 / R1”. ChatGPT had “128K tokens”. Claude’s API was “$3.00 per million input tokens”.

On 12 November 2026, three vendor pages said something different.

Anthropic lists every model in its current flagship line at 1M tokens of context. DeepSeek’s pricing page sells two models, DeepSeek-V4.1-Flash and DeepSeek-V4-Pro, at $0.15 to $1.32 per million input tokens depending on the hour. OpenAI’s plan table puts ChatGPT’s consumer context between 27K and 400K tokens, depending on which plan you bought.

None of those four April numbers was invented. Each one was accurate for a row the article had not named. $3.00 per million is Sonnet 4.6’s input price at Anthropic, not Opus’s. $0.27 sits inside DeepSeek’s real range. 200K was Claude’s context window through the 4.5 generation.

That is the failure this comparison keeps repeating. The number is real, the label is wrong, and the two get separated the moment somebody quotes it.

So this version names the access route for every figure, because a plan and an API are different products. It dates every price. It shows the multipliers that move a price by fifty times. And it gives you a way to check all of it on your own work.

What it will not do is score these models 8/10 or 10/10. The April version did, across five “tests”, with no protocol, no transcripts and no way to audit the result. A score without a method measures the person holding the clipboard. The closing protocol is one you can run in half an hour.

Where “the best AI” stops meaning anything

Start with the word Claude.

On the free plan you get Sonnet and Haiku, and no Opus at all. On the $20 monthly Pro plan you get Opus, Claude Code, and Fable through usage credits. On Max at $100 a month you get Fable for up to half your weekly limit, plus $100 in API credits. On Ultra at $200 you get ten times Pro’s weekly usage, and no five-hour cap on verified accounts. All of that is from Anthropic’s plan table, read today.

Four products, one name, four different answers to “what can Claude do?”

ChatGPT has the same problem in a different shape. The plan comparison gives Free a 27K-token window for its instant model. Go and Plus get 54K. Pro gets 128K, and a reasoning window of 400K against Plus’s 256K. So “ChatGPT has 128K of context” is true for one model class, on the most expensive plan.

Then there is the split between the app and the API. The app sells seats with message limits. The API sells tokens at per-model rates. They share model names and almost nothing else. Every comparison that mixes them, including the April version of this page, produces a sentence that sounds precise and means nothing.

DeepSeek is simpler and stranger. One API, two models, and the more expensive one has no vision. A scanned contract is a job for Flash, not for V4-Pro, whatever the price list implies.

None of this makes comparison impossible. It makes an unnamed comparison worthless. The unit is not “ChatGPT vs Claude”. The unit is “gpt-5.4 on the API at 272K input tokens against Claude Sonnet 5.5 on the same afternoon”. Anything shorter is a slogan.

That framing also changes what to read next. If your real question is whether to run two assistants instead of one, that argument already lives on this site’s hybrid-stack page, and it does not need repeating here.

What a token costs, and when the number doubles

A bill is built in four steps, and each one moves the price more than the model choice does.

Step one is the token count. Step two is the context tier. OpenAI charges $2.50 per million input tokens for gpt-5.4 up to 272K, then $5.00 above it. Output goes from $15 to $22.50. Same model, same request, double the input rate, because the input got longer.

Step three is the cache. Anthropic bills a cache read at 10% of the base input price on older models, 5% on Opus 5.5 and Sonnet 5.5, and 2.5% on Fable 5.2. DeepSeek goes further. A cache hit on Flash costs $0.003 per million against $0.15 for a miss. That is a 50x spread inside one model. Any “cost per million tokens” figure that does not state cache state is describing one of two very different products.

Step four is the clock. DeepSeek halves its rates outside peak hours, which it defines as 01:00 to 04:00 and 06:00 to 10:00 UTC, Monday to Friday, excluding Chinese public holidays. Flash input runs $0.30 at peak and $0.15 off it. Output runs $1.20 and $0.60. Schedule a batch job at the wrong hour and you pay double for identical work.

The seat prices themselves are a separate market with its own arithmetic, and worth reading on their own terms.

Now the numbers, with their labels attached. Every figure was read from the vendor page on 12 November 2026.

Read the table by column width, not by row. The widest ranges sit inside one vendor, not between vendors. Claude’s input price spans 80x from Haiku to Fable. OpenAI’s spans 100x from Luna to Astra. DeepSeek’s two models sit within 8.8x of each other. So “which vendor is cheaper” is the wrong question at every tier except the one you actually use.

Three readings survive the ranges.

If your documents fit inside 54K tokens, context is not your constraint and the seat price is. That covers most email, most drafts, most tickets.

If they run past 272K, the field narrows. OpenAI’s long-context surcharge takes gpt-5.4 to $5.00 per million. DeepSeek charges $0.15 off-peak for work up to its 1M window, with no long-context tier on the price list at all. At equal token volume that is more than thirty times cheaper, and the gap is structural rather than promotional. Even V4-Pro, the larger model, is $0.66 off-peak, still roughly seven times below the surcharged OpenAI rate.

If your input is scanned images, the cheap route closes. V4-Pro has no vision and Flash is the smaller model, so a document workflow that depends on OCR lands back at OpenAI or Anthropic, where image input is standard across the current line.

One sum makes the seat-versus-API split concrete. Twenty dollars buys 8 million input tokens of gpt-5.4 at $2.50, or 1.33 million output tokens at $15.00. The same twenty buys 10 million Sonnet 5.5 input tokens at $2.00, or 2 million output tokens at $10.00. On DeepSeek Flash, off-peak, it buys 133 million input tokens at $0.15, or 33 million output tokens at $0.60.

That reads like an argument for cancelling every subscription. It is not, and the reason matters. A seat buys a product: memory across chats, file handling, voice, a model picker, and no metering dashboard. An API key buys tokens and nothing else. A $20 seat is a bad deal only if you already know your token volume, and most people do not.

Throughput is the other number the seat plans hide. DeepSeek publishes concurrency limits of 2,500 parallel requests for Flash and 500 for V4-Pro. No consumer plan states its own equivalent in tokens, requests or queue position. That asymmetry is why builders end up on the API even when the seat looks cheaper.

The part the price list cannot answer

Vendor pages cannot tell you which model writes better, and this page will not pretend otherwise. They can tell you what you paid. The quality question needs your own tasks, and one afternoon answers it badly but honestly.

Pick three jobs from last week: a document long enough to matter, a bug you actually fixed, a draft you actually sent. Run each through all three models with the same prompt. Record four things per run: whether you accepted the output without editing, how many minutes you spent editing, what the run cost, and how it failed.

Then apply one rule before you buy anything annual. If the cheapest model is accepted without edits on two of your three jobs, the expensive one is solving a problem you do not have.

One caution. Three tasks is a preference, not a benchmark. Report it as a preference. The moment you call it a test, you owe the reader a protocol, transcripts and a sample size, which is exactly what the April version of this page did not have.

Two quality claims deserve separating from the pricing argument. Whether a model’s prose reads like a person wrote it shows up in patterns, and this site’s piece on the most-cited writing tell examines the em-dash accusation instead of repeating it. Whether an agent can hold a codebase in its head is a different question again, closer to what terminal-based coding agents actually do than to any context window.

DeepSeek’s position carries a constraint no price table shows. Its models are open-weight, which is why the same family keeps turning up in the open-model workaround around export controls. Cheap tokens and a self-hostable model are one business decision seen from two sides.

So what is still unresolved?

Whether a 1M-token window holds its quality at 800K tokens. Every vendor publishes the window and the price per token. None of them publishes a degradation curve, so the flat long-context rate is priced against a capability nobody has stated. That is the one number missing from this page, and it is missing from theirs too.

The condition that settles the comparison is simpler. Bring a dated evaluation on your own corpus, with the prompts and the edit times, and show the cheap model accepted without repairs. At that point the price argument stops being an argument.

JL HOUSSEM

Independent technology writer focused on artificial intelligence, emerging technologies, and digital innovation. Covers AI applications in sports, productivity, and online business.