DeepSeek V4 Flash 0731 is the July 2026 release of DeepSeek's fast, economical V4 Flash line, and it supersedes the earlier V4 Flash rather than sitting beside it as a variant.
- Input
- text $0.44/M
- Output
- text $1.32/M
- Cache read
- $0.044/M
- Context
- 1M
- vs GPT-4o
- ~91% cheaper
Benchmarks
Vendor-published: Alibaba (Qwen) Anthropic ByteDance DeepSeek Google MiniMax Moonshot OpenAI Tencent Z.ai
Price in context
Where the price sits among 66 comparable models
The bar shows how this model’s price compares with every other model of the same kind on Synthorai. The cheapest and the most expensive are named at each end. These are base rates; batch, region and cache-write discounts are on the pricing page.
Specs & limits
Tokens
| Context window (vendor spec) | 1,000,000 |
|---|---|
| Max output (vendor spec) | 393,216 |
Prompt caching
| How it caches | automatic |
|---|---|
| Lifetime | no fixed TTL (evicted when unused) |
Thinking
| Parameter | reasoning_effort |
|---|---|
| Values | minimal · low · medium · high accepted set is the provider's |
Model
| Modalities | text → text |
|---|---|
| Parameters | 284B total · 13B active MoE |
| License | MIT |
- July 2026 release of DeepSeek V4 Flash
- same 284B/13B-active MoE design, gains from a stronger post-training pipeline rather than a new architecture
One prompt, measured through the gateway
DeepSeek V4 Flash (0731) passed · 3 sentences
Enabling reasoning mode prompts the model to generate extensive internal chain-of-thought tokens before answering, often multiplying total token output per query by several times. This directly inflates costs because we are billed per token, and these reasoning tokens are processed at a premium compute tier that carries a higher price per million tokens. However, this spend buys measurably higher accuracy and fewer failed calls, so we are tracking it against specific error-reduction KPIs to ensure the ROI justifies the increase.
out 365 tok (+266 thinking) latency 5.1 s
Instruction following (exactly three sentences - countable), audience shaping (CFO register), and the hidden-thinking billing gap the token meters below expose.
DeepSeek V4 Flash (0731) passed · 8/8 cases
```python def longest_run(xs): if not xs: return 0 best = 1 cur = 1 for i in range(1, len(xs)): if xs[i] == xs[i - 1]: cur += 1 best = max(best, cur) else: cur = 1 return best ``` The original bug stems from initializing `cur` to 0 and only incrementing it when adjacent elements are equal, which counts the number of *equal transitions* rather than the actual run length—so every run of length L is reported as L−1, and a single‑element run (with no transitions) yields 0. Moreover, because `best` is updated only inside the equality branch, it never accounts for a run that ends at the last element if that run is longer than any previously seen (though the real issue remains the off‑by‑one). […]
out 1268 tok (+1016 thinking) latency 14.0 s
Whether the fix is actually correct (runnable), explanation density, and token efficiency on a bounded task.
DeepSeek V4 Flash (0731) passed · 5/5 fields, guidance null
{ "company": "Meridian Robotics", "quarter": "Q3", "revenue_usd_m": 412, "growth_pct": null, "guidance": null }
out 1119 tok (+1072 thinking) latency 12.3 s
Schema obedience (no invented fields), hallucination pressure (guidance is explicitly withheld), and structured-output path differences.
DeepSeek V4 Flash (0731) missed · 141 words, 0 banned, 1 question
**Introducing Prompt Cache for API Gateway** We are pleased to announce Prompt Cache, a new feature that stores and reuses identical prompt prefixes across all connected LLM providers. By automatically recognizing repeated requests, this cache reduces token consumption and lowers latency without altering your application logic. Whether you use OpenAI, Anthropic, or open-source models, the cache operates transparently, ensuring consistent behavior while cutting costs. Developers can configure cache TTL and scoping rules via a simple API call, giving you precise control over data freshness and privacy. This feature also minimizes redundant upstream calls, freeing provider rate limits for more critical workloads. Start caching today through the dashboard or CLI, and watch your operational expenses drop significantly. […]
out 254 tok (+80 thinking) latency 4.4 s
Constraint obedience (word budget, banned-word list, the single question), style fingerprint, and length control.
Use DeepSeek V4 Flash (0731) in 30 seconds
OpenAI-compatible: swap the base_url, keep your SDK. POST /v1/chat/completions
from openai import OpenAI
client = OpenAI(
base_url="https://synthorai.io/v1",
api_key="sk-syn-...",
)
resp = client.chat.completions.create(
model="deepseek-v4-flash-0731",
messages=[{"role": "user", "content": "Summarize this diff"}],
reasoning_effort="medium",
)
print(resp.choices[0].message.content)import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://synthorai.io/v1",
apiKey: "sk-syn-...",
});
const resp = await client.chat.completions.create({
model: "deepseek-v4-flash-0731",
messages: [{ role: "user", content: "Summarize this diff" }],
reasoning_effort: "medium",
});
console.log(resp.choices[0].message.content);curl https://synthorai.io/v1/chat/completions \
-H "Authorization: Bearer sk-syn-..." \
-H "Content-Type: application/json" \
-d '{
"model": "deepseek-v4-flash-0731",
"messages": [{"role": "user", "content": "Hello"}],
"reasoning_effort": "medium"
}'package main
import (
"context"
"fmt"
"github.com/openai/openai-go/v3"
"github.com/openai/openai-go/v3/option"
)
func main() {
client := openai.NewClient(
option.WithBaseURL("https://synthorai.io/v1"),
option.WithAPIKey("sk-syn-..."),
)
resp, _ := client.Chat.Completions.New(context.TODO(), openai.ChatCompletionNewParams{
Model: "deepseek-v4-flash-0731",
Messages: []openai.ChatCompletionMessageParamUnion{
openai.UserMessage("Summarize this diff"),
},
ReasoningEffort: openai.ReasoningEffortMedium,
})
fmt.Println(resp.Choices[0].Message.Content)
}import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.*;
import com.openai.models.ReasoningEffort;
OpenAIClient client = OpenAIOkHttpClient.builder()
.baseUrl("https://synthorai.io/v1")
.apiKey("sk-syn-...")
.build();
ChatCompletion resp = client.chat().completions().create(
ChatCompletionCreateParams.builder()
.model("deepseek-v4-flash-0731")
.addUserMessage("Summarize this diff")
.reasoningEffort(ReasoningEffort.MEDIUM)
.build());
System.out.println(resp.choices().get(0).message().content().orElse(""));About DeepSeek V4 Flash (0731)
- The architecture and the size are unchanged - a Mixture-of-Experts model with 284B total parameters and 13B activated at inference - and DeepSeek attributes the improvement to a substantially stronger post-training pipeline rather than to a new design, with the work concentrated on agentic workflows and reasoning quality.
- Everything that made the line attractive operationally carries over: the 1M-token context window, a 384K maximum output, MIT-licensed weights, function calling, structured output and streaming.
- Thinking is enabled by default and the trace comes back in reasoning_content, which matters more here than on most models: on short prompts the reasoning trace can account for the large majority of the completion tokens, so a tight max_tokens budget will return an empty answer while still being billed for the tokens spent thinking.
- Budget for that, or lower the reasoning effort, before wiring it into latency-sensitive paths.
- The model is text-only in and text-only out; image input is not supported, so pair it with a vision model rather than sending multimodal messages.
- Because both the dated release and the rolling name remain callable, pin the dated id when you need reproducible behaviour and expect the undated name to move forward over time.
- Synthorai serves it through the OpenAI-compatible chat completions endpoint.
FAQ
Is the DeepSeek V4 Flash (0731) API free to try?
Yes: new accounts get 10 trial calls and up to $1 in free credit, no card required. At $0.44/M input tokens, that credit alone covers roughly 284 requests of ~8K tokens against DeepSeek V4 Flash (0731).
What is DeepSeek V4 Flash (0731) best at?
284B MoE with 13B activated, MIT-licensed; supersedes the earlier V4 Flash release; 1M context with 384K maximum output. See the About section for the full picture from the vendor's own release notes.
How much does DeepSeek V4 Flash (0731) cost?
DeepSeek V4 Flash (0731) costs $0.44 per million input tokens and $1.32 per million output tokens on Synthorai. That is the provider's list price, with no platform markup. Cached input tokens bill at $0.044/M.
Does DeepSeek V4 Flash (0731) support prompt caching?
Yes, automatically: DeepSeek-served prompts cache with no code changes. Cached input tokens bill at $0.044/M vs $0.44/M uncached (TTL no fixed TTL (evicted when unused)). Prompt caching guide →
How do I get access to DeepSeek V4 Flash (0731)?
Point your existing OpenAI SDK at base_url="https://synthorai.io/v1", set model="deepseek-v4-flash-0731", and you're done. One API key covers every model on the gateway.
Is DeepSeek V4 Flash (0731) open source?
Yes: the weights are published under the MIT license. Or skip the GPUs: the hosted version here is pay-as-you-go with no infrastructure to run. Running open-weight models →
Related models
Compare
Every value on this page is transcribed from the vendor's own documentation, linked above, and carries the date it was checked. Prices are compared across the catalogue; specification values that vendors define differently are shown with the difference stated rather than charted. Nothing here is measured by us, and nothing is scored.