DeepSeek V4.1 Flash vs DeepSeek V4 Flash: One Week In, Independently Measured

The question this comparison was written to answer — should you move from DeepSeek V4 Flash to DeepSeek V4.1 Flash — got shorter this week, because DeepSeek answered part of it without being asked. Since 04:00 UTC on September 14, 2026, API calls aimed at the retired deepseek-v4-flash identifier are served by DeepSeek V4.1 Flash, and calls aimed at deepseek-v4-pro are too, both billed at Flash rates. Standing still quietly is no longer one of the options on the vendor's own endpoint. What is still genuinely open is whether the new model is better in the ways the launch claimed — and there the first independent measurement has now landed, and it splits the launch story cleanly in half.

Every figure below is dated, because the last seven days moved. Vendor-reported numbers are labelled vendor-reported and community numbers community-measured, and each one was read from its own source rather than carried over from the earlier version of this article. DeepSeek V4.1 Flash reached general availability on September 10, 2026 — six days ago — and enough has settled since September 9 that the previous draft of this comparison now misleads on two counts. One of them is speed, and it misleads in the direction the launch wanted.

What closed between September 9 and today

Six things were open questions when this pairing was first written up. All six have answers now, and only one of them is bad news.

• General availability — confirmed and dated. DeepSeek's own changelog carries the release as 2026-09-10, and the model is live across the App, the web client and the API under the identifier deepseek-flash.

• The price card — landed as announced. The rates that circulated before launch were reported as a pre-launch leak; they are now the published card, and they are the numbers two sections down.

• Open weights — answered. The weights are published on Hugging Face under an MIT licence with a technical report alongside, no gate and no access form.

• Independent measurement — arrived. Artificial Analysis has now run DeepSeek V4.1 Flash, which was the single largest hole in the September 9 piece. It is discussed below, and it does not say what the launch implied.

• Routing — activated. The redirect of DeepSeek V4 Pro traffic that the launch announcement described as forthcoming is now in force, with a date attached.

• Serving support — shipped, with caveats. NVIDIA vLLM, SGLang and Dynamo all put day-zero paths out; the local-runner story is narrower than "day-0 support" makes it sound.

Two things have not changed and belong before the numbers. DeepSeek V4.1-Pro is still unreleased: DeepSeek's own materials describe the Pro redirect as running "until V4.1-Pro ships", and as of today nothing has shipped. And DeepSeek V4 Flash has not stopped existing — its weights are still open and MIT-licensed, and anyone self-hosting it keeps working. What has ended is the vendor's API path to it.

Under the hood: a different model, not a faster one

The September 9 comparison argued that DeepSeek V4.1 Flash is not DeepSeek V4 Flash with the speed dial turned up, and a week of published detail has made that concrete. Where the older model is a 284B-parameter mixture-of-experts with 13B active — the V4-Flash-0731 post-training refresh — the successor is a new architecture DeepSeek calls a Causal Encoder-Decoder: a 20-layer causal encoder stacked on a 20-layer decoder, 40 Transformer layers, with the decoder's KV cache projected from the encoder's final hidden states rather than computed layer by layer. That last detail is where the efficiency claims come from.

• Active parameters — DeepSeek reports roughly 8B active per token during prefill and 16B during decode, against 552B of backbone parameters. DeepSeek V4 Flash activates 13B across a 284B backbone.

• KV cache — DeepSeek reports the new build needs one quarter the HBM and one eighth the SSD of the previous Flash generation. Note which of those is the persistent figure: the 8x reduction is the one that governs how much context you can keep parked on disk between turns.

• Input — text and images natively in one model. DeepSeek V4 Flash is text-only, and image work needed the separate experimental build DeepSeek-V4-Flash-Vision-Exp, which has now been retired alongside it.

• Context and output — 1,048,576 tokens of context and a 384,000-token output ceiling, the same headline shape DeepSeek V4 Flash published.

• Weights — MIT, published on Hugging Face.

Every size-based comparison above carries one caveat, and it is worth stating plainly rather than in a footnote. The 552B backbone figure is the vendor's. The checkpoint's own file listing totals roughly 510GB, which is smaller than a naive reading of 552B parameters would suggest because the weights ship already quantised. And DeepSeek's model card separately declares a 196B-parameter Engram conditional memory table — a token-addressed lookup consulted at two points in the network rather than a layer the text flows through. Add the vendor's own two numbers together and you get 748B, which is exactly the reading a credible community analysis arrived at when it disputed the 552B headline. Hugging Face's own page for the model displays a third figure, 763B, in its sidebar. Three numbers, all defensible, depending on whether you are counting the computing stack, the memory table, or the file on disk. Treat any "552B" in a spec comparison as the vendor's backbone count, not the size of the download.

Two rows of that card were open questions on launch day and both have since been filled in: the weights are published under MIT, and the first third-party score exists. The speed row is the one that went the other way, and it gets its own section below.

The rate card is confirmed — and it is still one card

The core finding of the earlier comparison survives, and is now better than a rumour. DeepSeek V4.1 Flash and DeepSeek V4 Flash bill against a single Flash-tier rate card rather than two, and since the old identifiers now alias to the new model, anything still calling deepseek-v4-flash bills on the new card too. These are DeepSeek's published numbers, effective 04:00 UTC on September 10, 2026:

• Cache-hit input — $0.003 per 1M tokens off-peak, $0.006 at peak

• Cache-miss input — $0.15 per 1M tokens off-peak, $0.30 at peak

• Output — $0.60 per 1M tokens off-peak, $1.20 at peak

• Peak windows — 01:00–04:00 and 06:00–10:00 UTC on weekdays. Weekends and public holidays are off-peak around the clock.

The off-peak column is the one that gets quoted and the peak column is the one that bites: a European or Asian working morning falls inside a peak window and pays double, which turns a headline $0.15 input rate into $0.30 for exactly the hours most teams are actually running traffic. Budget off the peak column unless your workload genuinely runs overnight UTC.

Against the card DeepSeek V4 Flash billed on before the change — $0.007 cache-hit, $0.22 cache-miss and $0.66 output per 1M tokens off-peak — the new sheet cuts cached input by roughly 57%, cache-miss input by roughly 32% and output by roughly 9%. So the successor is cheaper per token than the model it replaces, by a margin that is large on the tokens an agent loop re-reads constantly and modest on the tokens it generates. That is the real shape of the "Flash price cut" story: it is a cache-hit cut with an output discount attached.

That capture is the card as it stood before the September 10 cut — the sheet DeepSeek V4 Flash billed against through August, kept here as the before side of the comparison. The after side is the four bullets above.

What the benchmarks actually say, and who ran them

The benchmark picture has two halves that are routinely quoted as one, and they have very different standing.

The first half is DeepSeek's own evaluation table, published with the release. It puts DeepSeek V4.1 Flash at 74.2 on DeepSWE v1.1 — ahead of Claude Opus 5 at 74.0, GPT-5.6 Sol at 73.0, Kimi K3 at 67.5, GLM-5.3 at 66.9, DeepSeek V4 Pro 0813 at 62.7 and DeepSeek V4 Flash 0731 at 54.4. Those are vendor-run numbers, measured at maximum reasoning effort, and the same release reports the identical checkpoint scoring anywhere between 65.5 and 74.2 across eight different agent scaffolds — 74.2 on the scaffold that suits it best, 69.8 under Claude Code, 65.6 under Codex, 65.5 under OpenCode. A 0.2-point margin over Claude Opus 5, on a vendor-run suite, taken from the most favourable of eight scaffolds, does not establish a lead over Claude Opus 5. It establishes that the new Flash is competitive with the frontier on agentic coding when everything is set up its way — which is a real result and a much smaller one than "ahead of Opus 5" sounds.

The second half is the part that did not exist on September 9. Artificial Analysis has now measured DeepSeek V4.1 Flash independently and puts it at 40 on the Intelligence Index, against 35 for DeepSeek V4 Flash 0731 — sixth of 113 models measured, against eighth for the model it replaces, and well above the median of 18 for open-weight models of comparable size. That is the number the earlier version of this article said did not exist yet, and it settles the broad question in the successor's favour: on a third party's composite of reasoning, knowledge, mathematics and coding, the new build is measurably the stronger model. It does not settle the frontier question, because the same leaderboard has Kimi K3 and GLM-5.3 above it.

The speed story did not survive measurement

Here is where the earlier comparison has to be corrected rather than extended. Its spine was that the two models share a rate card and separate on speed, with DeepSeek V4 Flash measured at roughly 120–140 output tokens per second and first-day testers of DeepSeek V4.1 Flash reporting 280 to 500, peaks above 500. That gap did not reproduce.

On Artificial Analysis's measurement, DeepSeek V4.1 Flash generates 214.4 output tokens per second and DeepSeek V4 Flash 0731 generates 214.9 — a dead heat, a difference of half a token per second, on the same methodology that produced both figures. Whatever the first-day community runs were measuring, it was not a like-for-like comparison: tokens per second varies with provider, hardware, batch size, concurrency and how much of the answer is reasoning tokens, and the launch-week numbers came from setups that differed in all five. The honest revision is that the throughput advantage the launch implied is not visible in independent measurement. Anyone who moved to DeepSeek V4.1 Flash expecting two to three times the speed should re-measure on their own traffic before assuming it.

The cost picture is more interesting than the speed picture, and it is not a simple win either. At Artificial Analysis's per-token inputs — $0.30 in and $1.20 out for the new model against $0.44 and $1.32 for the old one, both at peak — DeepSeek V4.1 Flash is cheaper per token. But the measured cost per Intelligence Index task comes out at $0.27 against $0.22, slightly higher, because the new model is a heavier talker: 250M output tokens across the index against 240M for its predecessor, and one of the more verbose models the leaderboard measures. A cheaper token that is spent more often is not automatically a cheaper task. Which side of that you land on depends entirely on whether your workload is dominated by re-read context, where the 57% cache-hit cut does the work, or by generated output, where verbosity eats the discount.

Day-0 serving support, and what it is actually worth

If you already self-host DeepSeek V4 Flash, this is the section that decides whether the migration is cheap, and the answer is: cheaper than usual, but not free, and not on the runtime most people mean by "locally".

• NVIDIA vLLM — shipped a day-zero path as a preview Docker image rather than a released package; the architecture support was not merged into the mainline at release, so there is no pip install that includes it. Verified across a set of NVIDIA platforms rather than one, with roughly a 614GB memory floor for the weights plus headroom.

• SGLang — day-zero preview image and a cookbook entry, published without performance numbers because the vendor judged development-period measurements unstable. Verified on GB300-class hardware, with others listed as still being confirmed.

• NVIDIA Dynamo — day-zero deployment recipes alongside its existing Flash and Pro recipes.

• Other silicon — Cambricon reported day-zero adaptation through vLLM on the same day.

• Ollama and llama.cpp — the gap. Ollama lists the model, but as a cloud passthrough: it runs on Ollama's servers, not yours. The llama.cpp architecture support has not been merged, so there is no upstream local path yet, and community GGUF conversions exist without a released runtime that executes them end to end.

The practical read: the framework ecosystem moved unusually fast, and if you are deploying on vLLM or SGLang across a multi-GPU node you have a documented path within days of launch. If your DeepSeek V4 Flash deployment is a llama.cpp or Ollama box, there is no equivalent yet, and the ~510GB checkpoint means there is unlikely to be one at the sizes that hardware implies. The weights are also not the same shape of problem: DeepSeek V4 Flash at 284B total is a single-node proposition, and the new build at 552B of backbone — before the Engram table — is not.

Routing moved, and it moved for you

The most under-reported part of this launch is still that DeepSeek is routing traffic between its own models, and unlike on September 9 it now has dates. From 04:00 UTC on September 14, API requests aimed at deepseek-v4-pro are served by DeepSeek V4.1 Flash and billed at Flash rates, a policy DeepSeek describes as running until V4.1-Pro ships. DeepSeek V4 Flash and DeepSeek-V4-Flash-Vision-Exp are retired outright, with their identifiers kept alive only as compatibility aliases that also resolve to the new model.

Read that as an answer to the question this article exists for. A week ago, Pro callers switched automatically and Flash callers had a decision to make. Today the vendor has made it for both, which means the live choice is no longer "V4 Flash or V4.1 Flash" on the API — it is whether your prompts, evals and cost model are ready for a re-trained model, or whether you need a different fallback entirely.

That is the same logic a routing layer applies across vendors, and it is the part a platform like OrcaRouter earns. DeepSeek V4.1 Flash on OrcaRouter carries DeepSeek's list price — $0.15 per 1M input tokens and $0.60 per 1M output — passed through at 0% markup, which is what makes a vendor price cut land on our side the same day it lands on theirs. DeepSeek V4 Flash on OrcaRouter remains callable on the same key while you migrate, so the switch is a model string rather than a second contract, and DeepSeek V4 Pro on OrcaRouter stays listed while the vendor's redirect serves it with the new model at Flash rates. The automatic failover across providers is the cheap way to try a re-trained model on real traffic without betting a production path on day-one behaviour: route a slice, keep a known-good model behind it, and let the edge cases land on the fallback while you find out whether the new prompting behaves.

Which should you call?

If the honest answer were still "either, for everyone", this refresh would not be worth publishing. The week moved the decision twice — once in the successor's favour, once against.

The case for moving to DeepSeek V4.1 Flash is now stronger than it was on launch day, and it rests on the independent number rather than the vendor table. Forty against thirty-five on the Intelligence Index is a real gap measured by someone with no stake in it, the model is cheaper per token than the one it replaces on the same card, image input no longer needs a second model, and every third-party measurement agrees it is at least the equal of its predecessor on throughput rather than two to three times faster. If you are starting a new workload, or you were relying on DeepSeek-V4-Flash-Vision-Exp for images, the move is straightforward and the migration cost is a model string.

The case for pausing is narrower than it was and more specific. If your prompts, tool-calling schemas and evals were tuned against V4-Flash-0731, a re-trained model is a behaviour change and not a speed change — prompting, refusal boundaries and output length all move, and the fact that the new model is a heavier talker is itself a behaviour change that shows up in your bill before it shows up in your quality metrics. And if your deployment is self-hosted on llama.cpp or Ollama, or your budget depends on output tokens rather than cached input, the economics of moving are not the ones the launch headline implied. Running a day of your own traffic through both and comparing accepted completions per dollar will tell you more than any of the tables above.

For most teams the defensible position a week in is neither of the loud ones: treat DeepSeek V4.1 Flash as the default because the independent evidence now supports it, keep DeepSeek V4 Flash serving whatever it already serves well — its weights are still there, still MIT — and re-measure throughput on your own workload rather than trusting either the launch-week community numbers or a single leaderboard row. The successor is genuinely better. It is just better by less, and in different places, than the launch suggested.