DeepSeek V4 Pro Review: 80% SWE-bench, Now Half Price Off-Peak

TL;DR

DeepSeek V4 Pro packs 1.6 trillion parameters into a mixture-of-experts model that activates 49 billion per token, and DeepSeek reports 80.6% on SWE-bench Verified for the April preview. The general-availability build (V4-Pro-0813) now costs $1.32 input and $3.96 output per million tokens at peak and exactly half that off-peak, against $4/$20 for Claude Opus 5.5. That makes output 5x cheaper at peak and 10x cheaper off-peak. Two things changed the verdict since May. DeepSeek itself now says its smaller V4.1-Flash beats V4 Pro on performance, cost and speed, and the safety picture got worse after FAR.AI broke V4 Pro’s safeguards with a reused V3.2 jailbreak. Use it for batch work you schedule off-peak and fence with your own guardrails. For unattended agents, look elsewhere.

Pricing, model status and benchmarks last verified: November 9, 2026. This review was written against the April preview; the section below lists what has moved since.

What Changed Since May

Six months after the preview, the model name is the same, but much of what sits behind it has changed:

The pricing history is messier than the table can show. DeepSeek made the May promo permanent before it expired, The Decoder reported, so for most of the summer V4 Pro cost $0.435 / $0.87. The August GA brought a peak/off-peak schedule that took effect on August 16, and the current list price sits above the summer discount at every hour of the day. Peak hours are 01:00–04:00 and 06:00–10:00 UTC, Monday through Friday, excluding Chinese public holidays.

The bigger story is that V4 Pro nearly disappeared. DeepSeek’s September 10 announcement of V4.1-Flash, a 552B-parameter model with “just 8B active parameters for input, 16B for output”, said: “Tests by multiple parties put V4.1-Flash ahead of V4-Pro on performance, cost, speed & total runtime. We’re phasing out V4-Pro.” From September 14, every deepseek-v4-pro request was supposed to route to V4.1-Flash until a V4.1-Pro launched. The changelog entry for the same date reverses that: “In response to user demand, we have decided to continue providing API services for DeepSeek V4 Pro after September 14, 2026, with the billing method remaining unchanged.” The pricing page agrees and still lists V4-Pro-0813 as a separate model. No V4.1-Pro has been announced.

When the vendor says its cheaper model wins on every axis it measured, that’s the strongest argument against picking V4 Pro by default. The rest of this review explains where it still earns its higher price.

What a Task Costs Now, Peak vs Off-Peak

Per-token prices only tell you so much, so I wrote a short script that prices one multi-turn coding task on each model at November list prices. It also works out how much of a 09:00–18:00 working day lands inside DeepSeek’s peak window in a few time zones, because the audience here is mostly European and that window falls on European mornings.

# Prices: USD per 1M tokens, list prices checked 2026-11-09.
from datetime import datetime, timedelta
from zoneinfo import ZoneInfo

PRICES = {
    #                          input  cache-hit  output  cache-write multiplier
    "DeepSeek V4 Pro (peak)":  (1.32, 0.044, 3.96, 1.00),
    "DeepSeek V4 Pro (off)":   (0.66, 0.022, 1.98, 1.00),
    "DeepSeek V4.1-Flash (pk)": (0.30, 0.006, 1.20, 1.00),
    "GLM-5.3":                 (1.40, 0.26, 4.40, 1.00),
    "GPT-6.1 Sol":             (2.00, 0.10, 10.00, 1.00),
    "Claude Sonnet 5.5":       (2.00, 0.10, 10.00, 1.25),
    "Claude Opus 5.5":         (4.00, 0.20, 20.00, 1.25),
    "Claude Opus 4.7":         (5.00, 0.50, 25.00, 1.25),
}


def task_cost(model, input_tokens, output_tokens, hit_ratio):
    inp, hit, out, write_mult = PRICES[model]
    hits = input_tokens * hit_ratio
    misses = input_tokens - hits
    return (hits * hit + misses * inp * write_mult + output_tokens * out) / 1e6


# One multi-turn refactor: 1.5M input tokens re-sent across turns (85% cache hits), 60K output.
IN, OUT, HIT = 1_500_000, 60_000, 0.85
base = task_cost("Claude Opus 5.5", IN, OUT, HIT)
print(f"Task: {IN/1e6:.1f}M input ({HIT:.0%} cached), {OUT/1e3:.0f}K output")
for m in PRICES:
    c = task_cost(m, IN, OUT, HIT)
    print(f"  {m:<25} ${c:5.2f}  ({c / base:4.0%} of Opus 5.5)")

# Verbosity: Artificial Analysis logged 119M output tokens for V4 Pro 0813 on its index
# vs a 99.3M median for comparable open-weight models.
v = 119 / 99.3
c = task_cost("DeepSeek V4 Pro (peak)", IN, int(OUT * v), HIT)
print(f"  V4 Pro peak with {v:.2f}x output    ${c:5.2f}")

# Peak window: 01:00-04:00 and 06:00-10:00 UTC, Monday-Friday.
PEAK_UTC = [(1, 4), (6, 10)]


def peak_share(tz, day):
    start = datetime(day.year, day.month, day.day, 9, 0, tzinfo=ZoneInfo(tz))
    minutes = peak = 0
    t = start
    while t < start + timedelta(hours=9):
        u = t.astimezone(ZoneInfo("UTC"))
        if any(a <= u.hour < b for a, b in PEAK_UTC):
            peak += 1
        minutes += 1
        t += timedelta(minutes=1)
    return peak / minutes


print("\nShare of a 09:00-18:00 local weekday billed at peak:")
for label, day in (("winter, 2026-11-10", datetime(2026, 11, 10)), ("summer, 2026-07-07", datetime(2026, 7, 7))):
    row = ", ".join(f"{tz.split('/')[1]} {peak_share(tz, day):.0%}"
                    for tz in ("Asia/Nicosia", "Europe/Berlin", "Europe/London", "America/New_York"))
    print(f"  {label}: {row}")

Running it prints:

Task: 1.5M input (85% cached), 60K output
  DeepSeek V4 Pro (peak)    $ 0.59  ( 23% of Opus 5.5)
  DeepSeek V4 Pro (off)     $ 0.30  ( 11% of Opus 5.5)
  DeepSeek V4.1-Flash (pk)  $ 0.15  (  6% of Opus 5.5)
  GLM-5.3                   $ 0.91  ( 35% of Opus 5.5)
  GPT-6.1 Sol               $ 1.18  ( 46% of Opus 5.5)
  Claude Sonnet 5.5         $ 1.29  ( 50% of Opus 5.5)
  Claude Opus 5.5           $ 2.58  (100% of Opus 5.5)
  Claude Opus 4.7           $ 3.54  (137% of Opus 5.5)
  V4 Pro peak with 1.20x output    $ 0.64

Share of a 09:00-18:00 local weekday billed at peak:
  winter, 2026-11-10: Nicosia 33%, Berlin 22%, London 11%, New_York 0%
  summer, 2026-07-07: Nicosia 44%, Berlin 33%, London 22%, New_York 0%

Three things stand out. First, cache pricing weighs as much as the sticker price: Anthropic charges 1.25x for cache writes and DeepSeek charges nothing extra, which is part of why V4 Pro lands at under a quarter of Opus 5.5’s cost even at peak. Second, the verbosity penalty I warned about in May has mostly gone. At launch the preview looked 4.5x wordier than its peers; on the GA build the extra output adds about 9% to the task (more on that below). Third, the peak window is a European problem. A developer in Cyprus pays peak rates for a third of the working day in winter and 44% in summer, always in the morning. A team in New York never touches it. If you run batch jobs from Europe, schedule them for the afternoon or overnight and the price halves.

GLM-5.3’s price comes from Z.ai’s pricing page and the others from each vendor’s own. The task shape (1.5M input, 85% cached, 60K output) is my assumption for a long agentic refactor, so plug in your own token counts.

How V4 Pro Behaves on Real Code

The preview’s defining trait was verbosity. Artificial Analysis counted it producing 4.5x the median output on its evaluation suite (the numbers are in the cost section), and every one of those tokens is billed. On self-contained generation, the kind LiveCodeBench and Codeforces measure, DeepSeek’s self-reported scores are near the top of the field, and the price gap makes V4 Pro attractive for batch jobs over hundreds of files.

The benchmarks point to multi-step agentic work as the weak spot: reading a codebase, planning changes across files and executing them in sequence. On Terminal-Bench 2.0 it trails GPT-5.5 by about 15 points. The error cascade dynamics covered earlier on this blog explain the failure mode: one wrong step poisons everything downstream, and a slow model makes each recovery loop expensive in wall-clock time. Artificial Analysis now puts the GA build at 24.6 minutes per Intelligence Index task, against a median of 13.2 minutes for comparable models, and calls it “notably slow per task”.

Architecture: 384 Experts, 6 Active

V4 Pro uses a Mixture-of-Experts transformer with 384 routed experts plus 1 shared expert per MoE layer, activating 6 experts per token. The result is a 1.6T-parameter model that does as much compute per token as a 49B model.

The attention mechanism is a hybrid of Compressed Sparse Attention (CSA) and Heavily Compressed Attention (HCA). DeepSeek claims that at 1M context length, V4 Pro requires only 27% of the single-token inference FLOPs and 10% of the KV cache compared to their previous V3.2 model. Training used more than 32 trillion tokens, manifold-constrained hyper-connections (mHC) for residual paths, and the Muon optimizer for stability. The GA build keeps the 1M context and allows up to 384K output tokens per request.

The original V4 Flash ran 284B total parameters with 13B activated. It was retired on September 10. Its replacement, V4.1-Flash, uses a different design: a 552B MoE with a causal encoder-decoder split, 8B active parameters on the input side and 16B on the output side, plus native image input that V4 Pro still lacks.

Benchmarks: Self-Reported vs Independent

DeepSeek’s own benchmarks and independent evaluations tell different stories. All V4 Pro numbers below are DeepSeek’s self-reported figures for the April preview in Max mode, from the Hugging Face model card. DeepSeek hasn’t published a matching table for the 0813 GA build.

Coding Benchmarks

Z.ai’s GLM-5.2 scored 62.1% on SWE-bench Pro under MIT license (Z.ai-reported), beating V4 Pro on that benchmark at a similar price. The gap between DeepSeek’s SWE-bench Verified claim (80.6%) and NIST’s independent run (74%) is 6.6 points. The NIST CAISI evaluation attributes part of that to method, noting that “CAISI scores on SWE-Bench Verified tend to be lower than those of other evaluators, likely due to system prompt, scaffolding, and token budget differences”. The same page scores GPT-5.5 at 81% and Opus 4.6 at 79% under identical conditions, and concludes that V4’s capabilities “lag behind the frontier by about 8 months” in aggregate.

On competitive programming, V4 Pro’s Codeforces rating of 3,206 is the highest in DeepSeek’s own comparison table, ahead of GPT-5.4 (3,168) and Gemini 3.1 Pro (3,052). Competitive programming doesn’t translate directly to production coding, as the GPT vs Claude vs Gemini coding comparison on this blog argues.

Reasoning and Math

An earlier version of this table gave Opus 4.7 96.2% on HMMT. That figure is Opus 4.6’s, taken from DeepSeek’s model card, so the cell is now blank. The pattern still holds: V4 Pro is competitive and doesn’t lead its tier on any of these. GPQA Diamond trails Opus 4.7 by 4 points, HLE by 9, and HMMT trails GPT-5.4 by 2.5. Recent research like THINC shows a 4B model beating 235B models on math when trained to reason in code, a reminder that the reasoning medium can count for more than raw parameter count.

Long Context

V4 Pro has a real edge on long-context retrieval. On MRCR at 1M tokens, DeepSeek reports 83.5%, above the 74.0% OpenAI reported for GPT-5.5 on MRCR v2 at 512K–1M. The hybrid sparse attention was designed for exactly this case. For codebase-wide analysis, large document summarization or retrieval over very long inputs, it’s one of the stronger options per dollar. A big window doesn’t replace choosing what goes into it, though, and context engineering still decides whether an agent finds the right file.

What It Actually Costs

At November list prices V4 Pro’s output costs $3.96 per million tokens at peak, against $20 for Claude Opus 5.5: a 5x gap, or 10x off-peak. On input the gap is 3x at peak ($1.32 vs $4) and 6x off-peak. The May version of this review headlined “1/7th Claude’s price”, which was true only for output tokens against Opus 4.7’s $25. On input it was 2.9x even then.

Verbosity was the catch in May. Artificial Analysis measured the preview consuming 190 million output tokens on its evaluation, against a median of 42 million, which would have cut the effective output saving from 7x to roughly 1.6x. The GA build looks very different on the same page today: 119 million output tokens against a median of 99.3 million for comparable open-weight models. Artificial Analysis rates it “somewhat verbose”, and it costs $1.77 per index task. It also calls V4 Pro’s prices “expensive” next to the open-weight median of $0.47 input and $1.97 output, which is fair: the price story is strongest against Claude and GPT, weaker against other open models.

V4.1-Flash: The Model DeepSeek Wants You to Use

In May, V4 Flash at $0.14 input was cheaper than most small models, and I called it the pick for tool-calling, classification and extraction. That advice still points the right way, but the model changed underneath it. deepseek-flash now serves V4.1-Flash-1017, priced at $0.30 / $1.20 at peak and $0.15 / $0.60 off-peak. It’s no longer the cheapest small model either: GPT-6 Luna and Claude Haiku 5.5 (for prompts under 100K tokens) both list at $0.10 / $0.50. Still, DeepSeek’s own claim that V4.1-Flash beats V4 Pro means it’s the first thing to try before paying Pro rates.

Self-Hosting: Possible but Expensive

The April preview weights for both models are open under the MIT license on Hugging Face. The V4 Pro repo still labels them a preview, and DeepSeek hasn’t published a separate 0813 checkpoint there, so a self-hosted V4 Pro isn’t necessarily the model the API serves. Hugging Face currently shows about 335,000 downloads of V4 Pro in the last month and about 1.1 million of V4 Flash.

V4 Pro’s weights are 865 GB in mixed FP4+FP8 precision. Serving them takes more than 1 TB of GPU memory once you add KV cache, which in practice means 8–16 H200s or 8 B200s, often across nodes. Community Q4 quantizations reportedly need around 512 GB, which fits on 8x A100 80GB. Going below Q4 isn’t advisable since the source weights are already partly FP4.

V4 Flash is more practical. Its FP8 weights are 160 GB, more than a single H200’s 141 GB, so plan on two GPUs. Two 80 GB A100s hold the weights with almost nothing left for context. Quantized GGUF builds appeared on r/LocalLLaMA within hours of release. Keep in mind that this is the retired preview model, not the V4.1-Flash the API runs.

Both work with vLLM, SGLang, llama.cpp, Ollama and LM Studio. For production self-hosting, vLLM with tensor parallelism is the standard path, and it exposes an OpenAI-compatible endpoint:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="not-needed"
)

response = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V4-Pro",
    messages=[
        {"role": "user", "content": "Refactor this function to use async/await"}
    ],
    temperature=0.6,
    max_tokens=4096
)

print(response.choices[0].message.content)

DeepSeek’s hosted API speaks the same protocol (plus Anthropic-format and Responses API endpoints), so switching between self-hosted and hosted means changing base_url to https://api.deepseek.com and the model name to deepseek-v4-pro.

Safety Gaps NIST and FAR.AI Found

NIST’s Center for AI Standards and Innovation ran an evaluation of earlier DeepSeek models that found serious safety gaps. Its V4 report focused on capability benchmarks, and DeepSeek hasn’t published safety evaluations or red-teaming results for V4. The findings for R1-0528, which NIST called DeepSeek’s “most secure model” at the time:

• Responded to 94% of overtly malicious requests when a common jailbreaking technique was used, versus 8% for U.S. reference models
• As agents, were on average 12 times more likely than U.S. frontier models to follow malicious instructions designed to derail them from user tasks
• Echoed four times as many inaccurate and misleading CCP narratives as U.S. reference models

V4-specific evidence arrived later. FAR.AI’s stress test of V4 Pro’s safeguards found that “low-skill attackers were able to bypass the model’s safety mechanisms with success rates ranging from 98-100% across every domain tested”, and that a public jailbreak written for V3.2 “worked on DeepSeek-V4-Pro without a single modification”.

If you use V4 Pro for isolated code generation behind your own guardrails, these issues are manageable. The practical guardrail setups covered here apply: sandboxing, permission boundaries and kill switches. For user-facing applications, or agents that take actions on their own, a model whose safeguards fall to an off-the-shelf jailbreak is disqualifying.

Where V4 Pro Wins and Where It Doesn’t

V4 Pro is the right choice when:

• You’re processing large volumes of code at scale (batch reviews, linting, migration) and can schedule it off-peak
• You need long-context analysis over codebases or documents (1M context, 83.5% MRCR self-reported)
• Budget is the constraint and V4.1-Flash has already proven too weak for the task
• You want full control via self-hosting under the MIT license, and the preview weights are good enough
• The task is single-turn code generation without multi-step planning

Claude Opus 5.5, GPT-6.1 Sol or GLM-5.3 are better when:

• You need agentic multi-file workflows (Terminal-Bench 2.0: 67.9% vs 82.7% for GPT-5.5, and the GA build is about twice as slow per task as its peer median)
• Safety and guardrails are non-negotiable
• You’re building user-facing products
• The task requires deep reasoning chains (GPQA: 90.1% vs 94.2% for Opus 4.7, and the newer models are further ahead)
• You need image input, which V4 Pro doesn’t accept

API Availability and Speed

V4 Pro is available through DeepSeek’s native API and on third-party hosts such as OpenRouter. Check which checkpoint a host serves before comparing results: OpenRouter’s page is titled “DeepSeek V4 Pro 0423”, the preview date, while DeepSeek’s own API runs the 0813 build.

Speed is the weak point. Artificial Analysis clocks the GA build at 24.6 minutes per index task, nearly double the 13.2-minute median, and its reasoning mode adds a long wait before the first answer token. On the hosted API, DeepSeek now documents a fixed per-user limit of 500 concurrent requests for V4 Pro and 2,500 for Flash, returning HTTP 429 when you exceed it, and you can request more capacity for free. A batch job that fans out wide will hit that ceiling, so wrap calls in retries that honor 429s rather than a bare loop.

For latency-sensitive applications, V4.1-Flash is the better bet from DeepSeek, and a flash-tier model from another vendor is worth benchmarking alongside it.

FAQ

Is DeepSeek V4 Pro better than Claude for coding?

On isolated code-generation benchmarks like LiveCodeBench (93.5) and Codeforces (3,206), V4 Pro’s self-reported preview scores match or beat Claude Opus 4.7. On real-world bug fixing, Opus 4.7 led by 7 points on SWE-bench Verified (87.6% vs 80.6%). The agentic picture is mixed: Opus 4.7 led by 8.9 points on SWE-bench Pro (64.3% vs 55.4%) but only 1.5 points on Terminal-Bench 2.0 (69.4% vs 67.9%), where GPT-5.5 led both at 82.7%. Claude has since moved on to Opus 5.5, so the gap to the current flagship is larger than these numbers show.

How much does DeepSeek V4 Pro cost compared to Claude?

V4 Pro costs $1.32 per million input tokens and $3.96 per million output tokens at peak, and half that off-peak ($0.66 / $1.98). Claude Opus 5.5 costs $4 / $20, and Opus 4.7 still costs $5 / $25. For a long cached agentic task, the script above puts V4 Pro at 23% of Opus 5.5’s cost at peak and 11% off-peak. Peak hours are 01:00–04:00 and 06:00–10:00 UTC on weekdays.

Is DeepSeek V4 Pro still available?

Yes. DeepSeek announced on September 10 that it was phasing V4 Pro out in favor of V4.1-Flash, then reversed course “in response to user demand”. The deepseek-v4-pro model name serves DeepSeek-V4-Pro-0813 at its own prices. The older deepseek-v4-flash name now routes to V4.1-Flash, and the deepseek-chat and deepseek-reasoner aliases were retired on July 24.

Can you run DeepSeek V4 Pro locally?

Yes, if you have a data center. The preview weights are on Hugging Face under the MIT license (865 GB), and serving them takes more than 1 TB of GPU memory, meaning 8–16 H200 or 8 B200 GPUs. V4 Flash (160 GB at FP8) is more practical and fits on two 80 GB cards with little room for context. Both work with vLLM, SGLang, Ollama and llama.cpp.

Is DeepSeek V4 Pro safe for production use?

That depends on the application. NIST found earlier DeepSeek models answered 94% of jailbroken malicious requests (vs 8% for U.S. models), and FAR.AI bypassed V4 Pro’s safeguards at 98–100% success with a jailbreak built for V3.2. DeepSeek hasn’t published safety evaluations for V4. For batch processing behind your own guardrails, it’s workable. For user-facing or agentic applications, the safety gaps are a real risk.

What is the difference between DeepSeek V4 Pro and V4.1-Flash?

V4 Pro has 1.6T total parameters (49B active) with 384 experts, a 1M context and text-only input. V4.1-Flash is a 552B MoE with 8B active parameters for input and 16B for output, native image input, and a price of $0.30 / $1.20 at peak, about a quarter of Pro’s. DeepSeek says V4.1-Flash beats V4 Pro on performance, cost and speed, so start with Flash and move up only if a task proves it necessary.

For how the rest of the Chinese frontier stacks up, see the Kimi K3 section of the AI coding models guide.

Sources

• DeepSeek V4 Preview announcement: original release notes
• DeepSeek API changelog: V4 Pro GA (August 13), V4.1-Flash (September 10, October 17), and the reversal of the V4 Pro phase-out
• DeepSeek V4.1-Flash announcement: architecture, the “ahead of V4-Pro” claim, the original phase-out plan
• DeepSeek models and pricing: current peak/off-peak prices and peak hours
• DeepSeek rate limits: per-user concurrency limits
• DeepSeek V4 Pro model card on Hugging Face: architecture details, benchmark tables, weights
• NIST CAISI evaluation of DeepSeek V4 Pro: independent benchmark evaluation
• NIST CAISI evaluation of DeepSeek models: jailbreak, hijacking and censorship findings
• FAR.AI security stress test of DeepSeek V4 Pro: V4-specific safeguard bypass results
• Artificial Analysis: DeepSeek V4 Pro: verbosity, speed and cost per task
• The Decoder: DeepSeek makes its 75 percent discount permanent: the May price cut
• Z.ai pricing: GLM-5.3 list price
• Anthropic pricing and OpenAI API pricing: comparison prices
• DataCamp: DeepSeek V4 vs Claude Opus 4.7: cross-model benchmark comparison

Bottom Line

V4 Pro was among the strongest open-weight coding models at its April release, and the 1M context, the MIT license and the price are still real advantages. Since then GLM-5.2, GLM-5.3 and Moonshot’s Kimi K3 line have matched or passed it on several coding benchmarks, and DeepSeek’s own V4.1-Flash beats it by the vendor’s account. The gap between benchmark scores and agentic reliability hasn’t closed, and the safety evidence got worse.

My split for November: V4.1-Flash first for batch processing and structured extraction, V4 Pro off-peak for long-context jobs and one-off code generation where a cheap second opinion helps, and Claude Opus 5.5 or another frontier model for anything with multi-step planning, file orchestration or user-facing interaction. If you work from Europe, the cheapest optimization isn’t choosing a model at all. Move the batch run past 10:00 UTC.