deepseek-v4-pro: DeepSeek V4 Pro, the 1.6T open-weight MoE flagship, as a metered API

deepseek-v4-pro is this platform's serving alias for DeepSeek V4 Pro, DeepSeek's flagship open-weight model: 1.6 trillion total parameters, about 49 billion active per token, a one-million-token context window, and MIT-licensed weights. The name needs unpacking twice this month. Once for version: the model shipped as a preview on April 24, 2026, and its general-availability release, the checkpoint the publisher calls DeepSeek-V4-Pro-0813, landed August 13, 2026. Once for lifecycle: from September 14, 2026, DeepSeek's own first-party API retires the name, rerouting it to a newer model, while the weights stay public. This page fixes both mappings with dated official sources, traces every spec number to its owner, and lays out the request shape you send here today. The console's invite flow is the way in while the platform is in beta, and this page is the preparation.

Last verified: 2026-09-11

What it is

DeepSeek V4 Pro is a sparse mixture-of-experts model: the full network holds 1.6 trillion parameters, but only about 49 billion fire on any given token, which is how a model this large answers at usable speed. The counts come from the preview repository's download table, the official statement of them; the GA card itself lists no parameter counts. Per the official GA card, DeepSeek-V4-Pro-0813 is the official release of DeepSeek-V4-Pro, superseding the preview version with greatly enhanced agentic capabilities, built on the preview structure with a DSpark speculative decoding module fused into the checkpoint. Speculative decoding means a small draft module guesses ahead and the big model verifies, so tokens arrive faster than the 49B-active core could write them alone.

The family map, because the name alone will not tell you which model answers:

One date matters more than the rest. Per the official change log, after 12:00 Beijing time on September 14, 2026 (04:00 UTC), and until the future release of V4.1 Pro, all requests to deepseek-v4-pro on DeepSeek's first-party API are routed to V4.1-Flash and billed at V4.1-Flash prices. The publisher's wording is that extensive testing shows the new model outperforming V4 Pro across performance, cost, speed, and total time. Nothing errors on that day and nothing warns; a different model starts answering under the same name. What the change does not touch is the weights: the preview, the GA checkpoint, and a Blackwell-optimized variant remain public under MIT licenses, the base training checkpoints sit alongside them, and third-party hosts keep serving the 0813 generation by checkpoint. A first-party retirement is an API-name event. The model itself stays alive anywhere someone chooses to serve it.

The specs that matter for planning, each with its owner:

A pair of rows call for plain words. The context window: the publisher's own configuration sets 1,048,576 tokens, and that is the number a buyer should treat as the model's. Provider directories show the same 0813 checkpoint served with output caps anywhere from 64K to the full window depending on the host, so when a ceiling matters to your workload, ask the specific endpoint what it serves. The modality row: this model reads and writes text. Vision belongs to the newer flash generation at the first party, not to this one, so image input is the wrong reason to be on this page.

Thinking control is a first-class feature of this generation. The GA release carries three effort levels, low for simple tasks, high for daily agent work, and max for hard problems, selected through the reasoning_effort control, with thinking on by default. One structural note for self-hosters, identical to the flash sibling's: the release ships no Jinja chat template. The repository provides an encoding folder whose scripts turn OpenAI-format messages into the model's input format and parse its output back, and serving stacks apply that encoding for you when configured for the DeepSeek V4 tokenizer. A hosted API absorbs this entirely.

On this platform the alias is deepseek-v4-pro, one chat lane among the chat catalog, with the models index tracking the catalog as it stands. The row is live; the page's numbers describe the 0813 GA release, the version the publisher's own table lists for this name and the checkpoint the row serves.

Use cases

The GA release exists for one headline, and the record supports it:

• Agentic coding and terminal work. The publisher's GA table puts the 0813 release at 87.9 on Terminal Bench 2.1 and 62.7 on DeepSWE, evaluated with a named harness at the max effort level, against the preview's 72.1 and 12.8. A jump that size inside one generation is rare, and it is the release's whole reason to exist.
• Tool-calling agents. The platform's chat route accepts and forwards the standard OpenAI tool shapes (tools, tool_choice), and this model's encoding keeps earlier reasoning turns in context when tools are in play, which is the behavior agent loops need to track multi-step work.
• Long-context reading. A million-token window holds whole repositories, long transcripts, or full document sets in one request. It is also where host shopping matters most, because a capped window is usually discovered mid-project.
• Knowledge-heavy work. The family's April announcement led with world knowledge, claiming the preview ahead of other open models of its day, and the GA release carries that posture forward. Treat it as the publisher's framing; the benchmark section below shows what is measured and what is claimed.
• What it is not. It is not a vision model, it is not the newer V4.1-Flash architecture, and at the first party its name now points at that newer model. None of that changes what the weights do.

After the cutover: who can still serve V4 Pro

September 14 removes the first-party lane, not the model. Three continuation paths exist, and the honest differences between them are the point.

Serve it yourself when the data must stay inside a boundary you control or you want to fine-tune the checkpoint. The tooling is real: MIT weights on Hugging Face and ModelScope, GGUF quantizations from the runtime vendors that publish them, and first-class support in the vLLM serving recipe, which walks the four published checkpoints (GA 0813, preview, the Blackwell NVFP4 variant, and the preview-plus-draft build). The floor is the story: about 893 GB of fused checkpoint, official recipes targeting eight-GPU nodes, an 800K context cap on one common GPU configuration, and a two-tray requirement on another. Community quantization guides put a 4-bit build near 870 GB of memory. This is the datacenter sibling; the flash model is the one that fits a serious workstation.

Use a third-party host when you want the model without the fleet. Provider directories list dozens of hosts serving the 0813 checkpoint today. The one check that matters is the one this page keeps repeating: confirm which checkpoint a host pins and what context and output ceilings it actually serves, because listings disagree with each other on this model family more than on any other.

Use this platform when you want the model by name on a metered route. The deepseek-v4-pro row is live here: per-token metering against a prepaid wallet, each response carrying its own cost line, immediate per-key revocation, and the invitation queue below standing open.

API usage

Calls go to POST /v1/chat/completions with a console-issued Bearer key, OpenAI-compatible in shape. The model id is deepseek-v4-pro. The route is live; what follows is the contract as it stands.

Three laws of this lane that save debugging time:

1. The examples carry no thinking knob, on purpose. The publisher documents three effort levels for this generation, low, high, and max, selected through reasoning_effort, plus a thinking toggle, with thinking on by default. This platform's contract accepts a top-level reasoning_effort parameter, with the values minimal, low, medium, and high accepted at the contract; a value outside the accepted set is rejected with a named parameter error. How those values map onto the publisher's three depths follows the platform contract, so the tabs show only what is guaranteed. Do not send the publisher's nested template fields yourself; nested bodies sit outside this platform's accepted surface and are answered with a named parameter error. The accepted set can also grow, so treat the table above as the current surface, not a frozen contract.
2. Thinking tokens are real output. When thinking is on, the model's reasoning is generated text: it is metered, it takes time, and the card recommends allowing up to 384K output tokens at the high and max levels. A max-effort run on a hard problem is a long run, so budget output headroom and client timeouts accordingly.
3. Every response carries its own receipt. The usage object on the reply holds the retail charge for that call, derived from the token counts, and the prepaid wallet is debited in the same transaction that logs the call. That wallet balance is the spending stop. Spend caps per key have not shipped; turning off one key is instant. The pricing page renders the rates from the catalog.

curl

curl -X POST "https://api.ironstratum.com/v1/chat/completions" \
  -H "Authorization: Bearer $KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-pro",
    "messages": [
      {"role": "user", "content": "Review this migration plan and list every step that breaks under concurrent writes."}
    ],
    "max_tokens": 4096
  }'

python

import os
import requests

resp = requests.post(
    "https://api.ironstratum.com/v1/chat/completions",
    headers={"Authorization": "Bearer " + os.environ["KEY"]},
    json={
        "model": "deepseek-v4-pro",
        "messages": [
            {"role": "user", "content": "Summarize this incident log and rank the three likeliest root causes."},
        ],
        "max_tokens": 8192,
    },
    timeout=600,
)
resp.raise_for_status()

message = resp.json()["choices"][0]["message"]
# When thinking is enabled on a lane, deliberation arrives in a
# separate reasoning field and the answer itself in content.
# Reasoning tokens are output tokens and are metered as such.
print("answer:", message["content"])
print("usage:", resp.json()["usage"])

openai-sdk

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.ironstratum.com/v1",
    api_key=os.environ["KEY"],
)

response = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[
        {"role": "user", "content": "Check the refund rules and draft the policy update section."},
    ],
    tools=[
        {
            "type": "function",
            "function": {
                "name": "search_docs",
                "description": "Search the internal handbook",
                "parameters": {
                    "type": "object",
                    "properties": {"query": {"type": "string"}},
                    "required": ["query"],
                },
            },
        }
    ],
    tool_choice="auto",
    max_tokens=8192,
)

message = response.choices[0].message
if message.tool_calls:
    call = message.tool_calls[0]
    print(call.function.name, call.function.arguments)
else:
    print(message.content)

An existing OpenAI-SDK integration transfers with two lines: the base URL and the model id. Integrations written against the publisher's own API transfer the same way, since that API is OpenAI-compatible too, with one difference worth repeating: at the first party the name deepseek-v4-pro stops answering as V4 Pro on September 14, while this platform's alias exists to serve this model by name.

Benchmarks

The evidence below comes in three layers, all labeled, all dated. Since the platform hosts nothing yet for this model, nothing here is our own measurement.

The publisher's GA table. Self-reported, from the official GA card, released August 13, 2026 and mirrored in the official change log. Methodology per the card: code-agent tasks ran with the minimal mode of DeepSeek's harness at the max effort level, temperature 1.0, top_p 0.95; the two DSBench rows are internal test sets, not public benchmarks.

Carry the label with you as you read: publisher-reported, reference configuration, comparators chosen by the publisher. The shape that holds up: a very large step over its own preview on every row, at or near the top of the published agentic set, with the hardest reasoning rows still going to the strongest proprietary models. The preview column doubles as version evidence: it is what a marketplace page pinned to April numbers shows you.

The independent point. The publisher's September 10 release note says testing by multiple parties puts the newer V4.1-Flash ahead of V4 Pro across performance, cost, speed, and total time, and that this is why the name retires. That is a vendor claim about its own models. One independent index has since scored the pair on the same scale with V4.1-Flash ahead on the composite measure; it is a single third-party datapoint, quoted here by class and date rather than linked, and it measures an aggregate, not any row above. The honest summary: the claim is plausible, partially verified, and your workload is the arbiter that matters.

Community calibration. The retirement is days old and the reaction is split in an informative way. A large community thread frames the change as a soft retirement and shops alternatives. The character and roleplay user base, which runs on this model heavily, reads the reroute as a forced downgrade. And practitioners of the newer flash class report coding-harness failure modes, loops, early terminations, and malformed tool calls, that reward disciplined harnesses or a larger model. Put together: if V4 Pro is your model, the open weights and the hosts that serve them are the path that keeps it answering, and any migration decision deserves your own regression run first.

Getting started

1. Register on the console. While the platform is in beta the invite flow is the way in: an open account can call every served model the day it appears.
2. Cut an API key. One per project is the working pattern, and each key is its own kill switch: an exposed key is revoked alone, the others unaffected.
3. Check the rate. Per-token rates live on the pricing page and the per-call cost field settles each response; the same catalog that meters the route renders those numbers, so nothing is retyped.
4. Make the first call. Take the curl tab, export KEY, and keep the opening request modest so the first response is quick. A working first call means the rest is just bigger messages payloads.

More chat lanes are rounded up on the chat category page, and the models index carries the platform's served map.