TLDR: DeepSeek-V4-Pro-0813 is the general-availability (GA) release of DeepSeekโs flagship 1.6T-parameter MoE model (49B active). It delivers major agentic gains over the April 2026 preview, supports a 1M-token context window, up to 384K output tokens, three thinking-effort levels (low/high/max), native OpenAI Responses API, tool calling, JSON mode, and both OpenAI- and Anthropic-compatible endpoints.
Official pricing starts at $0.435 / $0.87 per 1M input/output tokens (cache miss), with peak/off-peak rates arriving August 16, 2026. The easiest and often most cost-effective way to access it is via CometAPIโs unified OpenAI-compatible gateway at discounted rates.
Key Takeaways
- DeepSeek-V4-Pro-0813 is the production GA version released around August 12โ13, 2026; model ID remains
deepseek-v4-pro. - Significant agent-benchmark lifts: DeepSWE 62.7, Terminal Bench 2.1 87.9, NL2Repo 61.5, Cybergym 83.3, HLE (w/ tools) 60.0.
- Three thinking modes/effort levels: non-thinking + low / high / max reasoning effort.
- Full feature set: 1M context, 384K max output, tool calls, JSON output, Responses API, Anthropic format, streaming, structured outputs.
- Peak/off-peak pricing starts August 16, 2026 (UTC); plan workloads accordingly.
- OpenAI SDK drop-in compatibility makes migration trivial.
This comprehensive guide covers everything developers need: what changed in the 0813 release, official specifications and pricing, thinking modes, streaming and structured outputs, and a step-by-step walkthrough of using the model through CometAPI (recommended for many production and multi-model workflows). All information is drawn from official DeepSeek documentation and contemporaneous reporting as of August 13, 2026.
What Is DeepSeek V4 Pro 0813?
DeepSeek-V4-Pro-0813 is the general-availability production snapshot of DeepSeek V4 Pro released in August 2026.
DeepSeek announced on August 13 that the official V4 Pro version had simultaneously become available through its app, website, and API. DeepSeek's August 13 announcement also adds native OpenAI Responses API compatibility and three practical reasoning levels: non-thinking, high-effort thinking, and max-effort thinking. Importantly for developers, DeepSeek states that the API model name does not change. Developers continue to call:
deepseek-v4-pro
The 0813 designation identifies the production snapshot rather than a model identifier that developers necessarily need to place in their API request.
The model is positioned primarily for advanced reasoning, software engineering, long-context analysis, and agentic workloads. Independent evaluation from Artificial Analysis currently reports an Intelligence Index score of 53, compared with a median of 27 among its selected comparable open-weight models. It also reports approximately 77.6 tokens/second output speed and a 1.71-second time-to-first-token measurement based on its API testing.
What Changes Have Been Made to the API in V4 Pro 0813?
The core model identifier and base URLs stay the same, so existing integrations continue to work without code changes. The meaningful upgrades are in capability, post-training quality, and supporting features.
Key Capability Improvements
According to the official DeepSeek-V4-Pro GA announcement and change log:
- Major agentic upgrades with especially strong gains in production-style workloads.
- Benchmark scores for the 0813 build include:
- HLE (without / with tools): 42.7 / 60.0
- Terminal Bench 2.1: 87.9
- NL2Repo: 61.5
- Cybergym: 83.3
- DeepSWE: 62.7
- Toolathlon-Verified: 74.1
- Agentsโ Last Exam: 25.7
- AutomationBench (Public): 31.8
- DSBench-FullStack: 71.1
- DSBench-Hard: 67.2
These represent substantial lifts over the April 2026 preview (e.g., DeepSWE moved dramatically higher). The model remains a Mixture-of-Experts architecture with 1.6 trillion total parameters and approximately 49 billion activated per token.
New and Enhanced API Features
- Native support for the OpenAI Responses API, optimized for Codex with one-click configuration scripts.
- More flexible thinking-effort control: low / high / max (previously more limited mapping on Pro).
- Continued dual-mode support (thinking enabled by default; non-thinking available).
- Full compatibility with OpenAI Chat Completions and Anthropic Messages formats.
- JSON Output, Tool Calls, Chat Prefix Completion (Beta), and FIM Completion (Beta, non-thinking only).
- Context length remains 1M tokens; maximum output is 384K tokens.
- Concurrency limit for Pro: 500 (Flash: 2,500).
Pricing Update Announcement
Current (as of August 13, 2026) pricing per 1M tokens:
| Model | Input (Cache Hit) | Input (Cache Miss) | Output |
|---|---|---|---|
| deepseek-v4-flash | $0.0028 | $0.14 | $0.28 |
| deepseek-v4-pro | $0.003625 | $0.435 | $0.87 |
Starting 16:00 UTC on August 16, 2026, peak/off-peak billing takes effect (off-peak = half of peak). Peak hours: 01:00โ04:00 and 06:00โ10:00 UTC. New rates:
| Model | Period | Input (Cache Hit) | Input (Cache Miss) | Output |
|---|---|---|---|---|
| deepseek-v4-pro | Off-peak | $0.022 | $0.66 | $1.98 |
| deepseek-v4-pro | Peak | $0.044 | $1.32 | $3.96 |
DeepSeek has also indicated further overall price increases may follow; monitor the official pricing page.
Theย DeepSeek rate-limit documentationย sets standard V4 Pro concurrency at 500 requests per account. A connection counts from submission until the response completes, and excess requests receive HTTP 429 responses. DeepSeek accepts aย for scheduling isolation; it must matchย and be no longer than 512 characters. It should not contain personal information.
Native Responses API support
One of the clearest API changes is native support for the OpenAI Responses API format.
DeepSeek says the Responses API is designed in part to support coding-agent workflows such as Codex. The official endpoint uses:
https://api.deepseek.com
and can be accessed with the OpenAI Python SDK.
Example:
from openai import OpenAI
client = OpenAI(
api_key="YOUR_DEEPSEEK_API_KEY",
base_url="https://api.deepseek.com"
)
response = client.responses.create(
model="deepseek-v4-pro",
instructions="You are an expert software engineer.",
input="Explain how database connection pooling works."
)
print(response.output_text)
DeepSeek's documentation also supports streaming for Responses API requests, using semantic server-sent events rather than the older data: [DONE] convention.
More flexible thinking controls
V4 Pro makes reasoning configurable instead of forcing developers to use a separate reasoning model.
DeepSeek's documentation describes the thinking switch as:
{
"thinking": {
"type": "enabled"
}
}
and reasoning effort as:
high
max
The default thinking configuration is enabled, with high used for regular requests. Certain complex agent workloads can automatically use max.
This creates three practical modes for application developers:
- Non-thinking
- Thinking โ High
- Thinking โ Max
This distinction is extremely useful when designing AI applications because not every request deserves maximum reasoning.
One important implementation detail: in thinking mode, parameters such as
temperatureandtop_pdo not affect the model's output. DeepSeek explicitly documents this behavior.
How to Use DeepSeek V4 Pro 0813 API with CometAPI
CometAPI is useful if you want to integrate DeepSeek V4 Pro without maintaining separate API integrations for every AI provider.
CometAPI currently advertises a unified API covering 500+ AI models, with a common API layer and unified billing. Its pricing documentation says official-model pricing is generally offered at a 20% discount to the provider's official rate.
Here is a practical CometAPI integration workflow.
Step 1: Create a CometAPI Account
First, create or sign into your CometAPI account.
Open the CometAPI website and access the API console.
CometAPI's DeepSeek V4 Pro documentation instructs users to obtain an API token from the CometAPI console.
Step 2: Create Your CometAPI API Key
After signing in, open the token/API-key section of your account and generate an API key.
Store it as an environment variable rather than hard-coding it inside your application.
Linux/macOS:
export COMETAPI_KEY="YOUR_COMETAPI_KEY"
Windows PowerShell:
$env:COMETAPI_KEY="YOUR_COMETAPI_KEY"
Never commit an API key to GitHub, frontend JavaScript, mobile applications, or publicly accessible configuration files.
Step 3: Install the OpenAI Python SDK
Because CometAPI provides an OpenAI-compatible interface, you can use the familiar OpenAI Python client.
pip install openai
This makes migration especially straightforward for developers who already know the OpenAI API format.
Step 4: Configure the CometAPI Base URL
Create the client like this:
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ["COMETAPI_KEY"],
base_url="https://api.cometapi.com/v1"
)
CometAPI's published V4 Pro example uses this base URL and the model ID deepseek-v4-pro.
Step 5: Send Your First DeepSeek V4 Pro Request
Now send a basic request:
response = client.chat.completions.create(
model="deepseek-v4-pro",
messages=[
{
"role": "system",
"content": "You are an expert technical writer."
},
{
"role": "user",
"content": "Explain the advantages of a 1-million-token context window."
}
]
)
print(response.choices[0].message.content)
The critical parameters are:
base_url = https://api.cometapi.com/v1
model = deepseek-v4-pro
endpoint = /chat/completions
Three Thinking Modes Explained
DeepSeek V4 Pro supports:
- Non-thinking mode โ Fastest responses, no explicit chain-of-thought. Ideal for simple Q&A or high-throughput scenarios.
- Thinking mode with low / high effort โ Model produces reasoning_content before the final answer. High is the practical default for most agent and coding work.
- Max effort โ Pushes the modelโs reasoning capability furthest; recommended for complex multi-step problems. May consume more tokens and latency.
In the OpenAI-compatible format you control this with the thinking object and reasoning_effort parameter. The chain-of-thought appears in message.reasoning_content. When tools are not used, prior reasoning can often be omitted from subsequent context; when tools are used, the full reasoning must be passed back.
Switch Between Thinking Efforts and Non-Thinking Mode
- Non-thinking:
"thinking": {"type": "disabled"}(or equivalent Anthropic-stylereasoning.effort: "none"). - Thinking with effort:
"reasoning_effort": "low" | "high" | "max"plus"thinking": {"type": "enabled"}.
Default is thinking enabled with high effort. Use low for simple queries, high for typical agent work, and max for the hardest reasoning or multi-step coding tasks.
Streaming Responses and Structured Outputs
Streaming is enabled simply by setting "stream": true. Both content and (where applicable) reasoning tokens can stream. This is critical for interactive agents and user-facing applications.
Structured / JSON outputs are first-class: use response_format={"type": "json_object"} or the more advanced schema support available via the Responses API and tool definitions. Combined with tool calling, this enables reliable agent loops that emit machine-readable actions.
The Responses API endpoint (/responses) provides a more modern, OpenAI-aligned surface especially useful for Codex-style workflows and is now natively supported for V4 Pro.
Use Structured Outputs / JSON Mode
DeepSeek supports JSON Output. Request it via response_format:
response = client.chat.completions.create(
model="deepseek-v4-pro",
messages=[
{"role": "system", "content": "Return valid JSON only."},
{"role": "user", "content": "Extract the key entities from this text: ..."}
],
response_format={"type": "json_object"},
extra_body={"thinking": {"type": "enabled"}, "reasoning_effort": "high"}
)
For stricter schema control, combine with tool calls or the Responses API where supported.
Implement Tool Calls (Function Calling)
Define tools in the OpenAI format. In thinking mode you must correctly pass reasoning_content back on subsequent turns when tools are involved.
When interacting with the tool later, developers must retain the corresponding reasoning_content when invoking the mindset tool. Improper handling may result in a 400 error.
Python
tools = [
{
"type": "function",
"function": {
"name": "get_weather",
"description": "Get current weather for a city",
"parameters": {
"type": "object",
"properties": {
"location": {"type": "string", "description": "City name"}
},
"required": ["location"]
}
}
}
]
response = client.chat.completions.create(
model="deepseek-v4-pro",
messages=[{"role": "user", "content": "What's the weather in Hangzhou?"}],
tools=tools,
extra_body={"thinking": {"type": "enabled"}, "reasoning_effort": "high"}
)
# Handle tool_calls, execute, append results, and continue the conversation
See the official Tool Calls and Thinking Mode guides for the exact multi-turn pattern required when tools are used.
Best Practices for Using DeepSeek V4 Pro 0813 API
Match reasoning effort to the task
Do not use Max reasoning for a task that only requires classification.
A simple routing policy works well:
Simple โ Non-thinking
Moderate โ High
Complex โ Max
This can reduce both latency and cost.
Stream long responses
If your application can take several seconds to generate a response, use:
stream=True
Users generally perceive incremental output as substantially faster than waiting for a complete response.
Validate structured output
JSON mode improves reliability, but your application should still validate the returned JSON.
Use:
import json
data = json.loads(response_text)
and then validate required fields before writing to your database or triggering an external action.
Monitor token usage
Always inspect:
response.usage
when available.
At V4 Pro's scale, token accounting is not an optional analytics feature. It is a core cost-control mechanism.
Separate stable and dynamic prompts
For long-context applications, keep recurring instructions and documents stable to maximize cache reuse.
Keep a fallback model
A practical production architecture can route:
Simple request
โ
V4 Flash
Complex request
โ
V4 Pro
Very difficult request
โ
V4 Pro Max reasoning
The exact routing policy should be determined through your own benchmarks.
Common DeepSeek V4 Pro API Errors
Error: Model not found
Check that you are using:
deepseek-v4-pro
rather than accidentally inventing a snapshot model name.
DeepSeek states that the API model name remains unchanged for the 0813 production release.
Error: Invalid thinking parameters
For OpenAI-compatible requests, use:
"thinking": {
"type": "enabled"
}
inside the appropriate request body, and use:
reasoning_effort=high
or:
reasoning_effort=max
DeepSeek's official API documentation defines these parameters.
Error: JSON output is malformed
Use:
"response_format": {
"type": "json_object"
}
and explicitly tell the model in the prompt to output JSON. DeepSeek warns that JSON mode should be accompanied by an instruction to generate JSON.
Error during multi-turn tool calling
When using thinking mode with tool calls, preserve the required reasoning_content in subsequent requests.
This is an easy detail to miss and can produce a 400 response.
DeepSeek V4 Pro 0813 API: Recommended Architecture
For a production application, a strong starting architecture looks like this:
โโโโโโโโโโโโโโโโโโโโโโโ
โ Your App โ
โโโโโโโโโโโโฌโโโโโโโโโโโ
โ
โผ
โโโโโโโโโโโโโโโโโโโโโโโ
โ Routing Layer โ
โโโโโโโโโโโโฌโโโโโโโโโโโ
โ
โโโโโโโโโโโโโโโโผโโโโโโโโโโโโโโโ
โผ โผ โผ
Non-thinking High Max
โ โ โ
โโโโโโโโโโโโโโโโผโโโโโโโโโโโโโโโ
โผ
โโโโโโโโโโโโโโโโโโโโโโโ
โ CometAPI โ
โ deepseek-v4-pro โ
โโโโโโโโโโโโฌโโโโโโโโโโโ
โ
โโโโโโโโโโโโโโโผโโโโโโโโโโโโโโ
โผ โผ โผ
Streaming Tools JSON Output
โ โ โ
โโโโโโโโโโโโโโโผโโโโโโโโโโโโโโ
โผ
โโโโโโโโโโโโโโโโโโโโโโโ
โ Validation / Logs โ
โโโโโโโโโโโโโโโโโโโโโโโ
This separates model selection from application logic.
If another model becomes more economical or performs better on a particular workload, the routing layer can change without rewriting the entire application.
Conclusion and Recommendations
DeepSeek-V4-Pro-0813 marks the maturation of the V4 Pro line into a production-ready flagship with markedly stronger agentic performance while preserving the generous 1M context and attractive economics of the series. Developers can start using it today with virtually zero migration cost thanks to OpenAI and Anthropic compatibility.
For most teams we recommend:
- Prototype and multi-model experimentation on CometAPI.
- Move high-volume or latency-sensitive DeepSeek-only workloads to the official endpoint once peak/off-peak pricing and any further adjustments settle.
- Default to thinking mode with reasoning_effort="high" for agent and coding tasks; reserve max for the hardest problems.
- Always implement proper tool-call round-tripping of reasoning_content and leverage streaming + structured outputs for robust applications.
With the 0813 release, DeepSeek has delivered a highly capable, cost-efficient open-weight-class model that is competitive for serious agentic and long-context workloads. Integrate it via CometAPI or the official API and start building. Explore DeepSeek V4 Pro on CometAPI.
Frequently Asked Questions
Is DeepSeek V4 Pro 0813 the same as deepseek-v4-pro?
Yes. DeepSeek's official release announcement says the API model name remains unchanged while the production version is updated to V4 Pro 0813.
Does DeepSeek V4 Pro support a 1M-token context window?
Yes. DeepSeek's current model/pricing documentation lists a 1M-token context length and 384K maximum output.
What are the three DeepSeek V4 Pro thinking modes?
For practical application design, they are:
- Non-thinking
- Thinking with high effort
- Thinking with max effort
The API uses the thinking toggle plus reasoning_effort. DeepSeek's current API exposes high and max, while compatibility values such as low and medium map to high.
Can I stream DeepSeek V4 Pro responses?
Yes. Streaming is supported through the Chat Completions API, and thinking-mode streams can include reasoning_content deltas before normal answer content.
Can I use DeepSeek V4 Pro with CometAPI?
Yes. CometAPI currently documents the deepseek-v4-pro model through its OpenAI-compatible /v1/chat/completions endpoint.
Should I use DeepSeek V4 Pro or V4 Flash?
Use V4 Flash when throughput, latency, and cost dominate. Use V4 Pro for difficult reasoning, coding, long-context analysis, and agentic workflows.
A hybrid routing strategy is usually better than using Pro for everything.
Is DeepSeek V4 Pro API pricing changing?
Yes. DeepSeek has announced peak/off-peak pricing beginning August 17, 2026. The official documentation lists V4 Pro at $0.66/M cache-miss input and $1.98/M output during off-peak periods, versus $1.32/M input and $3.96/M output during peak periods under the new schedule.