DeepSeek V4 Flash is DeepSeek's efficiency-focused mixture-of-experts language model: 284B total parameters with 13B activated per token, up to 1M tokens of context, and up to 384K output tokens. On July 31, 2026, DeepSeek released DeepSeek-V4-Flash-0731, the official release of the model, as an API public beta superseding the April preview. The API model ID is unchanged, deepseek-v4-flash, and as of 2026-07-31 the official price list shows $0.0028 per million cache-hit input tokens, $0.14 per million cache-miss input tokens, and $0.28 per million output tokens. This page is the hub of an independent, unofficial guide written by DeepSeek fans; we are not affiliated with or endorsed by DeepSeek. Every fast-moving fact below carries a last-verified date.
What Is DeepSeek V4 Flash?
Three different things share the name "V4 Flash": a hosted API model, an open-weight repository, and a chat model inside the DeepSeek app. Pinning down which one you mean prevents most launch-day confusion.
The model in one sentence
DeepSeek V4 Flash is a mixture-of-experts, text-generation language model with 284 billion total parameters, 13 billion activated per token, and up to one million tokens of context - the smaller, cheaper sibling of DeepSeek-V4-Pro in the V4 family that launched as a preview on April 24, 2026. It targets agentic and coding workloads: DeepSeek's July 31 release notes lead with terminal, repository, and tool-use benchmarks, not chat quality. It is served under the API ID deepseek-v4-flash, with current open weights on Hugging Face under MIT. For the head-to-head against the larger sibling, see our V4 Flash vs V4 Pro comparison.
What “Flash” and “0731” mean
"Flash" is the efficiency tier of the V4 family: 284B/13B versus V4 Pro's 1.6T total and 49B activated, per the V4 technical report. "0731" is a version stamp, not a different product: DeepSeek-V4-Flash-0731 is the July 31, 2026 official release that replaced the April preview behind the same API ID. Per the official changelog, 0731 keeps the same architecture and size and was "only re-post-trained." Calling deepseek-v4-flash today returns the 0731 version automatically; you never send "0731" to the API. What changed and what did not is detailed in our 0731 release guide.
DeepSeek V4 Flash Price
Price is where launch summaries mislead the most: the three official numbers differ by a factor of 100, and only one of them applies to any given token.
Cache-hit, cache-miss, and output prices
As of 2026-07-31, DeepSeek's Models & Pricing page lists these rates for deepseek-v4-flash, per one million tokens:
| Token type | Price per 1M tokens |
|---|---|
| Input, cache hit | $0.0028 |
| Input, cache miss | $0.14 |
| Output | $0.28 |
The cache-hit rate applies only to an input prefix the API has recently seen, such as a repeated system prompt; everything else bills as cache-miss input, and all generated text, including reasoning tokens, bills as output. The same page announces future peak pricing at 2x during 09:00-12:00 and 14:00-18:00 Beijing time, with the effective date "subject to the official announcement" - so as of 2026-07-31 it is announced, not active. Worked examples are in our pricing and real cost guide.
Why the lowest token price is not your task cost
The $0.0028 figure is real but conditional on your cache-hit rate. A coding-agent turn typically pays cache-miss rates on new file contents, then output rates on everything the model writes, including its thinking. Verbosity matters: Artificial Analysis reported that its evaluation suite consumed about 210M output tokens on this model versus a median of roughly 62M for comparable models. Retries and failed runs bill in full. The honest unit is cost per accepted result, not price per million tokens; the pricing guide walks through the math.
How Good Is DeepSeek V4 Flash?
The short launch-day verdict: the vendor's agent benchmarks jumped dramatically, one independent index moved up ten points, and everything else still needs independent reruns.
Where it looks strongest
Two signals stand out. DeepSeek's own July 31 table (vendor-reported) shows large agentic gains over the preview - Terminal Bench 2.1 rising from 61.8 to 82.7, DeepSWE from 7.3 to 54.4, per the changelog. Independently, Artificial Analysis scored the 0731 release at 50 on its Intelligence Index on 2026-07-31, up from 40 for the prior version, using its own nine-benchmark harness. Community reports on earlier Flash versions consistently describe a strong, cheap execution model for coding agents when a human or a stronger model does the planning - anecdotes, not measurements, but consistent with the agent-benchmark story.
Where the evidence is still weak
Three gaps as of 2026-07-31. First, apart from Artificial Analysis, we found no independent rerun of the 0731 checkpoint; every "82.7 on Terminal Bench" citation traces back to DeepSeek's own number, and DeepSeek does not yet appear on tbench.ai's official Terminal Bench 2.1 leaderboard. Second, harness sensitivity is large: community tests of earlier V4 models saw materially different outcomes when only the agent scaffold changed, so a score under DeepSeek's unreleased harness may not transfer to yours. Third, long-context quality at extreme lengths and knowledge-heavy tasks remain the least-evidenced areas. Details in the benchmark breakdown.
DeepSeek V4 Flash Benchmark
DeepSeek published a full agent-benchmark table with the 0731 release. Read the footnotes before quoting any single number.
The headline 0731 agent scores
All numbers below are DeepSeek-reported, from the July 31 changelog and the 0731 model card, retrieved 2026-07-31:
| Benchmark | Flash 0731 | Flash Preview | Pro Preview |
|---|---|---|---|
| Terminal Bench 2.1 | 82.7 | 61.8 | 72.1 |
| NL2Repo | 54.2 | 39.4 | 38.5 |
| Cybergym | 76.7 | 38.7 | 52.7 |
| DeepSWE | 54.4 | 7.3 | 12.8 |
| Toolathlon-Verified | 70.3 | 49.7 | 55.9 |
| Agents' Last Exam | 25.2 | 15.8 | 16.5 |
| AutomationBench Public | 25.1 | 10.8 | 12.8 |
| DSBench-FullStack (internal) | 68.7 | 37.0 | 41.8 |
| DSBench-Hard (internal) | 59.6 | 25.8 | 31.1 |
The table makes one claim: in DeepSeek's own evaluation, the re-post-trained Flash overtook both its preview and the larger Pro Preview on these agent tasks. The two DSBench rows use internal test sets nobody outside can rerun.
Vendor results versus independent evidence
DeepSeek's footnotes state that public Code Agent tasks ran under the DeepSeek Harness in minimal mode - a harness not yet released as of 2026-07-31 - at maximum reasoning effort, temperature 1.0, top-p 0.95. Until that harness ships, none of the public rows are reproducible as run. A version subtlety: the preview model card quoted Terminal Bench 2.0 (56.9 at max effort), and the maintainers repaired 28 tasks in 2.1, so 2.0 and 2.1 scores are not directly comparable. The one independent datapoint today is Artificial Analysis's Intelligence Index of 50. Our benchmarks page keeps vendor and independent columns separate.
DeepSeek V4 Flash API
The API is the primary way to use the 0731 release today; three details - model ID, base URL, endpoint flavor - avoid most confusion.
Model ID, API key, and base URL
The model ID is exactly deepseek-v4-flash, per the List Models endpoint; do not paste the repository name DeepSeek-V4-Flash-0731 into API calls. The base URL is https://api.deepseek.com, with an API key from the DeepSeek platform console. Status is official release in public beta, not GA. Default account concurrency is 2500 as of 2026-07-31, per the rate limit page. Thinking toggles on or off with effort levels low, high, and max; in thinking mode, sampling parameters like temperature are accepted but ignored, per the thinking mode guide. Setup steps live in our API guide.
Chat Completions, Anthropic compatibility, and Responses API
DeepSeek exposes three surfaces for the same model. OpenAI-compatible Chat Completions is the default path. The Anthropic-compatible endpoint at https://api.deepseek.com/anthropic maps Claude-style model names onto DeepSeek models, which is what makes Claude Code work with this model. New with 0731 is a native Responses API that supports only deepseek-v4-flash, built for Codex: streaming SSE, function tools, web search, and the apply_patch custom tool - but stateless, with previous_response_id, conversation, store, and background unsupported. On every surface the model accepts text only; see the vision and OCR explainer.
DeepSeek V4 Flash Size and Architecture
"How big is it" has two answers - an architecture answer and a memory answer - and mixing them up produces most of the bad hardware advice in circulation.
284B total versus 13B activated
The official figures are 284B total parameters, 13B activated per token: a mixture-of-experts design where each token touches a small slice of the network. Calling it "a 13B model" is wrong where it matters most - you must store all 284B parameters even though only 13B compute per token. Two display quirks confuse people: the Hugging Face UI shows "158B params" on the preview repo (a tensor-format counting artifact), and as of 2026-07-31 the 0731 model card shows a 304B total that appears to include the attached DSpark speculative-decoding module - DeepSeek has not published a reconciliation, so we flag the discrepancy rather than pick a side. The architecture combines hybrid compressed attention with manifold-constrained hyper-connections, trained on more than 32T tokens, per the technical report.
1M context and 384K maximum output
The API documents up to 1M tokens of context and 384K maximum output as of 2026-07-31, per the pricing/spec page; the open-weight config.json lists 1,048,576 positions. Two constraints follow. Input plus output must fit the window together, so a 900K-token prompt cannot also receive a 384K-token answer. And capacity is not a recall guarantee: community long-context tests of earlier Flash versions reported quality drift well before the limit. How to test effective recall on your own data is covered in the context window explainer.
DeepSeek V4 Flash Download and Hugging Face
DeepSeek published open weights for the 0731 release on launch day. Here is what is actually downloadable, and from where.
The official 0731 repository
The official weights live at deepseek-ai/DeepSeek-V4-Flash-0731, created July 31, 2026, MIT-licensed, with the DSpark speculative-decoding module attached. The checkpoint uses DeepSeek's native mixed precision (MoE experts in FP4, most other tensors in FP8), so the download is far smaller than a dense-FP16 reading of "284B parameters" suggests, while still a multi-hundred-gigabyte artifact. The April preview remains separately published at deepseek-ai/DeepSeek-V4-Flash; the two are different checkpoints, and claims do not transfer between them. MIT covers weights and code - it does not make the hosted API free, and it grants no DeepSeek trademark or domain rights.
Official weights versus community conversions
Everything under the deepseek-ai organization is first-party; everything else is a conversion. Community GGUF quantizations, MLX builds, and FP8 repacks carry their own quality, template, and runtime-compatibility properties - and several popular ones were still built from the April preview as of 2026-07-31. Before downloading, check the base model named on the repo card (preview or 0731), the exact quantization, and which runtime version the files were validated against. A conversion is not wrong for being unofficial, but a score or bug observed on a community quant belongs to that quant, not to the model in general.
How to Run DeepSeek V4 Flash Locally
Local deployment is real but not casual: working setups on launch day range from roughly 60GB to over 280GB of combined memory, and every number in between binds to a specific configuration.
Why there is no universal minimum machine
No one can honestly state one minimum RAM or VRAM figure, because memory needs are the sum of the model file (which varies about 5x across published quantizations), the KV cache (which scales with allocated context), and runtime overhead. Two dated examples show the spread: Unsloth's guide (vendor guidance, 2026-07-31) suggests about 110GB combined memory for its ~103GB 3-bit preview-based GGUF and about 169GB for its 162GB Q8 build, while Team Blobfish's community table (WIP, preview-based, retrieved 2026-07-31) spans ~57 GiB to ~282 GiB files. Each figure binds to its exact quant, runtime, and context; none is "the requirement."
Ollama cloud access versus a local model download
The Ollama library entry is a cloud alias, not a local model: as of 2026-07-31 its tags page lists exactly one tag, deepseek-v4-flash:cloud, meaning inference runs on Ollama's servers. Its launch commands for Claude Code, OpenCode, Hermes Agent, and OpenClaw all route through that cloud tag. Two caveats: the page metadata read "Updated 3 months ago" on launch day, and no statement says which checkpoint (preview or 0731) the alias serves - do not assume the July 31 model. For weights on your own disk, use the official Hugging Face repository or a community GGUF, not ollama pull.
What to record in a reproducible local setup
Five fields make a local result useful: the exact artifact (repository plus quantization file name), the runtime version or commit (fork name if any), the allocated context size, the hardware, and measured throughput split into prompt processing and generation, with the date. Community threads about earlier Flash builds were full of contradictory speed reports that dissolved once configs were compared - a 2-bit quant on a fork at 8K context is a different experiment from an 8-bit quant upstream at 262K. Apply the same discipline when reading other people's numbers, including ours.
DeepSeek V4 Flash with vLLM
vLLM is one of the two serving paths DeepSeek names in its own repository, and the most direct route to serving the official 0731 checkpoint on datacenter GPUs.
Official and vLLM-supported serving paths
The 0731 model card documents two named serving paths - vLLM (vllm serve deepseek-ai/DeepSeek-V4-Flash-0731) and SGLang - plus plain Transformers loading. The official vLLM recipe, updated 2026-07-31, specifies vLLM 0.26.0 for full support of both fused checkpoints, with flags including --tokenizer-mode deepseek_v4, --tool-call-parser deepseek_v4, and --reasoning-parser deepseek_v4. DSpark speculative decoding is enabled via --speculative-config '{"method":"dspark","num_speculative_tokens":7,"draft_sample_method":"greedy"}', shown in both the recipe and the model card. These are multi-GPU, datacenter-class instructions, not a consumer-laptop route.
Why checkpoint and runtime versions must match
Version pairing is the main failure mode. DSpark drafting landed in vLLM 0.25.0 and its ROCm support only in 0.26.0 per the recipe page, so an older vLLM that serves the April preview fine can fail on, or silently ignore features of, the 0731 checkpoint. The reverse also bites: in documented earlier V4 Flash cases, quantized exports produced for one runtime crashed on another, because artifact layouts encode runtime assumptions. Before filing a bug or believing a benchmark, confirm the tuple: exact checkpoint, exact runtime version, exact quantization. On launch day, most "the model is broken" reports are mismatched pairs.
DeepSeek V4 Flash Unsloth Quantizations
Unsloth's Dynamic GGUFs are the most-searched community builds for workstation-class memory, and 0731 versions began appearing within hours of the release.
What Unsloth publishes
As of 2026-07-31, Unsloth's DeepSeek-V4 guide states that for the 0731 build "Q4 and Q8 are up" with more quantizations pending. The live repository unsloth/DeepSeek-V4-Flash-0731-GGUF contained UD-Q4_K_XL (~155GB) and UD-Q8_K_XL (~162GB) at retrieval, uploaded on launch day. Unsloth claims the Q8 build is fully lossless - bit-identical expert tensors thanks to the model's quantization-aware MXFP4/FP8 training, with published perplexity and KL-divergence tables - and recommends roughly 7-10GB of memory headroom above file size. Treat those quality claims as vendor claims until independently reproduced.
How to verify Preview versus 0731 artifacts
Unsloth keeps separate repositories per checkpoint, and the names are the verification: unsloth/DeepSeek-V4-Flash-GGUF (no suffix) is built from the April preview, while unsloth/DeepSeek-V4-Flash-0731-GGUF is the July 31 build. This matters now because the preview repo carries the full quant ladder (1-bit through 8-bit, roughly 82GB to 162GB) while the 0731 repo held only two quants on launch day - a 103GB "V4 Flash GGUF" downloaded this week is almost certainly the preview checkpoint. Check the repo card's stated base model and file names before attributing behavior to the new release; the missing 0731 quants did not exist as of 2026-07-31.
DeepSeek V4 Flash GGUF
GGUF is the format that puts this model on Macs and mixed CPU/GPU boxes - and where checkpoint, converter, and runtime provenance get tangled fastest.
Why GGUF files are community conversions
DeepSeek ships safetensors, not GGUF; every GGUF of this model is a third-party conversion. The upstream story is better than many summaries suggest: llama.cpp merged DeepSeek V4 architecture support on June 29, 2026 (PR #24162) and fixed a quantized-KV-cache gibberish bug on July 7 (PR #25202), so current upstream llama.cpp loads V4-family GGUFs. But some community repos still target forks: Team Blobfish's WIP GGUFs, built from the preview checkpoint, state they require the cchuter/llama.cpp fork and will not load upstream - whether that claim survived the upstream merge was unresolved as of 2026-07-31. Read the repo card, not just the file list.
How to choose a quantization without guessing
Use measured quality data, not bit-count intuition. Unsloth's comparison table (vendor-run, wikitext-2, retrieved 2026-07-31) shows its Q8 build matching official-weight perplexity exactly and its Q4_K_XL close behind, while some third-party 2-bit conversions lose over 20% top-token agreement. Team Blobfish's card (community, WIP, preview-based) reports M3 Ultra decode speeds of 15.15-23.75 t/s across quants from 57 GiB to 282 GiB, context length not stated. The procedure: budget memory as file size plus KV cache plus ~10GB headroom, prefer the largest quant that fits, and confirm the quant was validated on your runtime and built from the 0731 checkpoint. A repo card that does not name its base checkpoint means preview until proven otherwise.
DeepSeek V4 Flash Release Timeline: Preview to 0731
Version confusion is the most common question pattern we see; this two-date timeline resolves it. We keep this DeepSeek V4 Flash hub updated as the status changes.
April 24: the Preview release
On April 24, 2026, DeepSeek released the V4 series as a preview: DeepSeek-V4-Pro (1.6T/49B) and the Flash variant (284B/13B), both with 1M context, available the same day via web/app, API, and open weights. The preview model card documented three reasoning modes (non-think, think-high, think-max) and recommended temperature 1.0 with top-p 1.0 for local use. Almost everything published between April and July - benchmark threads, GGUF conversions, hardware reports, most reviews still ranking in search - describes this preview checkpoint unless it explicitly says otherwise.
July 31: the official API release in public beta
On July 31, 2026, the API behind deepseek-v4-flash began serving DeepSeek-V4-Flash-0731, described in the changelog as the official release in public beta - same architecture and size, new post-training only. The release added the native Responses API and Codex adaptation, a new agent-benchmark table, and same-day MIT weights. Two scope limits: the update applied to the Flash API only - the V4 Pro API was unchanged, and DeepSeek's announcement says App/Web models remain unchanged for now - and "official release in public beta" is not GA. Our release guide tracks what existing users should retest.
DeepSeek Website, App, API, and Weight Access
There are four doors into this model - website chat, mobile app, API, and downloadable weights - and on launch day they are not all serving the same thing.
What the website currently surfaces
As of 2026-07-31, DeepSeek's website clearly promotes the release: the logged-out homepage at deepseek.com carries a banner announcing that the V4 Flash official-version API is in public beta with strengthened agent capability, and the logged-in site surfaces V4 Flash access alongside the announcement. The April release notes already offered Flash in the web/app chat modes. So the older claim that "the website was not upgraded" is stale as a blanket statement. What the banner does not say is which exact checkpoint answers your chat messages - the subject of the next section.
Why the website checkpoint and API checkpoint must stay distinct
DeepSeek's July 31 materials state the upgrade applies to the V4 Flash API, and its announcement adds that App/Web models remain unchanged for now; no reviewed first-party source names the checkpoint serving website chat. Two practical rules follow. Do not evaluate 0731 by chatting on the website - the API is the only surface DeepSeek says is serving DeepSeek-V4-Flash-0731. And do not report website chat behavior as a 0731 bug or benchmark: the published scores came from the API-side model, and the open weights are a third access path whose bit-level identity with the hosted API is likewise unstated. Treat website, API, and weights as separate claims until DeepSeek publishes otherwise.
DeepSeek V4 Flash FAQ
How good is DeepSeek V4 Flash for coding?
Strong on vendor-reported agent benchmarks and promising on the one independent index available, but unproven in independent coding reruns as of 2026-07-31. DeepSeek reports Terminal Bench 2.1 at 82.7 and DeepSWE at 54.4 under its own unreleased harness at max effort; Artificial Analysis independently scored it 50 on its Intelligence Index. Community experience with earlier versions favors it as a cheap execution model inside a well-planned agent loop. Judge it on your own repository tasks; see the benchmark caveats first.
How much does DeepSeek V4 Flash cost?
As of 2026-07-31: $0.0028 per million cache-hit input tokens, $0.14 per million cache-miss input tokens, and $0.28 per million output tokens, per DeepSeek's pricing page. Reasoning tokens bill as output, and announced 2x peak-hour pricing had no effective date yet. Real task cost depends on cache-hit rate, verbosity, and retries; our pricing guide shows worked examples.
Is DeepSeek Flash V4 a different model?
No. "DeepSeek Flash V4" is a word-order variant people type; the product is DeepSeek V4 Flash, the Flash tier of the DeepSeek-V4 family. The only strings that matter technically are the API model ID deepseek-v4-flash and the version/repository name DeepSeek-V4-Flash-0731. When a tool asks for a model name, use the API ID exactly.
Where can I download DeepSeek V4 Flash?
From the official Hugging Face repository deepseek-ai/DeepSeek-V4-Flash-0731, published July 31, 2026 under MIT. The April preview remains at deepseek-ai/DeepSeek-V4-Flash - a different checkpoint. Community GGUF conversions exist, but verify whether they were built from 0731 or the preview before downloading.
Can I run DeepSeek V4 Flash locally?
Yes, with serious memory - workstation or high-memory Mac territory, not a typical gaming PC. Community quantizations run from roughly 57GB to 282GB of file size plus KV cache, and llama.cpp supports the V4 architecture upstream since late June 2026. Every working setup binds to an exact quant, runtime, and context size; the local section above lists what to record and which artifacts were actually 0731-based as of 2026-07-31.
How much RAM or VRAM does it need?
There is no single number; any page giving one without a configuration is guessing. Memory equals model file plus KV cache plus overhead. Dated examples: Unsloth suggests ~110GB for its 103GB 3-bit preview GGUF and ~169GB for its 162GB Q8 build, with community setups below and above that band on other quants. Pick a quantization first, then add your context allocation and about 10GB headroom.
Does DeepSeek V4 Flash support images or OCR?
No. The current official API is text-only: image and document blocks are unsupported on the Anthropic-compatible endpoint, the Responses API substitutes placeholder text for image inputs, and the model config contains no vision component. DeepSeek-OCR is a separate model family. If an agent using Flash appears to "see" screenshots, a different vision model or tool is in the loop - our vision and OCR explainer shows how to route visual inputs correctly.
Is the DeepSeek website using the 0731 checkpoint?
Not confirmed. The website promotes the 0731 public-beta announcement and offers V4 Flash chat, but DeepSeek states the July 31 upgrade applies to the API, with App/Web models unchanged for now, and no first-party source names the website-serving checkpoint. To use the 0731 version verifiably, call the API with deepseek-v4-flash or download the official weights.
What is the DeepSeek V4 Flash context window?
Up to 1M tokens of context with a maximum output of 384K tokens, per the official API documentation as of 2026-07-31; the model config lists 1,048,576 positions. Input and output share the window, clients may expose less than the full limit, and capacity does not guarantee accurate recall at extreme lengths - see the context window explainer.
Is DeepSeek V4 Flash better than V4 Pro?
On DeepSeek's own July 31 agent-benchmark table, Flash 0731 outscored the V4 Pro Preview on every listed row - but that is a vendor-run comparison against Pro's older preview checkpoint, not a general verdict. Pro's official release is still pending, Pro remains far larger (1.6T/49B versus 284B/13B), and non-agentic strengths differ. The honest answer is task-dependent; see the full V4 Flash vs V4 Pro comparison.