DeepSeek V4 Review: We Ran Both Tiers (Flash 9/9, Pro 8/9)

We put both DeepSeek V4 tiers through our executed nine-task Python benchmark. V4-Flash scored 9/9 at a measured $0.13 per 1,000 tasks. V4-Pro scored 8/9 at $0.74. The cheaper model scored higher and cost 5.7x less. That result is real and it is narrow — nine short Python functions are exactly the bounded work a small model handles well, and V4-Pro exists for harder work our harness never touches. The rest of this review is the honest version of everything else: what V4 really costs (many "DeepSeek V4 pricing" posts online quote a number roughly 4x too high), what the vendor benchmarks do and do not show, and which tier to reach for.

The short version

• We ran both tiers, and the cheap one won. On our executed nine-task Python benchmark, V4-Flash scored 9/9 at a measured $0.13 per 1,000 tasks and V4-Pro scored 8/9 at $0.74 — 5.7x more money for one fewer passing task. Numbers, method and caveats in what we measured.
• Both are slow. V4-Flash averaged 14.5 s per task and V4-Pro 18.2 s — fourth- and second-slowest of the 23 models we have put through this harness — because both spend heavily on reasoning tokens before answering.
• What it is: DeepSeek V4 is an open-weights (MIT) Mixture-of-Experts model in two tiers — V4-Pro (1.6T total / 49B active) and V4-Flash (284B / 13B) — both with a 1M-token context. Released April 24, 2026.
• The price you've seen is probably wrong. DeepSeek's official API is $0.435 in / $0.87 out per million tokens for V4-Pro. Many "DeepSeek V4 pricing" posts quote ~$1.74/$3.48 — that's a third-party host's rate, about 4x the real price.
• And the real price moves. V4-Flash's list rate went from $0.09/$0.18 to $0.14/$0.28 between 2026-07-17 and 2026-07-29 — a 56% increase in twelve days. Our measured $0.13 was computed at the older rate; the repricing is shown below.
• It's genuinely frontier-adjacent at coding. DeepSeek reports SWE-bench Verified 80.6% — within a couple of points of Claude Opus 4.7 (82.0%) and GPT-5.5 (82.6%) on the independent board — and it leads on competitive coding (LiveCodeBench 93.5, Codeforces 3206). Those are vendor-reported; ours are not.
• Not on the gateway yet. DataLLM Lab carries DeepSeek V3.2 today; V4 is callable via DeepSeek's API, OpenRouter, or self-host.

What DeepSeek V4 is

DeepSeek V4 shipped on April 24, 2026 as a two-model release, both open-weights under the MIT license — meaning you can download, self-host, and fine-tune them for commercial use with no strings attached. Architecturally both are sparse Mixture-of-Experts models with a hybrid-attention design built for long context.

What we measured: Flash 9/9, Pro 8/9

Most DeepSeek V4 reviews restate the launch post. This section reports a run. Both tiers went through the same executed nine-task Python harness — the model gets a signature and a prose spec, returns code, and the code is executed against assertions it never sees.

V4-Flash scored 9/9. V4-Pro scored 8/9. The cheaper tier scored higher than the flagship, and it did so at $0.13 per 1,000 tasks against $0.74 — 5.7x less money for one more passing task. On this workload, paying up for Pro bought a worse result.

The one task V4-Pro dropped was parse_csv_line, a CSV-line parser with quoted fields and escaped quotes. It is the fiddliest spec-following task in the set — the one where the answer depends on reading the specification exactly rather than recognising a familiar algorithm. Of the 23 models we have run, only three dropped any task at all, and V4-Pro is one of them. V4-Flash, the only other DeepSeek model we have run, dropped none.

Our own run. Both DeepSeek tiers plus three reference models from the same harness. Cost is the token counts the API reported multiplied by list price on the date shown — a measured cost, not a vendor invoice.

The caveat, right next to the finding

Nine short, self-contained Python functions are exactly the bounded task a smaller model handles well. They are also exactly not the workload V4-Pro exists for. DeepSeek sells Pro for the hardest reasoning and long-horizon work; our harness is single-turn, Python-only, and every task fits in a few hundred tokens. A 9/9 from Flash here is not evidence it will match Pro on a 200,000-token refactor. It is evidence that nine short functions do not separate them — and that on work shaped like nine short functions, the premium tier is money spent for nothing we could detect.

The honest reading is therefore narrow and still useful: for bounded, clearly specified code generation, route to V4-Flash and keep V4-Pro for the cases Flash actually fails. That is the same routing advice the Pro vs Flash section gives, now with a measurement behind it instead of an assumption.

Both tiers are slow, and the reasoning tokens explain it

The other thing the run shows is latency. V4-Flash averaged 14.5 s per task and V4-Pro 18.2 s — fourth- and second-slowest of the 23 models we have run on this harness. The mechanism is visible in the same table: V4-Flash emitted 568 reasoning tokens per task and V4-Pro 732, the third-highest count of the 23. Reasoning tokens bill at the output rate and take wall-clock time to produce, so they show up twice — once on the invoice and once on the clock.

The contrast cases are instructive. Qwen3 Coder Next also scored 9/9, at $0.10 and 7.0 s with zero reasoning tokens — cheaper than V4-Flash and twice as fast, on the same nine tasks. Claude Haiku 4.5 scored 9/9 at $0.94 and 3.7 s, also at zero reasoning tokens: 7.2x V4-Flash's cost, but each answer arrives in about a quarter of the time. If a human is waiting for the output, that trade is not obviously in DeepSeek's favour. If the work is batch, it is.

How we produced those numbers

Nine executed Python tasks: two_sum, valid_parentheses, merge_intervals, roman_to_int, lcs_len, flatten, top_k_words, token_bucket, parse_csv_line.

The model receives a function signature and a prose spec. It never sees the assertions. The returned code runs against hidden assertions in an isolated python3 -I subprocess with a 12-second timeout. Every assertion passes or the task fails — no partial credit, no human grader, no LLM judge. Temperature 0, max_tokens 4000, one scored attempt per task; the harness retries only on an API error, never on a wrong answer, which is why V4-Pro's miss stayed a miss.

Calls go through OpenRouter's OpenAI-compatible endpoint, deliberately not through the DataLLM Lab gateway. Nothing on this page depends on our infrastructure, and you do not have to be our customer to reproduce it.

Cost is derived, not invoiced. It is the token counts the API reported multiplied by that model's list price on a stated date. Both DeepSeek tiers ran in our original 13-model sweep and are priced at 2026-07-17 rates; ten more models ran later on the same harness under the same settings, which brings the total to 23. Where this page says 23 models, that is the combined set — the core sweep was and remains 13.

What the harness does not measure: long-context reasoning, multi-file refactoring, agentic or multi-turn tool use, non-Python work, vision, translation quality, and anything run locally. V4's headline 1M-token context is completely untouched by this test. So is every claim in DeepSeek's own benchmark table. Nine tasks is nine data points — we did not run it twice, did not vary the prompts, and did not buy any model a retry. A known artefact: the 4,000-token ceiling can truncate a very verbose answer, and a truncated answer scores as a miss.

Benchmarks, honestly

Here are DeepSeek's published numbers for V4-Pro. These are vendor-reported — at the time of writing, independent leaderboards had not posted a clean V4 SWE-bench Verified result, so treat the table as DeepSeek's own measurement, not an audited one.

The honest read: on real-world software engineering (SWE-bench Verified, which patches actual GitHub issues), V4-Pro's reported 80.6% sits just behind the independently-measured leaders — Claude Opus 4.7 at 82.0% and GPT-5.5 at 82.6% on vals.ai. On competitive / algorithmic coding (LiveCodeBench, Codeforces), it's at or near the top of any model. So: a superb problem-solver, a strong-but-not-#1 bug-fixer — at a fraction of the price.

Note what this table cannot tell you, and what ours can. These are Pro's scores; DeepSeek did not publish a matching Flash row, so nothing here helps you choose between the tiers. That is precisely the gap our run fills — and it filled it in the direction the parameter counts do not predict.

The price everyone gets wrong

This is the single most important section for anyone budgeting, because the SERP is full of the wrong number. DeepSeek's official API pricing for V4 is remarkably low. Several popular review sites instead quote a third-party host's rate (around $1.74 / $3.48) as if it were DeepSeek's — roughly 4x too high.

Official figures from DeepSeek's API pricing page. The V4-Flash row is its post-increase rate, re-checked against the live listing on 2026-07-29; it was $0.09 / $0.18 on 2026-07-17. Third-party host rates vary by provider; always check whose price you're quoted, and on what date.

What it actually costs

Numbers per million tokens are abstract, so here's a concrete job: a 200K-token codebase audit (≈180K tokens of code in, 20K of analysis out). Same task, three models:

That's the whole story in one table: V4-Pro runs the job for about 1/15th of Opus 4.7's cost, and Flash for roughly 1/45th — before you even apply cache discounts. For high-volume work (CI checks, bulk refactors, log analysis), the gap compounds fast.

Arithmetic on list prices, at the 2026-07-29 V4-Flash rate. This is a modelled job, not a measured one — the measured figures on this page are the per-1,000-task numbers in the measured section, and they come from executed runs, not from an assumed token split.

Pro vs Flash: which to use

A good default: route to Flash first, escalate to Pro only when Flash's answer fails a check. That was already the sensible pattern on price alone; our run says it is also the better pattern on accuracy, at least on bounded work. The full tier-by-tier breakdown is in DeepSeek V4-Pro vs V4-Flash, and the standalone Flash write-up is here.

Neither tier is the automatic pick in the cheap bracket, though. On the same nine tasks Qwen3 Coder Next scored 9/9 at $0.10 in 7.0 s — cheaper and twice as fast as V4-Flash. If latency matters at all, start there; the cheap coding model roundup compares the whole sub-$1 tier.

Where it falls short

• The flagship dropped a task we ran. V4-Pro scored 8/9 on our nine executed Python tasks, missing parse_csv_line. Three of the 23 models we have run missed anything at all; Pro is one of them, and its cheaper sibling is not.
• Both tiers are slow. 14.5 s (Flash) and 18.2 s (Pro) mean latency, fourth- and second-slowest of the 23 models on this harness, driven by 568 and 732 reasoning tokens per task. Cheap per token is not the same as cheap per minute.
• Real-world SWE isn't #1. On the bug-fixing benchmark that best predicts agentic coding (SWE-bench Verified), it trails Opus 4.7 and GPT-5.5 by a couple of points — DeepSeek's own reported 80.6 against vals.ai's 82.0 and 82.6, so that comparison sets a vendor number beside independent ones. Close, but not the leader.
• Vendor benchmarks are self-reported. Until independent boards post V4 numbers, the headline scores are DeepSeek's own. Ours cover nine short Python functions and nothing else.
• Self-hosting 1.6T is heavy. "Open weights" is real, but running V4-Pro yourself needs serious GPU memory; for most teams the hosted API (or a gateway) is the practical path.
• The price moves. V4-Flash rose 56% in twelve days. Any DeepSeek cost comparison you read — including the one above — is true only as of its stated date.

DeepSeek V4 vs Opus 4.7, GPT-5.5 & Kimi

SWE-bench figures are vendor-reported or from vals.ai as marked. List prices captured 2026-07-29. The harness column is ours — measured cost per 1,000 tasks, priced 2026-07-17 for every row shown, and blank where we have not run the model.

The takeaway: the closed frontier (Opus 4.7, GPT-5.5) still edges DeepSeek on real-world bug-fixing, but by single-digit points at roughly 11x V4-Pro's input rate and 29-35x its output rate — and on our own nine bounded tasks, GPT-5.5 bought its identical 9/9 for $8.83 against V4-Flash's $0.13, a 68x gap for the same score. Among open-weights models, V4 is the value leader for raw capability, with Kimi close behind and already callable on the gateway. For a fuller ranking, see our best coding LLM guide, or the four-way disagreement in the AI coding ranking.

How to use DeepSeek V4 today

V4 isn't in the DataLLM Lab catalog yet (the gateway carries DeepSeek V3.2, listed at $0.27 / $0.40 per 1M as captured 2026-07-29). You can call V4 directly via DeepSeek's API, through OpenRouter — which is how our run was made — or self-host the open weights. All of these speak the OpenAI format, so it's a one-line model swap:

from openai import OpenAI

# DeepSeek's own endpoint (OpenAI-compatible)
client = OpenAI(base_url="https://api.deepseek.com/v1", api_key="$DEEPSEEK_API_KEY")

resp = client.chat.completions.create(
    model="deepseek-v4-flash",          # the tier that scored 9/9 in our run
    messages=[{"role": "user", "content": "Review this module for bugs..."}],
)
print(resp.choices[0].message.content)

Already routing through a gateway? When V4 lands on DataLLM Lab you'll only change the model id — same key, same code.

The verdict

DeepSeek V4 is the clearest "value frontier" release of 2026: open weights, a true 1M context, top-tier algorithmic coding on vendor numbers, and real-world coding within a couple of points of the closed leaders — at roughly a tenth of their input rate and a thirtieth of their output rate. What our own run adds is a correction to the obvious assumption about which tier to buy. On nine executed Python tasks, V4-Flash went 9/9 at $0.13 per 1,000 tasks and V4-Pro went 8/9 at $0.74. The premium tier was 5.7x the money and one task worse.

Take that for what it is. It says the flagship's price does not buy anything measurable on bounded, well-specified code generation — not that it fails on the long-context, multi-step work we never tested. So: default to Flash, keep Pro for the cases Flash actually misses, price both against the date on the rate card, and if latency matters look at the zero-reasoning-token coders before either. And whichever you pick, budget against the real price — $0.435/$0.87 for Pro, $0.14/$0.28 for Flash as of 2026-07-29 — not the inflated third-party rate the SERP keeps repeating.

FAQ