DeepSeek V4 Flash 0731 is the re-post-trained official release of DeepSeek's efficient V4 Flash mixture-of-experts model — 284B total / 13B active parameters, identical in architecture and size to the April V4 Flash release, with the post-training redone from scratch. It serves a 1M-token context window with up to 384K output tokens, supports both thinking and non-thinking modes (thinking on by default) plus JSON output and tool calls, and natively speaks the Responses API with a targeted adaptation for Codex-style coding agents. The 0731 revision is a major step up in agent capability, outscoring even DeepSeek V4 Pro Preview on DeepSeek's published agent benchmarks — 82.7 on Terminal Bench 2.1, 76.7 on Cybergym, 70.3 on Toolathlon Verified, 54.4 on DeepSWE, and 54.2 on NL2Repo. On the DeepSeek first-party API this revision is what the deepseek-v4-flash model id now serves; the dated identifier lists the same revision for callers that reference it by date. It is a strong pick for coding agents, terminal and tool-use workloads, and high-volume agentic pipelines at flash-tier cost.
DeepSeek V4 Flash 0731 is a text-only language model from the provider deepseek, available through OrcaRouter at the model ID deepseek/deepseek-v4-flash-0731. Its headline specifications are a…
Input is limited to text. The context window is 1,048,576 tokens, and the maximum output is 384,000 tokens per response. That is a large workspace: you can read about one million tokens of content before generating, and you can request up to 384,000 tokens of output in a single call. The model card lists these as two separate caps; it does not state a combined limit for a request that uses both near-maximums. In practice, to stay within limits, count your tokens before sending and set max_tokens below the output cap. The text-only constraint also means you must convert PDFs, spreadsheets, and other documents to plain text first. Tokenization is not specified in the available facts, so test representative content to see how large your prompts become. If your request exceeds 1,048,576 input tokens, the API call will fail; the same applies to outputs over 384,000 tokens.
Given the listed specifications, the model is best suited for tasks that combine long text inputs, long text outputs, and terminal-oriented agentic reasoning. The 82.7 Terminal Bench 2.1 score is evidence of strength in command-line task completion, where a model reads shell output and decides the next command. The 1,048,576-token context supports whole-repository analysis, multi-file code review, long legal or technical documents, and extensive chat histories. The 384,000-token output supports generating long structured documents, synthetic datasets, or step-by-step analyses in a single pass. The per-token pricing of $0.15 input and $0.29 output per million tokens makes high-volume text processing financially predictable. The model is less appropriate when you need image understanding, audio transcription, or very low latency, none of which are covered by the provided facts. If your task fits the text-only, large-context, large-output profile, this is a reasonable candidate to evaluate through OrcaRouter.
The model cannot accept non-text inputs; there is no vision, audio, or video modality in its catalog entry. It also has no published latency or streaming guarantees in the available facts. You should pick a cheaper model when your workload does not need the large context or output limits. For example, a short chatbot exchange that uses a few thousand tokens would still be billed at the same per-token rate but might be better served by a model with a smaller context and a lower price per million tokens. The available facts do not list prices for alternatives, so compare per-1M-token rates in the OrcaRouter catalog. If your task is simple classification or summarization of short passages, a cheaper model may be sufficient. If your task needs the full 1M context or 384K output, or benefits from the Terminal Bench 2.1 strength in command-line work, then this model's price is the relevant basis for evaluation.
Every input must be text. PDFs, images, spreadsheets, and audio files need to be converted to plain text or transcribed before they can be sent. That is a necessary preprocessing step, but it also simplifies the request format: standard OpenAI-style content fields containing strings are all you need. The 1,048,576-token context means you can pass long bodies of converted text in one request; the 384,000-token output means you can receive very long text back. Token count is the main operational concern, since the total bill depends on input and output tokens. OrcaRouter reports usage in the OpenAI-compatible response, letting you monitor both numbers. If you are working with languages or code that tokenize inefficiently, your effective context will shrink because token counts, not characters, are the bounding limit. No tokenizer details are provided, so run a quick test with your own content to learn typical token lengths.
Terminal Bench 2.1 evaluates a model's ability to work in a terminal environment: understanding command output, navigating directories, executing commands, and completing realistic system-administration or software-engineering tasks through a shell. The headline score for DeepSeek V4 Flash 0731 is 82.7, on a scale where higher is better. This is the single benchmark result supplied in the available facts. The score is a useful signal if you plan to build agent loops that issue shell commands, since the benchmark is designed to test exactly that kind of capability. It is not a measure of general knowledge, creative writing, mathematics, or multilingual competence. No comparison baselines or other benchmark numbers are provided, so the 82.7 should be interpreted in context: strong evidence for terminal-related tasks, and no evidence either way for other domains. Benchmark scores depend on the exact task distribution, so your own terminal tasks may score differently; validate with your own evaluation before production use.
The available facts for DeepSeek V4 Flash 0731 do not include tokens per second, time to first token, p95 latency, or throughput. The name Flash hints at a lighter variant, but the provided facts do not quantify speed. What the facts do include is a large context window of 1,048,576 tokens and a large output cap of 384,000 tokens. Longer inputs and outputs inherently consume more compute, so latency on full-context requests will likely be higher than on short prompts, even for a fast model. The $0.15/$0.29 per-million-token pricing describes cost, not speed. To make an informed decision, run your own load test against OrcaRouter's API with representative prompts of the size you intend to use, and compare time-to-first-token and total duration against other models in the catalog. Do not extrapolate latency from the benchmark score, which does not measure response time.
The main limitations are visible from the listed facts. It is text-only, so any multimodal input is out of scope. The benchmark evidence is limited to one score, 82.7 on Terminal Bench 2.1, which covers terminal-based task completion, not general reasoning or knowledge. No latency, availability, or error-rate metrics are published, so performance under load is unknown. The context and output caps are large but finite: 1,048,576 tokens of input and 384,000 tokens of output per request. Requests that exceed them will not succeed. There is no documented prompt-caching discount in the provided facts, so repeated prefixes are billed as ordinary input tokens. The pricing is low on a per-token basis, but absolute costs grow linearly with context size. If your application needs vision, low latency, or very high throughput, this model may not be the right fit; verify those requirements separately before committing.
Costs are calculated per token, with one rate for input and one for output. Input tokens cost $0.15 per 1,000,000 tokens; output tokens cost $0.29 per 1,000,000 tokens. OrcaRouter bills these at the provider rate with zero markup, meaning no additional platform percentage is added on top of deepseek's rate. A single request's cost is approximately input tokens times $0.15 divided by 1,000,000, plus output tokens times $0.29 divided by 1,000,000. For example, a full 1,048,576-token input costs about $0.1573, and a maximum-length 384,000-token output costs about $0.1114, if both limits were used in separate transactions. The available facts do not mention discounted cached-input pricing, so assume each input token is billed at the standard rate. Because pricing is linear, batch cost estimation is straightforward once you know your average prompt size and output length.
The main trade-off is between context size and price. At $0.15 per 1M input tokens, a prompt that uses the full 1,048,576-token context costs roughly $0.157 in input fees alone. If your task only needs a few thousand tokens of context, you are paying for unused capacity in the sense that a smaller-context model with lower per-token pricing might be cheaper, depending on its rates. The $0.29 per 1M output rate means long outputs are not especially expensive individually, but a workload generating gigabytes of text will accumulate cost. There is no batch discount, reservation, or caching discount listed in the provided facts. The zero-markup billing from OrcaRouter means the price you see is the provider's price; your final bill is simply a function of tokens sent and received. For large-scale batch jobs, estimate total input and output tokens, multiply by the two rates, and compare against alternatives in the catalog.
OrcaRouter explicitly bills DeepSeek V4 Flash 0731 at the provider rate with zero markup. The $0.15 per 1M input tokens and $0.29 per 1M output tokens are the provider's rates, not a marked-up version. The provided facts do not describe prompt caching for this model. No cached-input pricing tier is listed, and there is no statement that OrcaRouter automatically caches prompts on your behalf. If the underlying provider offers caching, the terms are not part of what was supplied for this catalog entry, so you should check OrcaRouter's current documentation before assuming a discount. The API response, because it follows OpenAI's chat completions format, includes usage information that lets you verify billed input and output tokens. For audit purposes, log the usage object from each response and compare it with your expected token counts. Any cost control must come from your own prompt and parameter choices.
Send standard chat completion requests to OrcaRouter's OpenAI-compatible API. The base URL is https://api.orcarouter.ai/v1, and the model ID is deepseek/deepseek-v4-flash-0731. Set the model field to that exact string, and put your OrcaRouter API key in the Authorization header as a bearer token. Build a messages array with text content; the model will not accept image or audio content. The response is formatted like an OpenAI chat completion and includes the generated message and a usage object. Because the model ID includes a provider prefix, keep it exactly as shown. The available facts do not require any non-standard headers or special transport settings. You can use the OpenAI SDKs, curl, or any HTTP client that speaks JSON. Start with a small request, verify the returned usage matches the expected input and output token counts, then scale up.
Because the endpoint is OpenAI-compatible, the typical chat completion parameters are available: model, messages, temperature, top_p, max_tokens or max_completion_tokens, stop, stream, and similar options supported by the SDK you use. The available facts do not enumerate which parameters OrcaRouter honors for this specific model, so you should test anything beyond model and messages. The crucial limits are the model's own: 1,048,576 input tokens and 384,000 output tokens. Keep max_tokens below the output cap to avoid failed requests. For tool or function calling, the facts do not state support; test a minimal tool definition before building an agent. For output format control, there is no mention of JSON mode or structured output guarantees; validate generated text yourself if you need reliable structure. Streaming is commonly supported on OpenAI-compatible endpoints, but the facts do not confirm it for this model, so consult OrcaRouter's API reference.
Migration is mostly configuration: change the base URL to https://api.orcarouter.ai/v1, switch the API key to your OrcaRouter key, and replace the model name with deepseek/deepseek-v4-flash-0731. Code that already builds messages, handles chat completion responses, and reads usage data will keep working as long as it follows the OpenAI convention. Two differences require attention. First, this model is text-only, so remove any image_url or audio fields from your requests. Second, the context and output caps are very large; adjust your max_tokens setting to respect the 384,000-token output ceiling and be prepared for occasionally long responses. If your code includes retries on 429 or 5xx errors, keep them; the facts do not change error-handling expectations. Run a smoke test against a small prompt, confirm billing appears at $0.15/$0.29 per million tokens, and then shift traffic gradually.
The base URL for OrcaRouter's API is https://api.orcarouter.ai/v1. All requests to this endpoint should use HTTPS. Authentication is an API key, sent as a standard bearer token in the Authorization header. The available facts do not list alternative authentication methods. The model ID is deepseek/deepseek-v4-flash-0731, which includes the provider name and the 0731 snapshot suffix; pass it exactly as written. In most OpenAI-compatible SDKs, you configure a client with base_url and api_key, then set the model name on each call. The response will include billing-relevant token counts in the usage object. The facts do not state rate limits, retry behavior, or timeout guidance, so check OrcaRouter's documentation for those operational details. Store your API key securely; the key determines access to every model account in your OrcaRouter project. If you use a proxy or gateway, point it at the OrcaRouter base URL and preserve the full model ID.
The provided facts cover only this specific snapshot, so a line-by-line numerical comparison with other DeepSeek entries is not possible from what is given. What we know about DeepSeek V4 Flash 0731 is its 1,048,576-token context, 384,000-token output cap, text-only input, $0.15/$0.29 per-1M-token pricing, and 82.7 Terminal Bench 2.1 score. Other DeepSeek models in OrcaRouter's catalog may differ on any of these axes. When deciding, compare the specifications that matter: how many tokens your prompts actually use, how many tokens your outputs require, whether you need a multimodal input, and the per-1M-token price of the candidate. The Flash label implies a leaner variant relative to other DeepSeek releases, but the only objective performance indicator in the facts is the Terminal Bench score. Use OrcaRouter's catalog listing pages for side-by-side specifications and current pricing before selecting.
At 1,048,576 tokens of context, this model is in the long-context tier. A smaller-context model might cap out at a few hundred thousand or fewer tokens, forcing you to split documents, embed chunks, or use retrieval. The advantage of this model is that you can place a very large corpus in one prompt and let the model attend to all of it in a single pass. The disadvantage is cost per request: each input token is billed, so a huge context multiplies input spend. The facts do not list any model with an even larger context window, so the only safe statements are about this model's own limits. In choosing, estimate your real prompt sizes. If your tasks typically use less than 100K tokens, the full context may be irrelevant and a cheaper, smaller model might be preferable. If you regularly exceed common context limits, this model's 1M-token window is the decisive feature.
Choose DeepSeek V4 Flash 0731 when the task is text-only and you can exploit its specifications. The 1,048,576-token context warrants selection when you need to read an entire repository, document set, or long transcript in one pass. The 384,000-token output cap warrants selection when you need very long generated answers without multiple round trips. The 82.7 Terminal Bench 2.1 score warrants selection for terminal automation and agentic CLI workflows. The $0.15/$0.29 per-1M-token price warrants selection for high-volume batch text processing where per-token cost dominates. Do not pick it when you need images or audio, when your context needs are tiny and a cheaper model exists, or when you cannot accept unknown latency characteristics. The available facts give no latency guarantees, so performance-sensitive teams should benchmark with real prompts first. In every case, confirm the model ID and billing on OrcaRouter before scaling.
OpenAI-compatible — keep the SDK you already use
https://api.orcarouter.ai/v1https://api.orcarouter.aiimport os
from openai import OpenAI
client = OpenAI(
base_url="https://api.orcarouter.ai/v1",
api_key=os.environ["ORCAROUTER_API_KEY"],
)
response = client.chat.completions.create(
model="deepseek/deepseek-v4-flash-0731",
messages=[{"role": "user", "content": "Hello"}],
)
print(response.choices[0].message.content)frequency_penaltyinclude_reasoninglogit_biaslogprobsmax_tokensmin_ppresence_penaltyreasoningreasoning_effortrepetition_penaltyresponse_formatseedstopstructured_outputstemperaturetool_choicetoolstop_ktop_logprobstop_p| Input / 1M tokens | $0.147 |
| Output / 1M tokens | $0.295 |
| Cache read / 1M | $0.020 |
| Currency | USD |
Estimate based on list price
Estimate only — actual token counts depend on the provider's tokenizer.
What developers are saying this week
GET /api/public/models/deepseek/deepseek-v4-flash-0731Open @misc{orcarouter_deepseek_v4_flash_0731,
title = {DeepSeek V4 Flash 0731 API},
author = {DeepSeek},
year = {2026},
howpublished = {OrcaRouter},
url = {https://www.orcarouter.ai/models/deepseek/deepseek-v4-flash-0731}
}DeepSeek. (2026). DeepSeek V4 Flash 0731 API. OrcaRouter. https://www.orcarouter.ai/models/deepseek/deepseek-v4-flash-0731