DeepSeek V4 Flash is the fast, economical member of the open-source DeepSeek-V4 series: a Mixture-of-Experts model with 284B total parameters and 13B activated, pre-trained like its larger sibling on more than 32T tokens.
- Input
- text $0.138/M
- Output
- text $0.275/M
- Cache read
- $0.0028/M
- Context
- 1M
- vs GPT-4o
- ~97% cheaper
Benchmarks
Vendor-published: Alibaba (Qwen) DeepSeek Google
Price in context
Where the price sits among 60 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
| Vendor control | thinking.type + reasoning_effort |
|---|---|
| Accepted values | thinking.type enabled · disabled; reasoning_effort high · max (low and medium map to high, xhigh maps to max) |
| Default | enabled, with reasoning_effort high; some complex agent requests are automatically set to max applied when the request sets nothing |
| Can be turned off | Yes |
| Thinking behaviour | Trace returns in reasoning_content, and on a turn where the model called a tool it must be passed back in every later turn; otherwise it is ignored. Thinking mode also silently ignores temperature, top_p, presence_penalty and frequency_penalty. DeepSeek publishes this default for its own API; other platforms that host the model document different defaults, so confirm against the platform you are routed to. |
| Parameter | reasoning_effort |
| Values | minimal · low · medium · high the gateway's parameter surface - the vendor mapping above applies |
Model
| Modalities | text → text |
|---|---|
| Parameters | 284B total · 13B active MoE |
| License | MIT |
- 284B/13B active MoE, 1M context, Thinking + Non-Thinking modes
- hybrid sparse attention, FP4+FP8 mixed precision
- the fast, economical V4 variant
One prompt, measured through the gateway
DeepSeek V4 Flash passed · 3 sentences
When reasoning is enabled, the model generates additional "chain-of-thought" tokens internally before producing the final answer, effectively doubling the total token count per request. Since our billing is based on tokens processed, this directly doubled your usage. Additionally, reasoning often requires more expensive model tiers or higher compute resources, further amplifying the cost increase.
out 154 tok (+85 thinking) latency 3.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 passed · 8/8 cases
The bug is that the function counts the number of consecutive equal **pairs** (i.e., `cur` increments for each `i` where `xs[i] == xs[i-1]`), but it should return the **length** of the longest run. For a run of length `L`, the number of pairs is `L-1`, so the result is always one less than the correct value. This causes the function to return 0 for a single‑element list (expected 1) and to undercount runs that end at the last index (e.g., `[1,1]` returns 1 instead of 2). Additionally, runs of length 1 that are not part of any pair (such as a single element at the end of a list) are never considered because `best` is only updated when a pair is found. […]
out 2494 tok (+2227 thinking) latency 19.4 s
Whether the fix is actually correct (runnable), explanation density, and token efficiency on a bounded task.
DeepSeek V4 Flash passed · 5/5 fields, guidance null
{ "company": "Meridian Robotics", "quarter": "Q3", "revenue_usd_m": 412, "growth_pct": null, "guidance": null }
out 1101 tok (+1054 thinking) latency 10.2 s
Schema obedience (no invented fields), hallucination pressure (guidance is explicitly withheld), and structured-output path differences.
DeepSeek V4 Flash passed · 119 words, 0 banned, 1 question
We're thrilled to introduce Prompt Cache, a new feature for our API Gateway that stores prompt responses from any provider. When a user submits a prompt you've already processed, the system returns the cached result instantly—eliminating redundant API calls and reducing latency. This works across OpenAI, Anthropic, Google, and more, with automatic cache invalidation based on your rules. What does this mean for your budget? Fewer API calls directly lower your monthly spend. Additionally, response times drop by up to 80% for cached prompts, improving user experience. Developers can configure cache duration per provider, set TTLs, and bypass cache when needed. The feature is available now in your gateway dashboard. Start saving time and money with Prompt Cache.
out 2039 tok (+1887 thinking) latency 15.6 s
Constraint obedience (word budget, banned-word list, the single question), style fingerprint, and length control.
Use DeepSeek V4 Flash 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",
messages=[{"role": "user", "content": "Summarize this diff"}],
)
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",
messages: [{ role: "user", content: "Summarize this diff" }],
});
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",
"messages": [{"role": "user", "content": "Hello"}]
}'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",
Messages: []openai.ChatCompletionMessageParamUnion{
openai.UserMessage("Summarize this diff"),
},
})
fmt.Println(resp.Choices[0].Message.Content)
}import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.*;
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")
.addUserMessage("Summarize this diff")
.build());
System.out.println(resp.choices().get(0).message().content().orElse(""));About DeepSeek V4 Flash
- It carries the series' 1M-token context window as standard, tops out at 384K output tokens, and supports non-thinking and thinking modes, including higher reasoning-effort settings.
- DeepSeek highlights hybrid sparse-attention innovations that sharply cut long-context inference compute and KV-cache cost versus DeepSeek-V3.2, with reasoning performance approaching V4 Pro at lower price and latency; the release notes go further and say Flash performs on par with Pro on simple agent tasks, which is the line to read when choosing between them: Pro for knowledge-intensive and hard agentic work, Flash for everything high-volume.
- It is also the higher-concurrency member of the pair.
- Mechanically the two are identical to integrate: the same thinking object and reasoning_effort levels, the same reasoning_content field carrying the chain of thought, the same requirement to pass that field back on turns that called a tool, the same 128-function tool calling, JSON output and automatic prefix caching, and the same FP4/FP8 mixed-precision packaging.
- Weights are MIT-licensed and published on DeepSeek's own model hub.
- Synthorai serves DeepSeek V4 Flash via its OpenAI-compatible endpoint with no client changes required.
FAQ
Is the DeepSeek V4 Flash API free to try?
Yes: new accounts get 10 trial calls and up to $1 in free credit, no card required. At $0.138/M input tokens, that credit alone covers roughly 905 requests of ~8K tokens against DeepSeek V4 Flash.
What is DeepSeek V4 Flash best at?
284B-parameter MoE with 13B activated; hybrid sparse attention cuts long-context costs; MIT-licensed weights with 1M-token context. See the About section for the full picture from the vendor's own release notes.
How much does DeepSeek V4 Flash cost?
DeepSeek V4 Flash costs $0.138 per million input tokens and $0.275 per million output tokens on Synthorai. That is the provider's list price, with no platform markup. Cached input tokens bill at $0.0028/M.
Does DeepSeek V4 Flash support prompt caching?
Yes, automatically: DeepSeek-served prompts cache with no code changes. Cached input tokens bill at $0.0028/M vs $0.138/M uncached (TTL no fixed TTL (evicted when unused)). Prompt caching guide →
How do I get access to DeepSeek V4 Flash?
Point your existing OpenAI SDK at base_url="https://synthorai.io/v1", set model="deepseek-v4-flash", and you're done. One API key covers every model on the gateway.
Is DeepSeek V4 Flash 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.