Why DeepSeek V4 Flash costs cents: the architecture behind the price

A price of $0.14 per million input tokens reads like a loss leader until you look at what DeepSeek actually spends to answer a request. Flash is not cheap because someone upstream is eating the cost. It is cheap because the model does a fraction of the arithmetic its parameter count implies, and because the two line items that usually dominate an inference bill — attention memory and repeated context — have been engineered down well below the industry norm. Once you see where the money goes, the sticker price stops looking like a promotion and starts looking like an honest reflection of serving cost.

Start with the parameter count, because it is the most misread number on the spec sheet. Flash is a 284-billion-parameter model, but only about 13 billion of those parameters activate on any given token. That gap is the entire trick. DeepSeek builds Mixture-of-Experts networks: instead of one dense feed-forward block that every token flows through, each layer holds a large bank of smaller expert blocks, and a small routing network selects a handful of them per token. The experts it skips cost nothing to compute for that token. So you get the representational capacity of a very large model while paying, per token, for something closer to a 13B one. The output price of $0.28 per million is what a 13B active footprint looks like when it is served efficiently.

This is not a one-off experiment. DeepSeek has been compounding the same idea across releases. V2 introduced the sparse layout at 236B total and 21B active; V3 scaled it to 671B total and 37B active and trained on 14.8 trillion tokens for a reported $5.576M in compute — roughly 2.788 million H800 GPU-hours at spot rates. That figure raised eyebrows precisely because it was an order of magnitude under what a dense model of comparable quality would have cost to train. Flash is the distilled, latency-tuned member of that lineage: smaller active footprint, same architectural DNA.

The second lever is attention, and it matters more than most cost breakdowns admit. Standard transformers cache a full key and value tensor for every attention head at every position; that KV cache is what lets the model attend to earlier tokens without recomputing them. It is also what fills GPU memory and caps how many requests a card can serve at once. DeepSeek's Multi-head Latent Attention compresses those keys and values into a shared low-rank latent space and caches the compact latent instead — roughly a tenfold reduction in KV memory. A card that can hold ten concurrent conversations under standard attention can hold far more under MLA, and throughput per GPU is most of what determines the floor on a per-token price.

Sparse routing has a well-known failure mode: if the router keeps favoring the same few experts, the rest go undertrained and effective capacity collapses. The usual fix is an auxiliary loss that punishes imbalance, but that loss fights the main training objective and tends to cost a little quality. DeepSeek's models balance expert load without leaning on that auxiliary term, which is part of why a sparse model this cheap does not feel like a downgrade on ordinary chat and coding work. You are not paying a quality tax for the low price on the majority of requests — you are paying it only at the long tail, which is exactly where the routing guidance on this site tells you to escalate.

Training efficiency feeds serving price more directly than it seems. The same discipline that produced the V3 training number — FP8 mixed precision to halve memory bandwidth, the DualPipe schedule to keep pipeline bubbles small, a multi-token prediction objective to squeeze more signal from each token — is the discipline that lets DeepSeek run inference at margins where $0.14 input is sustainable rather than promotional. Providers that trained a comparable model the expensive way have to recover that spend somewhere, and the API price is usually where.

Now connect the architecture to the one number that most affects your bill: the cache-hit rate. Because MLA makes the KV cache small, DeepSeek can afford to store request prefixes on a distributed disk array and replay them instead of recomputing. When the front of your prompt matches a recent request byte for byte, those tokens bill at the cache-hit rate of $0.028 per million rather than the $0.14 cache-miss rate — a 5x cut you earn simply by keeping your system prompt and tool definitions stable. That discount is not a billing gimmick bolted on top; it is a direct consequence of the attention design. A model with a full-size KV cache could not cache prefixes this cheaply.

The active-parameter framing also explains the Flash-versus-Pro gap without any hand-waving. Pro activates about 49B parameters per token against Flash's 13B, and its output price of $3.48 per million is roughly what that heavier activation costs to serve. You are not paying 12x more for a brand; you are paying for nearly four times the compute per token plus the accuracy that buys on genuinely hard problems. Framed that way, the routing question answers itself: send the volume to Flash, reserve Pro's activated compute for the tasks that measurably need it.

One caveat worth stating plainly, because it is where the cheapness stops. The low price lives on DeepSeek's serving side, not in the weights themselves. Flash is small only by comparison — 284B parameters in full precision is around 170 GB of memory, and even aggressive quantization keeps you above 30 GB of VRAM. Self-hosting does not inherit the API's economics; it inherits the hardware bill instead. If you are weighing local inference, the local setup guide breaks the memory tiers down before you commit to a GPU order.

The practical takeaway is that Flash's price is legible. It is cheap for reasons you can point at — sparse activation, latent attention, prefix caching, and a training pipeline built for efficiency rather than headlines — which means you can engineer around those reasons instead of hoping the price holds. Keep your prompt prefixes stable to bank the cache discount, route by task difficulty rather than by habit, and treat Pro as the escalation valve it was priced to be. The architecture is already working in your favor; the job is to stop accidentally working against it.