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

TL;DR

Last updated July 2026.

DeepSeek V4 Flash is the smaller, cheaper variant of DeepSeek V4, released April 24, 2026 under the MIT license. It has 284B total parameters with 13B active per token, a 1M-token context window, and 384K max output. First-party API pricing is $0.14/M input and $0.28/M output, roughly one-third of V4 Pro's $0.87 output rate. On the llm-stats SWE-bench Verified board, Flash-Max posts 79.0% versus Pro-Max's 80.6%.

What Is DeepSeek V4 Flash?

DeepSeek V4 Flash is the smaller of the two DeepSeek V4 models, released April 24, 2026 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. 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, and the legacy deepseek-chat / deepseek-reasoner endpoints now alias to Flash.

Morph serves it as morph-dsv4flash (DeepSeek V4 Flash) on custom kernels via an OpenAI-compatible API at $0.139/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 Flash model card describes a mixed FP4/FP8 quantization: MoE expert parameters ship in FP4, most other parameters in FP8. This is native to the released weights, not a community afterthought, and is part of why Flash is so memory-light. It also means "quantization" on Flash is not one lever: an aggressive local quant (an IQ3 GGUF, an fp8 KV cache) stacks on top of an already-low-precision base, which 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 DeepSWE entry for Flash at all: the written-from-scratch benchmark only ever tested V4 Pro, at 8% pass@1. 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 July 2026 none of the independent harnesses have a re-run Flash agentic-coding number.

The one clean independent signal is Artificial Analysis's standardized Intelligence Index, where Flash scores 40 (47 at Max effort). That places it in the competent-but-not-frontier band, consistent with a 13B-active model, and it is the number 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 emitting 230M output tokens to run its full Intelligence Index at Max reasoning effort, versus an 88M median for open-weight models of similar size. A model that talks 2.6x 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: on the same Index, Flash emitted more total output tokens than V4 Pro. Artificial Analysis's comparison run put Flash at 240M tokens ($113 to run the Index) against Pro's 190M ($1,071), and explicitly flagged Flash's count as "higher than Pro despite being smaller." The smaller model reasons longer to reach the same answer. Per token Flash is 3.1x cheaper than Pro; per task the gap is smaller, because Flash burns roughly 25% more output tokens getting there.

The Flash rows are the point. On a terse extraction task Flash costs a rounding error. On a Think-Max reasoning task where it emits 5x the tokens, the per-task cost climbs an order of magnitude, and the 3.1x 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 effort tiers (Non-think / Think High / Think 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 tier that clears your task, and cache aggressively (a Flash cache hit is $0.0028/M, 50x 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. The independent score gap is only 1.6 points on SWE-bench Verified (Flash-Max 79.0% vs Pro-Max 80.6%), so for most non-frontier tasks Flash is the rational default. Pro earns its 3.1x 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 is $0.14/M input (cache miss), $0.0028/M (cache hit), and $0.28/M output, with a 2500 concurrency limit. OpenRouter routes it across hosts (its own endpoint at $0.09/$0.18, DeepSeek Platform and Novita at $0.14/$0.28, Microsoft Foundry at $0.19/$0.51), with top throughput around 84 tok/s. 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.139/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.

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 the 2500 concurrency limit and $0.28/M output matter more than the last two points of benchmark accuracy. 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 3.1x 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 Non-think or Think-High effort tier rather than Think Max, and lean on caching.

Frequently Asked Questions

What is DeepSeek V4 Flash?

The smaller, cheaper variant of DeepSeek V4, released April 24, 2026 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 is $0.14/M input and $0.28/M output.

How is Flash different from V4 Pro?

Pro is 1.6T / 49B; Flash is 284B / 13B. Flash is 3.1x cheaper per output token and allows 5x the concurrency (2500 vs 500), but scores 79.0% vs 80.6% on SWE-bench Verified (Max) 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 are aggregated or self-reported. There is no contamination-free (DeepSWE) Flash entry; DeepSWE only ever tested V4 Pro, at 8%.

Does cheap Flash pricing mean cheap tasks?

Not automatically. Artificial Analysis measured Flash emitting 230M output tokens to run its Intelligence Index versus an 88M median for its size, and even more than V4 Pro on the same run. The $0.28/M sticker is real, but its verbosity pushes effective cost-per-task well above the per-token rate. Cap the effort tier 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 are deepseek-chat and deepseek-reasoner retired?

They alias to deepseek-v4-flash (non-thinking and thinking) and are fully retired after July 24, 2026, 15:59 UTC. Migrate to deepseek-v4-flash or deepseek-v4-pro before then. Flash exposes Non-think, Think High, and Think Max effort tiers.