DeepSeek V4-Pro: MIT Frontier Model Developer Guide 2026

On April 24, 2026, DeepSeek shipped two open-weight models under an MIT license: V4-Pro (1.6T parameters, 49B active) and V4-Flash (284B, 13B active). Both carry a 1M-token context window and full commercial rights — no usage restrictions, no revenue caps, no attribution walls beyond standard MIT terms.

The timing matters. GPT-5.5 and Claude Opus 4.7 both list $5 per million input tokens. V4-Pro launched at $1.74, dropped 75% on May 31, 2026, and DeepSeek then made that cut permanent: the official pricing page now shows $0.435 per million input tokens as the standing rate, not a promo tier. Self-hosting the full model is still a datacenter-scale operation, but the API economics alone make V4-Pro worth a hard look for teams currently paying frontier rates.

One caveat belongs up front, because it changes how much weight to put on the cost argument. The same pricing page carries a notice that DeepSeek plans to raise API prices "in the near future, with a significant increase expected," and gives no date or figure. Build the cost case on today's rates if you like, but do not build a two-year budget on them.

This guide covers what V4-Pro delivers, how to call its API without changing your existing OpenAI SDK code, where self-hosting is feasible today, and how to think about the V4-Pro vs V4-Flash decision. For a tighter look at the two model tiers, see our DeepSeek V4-Pro and V4-Flash developer guide; for another MIT-licensed frontier option, compare GLM-5.

What DeepSeek V4-Pro Actually Is#

DeepSeek V4-Pro is a Mixture-of-Experts (MoE) transformer. The headline number — 1.6 trillion parameters — describes total model weight, not what runs at inference time. Each token activates only 49B parameters via 6 routed experts per MoE layer (out of 384 routed + 1 shared). This sparse activation is how the model achieves frontier-class quality while remaining economically deployable at scale.

The architecture uses 61 transformer layers with a hidden dimension of 7168. The novel piece is a hybrid attention design combining two compression mechanisms: Compressed Sparse Attention (CSA) for local context and Heavily Compressed Attention (HCA) for long-range dependencies. Compared to DeepSeek-V3.2, this cuts single-token inference FLOPs to just 27% while shrinking KV cache at 1M-context to 10% of the previous generation. In practical terms: V4-Pro at 1M context costs roughly what V3.2 cost at 100K.

Training ran on 33 trillion tokens across a multilingual corpus weighted toward code, math, and scientific text. The optimizer shifted from AdamW (used in V3) to Muon, which handles the sparse gradient patterns in MoE more effectively during pretraining.

Benchmark Numbers#

Before running anything, it helps to know what third-party evaluations show.

Every V4-Pro figure above comes from the Hugging Face model card, and prices come from the vendors' own pricing pages (DeepSeek, OpenAI, Anthropic), all checked on 2026-08-08.

The SWE-bench Verified score of 80.6% is the one that matters most for developer work, since it measures whether a model can resolve real GitHub issues in large codebases rather than write isolated snippets.

The competitor benchmark cells are blank on purpose. Vendor-reported and third-party SWE-bench numbers for GPT-5.5 and Claude Opus 4.7 do not agree with each other, and we could not confirm a figure produced under the same harness and scaffold as DeepSeek's self-report. Cross-vendor benchmark comparison is unreliable at the best of times: scaffolding, retry budget, and test-time compute all move the number by several points. Treat 80.6% as evidence that V4-Pro belongs in the conversation, not as proof it beats a specific rival.

MIT License: What It Actually Means#

The "MIT license" on V4-Pro is genuinely the MIT License — the same two-clause license used by React, Vue, jQuery, and countless other production tools. For developers, the relevant permissions are:

• Commercial use: unrestricted. You can build a SaaS product, sell API calls, embed the model in an enterprise product.
• Redistribution: allowed with the original copyright notice preserved.
• Modification: allowed. Fine-tune it, adapter-train it, distill from it.
• No copyleft: using V4-Pro doesn't require you to open-source your own code.
• No usage cap: no revenue threshold, no user-count limit.

What MIT doesn't cover: DeepSeek's Terms of Service for the hosted API, data-residency obligations you may owe your own customers, or export controls on large model weights in certain jurisdictions. The license governs the weights. The API is a separate service with its own terms. Read both before making compliance decisions.

The practical implication: teams that have avoided certain models due to custom licenses (LLaMA 2's community license, Gemma's custom terms, Mistral's usage conditions) have no equivalent barrier here.

API Setup#

DeepSeek's API uses OpenAI-compatible endpoints. If you're already using the OpenAI Python SDK, the migration is two lines: swap the api_key source and set base_url.

pip install openai

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DEEPSEEK_API_KEY"],
    base_url="https://api.deepseek.com"
)

response = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[
        {"role": "system", "content": "You are a helpful coding assistant."},
        {"role": "user", "content": "Write a Python function that parses ISO 8601 durations."},
    ],
    stream=False
)

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

The model ID is deepseek-v4-pro. For structured output and function calling, the API accepts the same JSON schema format as the OpenAI Chat Completions API.

Enabling Thinking Mode#

V4-Pro supports extended reasoning — similar in concept to Claude's extended thinking or OpenAI's reasoning effort parameter. Pass reasoning_effort="high" to enable it:

response = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[{"role": "user", "content": "Prove that sqrt(2) is irrational."}],
    reasoning_effort="high"
)

The thinking tokens count toward your context budget but not toward billed output tokens on the standard tier. Check DeepSeek's current billing docs before relying on this for cost estimates.

Third-Party API Providers#

Beyond api.deepseek.com, V4-Pro is available on several inference providers if you need multi-region latency, higher rate limits, or specific compliance tiers:

• Together AI — available, listed under their standard model catalog
• OpenRouter — available as deepseek/deepseek-v4-pro
• DeepInfra — available with competitive per-token rates
• Fireworks AI — available under deepseek-v4-pro

Provider pricing may differ from DeepSeek's own rates. Check before committing to high-volume workloads.

Pricing Deep Dive#

The economics are the main story for most teams. All four rate cards below were read on 2026-08-08.

Two things in that table are easy to skim past. The cache-hit column is the first: DeepSeek's $0.003625/M is not a typo, and it is roughly 120x below its own cache-miss rate. The second is that GPT-5.5 bills more per million input tokens than V4-Pro bills per million output tokens.

Put it against a workload. Say a service processes one million input tokens and one million output tokens a day, with no caching:

• GPT-5.5: $35/day, about $1,050/month
• Claude Opus 4.7: $30/day, about $900/month
• DeepSeek V4-Pro: $1.31/day, about $39/month
• DeepSeek V4-Flash: $0.42/day, about $13/month

That's a 27x gap between V4-Pro and GPT-5.5 on the same token volume. Add caching and the gap widens, because the input side of a V4-Pro bill nearly disappears on repeated context while GPT-5.5 still charges $0.50/M for a cache hit.

The 1M-token context window carries no surcharge, and that is a real difference rather than a rounding one. OpenAI moves GPT-5.5 to $10/M input and $45/M output above 272K input tokens, so the two curves diverge sharply exactly where long-context applications live.

The obvious counter-question: if the price gap is this large, what is the catch? Mostly it is the price-increase notice quoted earlier, plus jurisdiction and data-handling terms that vary by team. Quality is a separate question, and one your own evals answer better than anyone's benchmark table.

V4-Pro vs V4-Flash: How to Choose#

The two models are priced roughly 3x apart and are built for different jobs, so the routing decision usually matters more than the model choice.

Use V4-Pro when:

• The task requires multi-step reasoning: complex debugging, architectural analysis, long-horizon planning
• You need strong agentic performance (the 80.6% SWE-bench score reflects real-world codebase editing, not just isolated snippets)
• Quality per output token matters more than latency or cost — high-value tasks where one wrong answer costs more than the token savings

Use V4-Flash when:

• High-volume, lower-complexity tasks: classification, summarization, short-form generation, RAG retrieval augmentation
• Latency is a constraint — Flash's smaller activated parameter count means faster time-to-first-token
• You're doing iterative work like drafting → review → refine where most passes don't need full-quality reasoning

A common production pattern is to route simple tasks to V4-Flash and escalate to V4-Pro on a complexity heuristic: query length, an ambiguity score, or a small classifier. The savings from that split follow directly from the published rate cards. V4-Flash costs $0.42 per million-in/million-out day against V4-Pro's $1.31, so every request you can safely demote is worth about 68% of its cost. What that adds up to depends entirely on how much of your traffic is genuinely simple, which is a number only your own logs have.

When to Use V4-Pro, and When to Skip It#

The license and the price make V4-Pro easy to try. Neither makes it right for every workload. Run down this checklist before committing engineering time.

Use it when most of these are true:

• Your current model bill is dominated by output tokens, where the gap is widest (34x against GPT-5.5)
• Your workload is coding, agentic editing, or long-document reasoning, which is where the model card's strongest scores sit
• You regularly exceed 272K input tokens per request, so GPT-5.5's long-context tier is already penalizing you
• You have a representative eval set and can measure quality loss instead of guessing at it
• Your compliance posture permits routing this class of data to a third-party API outside your existing vendor set, or you have GPU capacity to self-host V4-Flash
• You can absorb a price increase without re-architecting, given DeepSeek's own warning that rates will rise

Skip it, at least for now, when any of these apply:

• The data is regulated or contractually restricted, and a new processor means a new review cycle you cannot fund
• Your spend is small enough that the absolute saving is under the cost of migrating and re-validating prompts. A team paying $200/month saves under $2,400 a year, which one engineer-week erases
• Your prompts are heavily tuned to a specific model's quirks, since reasoning-mode behavior and tool-call formatting differ enough to need rework
• You need a vendor SLA, an enterprise support contract, or contractual indemnification. The MIT license grants rights, not guarantees, and it explicitly disclaims warranty
• Your task depends on a capability the model card does not claim, such as image input or realtime audio

The middle path is worth naming, because most teams land there rather than at either pole. Keep your existing model for the paths where quality is contractual or user-visible, and move the high-volume interior of your pipeline — classification, summarization, retrieval augmentation, batch enrichment — to V4-Flash or V4-Pro. The OpenAI-compatible surface means that split costs you a base URL and a model ID rather than a rewrite.

Self-Hosting: Reality Check#

The MIT license makes self-hosting legal and unrestricted. Whether it's practical depends on your hardware situation.

V4-Pro (1.6T full weights):

• Roughly 960GB of mixed-precision footprint, which in practice means a single 8-GPU H200 141GB node, an 8× B300 node for native FP4, or a multi-node H100/H200 cluster with InfiniBand
• Quantizing does not rescue this. A Q4 build still lands near 430GB of weights, and 1M-context KV cache pushes it back past what 8× H100 80GB can hold
• At this scale, self-hosting beats the API only at very high sustained volume or when data residency leaves you no choice
• Inference engine: vLLM or SGLang, both of which shipped Day-0 V4 recipes with CSA+HCA support, FP4 MoE backends, and disaggregated prefill/decode

V4-Flash (284B weights):

• The FP4+FP8 checkpoint is around 158GB, plus roughly 10GB for a full 1M-token KV cache and a few GB of runtime overhead. Budget 170–175GB
• That fits comfortably on 2× H200 141GB. It does not fit on 2× H100 80GB, which is the most common sizing mistake here
• This is the realistic self-hosting target for a team with an existing cluster

Ollama and llama.cpp: These work with community-built GGUFs but lose MoE routing efficiency. Usable for local prototyping; not recommended for production workloads where throughput matters. vLLM's native MoE routing preserves the 27%/10% efficiency gains described above.

For teams without existing GPU infrastructure, the API remains the practical choice. The self-hosting option is most valuable if you're operating at very high inference volume, have data that can't leave your perimeter, or want to fine-tune on proprietary data without weights leaving your environment. If you are weighing the self-hosting route, our LLM VRAM calculator estimates the memory the weights need against the GPUs you have.

Integration Patterns for Agent Systems#

V4-Pro's 1M context window and strong SWE-bench performance make it well-suited for agentic coding workflows. A few patterns worth knowing:

Large codebase analysis: With 1M tokens, you can pass a substantial portion of a codebase in a single context. This changes the architecture of code analysis tools — rather than chunking and retrieving, some teams are moving toward full-context passes for complex refactoring tasks.

Prompt cache for system prompts: If your agent system has a large shared system prompt (tool definitions, project context, coding standards), the cache hit rate on that portion drives significant cost savings. Structure your messages so the static context comes first and changes last — this maximizes cache utilization.

Multi-turn reasoning chains: For debugging workflows where you're iterating on a fix across multiple turns, V4-Pro's reasoning mode with reasoning_effort="high" gives you extended thinking trace behavior comparable to what reasoning-class models provide.

Fallback routing: Because V4-Flash shares the same base URL and uses the same API surface, building a V4-Flash → V4-Pro escalation path requires only a model ID swap, not a different SDK or request format.

What We Could Not Verify#

Some of the numbers in circulation about V4-Pro do not survive a check against a primary source. Here is where the evidence stops, so you know which claims to re-test yourself.

If you need this class of check run against your own workload rather than a spec sheet, that is the work Effloow's Proof Studio does: a bounded, claim-bound run with the method and raw counters published alongside the result. For an example of the output format, see our OpenAI prompt-cache retention cost proof.

FAQ#

Q: Is DeepSeek's API available in all regions?#

Availability and compliance vary by jurisdiction. Check DeepSeek's current terms of service and verify your organization's data handling requirements before routing sensitive data through any third-party API, including DeepSeek's. Third-party providers like Together AI or Fireworks AI may offer regional endpoints with different compliance profiles.

Q: Can I fine-tune V4-Pro weights?#

The MIT license permits modification and redistribution. Fine-tuning the full 1.6T model requires significant compute (comparable to the self-hosting hardware requirements above). LoRA-style adapter training on the activated-parameter subset is more practical — community recipes for this were emerging as of the April release.

Q: Is the 75%-off launch price still a promo?#

No. The 75% cut took effect on May 31, 2026 and DeepSeek made it permanent, so $0.435/M input and $0.87/M output are the standing rates rather than a discount tier. The launch prices of $1.74/$3.48 no longer appear on the pricing page. The direction of travel is the other way now: DeepSeek's own docs warn of a significant increase to come, without a date.

Q: What's the context window cost structure?#

The 1M-token context window is included at no surcharge in the published per-token pricing. Unlike some providers that add a multiplier for extended context, DeepSeek's pricing covers the full window. Verify this against the current pricing page before committing to long-context workloads in production.

Q: Is V4-Pro suitable for replacing production use of GPT-5.5 or Claude Opus 4.7?#

That depends on your specific tasks. The benchmark numbers suggest competitive quality for coding and reasoning tasks. Teams should run their own evals on representative samples of their production traffic before migrating — published benchmarks and real-world task distribution don't always align.

What Effloow Added#

DeepSeek's release is a model card and a pricing page. A team deciding whether to adopt it needs the licensing reality and the cost math, with every headline number traceable to where it came from. That's what we assembled:

• A cross-vendor price matrix read from the four vendors' own rate cards on the same day, including the cache-hit column that most write-ups omit and that drives the largest share of a real bill.
• Cost math against a concrete workload, one million tokens in and out per day, so the comparison lands as a monthly figure rather than a per-token abstraction.
• The MIT license read in plain terms, checked against the Hugging Face model card rather than a press summary, with the boundary drawn between what the license grants and what the hosted API's terms govern separately.
• A verification table naming what we could not confirm, including the absence of any same-harness benchmark comparison, so nobody builds a migration case on a number that does not hold.
• Corrected self-hosting sizing. V4-Flash's 158GB FP4+FP8 checkpoint does not fit the 2× H100 80GB configuration commonly quoted for it, and quantizing V4-Pro does not bring it within reach of a single 8× H100 node.

Key Takeaways#

DeepSeek V4-Pro is one of the clearest examples of the cost-quality frontier shifting in 2026. On the rate cards, a million-in/million-out day costs $1.31 on V4-Pro against $35 on GPT-5.5, and the weights ship under a license with no revenue cap and no attribution wall. For any workflow currently routing high-complexity tasks to a closed frontier model, that gap is large enough to justify the evaluation.

The practical path for most teams is narrower than "switch." Start on the API, run your own eval set against real traffic, and treat the V4-Pro versus V4-Flash split as the actual lever, since demoting simple requests saves more than picking a vendor does. Self-hosting is legal and unrestricted under MIT, but V4-Pro needs an 8-GPU H200-class node before it runs at all. Keep it on the list as a future option for high-volume or data-residency cases, not a day-one decision.

Two things should temper the enthusiasm. No same-harness benchmark comparison exists against GPT-5.5 or Claude Opus 4.7, so the quality question is genuinely open until you measure it. And DeepSeek has said, in its own docs, that prices are going up by a significant amount at an unannounced date. A cost case that only works at today's rates is a cost case with a fuse on it.