deepseek-v4-flash-0731: the July 31 GA snapshot of DeepSeek V4 Flash as a metered API

deepseek-v4-flash-0731 is this platform's serving alias for DeepSeek V4 Flash 0731, the general-availability release of DeepSeek's open-weight flash model, published July 31, 2026 under the MIT license. Its name carries a date because the V4 Flash family has shipped more than one snapshot, and buyers keep getting lost between them; fixing that mapping with dated official sources is this page's first job. Second is a spec sheet with every number traced to its owner, since host listings contradict the publisher's own configuration on context and output. Third is the request shape you send here today. The console's invite flow is how you get in while the platform is in beta, and the point of this page is arriving already prepared.

Last verified: 2026-09-11

What it is

DeepSeek V4 Flash 0731 is a sparse mixture-of-experts model: 284 billion total parameters, about 13 billion active per token, per the vLLM serving recipe and the major listings. Per the official model card, it is the official release of DeepSeek-V4-Flash, superseding the preview version with substantially enhanced agentic capabilities, and it carries the same structure as the DSpark checkpoint: a speculative decoding module ships fused inside the weights, which is how a 13B-active model answers fast enough to feel small.

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

Two dates matter for anyone holding old integration notes. On September 10, 2026, the publisher released V4.1-Flash and retired the V4 Flash and V4 Flash Vision Exp generations from its first-party API; the legacy model names deepseek-v4-flash and deepseek-v4-flash-vision-exp still parse there, but they route to V4.1-Flash, per the official change log. From September 14, 2026, the first-party deepseek-v4-pro name routes there too. None of that touches the open weights: 0731 remains the GA snapshot of V4 Flash that you download, fine-tune, or that a host serves by checkpoint. The official API never used the 0731 suffix. When a marketplace page says just "DeepSeek V4 Flash", you are looking at whichever snapshot that host pinned, and the only way to know is the checkpoint name.

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

Two table rows deserve plain handling. 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. One major marketplace advertises 1.3M for its 0731 page, and some endpoints cap context or output well below the card values, so host listings range roughly from 256K to 1.3M for the same checkpoint. Ask any door what it actually serves at the endpoints you will use. The modality row: this snapshot reads and writes text. The V4 generation's vision work lived in a separate experimental model that the publisher has since retired, and the new V4.1-Flash is the one with vision built in. If you need image input, this is the wrong row of the family table.

Thinking control on this model is a first-class feature, not a hidden flag. The card documents reasoning_effort with three levels: low, high, and max, which set how much deliberation the model spends before answering, and thinking is on by default. One structural note for self-hosters: this release ships no Jinja chat template. The repository provides an encoding folder with scripts that turn OpenAI-format messages into the model's input format and parse its output back, and serving stacks such as vLLM apply that encoding for you when configured for the DeepSeek V4 tokenizer. A hosted API absorbs this entirely; it is only visible if you run the raw weights.

Here the model serves under deepseek-v4-flash-0731 on the chat route, one lane in the chat catalog; the models index carries the catalog's current state. The row is live, and its metering is on.

Use cases

The card's own emphasis, and the record since release, point at the same jobs:

• Agentic coding and terminal work. This is the snapshot's headline. The publisher's table has it at 82.7 on Terminal Bench 2.1 and 54.4 on DeepSWE, evaluated with a named harness at the max effort level, and the jump over the preview (61.8 and 7.3 on the same rows) 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 post-training was aimed at long tool chains: the encoding spec keeps earlier reasoning turns when tools are in play, which is the behavior agent loops need.
• Long-context reading. A million-token window holds whole repositories, long transcripts, or document sets in one request. This is also where host shopping matters most: window caps below the card values are common, and a capped window is discovered at the worst time, mid-project.
• Fast-start text chat. One independent router's dated traffic medians put the snapshot at 541 milliseconds to first token across its endpoints, quick for the class; treat that as one router's measurement, not a guarantee, and expect host variance.
• What it is not. It is not a vision model, it is not the V4 Pro tier (deeper reasoning, heavier compute), and it is not the new V4.1-Flash architecture. Benchmarks below put honest bounds on all of that.

Local weights or a hosted lane: the honest split

The MIT license makes self-hosting a genuine option here, and for some readers it is the right one.

Run it locally when traffic is steady, the data must stay inside a boundary you control, or you want to fine-tune the snapshot. The tooling is real: LM Studio ships it as both a local download and a cloud model, Unsloth publishes GGUF quantizations and training support, and the community floor is roughly a 128 GB unified-memory machine on 2-bit-class quants, with about 104 GB of quantized weights to pull. Two cautions from the serving recipe: DSpark speculative decoding needs vLLM 0.25.0 or newer, and the raw release needs the encoding scripts or a stack that applies them.

Call a hosted lane when traffic is bursty or occasional, you want the full window without cap surprises, or you want metering wrapped around the model: the cost of each call stamped on its response, a prepaid wallet as the backstop, and per-key revocation. That set of services is what a hosted platform actually contributes for the model. The lane here is open, and the Getting-started steps below get you calling it.

API usage

The route will be POST /v1/chat/completions, Bearer-keyed from the console, OpenAI-compatible in shape. The model id is deepseek-v4-flash-0731. This section is the live shape: the registry listing is on, and the alias answers on this route today.

Three laws of this lane that save debugging time:

1. The thinking knob is reasoning_effort, top-level. The publisher's own ladder for this snapshot is low, high, max, and the publisher's API documents how requested efforts map to actual depth: minimal maps to low, medium to high. The platform contract accepts minimal, low, medium, and high at this parameter, and the publisher's mapping above, minimal to low and medium to high, is the documented reference for how those values reach the model's depths. Do not send the model's raw template fields yourself; nested template keys fall outside the accepted surface and draw a named parameter error. The accepted set can also grow, so read the list above as the current surface rather than a frozen one.
2. Reasoning arrives separated. When thinking is on, the model's reasoning text comes back in a reasoning_content field, distinct from the answer in content. Budget for it: reasoning tokens are output tokens and meter as such, and the card recommends allowing up to 384K output tokens at the high and max levels, so a max-effort run on a hard problem is a long run.
3. Every response carries its own cost. Inside the usage object sits the retail charge for that call, worked out from the token counts. The same transaction that records the call debits the prepaid wallet, and that balance is what halts spending. Per-key spend caps are roadmap; revoking a single key ships now. Rates render on the pricing page straight 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-flash-0731",
    "messages": [
      {"role": "user", "content": "Summarize this build log in three bullets: test timeout on shard 4, flaky retry, green on rerun"}
    ],
    "reasoning_effort": "low",
    "max_tokens": 512
  }'

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-flash-0731",
        "messages": [
            {"role": "user", "content": "Find the off-by-one bug in this loop and explain the fix."},
        ],
        "reasoning_effort": "high",
        "max_tokens": 8192,
    },
    timeout=300,
)
resp.raise_for_status()

message = resp.json()["choices"][0]["message"]
# With thinking on, the deliberation lands in reasoning_content
# and the answer itself in content. Reasoning tokens are metered.
print("reasoning:", (message.get("reasoning_content") or "")[:400])
print("answer:", message["content"])

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-flash-0731",
    messages=[
        {"role": "user", "content": "Check the shipping rules and draft the refund policy 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",
    reasoning_effort="medium",
    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 integration already on the OpenAI SDK moves with two lines: the base URL and the model id. The publisher's own first-party API is OpenAI-compatible too, so integrations written against it transfer the same way, with one difference worth repeating: the official alias deepseek-v4-flash now serves V4.1-Flash there, while this platform's alias pins the 0731 snapshot by name.

Benchmarks

Three evidence layers follow, every one labeled and dated. No lane serves this model here yet, so none of these numbers are our measurement.

The publisher's card. Self-reported, from the official model card, released July 31, 2026. Methodology per the card: code-agent tasks were run 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.

Read it with the label attached: publisher-reported, reference configuration, comparators chosen by the publisher. The shape that holds up across sources: a very large step over its own preview, ahead of the V4 Pro preview on every agentic row the publisher published, and competitive with the strongest proprietary models on terminal and tool work while trailing them on the hardest rows.

Independent verification. ARC Prize's verified results put the snapshot at 89.0 percent on ARC-AGI-1 Semi-Private and 61.4 percent on ARC-AGI-2 Semi-Private, both at the max effort level. This is a third party running the model, not the publisher grading itself. On the independent index side, one router's dated comparison has the snapshot behind GLM-5.3 Flash on aggregated intelligence and coding indexes while holding a first-token speed advantage on its own traffic; aggregated indexes are one lens, not a verdict.

Community calibration. The reception is genuinely split, which is itself information. One widely read hands-on report describes the snapshot persisting through a messy web-debugging task to a real fix where the previous Pro tier had pointed the author in wrong directions. A counter-thread calling the model overhyped draws real discussion too, and local-measurement tables show modest generation speeds on 128 GB-class hardware (tens of tokens per second), a useful reminder that the hosted experience and the local one are different products. If a workload matters, run it on your own tasks, on this platform or any other.

Getting started

1. Open an account on the console. Registration runs through the invite flow while the beta lasts: an open account can call every served model the day it appears.
2. Issue an API key. The intended shape is one key per project, each an independent off switch: revoke a compromised key and the rest keep serving.
3. Check the rate. The three token legs, input, cached input, and output, are priced on the pricing page, with the usage.cost field tracking the accrual call by call; the catalog-rendered table is the commitment.
4. Make the first call. Lift the curl tab, put your key in KEY, and hold the first request small at a low reasoning effort so the reply lands fast. Once one call returns, scaling is only a matter of a longer messages array.

The rest of the chat catalog sits on the chat category page; the models index tracks what the platform serves.