DeepSeek V4.1 Flash API

DeepSeek V4.1 Flash is the first model in a new architecture family from DeepSeek, the Hangzhou lab behind the V3, R1 and V4 open models. It is a 552-billion-parameter mixture-of-experts model that reads text and images, holds a one-million-token context, and activates only 8 billion parameters per token while reading input and 16 billion while writing. DeepSeek's launch line is short: "smarter, faster, more efficient."

The headline is how much agent skill DeepSeek fits into so few active parameters. In DeepSeek's own comparison V4.1 Flash scores 74.2 on DeepSWE v1.1, a hair ahead of Claude Opus 5 at 74.0 and GPT-5.6 Sol at 73.0, and 90.6 on Terminal-Bench 2.1, the best figure in the table. It also beats DeepSeek's own much larger V4 Pro on every agentic benchmark shown. Artificial Analysis places it at about 40 on its Intelligence Index on launch, ahead of V4 Pro.

The weights are on Hugging Face under the MIT License from day one. On Unicorn API the model comes in three routes: the standard model plus FP8 and FP4 versions served at lower numeric precision, each suited to a different kind of work.

DeepSeek's new family, under the MIT License

DeepSeek released V4 in April 2026 as two models, V4 Pro with 1.6 trillion parameters and V4 Flash with 284 billion. V4.1 Flash replaces V4 Flash directly: on launch day DeepSeek retired V4 Flash and its vision preview, and pointed their API names at the new model, which answers to deepseek-flash on DeepSeek's own API. DeepSeek calls it "the smallest model in our new architecture family" and describes it as a starting point for larger models built the same way.

Licensing is as simple as it gets. The repository and weights are published under the plain MIT License, with no usage restrictions, revenue thresholds or branding rules. The release includes the technical report, a reference inference implementation, a prompt encoder with test cases and a Rust toolkit called deepseek-recipe for production prompt formatting. There is no Jinja chat template in the release; DeepSeek points serving teams to its reference encoder instead.

The checkpoint is already stored in low precision: the dense weights are in FP8, and the routed experts are stored in 4-bit floating point. That detail matters for the FP8 and FP4 routes discussed below.

What changed from DeepSeek V4 Flash

About twice the parameters, fewer active. V4 Flash had 284 billion parameters with 13 billion active. V4.1 Flash has 552 billion, plus a separate 196-billion-parameter Engram memory looked up by token, yet activates 8 billion parameters per input token and 16 billion per generated token.

A quarter of the cache. The key-value cache, the memory a model keeps for every token of context, is the main memory burden of serving long contexts. V4.1 Flash needs 890 bytes per token of global cache, about a quarter of V4 Flash, and a persistent cache (the part kept on disk or in host memory for reuse) of about an eighth. DeepSeek charts this as a 437-fold reduction since its first model.

Context that barely slows it down. Going from a 4,000-token to a million-token context raises the compute per generated token by only a quarter, according to the technical report.

Native vision. V4 Flash relied on a separate experimental vision model. V4.1 Flash has its own vision encoder, DeepSeek-ViT, trained from scratch, and images are part of pre-training from the start.

Big agentic gains. DeepSeek's table, at maximum reasoning effort, shows the jump:

A continuous effort dial. The model was trained with a reasoning effort from 1 to 100. DeepSeek's API exposes three tiers: low (50), high (75) and max (100).

How the encoder-decoder design works

The 40 layers are split into a 20-layer causal encoder and a 20-layer decoder. Instead of each decoder layer building its own long-range cache, the decoder's cache is projected from the encoder's final states. That is why reading is lighter than writing: prefill, the pass over your input, runs through fewer active parameters. DeepSeek built this for agents, whose inputs (files, tool results, long histories) dwarf their outputs.

Attention uses Compressed Sparse Attention 2, in which layers share cached keys and values and reuse each other's choices of which earlier tokens to attend to. The main cache is stored in 4-bit, trained in during post-training so the model learns to live with it. Each MoE layer has 1 shared expert and 384 routed experts, 6 of which fire per token. A speculative decoding module, DSpark, drafts several tokens at once to speed up generation.

Pre-training used 45 trillion tokens of text and image data. DeepSeek says the base model matches V4 Pro's base model on knowledge, reasoning and coding with a third of the total and a quarter of the active parameters. Post-training uses a standard recipe, supervised fine-tuning, reinforcement learning and on-policy distillation; DeepSeek says all the substantive changes are in data, especially large-scale synthetic agent tasks and environments.

DeepSeek V4.1 Flash specs

Where V4.1 Flash is strong

Agentic coding. DeepSWE 74.2 and Terminal-Bench 2.1 90.6 put it level with or ahead of the closed frontier in DeepSeek's table, and DeepSeek describes it as "fully capable of handling everyday coding tasks and white-collar workflows." Developers on Hacker News reported the same in practice; one wrote that "it can build an entire Rails app in no time and even do the tests."

Tool use and automation. It leads the table on AutomationBench (54.8 against 50.3 for Opus 5), Agent's Last Exam (31.8) and Humanity's Last Exam with tools (63.9), and scores 88.1 on the CyberGym security benchmark.

Speed. Artificial Analysis measured about 216 output tokens per second on DeepSeek's API with under a second to first token, and the small active footprint is what makes it so light to serve. Testers on Hacker News reported even higher speeds on some hosts.

Long, cached contexts. The tiny cache makes million-token sessions practical to serve, and a persistent cache about an eighth the size of V4 Flash's lets long agent histories be kept and reused between turns instead of recomputed.

Charts and screenshots. DeepSeek reports it beats Kimi K3 on visual reasoning and professional chart reading, and can check its own frontend work from rendered screenshots.

Where it falls short

Knowledge without tools. On Humanity's Last Exam without tools it scores 36.8, against 56.3 for Opus 5 and 44.5 for GPT-5.6 Sol. For factual questions, give it search or documents.

Confident guessing. Artificial Analysis found 43% accuracy on its AA-Omniscience knowledge test but a non-hallucination rate of just 4%: when it does not know, it almost always answers anyway.

The hardest agent tasks. DeepSeek acknowledges a gap on science-heavy work such as Terminal-Bench 4.0, where it scores 31.2 against 51.8 for Opus 5, and on the hardest reasoning. ProgramBench (20.3 against 37.0) and NL2Repo (64.0 against 75.3) tell the same story.

Sensitive to the harness. DeepSWE scores range from 65.5 in OpenCode and 65.6 in Codex to 69.8 in Claude Code and 74.2 in the mini-SWE scaffold, so results depend on the agent wrapper.

Launch-week rough edges. Users reported the web app sometimes thinking and answering in Chinese to English questions, some third-party hosts returning invalid tool calls, and coarse effort tiers: one complained that "low is pretty much the same as turning reasoning off, and high is similar to max." DeepSeek itself notes that its new sparse attention and cache shortcuts may degrade in edge cases it has not tested.

Standard, FP8 or FP4: what quantization changes

Quantization stores a model's numbers with fewer bits. FP8 uses 8 bits per weight, FP4 uses 4. Fewer bits mean less memory and faster arithmetic on modern GPUs, so a host can serve more requests on the same hardware. The trade-off is precision: each weight is rounded more coarsely, which can shift answers slightly, usually showing up first in long reasoning chains, exact arithmetic and rare knowledge.

For a sense of scale, NVIDIA's 4-bit version of DeepSeek-R1 scored 84.2 on MMLU-Pro against 85 for the 8-bit model, and 80.0 against 81 on GPQA Diamond: a point or so lower, at about 1.6 times less memory. No such comparison has been published for V4.1 Flash, so treat FP4 as close but not guaranteed identical.

On Unicorn API:

• DeepSeek V4.1 Flash is the full-featured route: image input and every reasoning level from none to max. Pick it for screenshots, charts, or when you want maximum effort.
• DeepSeek V4.1 Flash FP8 runs at 8-bit precision, closest to the checkpoint DeepSeek publishes. It suits text work with long replies and heavy reasoning where you want answers as near the reference model as a quantized route gets.
• DeepSeek V4.1 Flash FP4 pushes more of the model into 4 bits, trading a little precision for the lightest serving footprint of the three. Pick it for bulk classification, extraction, summaries, drafts and agent steps you validate anyway.

The FP8 and FP4 routes are each pinned to a single provider at that precision with no silent fallback, accept text only, and offer reasoning_effort low, medium and high.

How to prompt DeepSeek V4.1 Flash

DeepSeek recommends temperature 1.0 and top_p 0.95. Its report shows that most of the accuracy arrives at moderate effort: an effort of 60 to 80 recovers most of the maximum's accuracy at under half the tokens, while the top setting lengthens agent runs by 1.6 to 1.8 times. Raising effort from 25 to 100 lifts DeepSWE from 66.0 to 74.2 but writes about 2.5 times as many output tokens. Use medium or high by default and save max for the hardest problems.

Give it a concrete, checkable job:

Write a Python script that reads orders.csv, flags rows where the ship date is earlier than the order date or the quantity is not a positive whole number, and writes the bad rows to errors.csv. Standard library only. Add three unit tests.

For agents, state limits plainly:

You are working in this repository. Fix the failing test in payments/. Do not change public function signatures or add dependencies. Run the tests after every change and stop when they pass.

For images on the standard route:

Here is a screenshot of our dashboard. List every chart, what it measures, and any axis label or legend that is missing or unreadable.

For facts, ground it: paste the source and ask for quotes, since the model rarely declines to answer.

DeepSeek V4.1 Flash versus Opus 5, GPT-5.6 Sol and Kimi K3

Claude Opus 5 is the model V4.1 Flash matches on DeepSWE and Terminal-Bench 2.1. Opus 5 is far ahead on Humanity's Last Exam, Terminal-Bench 4.0, ProgramBench and NL2Repo. Use Opus 5 for the hardest reasoning and long software builds; use V4.1 Flash for everyday coding and agent loops where volume matters.

GPT-5.6 Sol leads V4.1 Flash on GPQA Diamond, Humanity's Last Exam and SEC-Bench Pro, and trails it on DeepSWE (73.0 against 74.2) and CyberGym (84.5 against 88.1).

Kimi K3 is the other big open-weight option. V4.1 Flash beats it on DeepSWE (74.2 against 67.5), Terminal-Bench and the visual benchmarks in DeepSeek's table. K3 is a much larger model and Moonshot's licence adds conditions for very large deployments; V4.1 Flash's MIT licence adds none.

Among fast Flash-class models, Gemini 3.8 Flash is the closed alternative to consider if you also need video input, which V4.1 Flash does not take.

Getting started

Open the model in the Playground, or try the FP4 route side by side. To build with it, create a key on the API keys page and call the OpenAI-compatible /v1/chat/completions endpoint with model: "deepseek-v4-1-flash", deepseek-v4-1-flash-fp8 or deepseek-v4-1-flash-fp4. Tools use the standard tools array, response_format: { "type": "json_object" } returns JSON, and images go in as image_url parts on the standard model. The docs cover streaming, tools and errors.

Verdict

DeepSeek V4.1 Flash shows how far architecture can push efficiency. A model with 16 billion active parameters matches Claude Opus 5 on DeepSWE, clears 90 on Terminal-Bench 2.1, reads images and a million tokens, and ships under the MIT License. It is not a frontier reasoner: knowledge questions without tools, science-heavy agent tasks and its habit of guessing all argue for checks. For coding agents, automation and high-volume text work, with the FP4 route for bulk jobs, it is one of the strongest open models available at launch.