DeepSeek V4.1 Flash review: the cheapest serious model, and the half of its own benchmark table nobody quoted
Open weights under MIT, a million-token context and output at a fraction of frontier rates. Its own model card shows where it still loses by twenty points, and the thing that should decide it for most businesses is not a benchmark at all.
DeepSeek released V4.1 Flash on 10 September 2026 with the weights on Hugging Face under an MIT licence. The model card describes a 552-billion-parameter mixture of experts on a new causal encoder-decoder design, activating 8 billion parameters per token while reading your prompt and 16 billion while writing, a context window of up to a million tokens, and image as well as text input.
The price is the headline. DeepSeek's published table puts the flash model at $0.15 to $0.30 per million input tokens on a cache miss, well under a cent on a cache hit, and $0.60 to $1.20 per million output tokens. The range is a clock, not a negotiation: off-peak rates are half of peak, and peak is 01:00 to 04:00 and 06:00 to 10:00 UTC, Monday to Friday.
The benchmark story is where the coverage went soft. Its own card shows it beating Claude Opus 5.0 and GPT-5.6 Sol on the established agentic tests, and losing to Opus by ten to twenty points on the newer, harder ones. Both halves are printed in the same table, and only one half travelled.
What it costs, what it actually scores, and who should not use it
1. What changed since the last Flash, measured by someone else
Artificial Analysis, which runs its own evaluations rather than reprinting vendor numbers, scores V4.1 Flash at 40 on its Intelligence Index against 35 for V4 Flash 0731 from July, and ranks it sixth of 113 models evaluated. Output speed is effectively unchanged at about 218 tokens per second, time to first token 1.17 seconds. What moved most is the price: the July model was listed at $0.44 and $1.32 per million, the new one at $0.30 and $1.20. Five points of measured capability and a cheaper bill in six weeks is the actual story here.
2. The price, exactly, including the trick most write-ups miss
From DeepSeek's own pricing table, in dollars per million tokens: deepseek-flash costs $0.15 to $0.30 for input on a cache miss, $0.003 to $0.006 on a cache hit, and $0.60 to $1.20 for output. The larger deepseek-v4-pro runs $0.66 to $1.32 input, $0.022 to $0.044 cached, $1.98 to $3.96 output. Every low figure is the off-peak rate, which is exactly half the peak rate, and peak covers 01:00 to 04:00 and 06:00 to 10:00 UTC on weekdays. If your workload is a nightly batch rather than a live chat, scheduling it outside those windows halves the bill with no change to the model. Third-party trackers quote the peak numbers.
3. Where it genuinely wins, on the vendor's own table
At maximum reasoning effort the card reports Codeforces 3471 against 3348 for DeepSeek's own V4-Pro, MathArena Apex 65.6 tying Kimi K3, Terminal-Bench 2.1 at 90.6 against 89.1 for Opus 5.0 and 88.8 for GPT-5.6 Sol, and DeepSWE v1.1 at 74.2 against 74.0 and 73.0. Those are real wins on real agentic coding benchmarks, and they are the wins that made the headlines. Note the margins: two tenths of a point on DeepSWE is a tie in everything but the press release.
4. Where it loses, on the same table
Terminal-Bench 3.0: 30.0 against Opus 5.0's 43.3. Terminal-Bench 4.0: 31.2 against 51.8. ProgramBench: 20.3 against 37.0. Humanity's Last Exam: 36.8 against 56.3, below even its own V4-Pro. GPQA Diamond: 90.9 against Sol's 94.1. The pattern is consistent and worth internalising: the older and more saturated the benchmark, the better it looks; the newer and harder the test, the wider the gap to the frontier. A model that wins Terminal-Bench 2.1 and loses Terminal-Bench 4.0 by twenty points is telling you something specific about where its training has reached.
5. Read the evaluation settings before you budget
The card states that every instruct result uses the maximum effort setting, reasoning_effort=100, at temperature 1.0 and top_p 0.95, with a one-million-token window for the code agent benchmarks. Maximum effort means long reasoning traces, and reasoning tokens are output tokens. The cheapest per-token price in the industry attached to the most expensive per-task token count is not automatically a cheap bill, and the published scores are not what you get at a lower effort setting.
6. The engineering that makes the million-token window usable
The interesting part of the card is not the parameter count, it is the cache. DeepSeek reports FP4 key-value caching in E2M1 format at 890 bytes per token, alongside a compressed sparse attention scheme with reuse modes. At that size a million-token context costs under a gigabyte of cache per sequence, which is the difference between a context window that exists in the specification and one you can actually serve at scale. It also explains how a 552-billion-parameter model holds 218 tokens per second.
7. Open weights, which is not the same as cheap to run
The MIT licence is genuinely permissive: the weights are on Hugging Face and the card documents deployment through vLLM, SGLang and Transformers, with quantised paths for llama.cpp, Ollama and LM Studio. That gives inspection, air-gapping and provider independence, all of which are real. It does not give you a free model. A 552-billion-parameter backbone with a 196-billion-parameter conditional memory component is not laptop hardware, and for most teams the honest comparison is renting it from DeepSeek at these prices against renting it from a Western host at higher ones, not against running it yourself.
8. The default that should decide it for most businesses
DeepSeek's privacy policy says inputs are used to train and improve the technology by default, with opt-out by email to privacy@deepseek.com. Our knowledge base records that as training with opt-out rather than no-training-verified, which is the category that matters if you are pasting client material, unreleased code or anything under an NDA. This is not a China question dressed up as a policy question, it is the policy question: the same default would disqualify a vendor in Ohio. If you need the capability and not the default, the open weights are the answer, because self-hosted weights send nothing anywhere.
8. The default that should decide it for most businesses: verified pricing, fit and cautions →
9. Who it is for
High-volume agentic coding and automation where the task is well specified and the bill is the constraint. Long-document work that would be uneconomic at frontier prices, given the cache design. Teams that need open weights for regulatory or sovereignty reasons and can pay for the hardware. Anyone who can move batch work off peak and take the fifty percent. On those jobs it is, right now, the best value on the market by a distance.
10. Who it is not for
Anyone whose work lives at the hard end: the Terminal-Bench 4.0 and ProgramBench gaps say plainly that the frontier models are still ahead on the newest and most difficult agentic tasks, and twenty points is not a rounding error. Anyone who cannot accept training-by-default on the hosted service and cannot self-host. And anyone buying on the strength of a headline that quoted four rows of a nine-row table.
The fair summary is that DeepSeek has done again what it did last year, which is to make the price of competent look absurd. Five points of independently measured capability in six weeks, a third off the input price, a million-token context that the cache design actually supports, and the weights published under a licence that lets you walk away with them. Nothing in the frontier labs' pricing survives contact with that for volume work, and that is the reason this release matters more than the benchmark headlines suggest.
What it has not done is close the gap where the gap is hardest. On the newest agentic benchmarks its own card puts it well behind Opus 5.0, and the honest way to read the table is that capability per dollar has moved enormously while capability at any price has moved a little. For most workloads the first number is the one that pays your bill. For the workloads where being wrong is expensive, it is still the second.
Where we track this
- DeepSeek in our tool library →
The knowledge-base record behind this review: verified pricing checked 16 September 2026, the data-handling judgment and every source.
- Why a European host serves Chinese open weights →
The other half of this story: an MIT licence is what lets anyone serve these models, which is how you get the capability without the data default.
Questions people ask
- How much does DeepSeek V4.1 Flash cost?
- DeepSeek's published table lists deepseek-flash at $0.15 to $0.30 per million input tokens on a cache miss, $0.003 to $0.006 on a cache hit, and $0.60 to $1.20 per million output tokens. The lower figure in each pair is the off-peak rate, which is half the peak rate; peak hours are 01:00 to 04:00 and 06:00 to 10:00 UTC, Monday to Friday. The chat product is free.
- Is DeepSeek V4.1 Flash really open source?
- The weights are published on Hugging Face under the MIT licence, which is unusually permissive and allows commercial use and redistribution. Open weight is the more accurate term than open source: the licence covers the released weights, not the training data or the training process, and a 552-billion-parameter model is not cheap to self-host even when the weights are free.
- Does it beat GPT-5.6 Sol and Claude Opus 5.0?
- On some benchmarks in its own model card, yes: Terminal-Bench 2.1, DeepSWE v1.1, Codeforces and MathArena Apex. On others in the same table it loses clearly: Terminal-Bench 3.0 and 4.0, ProgramBench, Humanity's Last Exam and GPQA Diamond, in several cases by ten to twenty points to Opus 5.0. Independently, Artificial Analysis scores it 40 on its Intelligence Index, sixth of 113 models.
- Does DeepSeek train on your data?
- On the hosted service, yes by default. Its privacy policy states that inputs are used to train and improve the technology, with an opt-out available by email to privacy@deepseek.com. Our knowledge base classifies it as training with opt-out. Self-hosting the open weights avoids the question entirely, because nothing leaves your infrastructure.
- How fast is it?
- Artificial Analysis measures about 218 output tokens per second on DeepSeek's own API with a time to first token of 1.17 seconds, which is roughly three times the median for open-weight models of comparable size. The model card credits FP4 key-value caching at 890 bytes per token and a compressed sparse attention scheme, which is also what makes the million-token context practical to serve.
Checked 16 September 2026 against primary sources. Verified directly: the official DeepSeek-V4.1-Flash model card on Hugging Face, for the MIT licence, the 552-billion-parameter causal encoder-decoder mixture-of-experts with 8 billion active parameters at prefill and 16 billion at decode, the 196-billion-parameter conditional memory component, the context window of up to one million tokens, image-and-text input, the FP4 key-value cache at 890 bytes per token, the compressed sparse attention scheme, the documented deployment engines, and every benchmark figure quoted here in both directions, including the evaluation settings of reasoning_effort=100, temperature 1.0 and top_p 0.95; and DeepSeek's published API pricing page, for the full table and for the statement that off-peak rates are half of peak with peak hours of 01:00 to 04:00 and 06:00 to 10:00 UTC, Monday to Friday. Independent rather than vendor-reported: the Artificial Analysis Intelligence Index score of 40 on version 4.3 of its index, the sixth-of-113 placing, the output speed of about 218 tokens per second and the time to first token of 1.17 seconds, together with the score of 35 and the prices of $0.44 and $1.32 recorded there for the previous V4 Flash 0731 of 31 July 2026, which is where the comparison between the two releases comes from. Corrections to figures in circulation: several write-ups quote an input price of $0.22 per million, which does not appear in DeepSeek's table and appears to be a blended or derived number, and most quote only the peak rates without noting that the published low figures are the off-peak half; the claim that the model beats GPT-5.6 Sol and Claude Opus 5.0 on four of the five hardest agentic benchmarks is selective, since the same table shows it losing Terminal-Bench 3.0, Terminal-Bench 4.0, ProgramBench, Humanity's Last Exam and GPQA Diamond; and secondary reports of the parameter count vary between 552 billion and 763 billion, so we use the model card's own figures and name the memory component separately rather than adding them together. Labelled as vendor-reported and not reproduced by us: all benchmark scores in the model card, for DeepSeek's model and for the competitors it compares itself against. Not tested by us: we have not run the model, and this review makes no claim about its behaviour outside the published evaluations. Disclosure: TaskNorth's knowledge base holds a record for DeepSeek and recommends Claude, made by Anthropic, whose models this site is built with; we have no commercial relationship with DeepSeek. Nothing here is procurement or legal advice, and the data-handling default described above should be checked against the terms current for the specific product and tier you are buying.
Trying to work out which AI tools fit your task? Describe the outcome and get a Blueprint: the tools, the prompt, and the steps, with pricing we verified ourselves.