The DeepSeek V4 Family Explained: Pro, Flash and When

DeepSeek shipped V4 Pro and V4 Flash on the same day, 23 April 2026, under the same MIT licence, with the same 1M context window. The differences are active parameters and price, and both differ by roughly a factor of three.

That is an unusually clean design. Two models that agree on everything structural and disagree only on how much compute each token gets is close to an ideal setup for routing, because you can move a request between them without changing anything else about your pipeline.

What separates the two

V4 Pro is a 1.6T mixture-of-experts activating roughly 49B parameters per token. It reports 80.6 percent on SWE-bench Verified and an Artificial Analysis Intelligence Index around 44, at roughly $0.44 per million input tokens and $0.87 output.

V4 Flash comes from the same family with roughly 13B active per token, at around $0.14 input and $0.28 output. It also received a refresh, the 0731 build, on 30 July 2026.

Both carry the 1M context window and both are MIT. So the choice between them is genuinely one-dimensional: how much reasoning depth does this particular request need, and is it worth roughly three times the price.

Flash makes long inputs cheap

The most consequential thing about V4 Flash is not that it is a cheap model. It is that it is a cheap model with a million-token window, and those two properties together change what is architecturally reasonable.

At roughly $0.14 per million input tokens, reading 500,000 tokens costs about seven cents. That turns "load a large slice of the repository and ask a question about it" from an extravagance into a default. You are not budgeting for it; you are barely noticing it.

This competes directly with building a retrieval pipeline. For a small or medium codebase, feeding the relevant subset to a cheap 1M model avoids an index to maintain, a chunking strategy to tune, and a staleness problem to monitor. RAG against long context covers where that stops being true — large corpora, constant churn, and per-document access control are the three places it breaks.

Where Pro earns its multiple

Roughly 49B active against 13B is the whole difference in what the model brings to a token, and it shows up most in tasks with many dependent steps.

Multi-file refactors, debugging where the symptom and the cause are far apart, agent loops where a mistake at step four poisons everything after it — these reward reasoning depth disproportionately, because errors compound rather than average out. Paying three times as much on the turns that determine whether the run succeeds is cheap insurance.

The 80.6 percent on SWE-bench Verified is a reasonable prior for that class of work, with the usual caveat that a benchmark score reflects the benchmark's scaffold and not yours. The V4 Pro guide covers where the depth shows up in practice.

The routing pattern

Because the two models share a context window, a licence and an API shape, routing between them costs almost nothing to implement.

The pattern that works: default to Flash, and escalate to Pro on signals rather than on guesswork. Useful signals include the task class — planning and debugging escalate, summarising and reformatting do not — and failure, where a Flash attempt that produces something that does not compile or does not pass a test is retried on Pro.

Escalation-on-failure is the version most teams underuse. It means you pay the cheap rate on the majority of requests that Flash handles fine, and the expensive rate only on the minority where it demonstrably did not. Verify that your retry logic cannot loop, because a retry storm across two models is more expensive than simply using Pro everywhere. Routing and fallback patterns covers the mechanics, and the hidden cost of retries covers the failure mode.

MIT, and what self-hosting actually costs

Both models ship under MIT, which is as permissive as licensing gets: no revenue thresholds, no service restrictions, no clause that changes as you grow. That is a genuine advantage over families whose terms include conditions on offering the model as a service.

The licence permits self-hosting; the architecture prices it. V4 Pro holds 1.6T parameters in memory even though each token touches around 49B of them, which is a multi-node deployment. Flash is far smaller in active terms but is still a mixture-of-experts, so its memory footprint is governed by its total rather than its active count.

For most teams the value of MIT here is optionality — the ability to move if a provider changes terms or disappears — rather than a plan to run it next quarter. That insurance is real, but price the excess honestly before treating it as a deciding factor.

The refresh, and version pinning

Flash's 0731 refresh on 30 July is a reminder that a model name is not a fixed artefact. A refresh can change behaviour on prompts that were carefully tuned against the previous build, and the change need not be an improvement on your specific tasks.

Pin the dated version in production rather than tracking a floating alias. Then upgrade deliberately: run your evaluation set against the new build, compare, and switch when you have evidence rather than when the provider ships. Pinning model versions covers doing this without accumulating stale pins.

The decision rule for the family: start on Flash, escalate to Pro on task class and on failure, pin both, and re-run your evaluation whenever either gets a dated refresh. The head-to-head works through the crossover volume.