DeepSeek V4-Pro

DeepSeek V4-Pro is the flagship model of the DeepSeek V4 family: a Mixture of Experts large language model with 1.6 trillion total parameters, 49 billion of them activated per token, and a one-million-token context window, built by the Hangzhou lab DeepSeek.^[1][8] It first shipped on April 24, 2026 as a preview alongside the smaller DeepSeek V4-Flash, with open weights on Hugging Face under the MIT License.^[1][9]

DeepSeek released DeepSeek-V4-Pro-0813 on August 13, 2026 as the general-availability build, replacing the April preview in its app, web service and deepseek-v4-pro API endpoint.^[10][24] The company also published the 0813 weights under MIT that day. The new checkpoint retains the preview's 1.6T-total, 49B-active model structure, folds in a DSpark speculative-decoding module, changes the hosted mapping so low now maps to a distinct low-effort tier, while high remains the default and max remains available, and supports the OpenAI Responses API.^{[10][12][24][26]} DeepSeek describes its large agent-benchmark gains as a result of the new release, but those figures remain vendor-run and harness-dependent; a separate Artificial Analysis evaluation reports a methodology-bound gain on its own composite index.^[16][24][28]

Scroll sideways for more →

The DeepSeek V4 article covers the family as a whole, including the V3 lineage, market reception and the wider industry argument the release started. This page is about the Pro model itself.

Release and current status

DeepSeek announced the V4 series on April 24, 2026 with the line "1M context is now the default across all official DeepSeek services," describing V4-Pro as offering "performance rivaling the world's top closed-source models" and V4-Flash as "your fast, efficient, and economical choice."^[9] Both were explicitly preview builds. The April Pro model card opened with "We present a preview version of DeepSeek-V4 series," and its repository remained the reference instruct checkpoint through July.^[2][4]

On July 31 DeepSeek re-post-trained Flash, published the DeepSeek-V4-Flash-0731 weights, and reported that the 13-billion-active model beat the 49-billion-active Pro preview on nine agent-oriented rows.^[10][18] The same change-log entry said the official Pro build would follow soon. That inversion was real for the two named checkpoints, but it lasted less than two weeks and should not be read as a standing comparison between current models.

The August 13 entry closed the preview period. It says the GA build was rolled out to the app, web service and API while keeping the deepseek-v4-pro API name.^[10] The corresponding Hugging Face repository identifies DeepSeek-V4-Pro-0813 as the official release, says it supersedes the preview, and carries MIT-licensed weights created that day.^[24][26] DeepSeek did not publish a new V4 technical report or claim a new core architecture. It describes 0813 as using the preview model structure with a DSpark speculative-decoding module attached.^[24]

Scroll sideways for more →

The old April repositories remain available for reproduction. That matters because many benchmark tables, third-party measurements and deployment instructions still use the unversioned DeepSeek-V4-Pro preview repository. A claim about "V4-Pro" therefore needs either a build date or a repository identifier.

Architecture

V4-Pro and V4-Flash share one architecture and differ in scale. The three changes the technical report foregrounds are a hybrid attention design pairing Compressed Sparse Attention (CSA) with Heavily Compressed Attention (HCA), Manifold-Constrained Hyper-Connections (mHC) in place of ordinary residual connections, and the Muon optimizer for the bulk of the parameters.^[8] Both are treated in depth at DeepSeek V4; what follows is what the Pro checkpoint specifically declares.

What the shipped configuration declares

The config.json files in the preview and 0813 repositories are the most precise public descriptions of the model. The 0813 file preserves the core dimensions below and adds fields for the attached DSpark module.^[3][25]

Scroll sideways for more →

Positional encoding is YaRN rope scaling by a factor of 16 from an original 65,536-token window up to the full 1,048,576, with beta_fast 32 and beta_slow 1.^[25] Routing uses the noaux_tc top-k method with a sqrtsoftplus scoring function and a routed scaling factor of 2.5. Two of the training-stability mechanisms described in the technical report are visible as plain fields: swiglu_limit is set to 10.0, matching the SwiGLU clamping the paper describes, and hc_mult is 4 with hc_sinkhorn_iters 20, matching the mHC residual-stream expansion factor and the Sinkhorn-Knopp iteration cap.^[8][25] The DeepSeek Sparse Attention indexer that CSA depends on is configured with 64 heads, a head dimension of 128 and a top-k of 1,024 blocks.

The GA config also declares num_hash_layers: 3, dspark_target_layer_ids: [58, 59, 60], a block size of 5, Markov rank 512 and noise token ID 128799.^[25] Those fields describe the attached draft mechanism, not three newly trained transformer layers in the 1.6T target model. Neither the card nor the config discloses a different total or active parameter count for the target model.^[24][25]

The per-layer attention schedule

The preview configuration ships the attention schedule as an explicit 62-entry compress_ratios array: 61 core transformer entries followed by one auxiliary zero. The 0813 configuration instead has 64 entries: the first 61 preserve the same core pattern, while the last three are zeros associated with the three declared hash layers.^[3][25]

[128, 128, 4, 128, 4, 128, ... , 4, 128, 4, 0, 0, 0]

For the 61 core layers, layers 0 and 1 compress by 128 and layers 2 through 60 alternate 4 and 128.^[25] A ratio of 128 is HCA, which consolidates every 128 tokens into one key-value entry and attends densely over that compressed sequence. A ratio of 4 is CSA, whose learned compressor folds every four tokens into one entry before the sparse indexer selects the top 1,024 blocks.^[8] The three trailing zero entries in the GA file align with num_hash_layers: 3; the configuration does not label them as ordinary target-model attention layers. This distinction avoids inflating the reported 61-layer architecture when describing DSpark.

Efficiency

The point of the arrangement is the cost of a long context. The technical report states that at a one-million-token context DeepSeek-V4-Pro requires only 27 percent of the single-token inference FLOPs and 10 percent of the KV cache of DeepSeek V3.2.^[1][8] DeepSeek presents these figures as inference-efficiency results; the cited report does not quantify their contribution to hosted API pricing. Flash goes further on both counts, which is one reason the two models sit at very different price points despite sharing an architecture.

Precision and quantisation

V4-Pro ships in what DeepSeek calls FP4 + FP8 Mixed precision: MoE expert parameters in FP4, most other parameters in FP8.^[1] The quantization_config block declares FP8 E4M3 weights in 128 by 128 blocks with UE8M0 scales, and expert_dtype is set to fp4.^[3] The base checkpoint, DeepSeek-V4-Pro-Base, is FP8 throughout with no FP4 experts, which is why it is nearly twice the size on disk.^[1][5]

The FP4 experts are what DeepSeek ships and expects you to run, not a convenience quantisation of some other reference copy. Running them in FP8 instead is possible, but it means converting the weights first: the bundled instructions are to remove the "expert_dtype": "fp4" line from config.json and add --expert-dtype fp8 to convert.py, which also takes an expert count and a model-parallel degree. DeepSeek's own example sets that degree to 8, and launches inference with torchrun --nproc-per-node 8.^[22]

Variants and repositories

DeepSeek now publishes four Pro repositories with two different instruct builds. The unversioned instruct, Base and DSpark repositories preserve the April preview lineage. The versioned 0813 repository is the GA instruct checkpoint.^{[4][5][6][26]}

Scroll sideways for more →

The sizes above sum the current safetensors shard files rather than Hugging Face's usedStorage field, which can include repository history. The 0813 model record lists 66 shards, SHA 72e1d3230f6c080a530b0a1d46f8eb4602340597, and a creation time of 03:05 UTC on August 13.^[26][32] Its roughly 893 GB payload is about 28 GB larger than the preview instruct checkpoint because it carries the draft module.

DSpark remains a speculative-decoding attachment rather than a second target language model. The June repository says it is the same preview checkpoint with an additional module.^[7] DeepSeek presents it within DeepSpec alongside DFlash and EAGLE-3.^[7] The 0813 card likewise says the GA build uses the preview model structure with DSpark attached, although its post-training weights are the newer 0813 release.^[24] Under vLLM it is enabled with a dspark speculative configuration and seven speculative tokens; SGLang reads target and draft weights from the fused checkpoint without a separate draft-model path.^[24]

Reading the parameter count

Hugging Face's tensor-element total is not the same thing as the target model's parameter count once a draft module is fused into the repository. The April preview instruct weights contain 1,598,839,674,782 recorded tensor elements, while both DSpark-bearing repositories report 1,650,497,936,906.^[4][6][26]

Scroll sideways for more →

The preview instruct model's expert and non-expert FP8 tensor counts sum to 1,595,932,672,000, exactly the base checkpoint's FP8 element count.^[4][5] The roughly 51.7 billion extra elements in each fused DSpark repository belong to the attached draft machinery, so quoting 1.650T as the target model's size would overstate it. DeepSeek continues to report 1.6T total parameters and 49B active per target token.^[24] The 0813 release changes post-training and the included decoder, not that advertised scale.

Inference configuration

Reasoning modes

The GA API exposes non-thinking mode and three thinking effort levels. In the OpenAI-format API, reasoning_effort accepts low, high or max; in the Anthropic format, output_config.effort accepts the same values. The Responses API form accepts none to disable thinking. Thinking is enabled by default at high.^[12]

For the 0813 build the requested-to-actual mapping is identical for Pro and Flash:^[12]

Scroll sideways for more →

The effort mapping quirk

This replaces a preview-era quirk in which Pro silently promoted low to high. Callers that use medium or xhigh still receive high effort, so those names are compatibility aliases rather than separate compute tiers. DeepSeek recommends allowing up to 384K output tokens for high and max when self-hosting.^[24]

Other API behaviour

Thinking mode ignores temperature, top_p, presence_penalty and frequency_penalty; DeepSeek accepts them without error for compatibility but documents that they have no effect.^[12] Reasoning content has a rule of its own: if an assistant turn made no tool call, its intermediate reasoning_content need not be returned with the next user message. If it made a tool call, that reasoning content must be passed back on subsequent requests in the same tool-use turn, or the API can reject the request.^[12]

The official weights still ship no Jinja chat template. Instead, the repository provides an encoding directory with functions that encode OpenAI-compatible messages and parse completions.^[24] For local serving DeepSeek recommends temperature = 1.0, top_p = 0.95 for agentic work and top_p = 1.0 otherwise. Those sampling recommendations apply to local inference; they do not contradict the hosted thinking-mode documentation, where the corresponding parameters are ignored.^[12][24]

DSpark is optional at serving time. The card gives vLLM and SGLang flags for enabling it, but does not publish an 0813 acceptance rate, speedup, latency distribution or task-quality comparison with DSpark disabled.^[24] It is therefore accurate to describe the mechanism as included and supported, not to promise a particular speedup.

Benchmark record

DeepSeek publishes three separate sets of numbers for V4-Pro, and they are not interchangeable. Base-model figures come from the pre-training checkpoint with few-shot prompting and no reasoning. Instruct figures are labelled by reasoning mode, and the headline comparisons use Think Max. The base checkpoint scores 73.5 on MMLU-Pro and the instruct model in Think Max scores 87.5; they are different artifacts, and quoting one under the other's name is wrong by fourteen points.^[1]

Base model

DeepSeek-V4-Pro-Base against its own predecessor and its smaller sibling, all evaluated with the shot counts shown.^[1]

Scroll sideways for more →

Two of these rows are worth pausing on. The jump on knowledge-recall tests is the largest in the table: SimpleQA Verified nearly doubles from V3.2-Base to V4-Pro-Base, and FACTS Parametric more than doubles. The table does not isolate whether these gains come from scale, data, training compute, or other training choices. Against that, V4-Pro-Base loses to V3.2-Base on BigCodeBench and to V4-Flash-Base on MGSM and CMath, so the scaling is not uniform.

Instruct model against frontier competitors

The comparison DeepSeek published at launch, with V4-Pro in Think Max mode.^[1]

Scroll sideways for more →

V4-Pro-Max leads the table on three rows: LiveCodeBench at 93.5, the Codeforces rating at 3206, and Apex Shortlist at 90.2. The Codeforces figure was the highest value in DeepSeek's April comparison table, above GPT-5.4 xHigh's 3168 and Gemini 3.1 Pro's 3052. It is roughly tied with the field on SWE-bench Verified and on BrowseComp, and it is behind on the two long-context retrieval rows, on Terminal-Bench 2.0, and on Humanity's Last Exam both with and without tools. DeepSeek's own summary in the technical report is that V4 "falls marginally short of GPT-5.4 and Gemini-3.1-Pro, suggesting a developmental trajectory that trails state-of-the-art frontier models by approximately 3 to 6 months."^[8]

Note that the competitor columns are the versions DeepSeek benchmarked in April 2026. Anthropic, OpenAI, Google, Moonshot AI and Z.ai have all shipped successors since, including Claude Opus 4.8, Kimi K3 and GLM-5.2, so the table is a snapshot of a moment rather than a current standing.

What the reasoning modes are worth

The same card publishes each benchmark across all three effort levels, which is the clearest picture of what Think Max is actually buying.^[1]

Scroll sideways for more →

Most of the distance is between Non-Think and High, not between High and Max. On the mathematics and competition rows the gap is enormous: HMMT goes from 31.7 to 94.0 simply by turning thinking on, and Apex from 0.4 to 27.4. Max then adds anywhere from nothing to eleven points on top of High, depending on the task: SimpleQA Verified gains 11.7, Apex 10.9 and LiveCodeBench 3.7, while MMLU-Pro gains 0.4 and MRCR 0.2. One row goes backwards: MCPAtlas is 74.2 at High and 73.6 at Max. The marginal gain from Max varies by benchmark. The table does not report per-mode token use, latency, or cost, so it does not establish which setting is best for most workloads. DeepSeek documents High as the default.^[1][12]

The July 2026 inversion

On July 31, 2026 DeepSeek published nine agent-oriented scores for the re-post-trained Flash build against the April preview checkpoints. V4-Pro-Preview lost every row.^[10][18]

Scroll sideways for more →

That table remains useful as a historical account of why the official Pro release mattered, but it no longer compares the current products. It also used DeepSeek Harness minimal mode, max effort, temperature = 1.0 and top_p = 0.95 for public code-agent tasks. At the time the harness was unreleased; DeepSeek published it under MIT in developer preview on August 13.^[18][27] Its repository warns that compatibility-breaking changes are expected, so reproducing a run also requires pinning a harness revision and its plugins.

August 2026 general-availability results

DeepSeek's 0813 model card reports the following max-effort results. They are first-party measurements, not submissions to a single independent leaderboard.^[24]

Scroll sideways for more →

The model card's footnotes constrain how to read the table. Public code-agent tasks used DeepSeek Harness minimal mode with max effort, temperature = 1.0 and top_p = 0.95.^[24] Agent scores combine model, prompt, tool policy, retry behavior and harness implementation. Terminal-Bench 2.1 itself contains 89 terminal tasks and reports agent success, not a context-free property of the underlying model.^[28][30] DSBench-FullStack and DSBench-Hard are internal DeepSeek sets, so their examples, contamination controls and grading cannot be independently audited.^[24]

DeepSeek also placed newer proprietary models in its table, but those columns remain vendor-run comparisons under its setup. The 0813 result does not establish that the model categorically outperforms any competitor across workloads. For example, DeepSeek's own rows have Pro-0813 below Kimi K3 on Terminal Bench 2.1, below Opus 4.8 on HLE without tools and NL2Repo, and above those particular models on other rows.^[24]

Independent measurement

Artificial Analysis evaluated DeepSeek V4 Pro 0813 at max effort and reports 53.20, displayed as 53, on Intelligence Index v4.1.1.^[16] Its launch post described that as about eight points above its recalculated April Pro result and about one point above Flash-0731, while also noting a 3.6-fold increase in its blended price comparison.^[31] Those are differences within the operator's index and pricing convention, not an eight-point increase in universal intelligence or a uniform 3.6-fold rise in every token rate.

The index is an operator-designed, text-only English composite of nine evaluations. Its published weights assign 34 percent to agents, 24 percent to coding, 24 percent to scientific reasoning and 18 percent to general reasoning and knowledge. It uses pass@1 scoring, permits up to 30 API retries, and says the overall index has an estimated 95 percent confidence interval narrower than plus or minus one point based on repeated runs of selected models, while individual evaluations may be wider.^[28] Version 4.1.1 also changed datasets and graders, so current scores for the April build need not equal values recorded under v4.1.

Scroll sideways for more →

The GDPval number is an Elo rating from 1,989 pairwise matches, not an accuracy percentage. Artificial Analysis's model record gives a 95 percent interval from 1568.77 to 1611.26, so close rank ordering should not be treated as exact.^[16][28]

AA-Omniscience deserves separate wording because its "hallucination rate" is not simply one minus accuracy. For Pro-0813, Artificial Analysis reports 49.10 percent accuracy and a 94.83 percent hallucination rate.^[16] The benchmark paper defines the latter as incorrect answers divided by partial, incorrect and abstained answers, excluding correct answers from the denominator. Its Omniscience Index is 100 * (correct - incorrect) / total, which yields 0.83 here.^[29] The public model record does not expose an attempt-rate field, so this article does not infer or report one. The paper also notes English-language and Anglophone sampling limits and reliance on automated generation and grading.^[29]

Artificial Analysis counted 887,047,761 input tokens and 127,800,047 output tokens in the full sweep, including 119,336,817 reasoning tokens and 8,463,230 answer tokens.^[16] At the price fields used on its page, the run cost $604.51, or about $0.252 per weighted task. The operator reports median output speed of 89.66 tokens per second and 1.82 seconds to the first chunk from DeepSeek's first-party API. For its long-prompt sample, median time to first answer token was 24.12 seconds and median end-to-end time was 29.70 seconds.^[16] These medians describe Artificial Analysis's prompts, provider route and run period. They are not guaranteed service-level figures.

The page prices its run using $1.32 per million uncached input tokens, $0.044 per million cache hits and $3.96 per million output tokens, which match DeepSeek's scheduled peak rates effective August 16.^[11][16] As of August 15, those were not yet the API's standing rates. That timing difference should be kept with the cost comparison.

Pricing

DeepSeek's first-party API is changing price schedules one day after this article's evidence cutoff. Through 15:59 UTC on August 16, 2026, the pricing page still lists the flat rates below for Pro.^[11]

Scroll sideways for more →

The peak pricing that has not arrived

At 16:00 UTC on August 16, peak/off-peak billing takes effect. Peak hours are 01:00 to 04:00 and 06:00 to 10:00 UTC; all other hours are off-peak.^[10][11]

Scroll sideways for more →

The change is not a uniform multiplier. Relative to the preceding flat schedule, cache-hit input rises about 6.1 times off-peak and 12.1 times at peak, cache-miss input rises about 1.52 times and 3.03 times, and output rises about 2.28 times and 4.55 times. Artificial Analysis's "3.6x" launch summary is therefore best understood as its blended comparison rather than a description of every billing item.^[11][31]

Cache-hit pricing remains automatic: DeepSeek applies context caching itself instead of requiring caller-declared cache keys. Under the old schedule a cache hit costs one 120th of a miss. Under the new schedule the hit discount is about 96.7 percent in either period. Whether a workload becomes cheaper or more expensive depends on its cache-hit ratio, input/output mix and execution time.

How it got here

V4-Pro's price history has three distinct phases.

Scroll sideways for more →

The word "permanent" in the May announcement described the then-current discount, not an immutable lifetime price. The August schedule supersedes it on a published effective date. For how these rates sit against other vendors, see LLM API pricing comparison.

Availability

API

deepseek-v4-pro is served from https://api.deepseek.com for OpenAI ChatCompletions-format calls and from https://api.deepseek.com/anthropic for Anthropic Messages-format calls.^[9][11] The stable API identifier now resolves to DeepSeek-V4-Pro-0813. DeepSeek also lists JSON output, tool calls, prefix completion, FIM in non-thinking mode, the Anthropic API and the OpenAI Responses API as supported features.^[11]

The concurrency limit remains 500 simultaneous requests per account, compared with 2,500 for Flash. Limits are counted per account rather than per API key; exceeding them returns HTTP 429. DeepSeek documents optional capacity expansion and per-user_id scheduling isolation.^[19]

Responses API support is no longer a Flash-only preview feature. DeepSeek's August 13 change log says V4-Pro is natively supported and specifically adapted for OpenAI Codex, while the pricing matrix marks the feature for both V4 models.^[10][11] The Claude Code route continues to use the Anthropic-format endpoint.^[23]

Weights

The GA instruct weights are public in deepseek-ai/DeepSeek-V4-Pro-0813 under MIT, which permits commercial use, redistribution and modification subject to the license notice.^[24][26] They include the DSpark module and differ from the April preview instruct weights. The April Base repository remains the only published Pro pre-training checkpoint; DeepSeek has not labelled it an 0813 base model.^[5]

The 0813 card supplies encoding code, a basic local inference implementation, vLLM and SGLang launch examples, and the full 66-shard checkpoint.^[24] It does not publish the post-training dataset, reinforcement-learning recipe, per-stage compute, or production traffic evaluation behind the claim that gains are "especially pronounced in production environments." That phrase remains a vendor characterization rather than an independently reproduced production study.

Hardware requirements

V4-Pro remains a datacentre-scale model to self-host. The 0813 checkpoint is 892,744,322,880 bytes across 66 shards before KV cache, runtime buffers and replicated dense parameters are allocated.^[26][32] The April Base checkpoint is roughly 1.61 TB.^[5]

The 0813 model card gives a single-node example on 4 GB300 GPUs, using data parallelism 4, expert parallelism, an FP8 KV cache, the deep_gemm_mega_moe backend and DSpark.^[24] This is the lowest GPU count in DeepSeek's own GA card, but GB300 is a current datacentre accelerator, not a consumer GPU. The example is a launch configuration, not a published throughput, concurrency or full-context validation report.

The independently maintained vLLM recipe provides broader configurations and was updated August 14.^[14] It lists 8 B300 GPUs for a single-node data-plus-expert-parallel setup; 8 H200s with context capped at 800K to leave KV headroom; 8 MI355X GPUs under ROCm; and two 4-GPU GB200 trays because the mixed-precision checkpoint does not fit on one tray. The recipe distinguishes the fused 0813/DSpark checkpoints, which need vLLM 0.25.0, from its 0.20.0 baseline for older variants.^[14]

SGLang's cookbook supplies separate hardware and workload presets.^[21] The 0813 card's SGLang example uses four GB300 GPUs, tensor parallelism 4, the FlashInfer MXFP4 MoE runner and fused DSpark.^[24] As with the vLLM paths, achievable context, throughput and concurrency depend on memory reserved for KV cache and serving overhead.

The correct practical conclusion is narrower than the old "eight GPUs" rule. DeepSeek documents one 4xGB300 configuration, while vLLM documents several 8-GPU or multi-node alternatives. Nothing in these sources supports running the full official checkpoint on a typical workstation or laptop.

Limitations

Post-training disclosure is thin. DeepSeek documents the core architecture in its April report and says 0813 uses the same structure, but it does not disclose the GA post-training corpus, data filters, training compute, ablation studies or detailed production evaluation.^[8][24] The scale of the reported agent gains therefore cannot be assigned to a specific reproducible training change.

Vendor agent scores depend on a young harness. Public code-agent tasks used DeepSeek Harness minimal mode at max effort, and the harness itself is in developer preview with compatibility-breaking changes expected.^[24][27] Two DSBench rows are internal and cannot be audited from public task data.

Independent evidence is narrower than the launch table. Artificial Analysis confirms a gain on its v4.1.1 composite, but that index is English, text-only and weighted 58 percent toward agents and coding.^[16][28] Its score should not be presented as an objective overall-intelligence measure or as evidence for every production workload.

Text only. The official API and independent model record list text input and text output, with no image, audio or video modality.^[11][16]

Verbosity and cost. Artificial Analysis counted 127.8 million output tokens and $604.51 for its index run at the price fields on its model page.^[16] Max effort can improve agent scores, but token use is a material part of both latency and bill. The operator's values are specific to its task mix and should not be extrapolated linearly to unrelated workloads.

Knowledge reliability remains task-dependent. On AA-Omniscience the model record shows 49.1 percent accuracy and a 94.83 percent operator-defined hallucination rate.^[16][29] The unusual denominator excludes correct answers, so the number must not be paraphrased as "94.83 percent of all answers were hallucinations."

Long-context capacity is not uniform long-context quality. The official limit is 1,048,576 tokens and the API rounds it to 1M, but the April model card's MRCR and CorpusQA results already showed retrieval below some contemporaneous proprietary models.^[1] Hardware can also reduce the usable window: vLLM caps its H200 recipe at 800K.^[14]

Self-hosting is a datacentre exercise. The fused checkpoint is about 893 GB before runtime memory. DeepSeek's smallest published GA example uses four GB300 GPUs, and other documented configurations use eight accelerators or multiple nodes.^[14][24][32]

Price comparisons are time-sensitive. The old flat rates expire at 16:00 UTC on August 16, after which peak and off-peak prices differ by a factor of two. A comparison without its effective date, time band and cache assumptions can be wrong even when each quoted number once appeared on the same pricing page.^[11]

See also

• DeepSeek V4
• DeepSeek V4-Flash
• DeepSeek
• DeepSeek V3.2
• DeepSeek Sparse Attention
• Mixture of Experts
• Muon (optimizer)
• Speculative decoding
• FP4
• FP8
• Quantization
• Open weights
• MIT License
• vLLM
• SGLang
• Artificial Analysis
• Context caching
• LLM API pricing comparison
• Kimi K3
• GLM-5.2
• AI API cost and context planner
• AI model comparison finder

References

1. ^deepseek-ai/DeepSeek-V4-Pro model card, Hugging Face (accessed August 1, 2026)
2. ^deepseek-ai/DeepSeek-V4-Pro README.md, Hugging Face
3. ^deepseek-ai/DeepSeek-V4-Pro config.json, Hugging Face
4. ^Model record for deepseek-ai/DeepSeek-V4-Pro, Hugging Face API (accessed August 1, 2026)
5. ^Model record for deepseek-ai/DeepSeek-V4-Pro-Base, Hugging Face API (accessed August 1, 2026)
6. ^Model record for deepseek-ai/DeepSeek-V4-Pro-DSpark, Hugging Face API (accessed August 1, 2026)
7. ^deepseek-ai/DeepSeek-V4-Pro-DSpark model card, Hugging Face
8. ^DeepSeek-V4: Towards Highly Efficient Million-Token Context Intelligence, arXiv:2606.19348 (submitted April 26, 2026)
9. ^DeepSeek-V4 Preview Release, DeepSeek API Docs (April 24, 2026)
10. ^Change Log, DeepSeek API Docs (entries dated July 31 and August 13, accessed August 15, 2026)
11. ^Models & Pricing, DeepSeek API Docs (accessed August 15, 2026)
12. ^Thinking Mode, DeepSeek API Docs (accessed August 15, 2026)
13. ^The DeepSeek-V4-Pro discount has been extended until May 31, 2026, @deepseek_ai on X (April 29, 2026)
14. ^DeepSeek-V4-Pro deployment recipe, vLLM Recipes (updated August 14, accessed August 15, 2026)
15. ^DeepSeek permanently reduces the price of its flagship V4 model by 75 percent, Engadget (May 23, 2026)
16. ^DeepSeek V4 Pro 0813 (max): Intelligence, Performance & Price Analysis, Artificial Analysis (accessed August 15, 2026)
17. ^deepseek-ai models sorted by creation date, Hugging Face API (accessed August 1, 2026)
18. ^deepseek-ai/DeepSeek-V4-Flash-0731 model card, Hugging Face (accessed August 1, 2026)
19. ^Rate Limit & Isolation, DeepSeek API Docs (accessed August 1, 2026)
20. ^We are making our discount permanent, @deepseek_ai on X (May 22, 2026)
21. ^DeepSeek-V4 cookbook, SGLang documentation (accessed August 1, 2026)
22. ^deepseek-ai/DeepSeek-V4-Pro inference/README.md, Hugging Face
23. ^Integrate with Claude Code, DeepSeek API Docs (accessed August 1, 2026)
24. ^deepseek-ai/DeepSeek-V4-Pro-0813 model card, Hugging Face (released August 13, accessed August 15, 2026)
25. ^deepseek-ai/DeepSeek-V4-Pro-0813 config.json, Hugging Face
26. ^Model record for deepseek-ai/DeepSeek-V4-Pro-0813, Hugging Face API (accessed August 15, 2026)
27. ^deepseek-ai/deepseek-harness repository, GitHub (developer preview, accessed August 15, 2026)
28. ^Intelligence Benchmarking methodology v4.1.1, Artificial Analysis (accessed August 15, 2026)
29. ^AA-Omniscience: Evaluating Cross-Domain Knowledge Reliability in Large Language Models, arXiv:2511.13029
30. ^Terminal-Bench: Benchmarking Agents on Hard, Realistic Tasks in Command Line Interfaces, arXiv:2601.11868
31. ^DeepSeek V4 Pro 0813 Artificial Analysis results, @ArtificialAnlys on X (August 15, 2026)
32. ^File tree for deepseek-ai/DeepSeek-V4-Pro-0813, Hugging Face API (accessed August 15, 2026)