DeepSeek V4 Pro Launches: Output Costs 6 Yuan

DeepSeek Officially Brings V4 Pro to the API

On the evening of August 12, DeepSeek-V4-Pro-0813 was added to the model list in DeepSeek’s API documentation. Information that surfaced shortly afterward showed that the production release of V4 Pro had begun rolling out to the API. The model name used by developers remains unchanged, while the previously announced Responses API support and Codex integration have also been added.

Pricing was announced at the same time: RMB 0.025 per million input tokens for cache hits, RMB 3 for uncached input, and RMB 6 for output.

| Billing Item | DeepSeek V4 Pro Production Pricing | | --- | ---: | | 1 million input tokens, cache hit | RMB 0.025 | | 1 million input tokens, cache miss | RMB 3 | | 1 million output tokens | RMB 6 |

The focus of this update is not “yet another chat model.” Rather, DeepSeek has officially brought its higher-spec Pro model into the agent development pipeline. The combination of the Responses API, Codex, tool calling, and long-context support points to one thing: enabling models to continuously read codebases, operate terminals, invoke tools, and repeatedly correct themselves based on execution results, rather than ending after answering a single question.

However, as of publication on August 12, there may still be brief synchronization discrepancies between different pages of DeepSeek’s documentation. The new version has already appeared on the model and pricing pages, while older documentation previously stated that V4 Pro did not yet support the Responses API. Before routing production traffic to the new model, developers should rely on the capabilities actually available in the console, API responses, and subsequent changelogs rather than a single status line on a documentation page.

The Responses API Is the Engineering Focus of This Update

Chat Completions works well for question-and-answer interactions, but today’s coding agents do much more than “generate a snippet of code.” Within a single task, they need to maintain tool calls, terminal output, file changes, error messages, and subsequent reasoning. The significance of the Responses API is that it places all of this content into an interaction structure better suited to agents.

The difference can be understood this way: Chat Completions is more like a chat window, while the Responses API is more like a task execution bus.

For developers, adding Responses API support to V4 Pro offers three immediate benefits:

1. Easier integration into existing Codex workflows. Teams that have already built workflows around Codex CLI, desktop clients, or editor plugins do not need to maintain an entirely separate interaction protocol.
2. More natural multi-step tool calling. The model can initiate tool calls, read returned values, and continue reasoning within the same task, making it better suited to fixing bugs, running tests, refactoring code, and handling repository-level tasks.
3. Lower model-switching costs. When upper-layer tools depend on a relatively standardized Responses API rather than vendor-specific fields, teams can more easily conduct A/B tests and implement failover between different models.

The key here is not the phrase “OpenAI-format compatible,” but the extent of that compatibility. For ordinary chat requests, compatibility may simply mean that the server accepts the fields. For agents, however, tool-call state, streaming events, error recovery, long-running task stability, and context reuse must all work before the API can be considered truly usable.

DeepSeek previously completed the first round of Responses API and Codex integration with the production release of V4 Flash. With V4 Pro now following suit, the division of labor across the product line is clearer: Flash handles cost-sensitive, high-frequency tasks, while Pro takes on more difficult tasks with longer execution chains and higher rework costs.

RMB 6 for Output Is Cheap, but Do Not Focus Only on the Unit Price

RMB 6 per million output tokens remains an extremely aggressive price in the high-capability model market. Coding agents, in particular, often generate large volumes of reasoning text, patches, test logs, and tool-call parameters, so output pricing directly affects whether a task can run continuously for hours.

But the final bill is determined by more than just the price per million tokens.

The first factor is the cache hit rate. V4 Pro charges only RMB 0.025 for one million cached input tokens, compared with RMB 3 for uncached input—a 120-fold difference. For agents that repeatedly include the same repository instructions, system prompts, and code context, the stability of the prompt prefix can significantly affect costs.

This means the application layer should strive to:

• Place long-lived system instructions and repository context at the beginning of the input;
• Avoid randomly rewriting fixed prompts on every turn;
• Put dynamic content after a stable prefix;
• Monitor cache hit rates, input tokens, and output tokens separately;
• Avoid reinserting the entire repository on every turn merely because “the context window is large enough.”

The second factor is the failure rate of long-running tasks. Even if a model has a low unit price, its actual cost may still exceed that of a more expensive model that succeeds on the first attempt if it frequently goes off track at step ten, repeatedly invokes tools, or generates changes that fail to compile. Agent costs should be evaluated based on “how much it costs to complete one valid task,” rather than simply comparing listed token prices.

Another consideration is the upcoming peak and off-peak pricing model. DeepSeek’s documentation previously indicated that its API service plans to adopt time-of-use pricing, with prices during peak periods potentially reaching twice the standard rate across all billable items. The proposed peak periods are 9:00 a.m.–12:00 p.m. and 2:00 p.m.–6:00 p.m. Beijing time each day. The official implementation date is still pending, but teams performing batch code scans, offline evaluations, or data processing can prepare task-scheduling mechanisms in advance.

If doubled peak pricing is implemented, V4 Pro’s uncached input price would rise to RMB 6 per million tokens, while output could reach RMB 12. That would still be inexpensive, but it would change the economics of running tasks indiscriminately at any time.

Pro and Flash Differ in More Than Speed

On July 31, DeepSeek launched the production release of the V4 Flash API in public beta and said that the production release of V4 Pro would follow as soon as possible. Less than two weeks later, Pro has appeared on the model and pricing pages. This pace indicates that DeepSeek is rapidly filling out a complete agent product portfolio.

The two should not be understood simply as “Flash is faster, Pro is stronger.” A more practical approach is to tier them according to the cost of task failure:

• Code explanation, format conversion, simple scripts, and batch classification can prioritize Flash;
• Cross-file changes, complex debugging, architecture migrations, and long-running terminal tasks are better suited to Pro;
• For tasks of uncertain difficulty, Flash can be tried first, with automatic escalation to Pro upon failure;
• In high-concurrency systems, Flash can handle pre-planning triage, while a small number of high-value tasks are routed to Pro.

This routing strategy is generally more economical than sending every request to the strongest model, and more reliable than using Flash for everything simply to save money.

V4 Pro supports both thinking and non-thinking modes, allowing developers to add another scheduling layer beyond model selection. Non-thinking mode can be used for highly deterministic tasks with simple steps, while thinking mode can be enabled when troubleshooting complex dependencies or planning multi-file changes. Thinking should not be a fixed global switch, but a task-level parameter.

Approaching Fable 5 Does Not Mean It Has Caught Up

According to a benchmark comparison table circulated from an official group, DeepSeek-V4-Pro-0813 approaches Fable 5 on multiple tests and shows a clear improvement over the earlier preview release. These results suggest that post-training and agent optimization have been effective, but they should not yet be interpreted as evidence that the model has “fully caught up.”

The reason is simple: agent benchmarks are highly sensitive to the execution environment. System prompts, tool permissions, maximum execution time, retry strategies, context-compression methods, and whether the model is allowed to self-correct can all affect final scores. Even if two models appear in the same table, that does not necessarily mean developers will get the same experience in real-world repositories.

What deserves more attention is V4 Pro’s reliability in the following scenarios:

• Whether it can still remember the original objective after dozens of consecutive tool calls;
• Whether it can diagnose issues from logs after tests fail, rather than generating an entirely new set of code;
• Whether it preserves existing interfaces when modifying multiple files;
• Whether it proactively clarifies boundaries when requirements are incomplete;
• Whether system prompts, language controls, and permission restrictions remain consistently effective;
• Whether information from earlier in the context is actually used under extremely long-context conditions.

Since the launch of V4 Flash, developers have reported clear improvements in its terminal and programming capabilities. However, they have also noted issues such as a tendency to go off track when instruction boundaries are unclear, insufficient control over the agent’s reasoning language, and occasional compilation failures in embedded code. Whether V4 Pro can address these shortcomings matters more than its lead on any single benchmark table.

A 1M-Token Context Window Does Not Mean You Should Put Every File Into It

The DeepSeek V4 series supports a context window of one million tokens and a maximum output of up to 384K tokens. This is enough to accommodate a large number of files from major code repositories, lengthy technical documents, and extensive terminal histories.

But a large context window is neither free memory nor a substitute for a retrieval system.

Dumping an entire repository into the model without filtering typically creates three problems: higher input costs, increased time to first token, and dilution of critical information by large amounts of irrelevant content. A mature agent still requires file indexing, semantic retrieval, dependency analysis, and context trimming, expanding its reading scope only when necessary.

A more sensible use of the one-million-token context window is to give agents additional headroom for complex tasks. When migrating a legacy project involving hundreds of files, for example, the model can read more interface definitions and historical changes at different stages instead of being constrained by a narrow window at every step. It is a larger workbench, not an invitation to dump everything in the repository onto it at once.

Three Things Developers Should Do First

If you plan to switch an existing coding agent to V4 Pro, complete the following validation steps first:

1. Build Your Own Task Set

Do not run only short coding benchmarks such as HumanEval. Select 20–50 tasks that your team has actually handled, including cross-file bugs, test fixes, dependency upgrades, and terminal operations. Record the completion rate, number of human interventions, and total token cost.

2. Monitor Caching Separately

The price difference between cache hits and misses is enormous. At a minimum, monitoring systems should separately track cached input, uncached input, model output, and failed retries. Otherwise, it will be difficult to identify the cause of billing changes.

3. Preserve Fallback and Rollback Paths

During the initial rollout of a new model, there may be changes to rate limits, documentation synchronization issues, or compatibility problems with individual parameters. Do not switch all production traffic at once. Retain fallback options such as Flash, older versions, or other models.

Such transitions are much simpler for teams using a unified model gateway. Aggregation platforms such as OpenAI Hub that support the OpenAI format can reduce the cost of multi-model integration and API key management. However, the availability of the new V4 Pro release and its Responses API support should still be verified through the platform’s console.

Assessment: A DeepSeek Model That Feels More Like a “Production Tool”

The most important change in the production release of V4 Pro is not that pricing has reached another low. It is that DeepSeek is shifting from providing inexpensive models to providing model services that can be embedded into mainstream agent toolchains.

RMB 6 per million output tokens is attractive, while Responses API and Codex integration determine whether the model can truly enter development workflows. The former lowers the cost of experimentation; the latter lowers migration costs. Together, they form the competitive core of this update.

At this stage, however, it would still be unwise to fully replace existing models based solely on official benchmarks. Documentation synchronization, the completeness of Responses API compatibility, success rates on long-running tasks, peak and off-peak pricing, and stability under high concurrency all require validation with real traffic.

If V4 Pro can remain stable during multi-hour agent tasks while maintaining this pricing, the resulting pressure will not be limited to other Chinese models. Closed-source models that rely on high output prices to sustain revenue without demonstrating a clear advantage in task success rates will also be forced to justify their premiums.

References

• ITHome: DeepSeek V4 Pro Production API Update Goes Live, Approaching Fable 5 in Multiple Performance Tests — Provides information on the production release, Responses API, Codex integration, benchmarks, and pricing.
• ITHome: DeepSeek Adds the DeepSeek-V4-Pro-0813 Model to Its Official API Documentation — Documents the model version’s appearance in the official documentation on the evening of August 12, as well as support for thinking mode.