How much does it really cost to serve DeepSeek V4.1 Flash?
DeepSeek V4.1 Flash is the newest open-weight model from DeepSeek, released in September 2026. On OpenRouter DeepSeek sells it for $0.15 per million input tokens ($0.003 when the prompt is cached) and $0.60 per million output tokens. Those are its off-peak rates; on its own API the price doubles during Chinese business hours. Thirty-six endpoints from other providers compete on the same model, some selling output tokens for as little as $0.18 per million.
How can anyone make money at that price with a model this large? Let’s find out the engineer’s way: start from the architecture, work out how much memory it needs and which GPUs can host it, what those GPUs cost per hour, and how many tokens per second they produce. Divide one by the other and you get a cost per token to compare with the real price list.
To see how fast things are moving, every chart can also switch to DeepSeek V3.2, the flagship of just ten months earlier. Every chart is live: change a parameter in any section and all the numbers in the article update with it.
The model: a sparse giant that activates almost nothing
V4.1 Flash is a Mixture-of-Experts (MoE) transformer, but it stacks several new ideas on top of the classic design:
| DeepSeek V4.1 Flash | DeepSeek V3.2 (for reference) | |
|---|---|---|
| Backbone parameters | 552 B (+196 B Engram memory) | 671 B |
| Active parameters per token | 8 B in prefill, 16 B in decode | 37 B |
| Layers | 40 (20-layer encoder + 20-layer decoder) | 61 |
| Experts per MoE layer | 384 routed + 1 shared, 6 active | 256 routed + 1 shared, 8 active |
| Attention | CSA2 sparse attention (top-512) + 128-token sliding window | MLA + DSA sparse attention (top-2,048) |
| KV cache per token | 890 bytes (FP4) | 68.6 KB (BF16) |
| Weights | FP4 experts, FP8 everything else | FP8 |
| Context window | 1M tokens | 160K tokens |
Each of these lines matters for the bill:
- MoE. Each token is routed to 6 of the 384 experts in every layer, so memory scales with total parameters while compute scales with active ones. V4.1 Flash has the memory footprint of a giant and the compute of a 16 B model.
- Causal Encoder-Decoder (CED). Prompt tokens mostly go through the 20-layer encoder only. The decoder builds its attention cache from the encoder’s output, which halves the compute of reading a prompt: 8 B active parameters per input token, 16 B per output token.
- Engram. 196 B parameters of “conditional memory”: huge lookup tables indexed by the input tokens. They take memory but almost no compute or bandwidth, because each token only reads a few rows.
- FP4 everywhere it matters. The routed experts and the main KV cache are stored in 4 bits.
Step 1: memory and GPU allocation
The released checkpoint weighs about 510 GB. Roughly 300 GB is the backbone, dominated by the FP4 experts, and about 200 GB is the Engram tables. Engram lookups are sparse and predictable, so the tables could live in host RAM. By default we keep them in GPU memory to stay conservative.
The real revolution is the KV cache, the attention memory each conversation keeps while it’s being served. V4.1 Flash shares one compressed FP4 cache across layers, at 890 bytes per token, plus a small fixed sliding-window buffer of about 2.6 MB. A conversation with a 3,000-token prompt and 500 generated tokens needs about 5.5 MB. The same conversation on V3.2 needs 228 MB, roughly 40× more.
Whatever memory is left after the weights decides how many conversations a replica can serve at the same time, and that number drives the whole cost. Pick a deployment, then play with GPUs, precision and prompt length:
Things worth trying:
- 8×H100: even the full 510 GB fits on a single 640 GB node, and there is still room for about 15,000 concurrent conversations.
- Switch to V3.2 on 8×H200: the weights take two thirds of the memory, and the maximum concurrency drops from about 94,000 sequences to about 1,500.
- Push the prompt to 64K tokens: V4.1 Flash still fits thousands of conversations. V3.2 can hold only a few dozen.
Step 2: what the hardware costs per hour
A GPU you own costs its purchase price spread over its useful life, plus electricity and the datacenter around it. The defaults are rough 2026 market figures: about $42K per H200 including its share of the server, networking and storage, a 4-year amortization, $0.12/kWh, a PUE of 1.3 and $0.30 per GPU-hour for hosting and operations. You can switch to renting, which is what most inference providers do.
On owned hardware, amortization dominates and energy is only about 10% of the bill. An idle GPU costs almost as much as a busy one, so the business is all about keeping GPUs busy.
Step 3: how many tokens per second
Generating text happens one token at a time per conversation. For every decode step, the GPUs must:
- Read the weights of the experts the batch’s tokens were routed to.
- Read the KV cache of every conversation in the batch.
- Do the math: about 32 GFLOP per output token for V4.1 Flash, against 74 GFLOP for V3.2.
The time of one step is therefore roughly:
step ≈ max( bytes read ÷ memory bandwidth, FLOPs ÷ compute ) + overhead
With a batch of one, a step only touches 6 of the 384 experts per layer. Every extra conversation routes to different experts, so the fraction touched by a batch of B tokens is 1 − (1 − 6/384)^B: about 40% at B = 32 and over 98% at B = 256. Past that point the weights are read once per step no matter how many conversations share it. Batching is almost free until compute runs out, and with a 5.5 MB KV cache, memory no longer runs out first.
The two charts show the central tension of LLM serving:
- Total throughput (what the provider sells) climbs as hundreds, then thousands, of conversations share each weight read.
- Per-user speed (what the user feels) falls once the step becomes compute-bound.
A provider picks the largest batch that still feels fast. For V4.1 Flash on one H200 node, a batch of about 2,000 conversations gives roughly 45 tokens per second per user and over 90,000 output tokens per second for the node. Switch to V3.2: even at a slower 28 tokens per second per user, the same node delivers only about 7,000.
Can we trust these numbers?
DeepSeek hasn’t published production throughput for V4.1 Flash, so we can’t check it directly. We can check the model against the one time DeepSeek did publish numbers. In early 2025 their inference system overview reported 14.8K output tokens/s and 73.7K prefill tokens/s per 8×H800 node for the V3 architecture.
Select DeepSeek V3.2 and the Large EP · 144×H800 preset: this calculator predicts about 16.5K and 72.7K, within 10–15%. The same equations, with V4.1 Flash’s published architecture, give the figures above. Treat them as what a well-tuned deployment can reach, not as a guarantee: V4.1’s new pieces (encoder-decoder split, hyper-connections, sparse indexers) add overheads that this first-order model doesn’t capture.
Step 4: from GPU-hours to dollars per token
One ingredient is still missing: saturation. Real traffic follows the sun. A replica sized for the peak is half empty at night, and the GPUs cost the same either way. At 50% average load, every token costs twice what it would at full load.
The cost of a request adds up two parts. Both are multiplied by the replica’s cost per second and divided by the saturation:
- Prefill: the uncached prompt tokens divided by the prefill throughput. Thanks to the encoder-decoder design, V4.1 Flash reads prompts at about 450K tokens/s per node, more than 6× faster than V3.2.
- Decode: the output tokens divided by the decode throughput.
How this compares with the real market
DeepSeek’s own API charges two rates for V4.1 Flash. Peak hours (01:00–04:00 and 06:00–10:00 UTC on weekdays, the Chinese working day) cost $0.30/$1.20 per million input/output tokens. Every other hour costs half: $0.15/$0.60. That’s a saturation tool. Cheap nights pull batch jobs into the hours when GPUs would otherwise sit idle.
A selection of the 36 OpenRouter endpoints on 17 October 2026 (USD per million tokens):
| Provider | Quantization | Input | Output | Cached input |
|---|---|---|---|---|
| Decart | FP4 | 0.09 | 0.18 | 0.018 |
| Sail Research | FP4 | 0.09 | 0.30 | 0.006 |
| DeepInfra | FP8 | 0.11 | 0.34 | 0.003 |
| DeepSeek (off-peak rate) | n/a | 0.15 | 0.60 | 0.003 |
| CoreWeave | FP8 | 0.15 | 0.65 | 0.002 |
| Novita | FP8 | 0.20 | 0.78 | 0.004 |
| Together, Fireworks, Baidu, Nebius and 9 others | various | 0.30 | 1.20 | 0.006–0.03 |
| BaseTen (fast tier) | n/a | 0.60 | 2.40 | 0.014 |
What the model tells us about these prices:
- V4.1 Flash is extremely cheap to serve. One owned H200 node at 50% saturation produces output tokens for about $0.08 per million and reads prompts for about $0.016 per million. Even rented at $3/GPU-hour, output stays below $0.15 per million.
- The cheapest providers are probably still profitable. Selling output at $0.18–0.34 per million, as Decart and DeepInfra do, leaves room for rented GPUs and modest saturation. With V3.2, the same prices would have been at or below cost for almost every deployment in this model.
- The $1.20 crowd sells something else: reliability, latency, data guarantees and US or EU hosting. The tokens themselves cost a small fraction of the price.
- Margins moved from hardware to architecture. In 2025 DeepSeek needed huge expert-parallel clusters to make V3 profitable. Switch to V3.2 and you’ll see that, at its default batch, a single node barely breaks even at $0.42. V4.1 Flash makes a single 8-GPU node the efficient unit again, because the KV cache stopped being the bottleneck.
Takeaways
- KV cache size is now the most important number in a model card. Going from 228 MB to 5.5 MB per conversation lets one node serve 60× more conversations at once, and that is where most of the cost reduction comes from.
- Active parameters set the compute floor. With 16 B active per output token and 8 B per input token, V4.1 Flash costs less per token than models a tenth its size did two years ago.
- Saturation is the remaining lever. Halve the average load and you double the cost per token, which is why DeepSeek halves its prices at night.
- Hardware generations still reset the floor. On a B200 node with native FP4, the model predicts output tokens at about $0.04 per million.
Assumptions and limits
This is a first-order model, deliberately simple enough to fit in one script (llm-cost.js). Things it does not capture:
- Efficiency factors are fixed: 70% of peak memory bandwidth, 30% of peak FLOPs during decode and 50% during prefill. Real kernels vary with batch shape.
- The parameter split of V4.1 Flash is reconstructed from its
config.jsonand checkpoint size: about 543 B in routed experts, about 9 B always active, 196 B in Engram. DeepSeek’s exact figures may differ by a few percent. - Speculative decoding is ignored. V4.1 Flash ships with DSpark, which drafts several tokens per step and would raise throughput further. V3.2’s multi-token prediction module is ignored too.
- Prefill and decode share the same GPUs in a time-sliced way. DeepSeek actually runs encoder, prefill and decode on separate pools.
- Load imbalance between experts, activation memory and inter-GPU communication are folded into a single per-step overhead.
- Hardware prices are rough market estimates. Adjust them to your own quotes.
Even with these simplifications, the model lands within about 15% of DeepSeek’s published V3 throughput, and the trend it shows is hard to miss. In about ten months the cost of a frontier-class token fell by roughly 4–12×, depending on how well the older model was deployed, mostly thanks to smarter architecture rather than faster chips.
References
- DeepSeek-AI, DeepSeek-V4.1-Flash: Pushing the Limits of KV Cache Compression, technical report, 2026, and the model card with its
config.json. Architecture, CED, CSA2, Engram, FP4 KV cache (890 bytes/token), active parameters, deployment. - DeepSeek-AI, DeepSeek-V4: Towards Highly Efficient Million-Token Context Intelligence, arXiv:2606.19348, 2026, and the DeepSeek-V4-Flash model card. Hybrid compressed attention and FP4 experts.
- DeepSeek-AI, DeepSeek-V3 Technical Report, arXiv:2412.19437, 2024. V3/V3.2 backbone, MoE configuration, FP8 weights.
- DeepSeek-AI, DeepSeek-V2, arXiv:2405.04434, 2024. Multi-head Latent Attention and its compressed KV cache.
- DeepSeek-AI, DeepSeek-V3.2-Exp repository and DeepSeek-V3.2 model card. DeepSeek Sparse Attention.
- DeepSeek-AI, DeepSeek-V3/R1 Inference System Overview, February 2025. Per-node throughput used to calibrate the model.
- DeepSeek, API pricing. Peak and off-peak rates for V4.1 Flash, retrieved 17 October 2026.
- OpenRouter, DeepSeek V4.1 Flash and DeepSeek V3.2 model pages and
/api/v1/models/…/endpoints. Provider prices and quantizations, retrieved 17 October 2026. - NVIDIA, datasheets for H100, H200 and DGX B200. Memory capacity, bandwidth, dense FP8/FP4 throughput and power.