DeepSeek V4 Flash: 284B MoE, 1M Context, $0.66/M Output

TL;DR

Last updated August 21, 2026.

DeepSeek V4 Flash is the smaller, cheaper variant of DeepSeek V4, previewed April 24, 2026 and GA since July 31, 2026 as DeepSeek-V4-Flash-0731, under the MIT license. It has 284B total parameters with 13B active per token, a 1M-token context window, and 384K max output. Since August 16, 2026, first-party API pricing is $0.22/M input and $0.66/M output off-peak (double at peak), exactly one-third of V4 Pro's rates. Artificial Analysis scores Flash-0731 at 52 on its Intelligence Index, 1 point behind Pro-0813's 53, at a third of the price.

What Is DeepSeek V4 Flash?

DeepSeek V4 Flash is the smaller of the two DeepSeek V4 models, previewed April 24, 2026 and GA since July 31, 2026 as DeepSeek-V4-Flash-0731, under the MIT license. It has 284 billion total parameters with 13 billion active per token (versus V4 Pro's 1.6T / 49B), a 1M-token context window, and 384K max output. The 0731 checkpoint kept the architecture and rebuilt the post-training for agents: DeepSeek reports Terminal-Bench 2.1 jumping from 61.8 to 82.7 and DeepSWE from 7.3 to 54.4 versus the preview. It shares Pro's attention stack, so the context capability is identical; the variant choice is about quality-per-token and cost, not context size.

The Flash-specific design goal was efficiency at long context. Per DeepSeek's own numbers, in the 1M-token setting Flash runs at about 10% of the single-token FLOPs and 7% of the KV-cache size of DeepSeek V3.2. That is why practitioners report fitting a full million-token context on a single 128GB machine, something V3.2 could not do on the same hardware. The API speaks both the OpenAI ChatCompletions and Anthropic formats; the legacy deepseek-chat / deepseek-reasoner aliases retired on July 24, 2026.

Morph serves it as morph-dsv4flash (DeepSeek V4 Flash 0731) on custom kernels via an OpenAI-compatible API at $0.09875/M input and $0.278/M output. See Morph Open Source Models and pricing.

Architecture: CSA + HCA, FP4/FP8

DeepSeek V4 Flash pairs two interleaved sparse-attention mechanisms, Compressed Sparse Attention (CSA) and Heavily Compressed Attention (HCA), with a mixed FP4/FP8 quantization scheme. The combination is what lets a 1M-token default context run at 10% of V3.2's per-token FLOPs. DeepSeek publishes the attention design and Flash's efficiency ratios; it does not publish Flash's exact layer count or the indexer's top-k, so those are marked unconfirmed below.

CSA and HCA: how the KV cache shrinks

Per the Hugging Face DeepSeek V4 blog, the two attention paths compress the KV cache at different ratios and interleave across layers:

• CSA compresses KV entries 4x along the sequence dimension using softmax-gated pooling with a learned positional bias. A lightning indexer, run in FP4 as a ReLU-scored multi-head dot product, selects the top-k compressed blocks per query, and a sliding-window branch handles the most recent uncompressed tokens.
• HCA compresses KV entries 128x and drops sparse selection entirely: every query attends densely over the short compressed sequence.

Both paths store most KV entries in FP8 and keep BF16 only for the RoPE dimensions. DeepSeek publishes the layer arrangement for Pro (a 61-layer stack, layers 0-1 HCA, 2-60 alternating CSA/HCA); it does not publish Flash's split, so treat Flash's layer count and CSA/HCA arrangement as unconfirmed.

Mixed-precision weights: FP4 experts

The preview Flash model card described a mixed FP4/FP8 quantization: MoE expert parameters in FP4, most other parameters in FP8. Note the checkpoint difference: the DeepSeek-V4-Flash-0731 GA repo on Hugging Face lists BF16 tensors, so if you self-host the GA build, budget memory for BF16 weights and quantize yourself. The low-precision lesson still applies at serving time: an aggressive local quant (an IQ3 GGUF, an fp8 KV cache) stacked on further quantization is where the garbage-output reports in the serving section come from.

Benchmarks: Self-Reported vs Independent

DeepSeek V4 Flash's SWE-bench numbers are self-reported or aggregated, not contamination-free. The llm-stats SWE-bench Verified board lists DeepSeek-V4-Flash-Max at 79.0% (rank #16); DeepSeek's own technical report lists 73.7%. There is no independent DeepSWE re-run for Flash: the written-from-scratch benchmark only ever tested the V4 Pro preview, at 8% pass@1. For the 0731 GA checkpoint, DeepSeek self-reports DeepSWE 54.4, Terminal-Bench 2.1 82.7, and Toolathlon-Verified 70.3, all on its own harness. Read the number, then read where it came from.

The reconciliation is the same story the broader V4 guide tells for Pro, one variant down: the flattering 79% comes off a loose-verifier harness (SWE-bench Verified) fed by provider-reported runs, while the one contamination-free benchmark that stress-tested long-horizon agent behavior never covered Flash. If you see a Flash SWE-bench figure quoted as fact, check whether it is a vendor scaffold, an aggregator, or an independently re-run harness. As of August 2026 none of the independent harnesses have re-run the 0731 checkpoint's agentic-coding claims.

The one clean independent signal is Artificial Analysis's standardized Intelligence Index, where Flash-0731 scores 52, well above the median of 27 for open-weight models of similar size and 1 point behind V4 Pro-0813's 53. AA also clocks it at 133.1 output tokens per second on DeepSeek's API, double the 66.8 median. Those are the numbers to trust over the 79% headline.

Cheap Tokens, Expensive Habits

The number that decides whether Flash is actually cheap is output tokens per task, not price per token. Artificial Analysis measured Flash-0731 emitting 210M output tokens to run its full Intelligence Index, versus a 100M median for open-weight models of similar size. A model that talks 2x more than its peers spends its per-token discount on itself. This is the "cheap tokens, expensive habits" trap, and Flash is a textbook case.

The counterintuitive part, measured on the April preview checkpoints: on the same Index, Flash emitted more total output tokens than V4 Pro. Artificial Analysis's preview-era head-to-head run put Flash at 240M tokens against Pro's 190M and explicitly flagged Flash's count as "higher than Pro despite being smaller." The pattern persists on the GA builds: AA flags both Flash-0731 (210M vs 100M median) and Pro-0813 ("somewhat verbose") on verbosity. The smaller model reasons longer to reach the same answer. Per token Flash is 3x cheaper than Pro; per task the gap is smaller, because Flash burns more output tokens getting there.

The Flash rows are the point. On a terse extraction task Flash costs a rounding error. On a max-effort reasoning task where it emits 5x the tokens, the per-task cost climbs an order of magnitude, and the 3x per-token discount over Pro partly evaporates because Flash needs more tokens to land the answer. The task-cost numbers above use Flash's three reasoning effort levels (low / high / max) as the output-token driver; the per-task token estimates for the reasoning rows are illustrative, anchored on the Artificial Analysis Index measurements, and will vary with your prompt. The lesson is structural: pick the lowest effort level that clears your task, and cache aggressively (a Flash cache hit is $0.007/M off-peak, roughly 31x below the miss rate).

Flash vs Pro: When Each Wins

Use Flash for high-volume, latency-tolerant, and cost-sensitive work; reach for Pro when the task needs the extra active parameters and you want it done in fewer tokens. On the GA checkpoints the independent gap is 1 point on the Artificial Analysis Intelligence Index (Flash-0731 at 52 vs Pro-0813 at 53), so for most non-frontier tasks Flash is the rational default. Pro earns its 3x output premium on hard, long-horizon agent loops where terseness and capability compound.

The routing pattern most teams land on: Flash as the workhorse for bulk extraction, classification, first-draft edits, and background agent tasks; Pro reserved for the hardest planning and multi-file refactors. Because both speak the same API and share the 1M context, switching is a model-string change, not a re-architecture.

Serving Footguns (vLLM / SGLang)

DeepSeek V4 Flash's efficiency comes from aggressive low-precision attention, and that is exactly where serving breaks. Across vLLM and SGLang, the recurring failures are FP8 quantization interacting badly with parallelism, and the DSML tool-call parser mishandling edge cases. The serving flags are --tool-call-parser deepseek_v4 and --reasoning-parser deepseek_v4; the bugs below are all real, filed issues.

• FP8 crashes under DP + EP (vLLM #43648). DeepSeek-V4-Flash-FP8 "crashes consistently after processing partial benchmark requests" with data-parallel + expert-parallel on H200; one report died after 135/600 requests at ~1118 tok/s.
• DSML tool parser mishandles wrapped/reserved args (vLLM #41240). Wrapper params named arguments or input get incorrectly unwrapped when they are real schema fields, and streaming "doesn't flush plain text that resembles DSML markers (like 2 <)." If your tools have an arguments parameter, test round-tripping first.
• FP8 + pipeline-parallel garbage output (SGLang #25662). DeepSeek-V4-Flash-FP8 with --pp-size 8 on 8x H20 emitted garbage CJK tokens (第 〖 〗 …) instead of coherent text, a precision breakdown, not a prompt issue.
• Local (llama.cpp) multi-turn was broken until July 7, 2026. Per Unsloth, multi-turn tool calling was only fixed and merged that day (llama.cpp #25202), and --cache-type-k/v q8_0 "caused malformed outputs." Unsloth recommends the UD-IQ3_XXS quant (103GB) and sampling at temperature 1.0, top-p 1.0.

Pricing and How to Run It on Morph

DeepSeek V4 Flash first-party pricing since August 16, 2026 runs peak and off-peak: $0.22/M input (cache miss), $0.007/M (cache hit), and $0.66/M output off-peak, doubling to $0.44/$0.014/$1.32 during peak hours (01:00-04:00 and 06:00-10:00 UTC). OpenRouter lists deepseek/deepseek-v4-flash-0731 at $0.065/M input and $0.18/M output across third-party hosts, with no peak surcharge. Artificial Analysis clocks the DeepSeek API at 133.1 output tokens per second. Most serverless hosts quantize activations to fp8 to cut cost, which moves output away from the reference weights.

Morph serves morph-dsv4flash at 16-bit (bf16) activations with no fp8 activation quantization, so output matches the published weights, at $0.09875/M input and $0.278/M output with the full 1M-token context. For coding agents specifically, Morph adds codegen-tuned speculative decoding and custom low-level inference kernels built for code generation. Call it through the OpenAI-compatible API:

from openai import OpenAI

client = OpenAI(
    base_url="https://api.morphllm.com/v1",
    api_key="YOUR_MORPH_API_KEY",
)

resp = client.chat.completions.create(
    model="morph-dsv4flash",
    messages=[
        {"role": "user", "content": "Refactor this function to be async."},
    ],
)
print(resp.choices[0].message.content)

See Morph Open Source Models for the full lineup and pricing for every model's rates. For the broader DeepSeek V4 family, cost math against Opus 4.8 and GPT-5.5, and the Claude Code setup, see the DeepSeek V4 guide and DeepSeek API guide.

DeepSeek V4 Flash API: Pricing and How to Call It

The DeepSeek V4 Flash API is OpenAI-compatible (it also speaks the Anthropic format), so calling it is a base-URL and model-id change. Morph serves it as morph-dsv4flash at $0.09875/M input and $0.278/M output with the full 1,048,576-token (1M) context, at 16-bit activations, flat at every hour. DeepSeek's own platform prices it at $0.22/M input (cache miss), $0.007/M input (cache hit), and $0.66/M output off-peak, double at peak. The legacy deepseek-chat and deepseek-reasoner aliases retired on July 24, 2026.

Call the DeepSeek V4 Flash API with the OpenAI SDK

Point any OpenAI-SDK client at https://api.morphllm.com/v1, pass your key as a Bearer token, and set the model to morph-dsv4flash:

from openai import OpenAI

client = OpenAI(
    base_url="https://api.morphllm.com/v1",
    api_key="YOUR_MORPH_API_KEY",
)

resp = client.chat.completions.create(
    model="morph-dsv4flash",
    messages=[
        {"role": "user", "content": "Refactor this function to be async."},
    ],
)
print(resp.choices[0].message.content)

The raw HTTP call is a POST to https://api.morphllm.com/v1/chat/completions with an Authorization: Bearer YOUR_MORPH_API_KEY header and a JSON body naming morph-dsv4flash. Because Flash is verbose, cap the reasoning effort level (low / high / max) at the lowest that clears your task, and keep the model's reasoning_content in history so multi-turn tool calling does not break.

DeepSeek V4 Flash API pricing compared

Since DeepSeek's August 16, 2026 repricing, Morph's flat rate sits below DeepSeek's own off-peak cache-miss rates and at less than a quarter of its peak rates. The serving also differs: DeepSeek's serverless path typically quantizes activations to fp8; Morph runs bf16 with no fp8 activation quant, so output matches the reference weights:

Sources: DeepSeek's rates reflect the August 16, 2026 repricing reported by InfoWorld and announced in DeepSeek's V4-Pro GA release note; Morph rates are the canonical pricing for morph-dsv4flash.

Getting a DeepSeek V4 API key on Morph

Sign up at morphllm.com, create a key in the dashboard, and send it as Authorization: Bearer YOUR_MORPH_API_KEY. One key covers the whole model lineup. For the head-term DeepSeek API walkthrough (setup, cache pricing, Claude Code), the pricing hub is the DeepSeek API guide; for the Pro variant and the full family cost math, see the DeepSeek V4 guide. This page is the Flash-variant deep dive, not the pricing hub, so those complement rather than duplicate it.

Flash vs GLM 5.2, MiniMax M3, Qwen 3.5

Among cheap open-weight coding models, DeepSeek V4 Flash is the cost floor: lowest per-token price and the only one that fits a full 1M context on a single 128GB box. It trades raw intelligence for that. GLM 5.2 leads on the Intelligence Index, MiniMax M3 adds native multimodality, and Qwen 3.5 offers a permissive Apache license with a hybrid-attention design. The right pick depends on whether you optimize for cost, capability, or modality.

Deep-dives on each: GLM 5.2, MiniMax M3, and Qwen 3.5. A common production pattern routes bulk work to Flash, hard text reasoning to GLM 5.2, and multimodal or UI-agent tasks to MiniMax M3, all behind one OpenAI-compatible endpoint.

Pros and Cons

When to Use It, When Not

Use DeepSeek V4 Flash when you run high-volume, latency-tolerant, cost-sensitive workloads: bulk extraction, classification, first-draft edits, batch evals, and background agent tasks where $0.66/M off-peak output (or Morph's flat $0.278/M) matters more than the last point of benchmark accuracy. Schedule batch jobs in the 17 off-peak hours to dodge the 2x peak surcharge. It is also the best pick when you want to self-host a full 1M-token context on a single box.

Reach for V4 Pro on hard, long-horizon agent loops where terseness and the extra active parameters pay for the 3x premium; GLM 5.2 when you want the top open-weight Intelligence Index for text-only reasoning; or MiniMax M3 when the agent needs to read screenshots or video. And on any task where Flash's verbosity would blow your token budget, cap it at the low or high reasoning effort level rather than max, and lean on caching.

Frequently Asked Questions

What is DeepSeek V4 Flash?

The smaller, cheaper variant of DeepSeek V4, previewed April 24, 2026 and GA since July 31, 2026 as DeepSeek-V4-Flash-0731, under MIT. 284B total / 13B active, 1M-token context, 384K max output. It shares V4 Pro's CSA + HCA sparse attention but fits a full 1M context on a single 128GB box. First-party pricing since August 16 is $0.22/M input and $0.66/M output off-peak, double at peak.

How is Flash different from V4 Pro?

Pro is 1.6T / 49B; Flash is 284B / 13B. Flash is 3x cheaper on every line item ($0.66/M vs $1.98/M output off-peak) but scores only 1 point lower on the Artificial Analysis Intelligence Index (52 vs 53 on the GA checkpoints) and is more verbose per task. Both share the 1M context, 384K max output, and attention design.

What is DeepSeek V4 Flash's SWE-bench score?

79.0% on the llm-stats SWE-bench Verified board (Flash-Max), and 73.7% in DeepSeek's own technical report, both preview-era and aggregated or self-reported. For the 0731 GA checkpoint DeepSeek self-reports DeepSWE 54.4 and Terminal-Bench 2.1 82.7 on its own harness. No independent tracker has re-run the GA build's agentic-coding claims.

Does cheap Flash pricing mean cheap tasks?

Not automatically. Artificial Analysis measured Flash-0731 emitting 210M output tokens to run its Intelligence Index versus a 100M median for its size. The $0.66/M off-peak sticker is real, but its verbosity pushes effective cost-per-task well above the per-token rate. Cap the reasoning effort level and cache to control it.

Can DeepSeek V4 Flash run locally?

Yes. Unsloth recommends the UD-IQ3_XXS quant (103GB, needs 110-135GB RAM); HN users report running it "under 128GB" with a full 1M context entirely in GPU RAM. Note llama.cpp multi-turn tool calling was only fixed July 7, 2026, and a q8_0 KV cache caused malformed outputs.

What serving flags does Flash need on vLLM/SGLang?

--tool-call-parser deepseek_v4 and --reasoning-parser deepseek_v4, with FP8 via --kv-cache-dtype fp8. Watch for the FP8 + DP/EP crash (vLLM #43648), the DSML tool-parser edge cases (vLLM #41240), and FP8 + pipeline-parallel garbage output (SGLang #25662). Validate your quant-plus-parallelism combination first.

When were deepseek-chat and deepseek-reasoner retired?

They aliased to deepseek-v4-flash (non-thinking and thinking) and retired on July 24, 2026, 15:59 UTC. Call deepseek-v4-flash or deepseek-v4-pro directly. Since the 0731 checkpoint, Flash exposes three reasoning effort levels: low, high, and max.