DeepSeek V4 Flash-0731 Is Live: Where It Actually Wins

DeepSeek V4 Flash-0731 is live on SafeRouter, across every channel we route it through. It's a hybrid reasoning model with a full 1M-token context window and up to 384K tokens of output, and you can switch it between a fast non-thinking mode and a slower thinking mode depending on what the request actually needs. Pricing is $0.14 per million input tokens and $0.28 per million output, and that's not a SafeRouter markup, it's DeepSeek's own listed rate passed straight through. On our direct DeepSeek line and the two resale channels we run it over, the number doesn't move.

We wanted to do more than announce it, though. There's now enough independent testing out in the world to say something useful about where this model is genuinely strong, where it isn't, and what it's actually good for on a real workload rather than a leaderboard screenshot.

One number worth calling out before the rest: cached input tokens run at $0.0028 per million, about 1/50th of the fresh-input rate. That matters more for this model than most, because the workloads it's best suited for, long agent sessions and long-document work, tend to reuse the same context across many calls in a row. The first call in a session pays full price for its context. Every call after it, as long as that context is still warm, pays a fraction of a cent.

What shipped on July 20

DeepSeek V4 went from preview to general availability on July 20, 2026, three months after the April 24 preview release. The family has two members: V4-Pro, a 1.6-trillion-parameter mixture-of-experts model with 49 billion active parameters, and V4-Flash, the smaller sibling at 284 billion total parameters with 13 billion active. Both ship with a 1-million-token context window by default over the API, which is the number we carry through on SafeRouter's catalog entry as well.

The interesting detail in DeepSeek's own release notes is that Flash isn't positioned as a stripped-down discount tier sitting below Pro. On nine separate agent benchmarks, DeepSeek reports V4-Flash beating V4-Pro-Preview outright: 82.7 on Terminal Bench 2.1 for long-horizon shell agent tasks, 76.7 on Cybergym for security and CTF-style reasoning, 70.3 on Toolathlon for multi-tool orchestration under verification, 54.2 on NL2Repo for building working repositories from a natural-language spec, and 54.4 on DeepSWE for real-world software issue resolution. The two full-stack coding suites landed at 68.7 and 59.6, and the harder, more open-ended end of the range, Agent Last Exam and public Automation Bench, came in lower at 25.2 and 25.1, which is honest signal that the model's strengths cluster around structured agent tasks with a clear tool loop rather than open-ended, loosely specified reasoning. Whatever DeepSeek changed going from Pro to Flash, it wasn't a pure quality-for-price tradeoff on agentic tasks. It's the cheaper model and, on most of this benchmark slice, the better one.

Architecturally it's a mixture-of-experts model, 284 billion parameters in total with only 13 billion active on any given token, which is most of why it's both cheap to run and fast to respond. The hybrid reasoning setup means you're not locked into one mode: send a request with thinking mode off and you get a fast, direct answer at the lower end of the latency range; turn it on for a harder problem and the model spends extra tokens working through the problem before answering, at the cost of a slower response and a larger output-token bill. Which mode you want is a per-request decision, not a model-selection decision, and that flexibility is part of what makes it a reasonable default rather than a niche pick.

Where it sits against the field

Independent benchmarking from Artificial Analysis puts V4 Flash's Intelligence Index at 52, good for third out of the 101 models it tracks, and well above the field median of 26. Output speed measured at roughly 136.5 tokens per second with a time-to-first-token around 1.1 seconds, which is fast enough that latency isn't the constraint on most workloads.

There's a real caveat worth knowing before you budget around the sticker price: the model is verbose. In Artificial Analysis's own evaluation run, it produced close to double the output tokens of a typical model answering the same benchmark set. At $0.28 per million output tokens that's still inexpensive in absolute terms, but the token count is doing as much work on your bill as the per-token price is. Worth a system-prompt instruction to keep answers tight if verbosity isn't what you want.

On a pure per-token basis, V4 Flash's output price runs at roughly 1/14th of Kimi K2.6 and about 1/89th of Claude Opus 4.7.

That ratio isn't marketing rounding, it comes directly from comparing DeepSeek's listed per-token rate against the other models' listed rates, and it's the same ratio you get on SafeRouter since none of the three lines we serve it over carry a markup. It's also worth being straight about the other side of that comparison: on public coding leaderboards, the V4 family currently sits behind GLM 5.1 and Kimi K2.6, and further behind Western frontier models like Claude Opus 4.8. This isn't a frontier-class model pretending otherwise. It's a genuinely capable model at a price point roughly two orders of magnitude below the top of the market, and those two facts are both true at once.

The part that's genuinely impressive

One independent hands-on comparison, run against Claude Opus 4.7 and Kimi K2.6 on a coding-heavy internal test suite, scored V4 Flash at 60 out of 100 against Opus 4.7's 91 and Kimi K2.6's 68. On raw output quality it landed where you'd expect a budget-tier model to land. What stood out wasn't the score, it was how the model behaved inside an actual agent loop: it read files before editing them, installed dependencies and ran the test suite at sensible points in the task, and didn't get stuck retrying the same broken action over and over. That's a specific and fairly rare trait. A lot of cheaper models fail agent tasks not because they lack the underlying knowledge, but because they behave erratically once they're driving tools themselves: hallucinating a file path, repeating a failed call indefinitely, losing track of what they already tried. V4 Flash, in this testing, mostly didn't do that.

Where it did fall down was on backend correctness under the hood. The same test caught it mounting an API endpoint under the wrong route prefix, failing to block a workflow from resuming after it had already failed, and rejecting a technically valid JSON input the spec allowed for. These are the kind of mistakes a competent reviewer catches in minutes, not the kind that should ship straight to a production system unreviewed.

There's a cost-normalized way to think about that tradeoff instead of treating the accuracy gap as the whole story. The same testing that measured a full run against V4 Flash put the total cost at two cents. At Claude Opus 4.7 pricing, two cents doesn't buy you a comparable task once. At V4 Flash pricing, it buys enough headroom to run the same request three or four times and keep the best result, add a second pass that checks the first one's work, or throw more attempts at the parts of a task that are likely to go wrong. Whether that's a better strategy than one expensive, more reliable call depends entirely on the task, but for anything where a wrong first attempt is cheap to detect and retry, it's a real option that frontier pricing doesn't leave much room for.

Where this model earns its price

Put the pricing, the benchmarks, and the hands-on testing together and a fairly clear picture of the right workload emerges:

• High-volume first-pass generation. Drafts, boilerplate, scaffolding you plan to review before anything ships. At this price, running the same request three or four times and picking the best result still costs less than a single call to a frontier model.
• Agentic tool-use loops that need discipline more than genius. Reading before writing, running tests at the right point, not spiraling into retries. Long agent sessions that would get expensive fast on frontier pricing stay cheap here.
• Long-document work that needs the full context window. Large codebases, long contracts, multi-file refactors, anything where the binding constraint is whether it fits in context before it's whether the answer is brilliant.
• Workflows that benefit from switching modes mid-task. A fast non-thinking pass for the easy parts of a job and a slower thinking pass for the hard parts, without switching models or providers to get it.

And the honest flip side: production backend logic that ships without a human reviewing it, or any task where a first-try mistake is expensive, is a worse fit. That's what frontier-tier models and careful review passes are for. This model is at its best as an economical engine for volume and exploration, not as the last set of eyes on something that matters.

Try it now

DeepSeek V4 Flash-0731 is in the model picker on chat and compare today, or call it directly by its model id, deepseek-v4-flash. Put it side by side with a frontier model on the same prompt in compare and the price-to-quality tradeoff described above stops being an abstraction and becomes something you can see on your own request.

It carries the same guarantees as every other model on SafeRouter regardless of price tier: it runs inside the TEE-attested enclave, every call gets written into the transparency log, not sampled, all of them, and every response comes back with proof headers you can independently verify against the log. Cheap doesn't mean unverified here, and it doesn't mean a lower standard of evidence than what you'd get calling the most expensive model in the catalog.

Full specs and current pricing are on the models page.

What's coming

DeepSeek V4 Flash-0731 is first in line as we start rolling promotional pricing out across the catalog. We're not putting a number on it yet, but watch this space, it'll be the first model to carry a platform-wide discount on top of the rate above.