DeepSeek gave its own flagship four days’ notice. On September 10, 2026, the company published the model card for DeepSeek V4.1 Flash, positioning it as the smallest model yet in the V4 architecture family, and buried in the release note was a line that mattered more than any benchmark score: starting September 14 at 04:00 UTC, every request sent to deepseek-v4-pro would be silently rerouted to V4.1 Flash and billed at Flash rates. V4-Pro, the model DeepSeek sold as its premium tier just weeks earlier, was being retired by default, not by announcement.
That makes this a strange kind of comparison. It isn’t “which model should I pick,” because for most developers the pick is being made for them. It’s closer to a ledger: what changes when a cheaper, smaller model takes over the traffic of a more expensive one, and what that means if you’re running DeepSeek V4-Flash, V4-Pro, or the new V4.1 Flash in production right now. This piece lays out the full specs, DeepSeek’s own benchmark numbers, six pricing tiers, a real monthly cost example, how the winner compares to closed models like Claude Opus 5.5 and GPT-6 Astra, and a step-by-step migration path before the cutover finishes rolling out.
The timing lands in the middle of the most crowded stretch open-weight AI has seen. DeepSeek’s own V4 generation has shipped three distinct pricing updates since V3.2, and rivals moved just as fast: our breakdown of DeepSeek V4 vs R1 vs V3.2 covered how peak prices swung 355% across that earlier generation shift alone. Anyone budgeting an API-dependent product around a specific DeepSeek model right now is budgeting around a moving target, and V4.1 Flash’s four-day retirement notice for V4-Pro is the clearest example yet of how fast that target moves.
Don't miss new tech stories on Google
Add Tech Insider once in the Google app and our stories appear in your news suggestions.
DeepSeek Retires V4-Pro on September 14: What’s Actually Happening
DeepSeek V4.1 Flash is not a patch release. DeepSeek calls it a Causal Encoder-Decoder, a new architecture family that replaces the Mixture-of-Experts design behind both V4-Pro and the original V4-Flash, trained from scratch on a reported 45 trillion tokens according to a Ground News report published in October 2026. According to DeepSeek’s official announcement, the new model ships with a KV cache roughly one-quarter the size of V4-Flash’s and needs about one-eighth the SSD storage of the previous generation, changes that show up directly in serving cost and concurrency limits.
The rollout has three distinct phases, and each one lands on a different model. V4-Flash was quietly absorbed first: the deepseek-v4-flash endpoint has already been served by V4.1 Flash since the September 10 launch, according to pricing documentation reviewed by BenchLM’s DeepSeek pricing tracker. V4-Pro gets a grace period, with the reroute taking effect on September 14. After that date, there is no API path left to reach the original V4-Pro checkpoint. Anyone who wants to keep using it has to download the open weights and self-host, and even that only works for the models DeepSeek actually publishes under an open license.
The practical effect: if your code calls deepseek-v4-pro today, it will keep working after the 14th, but the model answering it will be different. Output length, verbosity, tool-call formatting, and reasoning-token counts can all shift, which matters if you’ve tuned prompts against V4-Pro’s specific behavior. DeepSeek frames this as a straightforward upgrade. For teams with prompts locked to a specific model’s quirks, it’s closer to an unannounced model swap with a deadline attached.
DeepSeek V4.1 Flash vs V4 Pro vs V4-Flash: Full Specs Table
Here’s how the three models compare on paper. DeepSeek has not published every field for every model. Where a spec is missing from the official model card, that’s noted rather than guessed at, following reporting from Apidog’s side-by-side breakdown.
| Spec | V4-Flash | V4-Pro | V4.1 Flash |
|---|---|---|---|
| Architecture | V4 Mixture-of-Experts | V4 Mixture-of-Experts | V4.1 Causal Encoder-Decoder, 40 layers |
| Total parameters | 284B (vision build listing) | Not disclosed | 552B backbone, 763B with vision encoder |
| Active parameters | 13B | Not disclosed | 8B on prefill, 16B on decode |
| Context window | 1M tokens | 1M tokens | 1M tokens |
| Max output | 384K tokens | 384K tokens | 384K tokens |
| Vision support | Separate Vision-Exp build | Not disclosed | Native, built-in DeepSeek-ViT encoder |
| License | Not specified | Not specified | MIT, weights published on Hugging Face |
| Concurrency limit | 2,500 | 500 | 2,500 |
| API status (as of Sept 25, 2026) | Retired, alias served by V4.1 Flash | Reroutes to V4.1 Flash Sept 14 | Generally available since Sept 10 as deepseek-flash |
Two numbers stand out. First, V4.1 Flash runs with fewer active parameters than the old V4-Flash (8B on prefill versus 13B) despite a much larger total parameter count, which is the point of a Mixture-of-Experts-adjacent design: most of the network sits idle for any given token. Second, the concurrency jump for anyone currently on V4-Pro is real. Rerouted traffic inherits V4.1 Flash’s 2,500-request limit, a five-fold increase over V4-Pro’s 500, which matters a lot more for agent fleets running many parallel calls than it does for a single chatbot.
Architecture: Why V4.1 Flash Isn’t Just a Smaller V4-Pro
Both V4-Flash and V4-Pro use the same underlying V4 Mixture-of-Experts design, which routes each token through a small subset of specialized expert sub-networks. V4.1 Flash breaks from that pattern entirely. DeepSeek’s model card describes it as a causal encoder-decoder with 40 total layers, split evenly into 20 encoder layers and 20 decoder layers, backed by 384 routed experts plus one shared expert per layer.
The split between prefill and decode compute is the detail worth paying attention to if you’re building latency-sensitive tools. V4.1 Flash activates 8 billion of its 552 billion total parameters while reading your prompt (prefill), a figure DeepInfra’s model tracking confirmed in September 2026, and 16 billion while generating tokens (decode), a number Ground News reported in October 2026. That asymmetry lets DeepSeek keep time-to-first-token low on long contexts, since the expensive read phase runs on the smaller active parameter count, while the generation phase gets more compute where output quality actually depends on it.
Vision support tells a similar story about design intent. V4-Flash needed a separate model, the Vision-Exp build, to handle images. V4.1 Flash bakes a DeepSeek-ViT encoder directly into the base model, so there’s one model ID to call whether the request includes an image or not. For teams building multimodal agents, that removes a routing decision from the application layer entirely.
Benchmark Results: DeepSWE, Terminal-Bench, HumanEval, and GSM8K
All of the benchmark numbers below come from DeepSeek’s own model card, not an independent lab. DeepSeek’s retirement notice references “tests by multiple parties” without naming them, so treat these as vendor-reported figures worth verifying on your own prompts rather than settled facts, a caveat Apidog’s benchmark writeup makes explicitly. A separate figure reported by Ground News in October 2026 put V4.1 Flash’s score on CyberGym, a security-and-exploitation benchmark DeepSeek hadn’t previously published numbers for, at 88.1, which only reinforces how incomplete the official picture still is more than a month after launch.
| Benchmark | V4-Flash | V4-Pro | V4.1 Flash | Gap vs V4-Pro |
|---|---|---|---|---|
| DeepSWE v1.1 | 54.4 | 62.7 | 74.2 | +11.5 |
| Terminal-Bench 2.1 | — | 87.9 | 90.6 | +2.7 |
| HumanEval | — | Near-saturated | Near-saturated | +2.6 |
| GSM8K | — | Near-saturated | Near-saturated | +0.4 |
DeepSWE v1.1 is the number that actually changes decisions. It measures multi-file software engineering tasks, the kind of work a coding agent grinds through all day: reading across a repo, editing several files, and keeping consistency between them. An 11.5-point gap on that specific benchmark is large enough to matter for any team running autonomous coding agents against the DeepSeek API. The gap between V4.1 Flash and the older V4-Flash is even wider, at 19.8 points, which tells you the architecture change did more work than the pricing change. For context on how DeepSeek’s coding scores have shifted across the wider V4 generation against other open models, see our Kimi K3 vs Qwen3.8-Max vs GLM-5.2 comparison, which tracked a similar pattern of newer, cheaper releases outscoring their predecessors within the same product family.
The other three benchmarks matter less than the headline suggests. Terminal-Bench 2.1 measures shell-driven agent tasks, and a 2.7-point edge is real but not decisive on its own. HumanEval and GSM8K are both close to saturated across every current frontier model, meaning nearly all serious models clear 90+ on GSM8K and HumanEval says little about production code quality anymore. A 2.6-point or 0.4-point gap on a saturated benchmark is closer to noise than signal, and the same logic extends to MMLU-Pro, where DeepInfra’s September 2026 tracking put V4.1 Flash at 74.1 against V4-Pro’s 73.5, a 0.6-point edge that’s effectively a rounding error. If you’re choosing based on this table, weight DeepSWE heavily and the other three lightly.
Pricing Breakdown: Six Tiers, One Clear Winner
DeepSeek runs a peak and off-peak pricing schedule, with peak hours set at 01:00–04:00 and 06:00–10:00 UTC on weekdays and everything else billed at half price. Combined with three separate models, that produces six distinct rate cards. The numbers below, current as of the September 10, 2026 pricing update, come from BenchLM’s pricing tracker and DeepSeek’s own release note, with V4-Flash rows reflecting its August 21, 2026 rate card as the pre-migration baseline.
| Model and tier | Input, cache hit (per 1M tokens) | Input, cache miss (per 1M tokens) | Output (per 1M tokens) |
|---|---|---|---|
| V4-Flash, off-peak | $0.007 | $0.22 | $0.66 |
| V4-Flash, peak | $0.014 | $0.44 | $1.32 |
| V4-Pro, off-peak | $0.022 | $0.66 | $1.98 |
| V4-Pro, peak | $0.044 | $1.32 | $3.96 |
| V4.1 Flash, off-peak | $0.003 | $0.15 | $0.60 |
| V4.1 Flash, peak | $0.006 | $0.30 | $1.20 |
Line up V4-Pro’s peak cache-miss input price against V4.1 Flash’s peak rate and the gap is 4.4x: $1.32 per million tokens against $0.30. Output pricing tells the same story at a slightly smaller ratio, with V4-Pro peak output at $3.96 against V4.1 Flash’s $1.20, a 3.3x difference. Against the older V4-Flash, the savings are smaller but still meaningful: V4.1 Flash cuts cache-hit input pricing by roughly 57%, cache-miss input by about 32%, and output by around 9%, compared to V4-Flash’s prior rate card.
Cache-hit pricing deserves its own line, because it’s the tier most agentic workloads actually run on. Any coding agent or chat application that reuses a system prompt and repo context across turns racks up mostly cache-hit tokens, and there V4.1 Flash off-peak drops to $0.003 per million tokens, roughly 7 times cheaper than V4-Pro’s off-peak cache-hit rate of $0.022.
Real-World Cost Example: What a Coding Agent Actually Pays
Rate cards are easy to misread because output tokens dominate most real bills, not input tokens. Here’s a worked example built on a realistic coding-agent workload: 2 billion input tokens a month at a 70% cache-hit rate (a system prompt and repo context reused across turns), plus 300 million output tokens, all measured at peak pricing.
| Cost component | V4-Pro, peak | V4-Flash, peak | V4.1 Flash, peak | V4.1 Flash, off-peak |
|---|---|---|---|---|
| 1.4B cache-hit input tokens | $61.60 | $19.60 | $8.40 | $4.20 |
| 600M cache-miss input tokens | $792.00 | $264.00 | $180.00 | $90.00 |
| 300M output tokens | $1,188.00 | $396.00 | $360.00 | $180.00 |
| Monthly total | $2,041.60 | $679.60 | $548.40 | $274.20 |
At peak pricing, moving that workload from V4-Pro to V4.1 Flash cuts the bill by 73%, from $2,041.60 to $548.40. Shifting the same workload to off-peak hours halves it again, down to $274.20, a combined reduction of roughly 87% from the original V4-Pro peak bill. Output tokens are the biggest line item in every column, which is why the 70% output price cut between V4-Pro and V4.1 Flash matters more to your actual invoice than the cache-hit discount headline suggests. If your workload is output-heavy, like long-form code generation or detailed agent reasoning traces, the savings compound faster than this example shows.
DeepSeek V4.1 Flash vs Claude Opus 5.5 vs GPT-6 Astra: How the Open-Weight Model Stacks Up
DeepSeek’s real competition isn’t its own retired models. It’s the closed frontier tier. Anthropic shipped Claude Opus 5.5 on September 22, 2026, pricing it at $4 per million input tokens and $20 per million output tokens, with cache reads at $0.20 per million, according to Artificial Analysis’s release coverage. OpenAI’s GPT-6 Astra runs higher still, at a reported $10 input and $50 output per million tokens.
| Model | Input (per 1M tokens) | Output (per 1M tokens) | License | Context window |
|---|---|---|---|---|
| DeepSeek V4.1 Flash, peak | $0.30 | $1.20 | MIT, open weights | 1M tokens |
| DeepSeek V4.1 Flash, off-peak | $0.15 | $0.60 | MIT, open weights | 1M tokens |
| Claude Opus 5.5 | $4.00 | $20.00 | Closed | Not directly comparable field |
| GPT-6 Astra | $10.00 | $50.00 | Closed | Not directly comparable field |
On peak pricing, V4.1 Flash costs roughly 13x less than Claude Opus 5.5 on input and about 17x less on output. Against GPT-6 Astra, the gap widens to roughly 33x on input and 42x on output. Off-peak, those ratios roughly double again. That price gap is exactly why open-weight models from DeepSeek, Alibaba’s Qwen line, and others have pulled meaningful API traffic away from closed labs over the past year: for cost-sensitive, high-volume workloads like customer support triage or bulk document processing, a 10 to 40x price difference outweighs a benchmark gap that, on paper, often runs in the single digits.
The trade-off is the one Palo Alto Networks’ CIO has raised publicly about open-weight models in general: you inherit whatever safety and alignment work the lab did or didn’t do, and you can’t audit a closed competitor’s training process any more easily than you can audit an open one’s. Cheaper and faster doesn’t automatically mean safer for regulated or high-stakes deployments, and that calculus is separate from the price table above.
It’s also worth noting that Claude Opus 5.5 itself launched with a cost story of its own, cutting cache-read pricing 60% from the prior Opus 5 generation, which our Claude Opus 5.5 cost comparison covers in more detail. That’s the pattern across the entire frontier model market in September 2026: every lab, open-weight or closed, is racing to cut serving costs simultaneously, which is exactly why a snapshot comparison like this one needs a clear publish date attached. For a wider view of how DeepSeek stacks up against Gemini 3.8 and GPT-6 Astra specifically, see our GPT-6 Astra vs Gemini 3.8 vs DeepSeek V4.1 comparison, which found an 83x pricing gap between the cheapest and most expensive options in that three-way matchup.
Throughput and Concurrency: The Speed Story Nobody Can Fully Verify
DeepSeek does not publish a tokens-per-second figure for any of the three models, which leaves the speed comparison resting on architecture and one unverified anecdote rather than a hard number. What is documented: V4.1 Flash’s KV cache runs at roughly 890 bytes per token, and DeepSeek’s release note states the design needs about one-quarter the HBM and one-eighth the SSD storage of the previous generation. A full 1-million-token context needs under 1GB of cache space under that design, which is a meaningful serving-cost reduction regardless of raw speed.
The prefill-side parameter count matters here too. V4.1 Flash activates 8 billion parameters to read your prompt, against V4-Flash’s 13 billion, which should translate to a faster time-to-first-token on long contexts simply because there’s less compute per input token. One unverified report circulating during the beta period claimed throughput near 400 tokens per second on video-generation-adjacent tests, but that’s an anecdote from a single user, not a benchmark, and should not be treated as a reliable figure. If throughput matters to your application, measure your own p50 and p95 latency rather than trusting any vendor claim or forum post.
Concurrency is the one number that’s fully documented and immediately actionable: V4-Pro capped at 500 simultaneous requests, while both V4-Flash and V4.1 Flash allow 2,500. Any team running an agent fleet that was previously rate-limited on V4-Pro gets a five-fold increase in parallel capacity the moment the reroute completes, no code change required.
5 Real-World Use Cases: Which DeepSeek Model Fits Your Workload
The pricing and benchmark data point toward different answers depending on what you’re actually building. Here’s how the trade-offs play out across five common deployment patterns.
- Autonomous coding agents. The 11.5-point DeepSWE v1.1 gap combined with a 70%+ price cut makes V4.1 Flash the clear choice for multi-file code editing and repo-wide refactoring tasks. Route all new agent traffic to
deepseek-flashdirectly rather than waiting for the V4-Pro alias to reroute. Agent frameworks that loop through edit-test-fix cycles hundreds of times per session are exactly the workload where DeepSWE gains translate into fewer failed patches, and the 2,500 concurrency ceiling means a fleet of agents running in parallel won’t hit rate limits the way a V4-Pro-backed fleet would. - High-volume customer support triage. Off-peak V4.1 Flash pricing at $0.15/$0.60 per million tokens undercuts closed alternatives by more than an order of magnitude, which matters most for support workloads that run thousands of short classification and routing calls a day rather than a handful of long, complex ones. A support desk classifying incoming tickets by urgency and department doesn’t need frontier-level reasoning, it needs a cheap, fast, consistent classifier, and shifting that traffic to off-peak hours where feasible pushes the savings even further.
- Document processing with images. V4.1 Flash’s native vision encoder removes the need to route between a text model and a separate vision build, simplifying pipelines that mix scanned PDFs, screenshots, and plain text in the same batch job. Teams that previously ran conditional logic to detect whether a document needed the vision-capable model or the standard one can collapse that branch entirely, since a single model ID now handles both cases with the same pricing.
- Latency-sensitive chat applications. The smaller prefill-side active parameter count (8B versus V4-Flash’s 13B) should shorten time-to-first-token on long conversation histories, though teams building real-time chat should benchmark their own p95 latency rather than assume the architecture claim translates directly. Applications with long-running conversation threads, where the model re-reads growing context on every turn, stand to benefit the most from a lighter prefill pass.
- Regulated or high-stakes deployments. Teams in finance, healthcare, or other compliance-heavy sectors should weigh the open-weight license against the lack of independent benchmark verification and factor in their own audit requirements before defaulting to the cheapest option on the table. An MIT license makes self-hosting and internal auditing possible in a way closed models don’t allow, which can actually be an advantage for compliance teams that need to inspect exactly what a model does with sensitive data, provided the organization has the infrastructure to run a 552B-parameter model in-house.
Where DeepSeek Fits in the Open-Weight Race: Qwen, GLM, and Kimi
DeepSeek isn’t the only lab racing to undercut closed frontier pricing with open weights. Alibaba’s Qwen3.8-Max, reported at roughly 2.4 trillion total parameters with 95 billion active, and Moonshot AI’s Kimi K3, a 2.8 trillion-parameter open-weight release, both launched within weeks of the V4.1 Flash rollout, putting several large open models into the field at once during August and September 2026. Zhipu’s GLM-5.3 rounds out the group as another actively priced open-weight competitor in the same general window.
What sets V4.1 Flash apart in that field isn’t raw parameter count, since Qwen3.8-Max and Kimi K3 both list larger total parameter figures. It’s the active-parameter efficiency: V4.1 Flash needs just 8 billion active parameters on prefill against Qwen3.8-Max’s 95 billion active, which is a meaningfully lighter compute footprint per token even though the total model is smaller. For teams comparing serving costs across open-weight options rather than committing to DeepSeek specifically, active parameter count is a better predictor of inference cost than total parameter count, since it’s the active parameters that actually run for every token generated.
The broader pattern worth watching: every major open-weight lab shipped a new flagship within the same six-week window in the run-up to this comparison. That kind of release cadence makes any single snapshot comparison go stale fast, which is part of why DeepSeek’s own decision to sunset V4-Pro just four days after announcing its replacement makes sense from a competitive standpoint. Sitting on an older, more expensive model while three other labs undercut it on price was not a position DeepSeek wanted to hold for long.
Migration Guide: Moving From V4-Pro to V4.1 Flash Before September 14
DeepSeek’s automatic reroute means you don’t technically have to change anything, but teams with prompts tuned to V4-Pro’s specific output style should run a diff before the cutover rather than after. The core idea: hit both model IDs with the same prompt set, compare outputs, latency, and token usage, and catch any regression while you still have a fallback. If you haven’t set up a DeepSeek integration before, our step-by-step DeepSeek V4.1 Flash API setup guide covers authentication and request formatting in more depth than the quick example below, and our earlier DeepSeek V4-Pro setup walkthrough is worth reviewing if you’re trying to understand exactly what configuration you’re migrating away from.
Step-by-step migration checklist
- Pull your last 30 days of production prompts and responses from V4-Pro logs.
- Set up two environment configs pointing at the same API endpoint with different model IDs: one for
deepseek-v4-pro, one fordeepseek-flash. - Run the same prompt set through both model IDs and capture the raw JSON responses.
- Diff output length, formatting, and any tool-call schemas your application depends on.
- Check reasoning-token counts specifically, since DeepSeek’s release note describes a continuously controllable reasoning-effort dial on a 1-to-100 scale that didn’t exist on V4-Pro.
- Re-run cost projections using the V4.1 Flash rate card, not the V4-Pro card your budget was built on.
- Update any hardcoded model-name checks or logging that assumes
deepseek-v4-promeans the original architecture. - Switch
deepseek-v4-flashreferences to thedeepseek-flashalias the next time you touch that config, since DeepSeek hasn’t announced a removal date for the old name but has signaled it’s the long-term path.
The API call itself doesn’t change shape, only the model parameter. Here’s the basic request structure for testing both model IDs side by side:
curl https://api.deepseek.com/chat/completions \
-H "Authorization: Bearer $DEEPSEEK_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "deepseek-flash",
"messages": [
{"role": "user", "content": "Refactor this function to reduce cyclomatic complexity."}
],
"max_tokens": 4096
}'Swap "model": "deepseek-flash" for "model": "deepseek-v4-pro" in a second request against the same prompt to capture the pre-cutover baseline while it’s still available. Once you’re past September 14, that second call will return V4.1 Flash’s output regardless of what model name you send, so the comparison window is short.
Self-Hosting V4.1 Flash: When It Makes Sense
An MIT license and published Hugging Face weights mean V4.1 Flash doesn’t have to run through DeepSeek’s API at all. That option looks attractive on price alone, but the hardware requirement is the part teams underestimate. A 552B-parameter backbone, or 763B counting the vision encoder, is not a model you run on a single GPU. Even in FP8 quantization, checkpoints at that scale typically require multi-GPU serving setups with enough combined VRAM to hold the full parameter set, plus overhead for the KV cache during long-context requests.
The economics only favor self-hosting at genuinely high volume. DeepSeek’s hosted API pricing already reflects massive scale efficiencies from running the model across its own infrastructure for millions of requests a day. A team self-hosting to save money needs sustained request volume high enough to justify GPU cluster costs that run into the tens of thousands of dollars a month before the per-token savings catch up. For most teams below that threshold, the hosted API at $0.15 to $0.30 per million input tokens is cheaper than provisioning and maintaining the hardware yourself, even before accounting for the engineering time spent on serving infrastructure, load balancing, and failover.
Where self-hosting does make sense: data residency requirements that prohibit sending prompts to an external API, air-gapped environments with no internet access at all, or organizations that need to fine-tune the base weights for a narrow domain and don’t want that fine-tuned checkpoint touching a third-party server. The MIT license permits all of that without a commercial licensing negotiation, which is a real structural advantage over closed models like Claude Opus 5.5 or GPT-6 Astra, where self-hosting isn’t an option at any price.
Pros and Cons of Each DeepSeek V4 Model
DeepSeek V4.1 Flash
- Pros: Cheapest of the three on every pricing tier, highest DeepSWE v1.1 score, native vision support, 5x the concurrency of V4-Pro, MIT license with published weights.
- Cons: Benchmark numbers are vendor-reported with no confirmed independent verification, no official throughput figure, prompts tuned for V4-Pro’s output style may need rework.
DeepSeek V4-Pro
- Pros: Familiar, established output behavior for teams that already tuned prompts against it; was the higher-tier option for teams that wanted DeepSeek’s most capable checkpoint before the reroute.
- Cons: Being retired from the API entirely on September 14, most expensive per-token pricing of the three, lowest concurrency limit at 500, now scores lower than a cheaper model on DeepSeek’s own coding benchmark.
DeepSeek V4-Flash
- Pros: Was already the budget option in the V4 generation before the cutover; 1M context window and 2,500 concurrency limit matched V4.1 Flash’s current specs.
- Cons: Already fully replaced in serving by V4.1 Flash as of September 10, needed a separate Vision-Exp build for image input, scores lowest of the three on DeepSWE v1.1.
What You Gain and Lose in the Cutover
There’s no real “which should I pick” decision left for anyone currently on V4-Pro, since the API is making that choice on DeepSeek’s schedule. The honest framing is a ledger of trade-offs rather than a recommendation.
On the gain side: higher scores on every benchmark DeepSeek has published, 70 to 77% lower peak pricing, five times the concurrency limit, native image input without juggling a separate vision model ID, and a continuously controllable reasoning-effort setting that V4-Pro never had. On the loss side: you can no longer pin a V4-generation checkpoint through the API, so any prompt tuned to V4-Pro’s specific verbosity or tool-call formatting can drift without warning. Output length and reasoning-token counts can shift too, which changes your bill in ways the rate table alone won’t show you. And the timing is entirely DeepSeek’s call, not yours, which is an unusual amount of control to hand a vendor over a production dependency.
The reasoning-effort dial is worth a closer look because it’s the one genuinely new capability in this list rather than a price or speed change. DeepSeek describes it as continuously controllable on a 1-to-100 scale, which lets a developer trade latency and cost against answer depth on a per-request basis instead of picking between a small handful of preset modes. For a support bot that needs fast, cheap answers on routine questions but deeper reasoning on escalated tickets, that’s a single parameter change instead of a model switch, something neither the old V4-Pro nor V4-Flash offered. It’s also the kind of feature that’s easy to overlook in a pricing comparison but ends up mattering more than raw benchmark scores once a team is optimizing a production system rather than picking a model for the first time.
The Verdict: Which DeepSeek Model Should You Actually Use
For anyone starting fresh, the answer is straightforward: use deepseek-flash. It’s cheaper than both retired options on every pricing tier, scores highest on the one benchmark that actually predicts real coding-agent performance, and carries five times the concurrency of the old V4-Pro tier. There’s no scenario in this data where a new integration should target V4-Pro or the original V4-Flash endpoint, since both are being phased out regardless of preference.
For teams already running V4-Pro in production, the verdict is about timing, not choice. Run the diff described in the migration section before September 14, not after, because that’s the only window where you can compare both models’ actual output side by side. Budget for the new rate card immediately since the cost savings are real, averaging around 73% at peak pricing and up to 87% if you can shift batch workloads off-peak, but don’t assume “cheaper and higher-scoring” means “identical behavior.” The architecture changed completely, from Mixture-of-Experts to a causal encoder-decoder, and that kind of structural shift tends to show up in edge cases that a benchmark table won’t catch.
Set against the closed-model field, V4.1 Flash’s value case gets stronger, not weaker. At 13 to 42x cheaper than Claude Opus 5.5 and GPT-6 Astra depending on the pricing tier and token type, it’s a legitimate default for cost-sensitive, high-volume workloads. Teams with strict compliance, audit, or safety requirements should still weigh that against the lack of independent benchmark verification before committing a regulated workload to any open-weight model, DeepSeek included.
Frequently Asked Questions
Is DeepSeek V4.1 Flash actually better than V4-Pro at coding?
On DeepSeek’s own reported numbers, yes. V4.1 Flash scores 74.2 against V4-Pro’s 62.7 on DeepSWE v1.1, an 11.5-point gap, and 90.6 against 87.9 on Terminal-Bench 2.1. These are vendor-reported figures without confirmed independent verification, so test against your own codebase before fully trusting the gap size.
What happens to my V4-Pro integration on September 14, 2026?
Starting at 04:00 UTC, every request sent to the deepseek-v4-pro model ID gets served by V4.1 Flash and billed at Flash rates instead. Your existing code keeps working without changes, but the model generating the responses changes completely.
Do I need to rename deepseek-v4-flash to deepseek-flash right now?
Not immediately. Both deepseek-v4-flash and deepseek-v4-flash-vision-exp are still accepted as of September 25, 2026, and both are served by V4.1 Flash under the hood. DeepSeek hasn’t announced a removal date for the older names, but switching to deepseek-flash the next time you touch your configuration is the safer long-term move.
Is DeepSeek V4.1 Flash actually faster than V4-Pro?
DeepSeek claims it is but has not published a tokens-per-second figure to confirm it. The architecture supports the claim on paper: 8 billion active parameters on prefill versus more compute-per-token designs, plus a KV cache roughly a quarter the size of V4-Flash’s. Measure your own p50 and p95 latency rather than relying on the vendor claim alone.
Can I still run the original DeepSeek V4-Pro anywhere after the cutover?
Not through DeepSeek’s official API after September 14, 2026. If DeepSeek has published open weights for that specific checkpoint, self-hosting would be the only remaining path, though V4.1 Flash’s weights, not V4-Pro’s, are the ones confirmed published under an MIT license on Hugging Face.
How does DeepSeek V4.1 Flash pricing compare to Claude Opus 5.5 and GPT-6 Astra?
V4.1 Flash costs roughly 13x less than Claude Opus 5.5 and about 33x less than GPT-6 Astra on input tokens at peak pricing, with output savings running even higher at 17x and 42x respectively. Off-peak DeepSeek pricing widens that gap further, though closed models generally offer stronger independent benchmark verification and established safety testing records in exchange for the premium.
Does DeepSeek V4.1 Flash support image input natively?
Yes. Unlike V4-Flash, which required a separate Vision-Exp model build for image understanding, V4.1 Flash includes a native DeepSeek-ViT vision encoder in the base model, so the same model ID handles both text-only and multimodal requests.
What license covers DeepSeek V4.1 Flash’s weights?
DeepSeek published V4.1 Flash’s weights under an MIT license on Hugging Face, matching the open-weight approach the company has used for prior V4-generation releases, according to Coursiv’s release summary. License status for the original, unmodified V4-Pro checkpoint has not been separately confirmed in DeepSeek’s public documentation.
