How Cheap Is DeepSeek, Really? A Cost Comparison Against Every Leading Model

Every few months somebody sends round a screenshot of DeepSeek's pricing page with a comment along the lines of "how is this legal". The prices are genuinely startling in isolation, and the standard response is to quote a multiple, usually something like "thirty times cheaper", and move on.

That multiple is almost always wrong, in both directions. It is wrong on the low side because per-token comparisons ignore how many tokens a model spends to answer a question. It is wrong on the high side because the sticker price is not the whole cost of running a model in production. This piece works through the arithmetic on a realistic workload, against every model a buyer might reasonably be comparing.

The list prices, side by side

Rates per million tokens, as of 4 August 2026. DeepSeek's current lineup is V4-Pro and V4-Flash; both quote a separate, much lower rate for cache hits.

The multiple column uses a 4:1 input to output blend, roughly typical for retrieval-heavy production traffic. Change the blend and the multiples move considerably. Against Fable 5 on an output-heavy workload the multiple passes fifty. Against Gemini 3.1 Pro on an input-heavy one it falls below five.

So the headline is real. Against the closed frontier, V4-Pro costs between one seventh and one thirty-fourth as much per token. On output alone the comparison is starker: $0.87 against GPT-5.6 Sol's $30 is a factor of thirty-four.

Note the bottom two rows, because people miss the point of them. DeepSeek is not one price. V4-Flash undercuts V4-Pro by roughly three times again and sits below every closed model on the board. And DeepSeek is not the only cheap option any more, which is newer than most buyers realise: Qwen3.8-Max at $2 and $6 and Gemini 3 Flash at $0.50 and $3 have compressed the middle of this table hard in the last quarter.

Per token is the wrong unit

Here is where most comparisons fall apart.

A reasoning model does not just emit an answer. It generates a long internal chain first, and you are billed for those hidden tokens at the output rate. We went through the mechanics in the reasoning token piece. The consequence for this comparison is direct: if model A charges half as much per token but spends three times as many tokens thinking, model A is more expensive.

This cuts against DeepSeek more than people expect, because its reasoning traces run long. The same is documented for the Qwen family, where Qwen3.5-27B consumed roughly 98 million output tokens against about 56 million for MiniMax-M2.5 on the same Artificial Analysis evaluation. Cheap models are frequently verbose models, and verbosity is billed at the expensive rate.

Work an illustration. Take a prompt with 2,000 input tokens and a 400-token visible answer, and assume the frontier model emits 1,100 hidden reasoning tokens while DeepSeek emits 2,900 for a comparable answer. Those hidden-token figures are assumptions rather than published numbers, and they are the two you should replace with your own measurements.

GPT-5.6 Sol: 2,000 input at $5.00 gives $0.010. Output of 400 visible plus 1,100 hidden is 1,500 at $30.00, giving $0.045. Total $0.055 per request.

DeepSeek V4-Pro: 2,000 input at $0.435 gives $0.00087. Output of 400 plus 2,900 hidden is 3,300 at $0.87, giving $0.00287. Total $0.0037 per request.

DeepSeek is about fifteen times cheaper. Not nineteen, which the blended token rate suggested, and not thirty-four, which the output-price comparison alone suggests. The verbosity assumption eats roughly a fifth of the nominal advantage.

Fifteen times is still an enormous number. The point is that the multiple you can bank is smaller than the one on the pricing page, and it moves with your workload. On a classification task with no reasoning at all the advantage widens back toward the full nineteen.

What it does to a real bill

Take a support automation workload doing 8 million requests a month at the shape above.

At GPT-5.6 Sol rates that is 8,000,000 x $0.055, or $440,000 a month.

At V4-Pro rates it is 8,000,000 x $0.0037, or $29,900 a month.

Nobody sane moves all of it. Suppose 15% of that traffic involves multi-step tool use and code, where DeepSeek's coding results leave a real gap against the closed frontier, and you keep that portion where it is:

0.85 x $29,900 + 0.15 x $440,000 = $25,415 + $66,000 = $91,415 a month.

A 79% reduction against running everything on GPT-5.6 Sol, with the hard fifteen per cent untouched because it never moved. This is the multi-model strategy in one calculation, and it is why the useful question is never "which model" but "which model for which slice".

The saving is roughly $349,000 a month, or about $4.2 million a year. At that scale the engineering cost of a routing layer is a rounding error, which is exactly the situation where teams still somehow fail to build one.

Cache pricing moves the answer again

One more variable, and on some workloads it matters more than the base rate.

Every major provider now discounts repeated prefixes, and the discounts are steep. DeepSeek's cache-hit input rate is a small fraction of its cache-miss rate, in the region of a hundredth. Anthropic prices cache reads at roughly a tenth of standard input. Qwen3.8-Max reads implicit cache at $0.25 against $2.00 fresh, a factor of eight.

The practical effect is that a workload with a large fixed prefix and a small variable suffix, which describes most retrieval-augmented applications, can shift its effective input cost by an order of magnitude depending on whether prompts are built to hit the cache.

Building for the cache is mostly ordering. Put everything stable at the front, in a fixed order, and everything variable at the end. Teams that assemble prompts by concatenating retrieved chunks in relevance order destroy their own cache on every request, because the prefix changes each time even when the content barely does. Sorting those chunks by a stable key instead of by score costs nothing and can halve an input bill.

Against DeepSeek specifically, cache design narrows the gap on input and does nothing for output, which is where its verbose reasoning already concentrates the cost. So models with expensive input and dense reasoning benefit most from cache discipline, and the comparison shifts in their favour. Not enough to overturn a fifteen-times advantage, but enough to matter on a workload with an 8,000-token fixed preamble.

One related trap: Anthropic's tokenizer from Claude 4.7 onward produces roughly 30% more tokens for the same text than earlier versions. A per-token price comparison against Claude that ignores this understates the real cost by about a third. Count tokens with the tokenizer of the model you intend to deploy, not with a generic one.

How DeepSeek can charge this

Worth understanding, because the answer determines whether the price holds.

The naive explanation is that DeepSeek is selling below cost to buy market share, and there is probably some of that. The larger part is architectural. Its models are sparse mixtures of experts, meaning only a fraction of the parameters activate for any given token. A dense model of comparable capability has to run every parameter on every token, and serving cost tracks active parameters rather than total ones. That is a structural cost advantage, not a promotional one.

On top of that sits a set of efficiency choices DeepSeek has published in unusual detail: aggressive attention variants that shrink the memory footprint of the key-value cache, a training pipeline that reached strong quality for a reported fraction of what the US labs spend, and inference stacks tuned for high batch throughput rather than low single-request latency. That last one is a deliberate trade, and it is why the API can feel slower than its price suggests it should. They optimised for tokens per dollar, and you feel that in both directions.

The reason this matters to a buyer is durability. A price propped up by a funding round can be withdrawn. A price produced by a genuinely cheaper architecture tends to hold and to pull competitors down with it, which is what has happened repeatedly through the efficiency race. The clearest evidence is what the closed labs have done in response: Anthropic's Opus tier moved from $15 and $75 to $5 and $25 across recent releases, and Qwen3.8-Max launched in August at $2 and $6 while claiming near-frontier capability. Neither of those is a reaction to a competitor's marketing. They are reactions to a floor that open weights set.

The risk to plan around is not that DeepSeek raises prices. It is availability, geopolitics and export controls, none of which respond to how good your cost model is. Anthropic's own Fable 5 was taken offline for nearly three weeks in June by an export-control order before being restored on 1 July, which is a useful reminder that this exposure is not unique to Chinese labs. The mitigation is the same either way: hold the weights where you can, keep a self-host path warm, and treat any hosted API as a convenience rather than a dependency.

The costs that do not appear on the pricing page

Latency and throughput. DeepSeek's hosted API has historically been slower and less consistently available than the hyperscaler-backed alternatives, and verbosity compounds it, because more reasoning tokens means more time before anything visible appears. For a batch job that costs nothing. For an interactive product it can cost you the workload. Measure time to last token, not time to first.

Data residency and procurement. For a meaningful share of enterprises, sending customer data to DeepSeek's hosted API is a non-starter regardless of price. The open weights are the release valve: you can run them inside your own perimeter, which converts a procurement blocker into an infrastructure decision. That is a genuine advantage over every closed model in the table.

Self-hosting is not free. The weights cost nothing and the serving costs plenty. Below roughly a billion tokens a month, the hosted API is cheaper and simpler than anything you can stand up yourself, and we worked the break-even through in the cloud versus on-premise analysis. Standing up a GPU cluster to save a few hundred dollars is a hobby, not a saving.

Where the money actually is

If your bill is dominated by classification, extraction, routing decisions and structured generation, which is true of most production traffic, V4-Pro is not even the right comparison. That work runs fine on V4-Flash at a third the price, or on a model you tuned on your own data for less again.

DeepSeek's real slot is the middle of the distribution, and it is a large slot: work that genuinely needs strong reasoning, at volumes where frontier pricing becomes unaffordable. That work used to force you onto a model at $25 or $50 per million output tokens. It no longer does.

The corollary is that DeepSeek makes a poor default. Sending every request to it spends reasoning tokens on prompts that needed none, and produces a worse answer than a frontier model on the hard slice. The saving comes from placement, not from adoption.

The honest summary

DeepSeek V4-Pro is roughly fifteen to nineteen times cheaper than GPT-5.6 Sol and thirty-plus times cheaper than Claude Fable 5, for reasoning quality that holds up well and coding quality that still trails. The pricing-page multiples overstate the advantage by around a fifth once verbosity is accounted for, and understate it for workloads that do no reasoning at all.

None of which is the most important thing about it. The most important thing is that the weights exist, because a price can be raised and an API can be deprecated, while a file on your own disk cannot be taken back. Every closed model in that table is a price you are quoted. DeepSeek is a price you can walk away from, which is the only kind of pricing leverage that survives contract renewal.

Run the comparison on your own traffic before moving anything. If you route through Swfte Connect you already have the token counts per route to do it, including hidden reasoning tokens, and you can shadow a slice of live traffic to get real quality numbers rather than benchmark ones. The arithmetic above will be roughly right for most teams. Roughly right is not a basis for a seven-figure decision.

---

Related: open source LLM cost savings, open weights versus proprietary models, and the live model leaderboard.