AI DevelopmentOpen Source

DeepSeek V4.1 Flash: What Changed and How to Migrate

October 14, 2026
11 min read
Rows of server racks fading into soft focus in a quiet data center
Share:

On September 10, 2026, DeepSeek released DeepSeek-V4.1-Flash: an MIT-licensed, multimodal mixture-of-experts model with a 1M-token context that takes image and text input and answers in text. The API name is deepseek-flash, and it replaces the V4 Flash names you may already have in production.

This is a migration guide, not a hype piece. Every number below comes from DeepSeek’s own docs or model card (checked October 14, 2026), and benchmarks are labeled self-reported. I did not run the model myself, so there are no first-hand latency or quality claims here.

1. The spec sheet, and one number that doesn’t add up

DeepSeek’s changelog dates the release to 2026-09-10 and tells API users to set the model to deepseek-flash. The model card calls it a multimodal Mixture-of-Experts model with 552B backbone parameters and support for contexts of up to one million tokens, released under the MIT license.

ā€œActive parametersā€ needs care here. The card says the model activates 8B parameters per token during prefill and 16B during decode, because it uses a causal encoder–decoder layout (a 40-layer stack split into a 20-layer encoder and a 20-layer decoder). That is not the single ā€œ13B activatedā€ figure V4 Flash’s card gave.

Model card at a glance

  • • Released: 2026-09-10 (DeepSeek changelog); weights at deepseek-ai/DeepSeek-V4.1-Flash on Hugging Face
  • • License: MIT for repository and weights (model card)
  • • Size: 552B backbone parameters plus a 196B Engram memory table, sparsely accessed (model card)
  • • Experts: 384 routed + 1 shared per MoE layer, 6 routed experts per token (card and config.json)
  • • Active: 8B per token in prefill, 16B in decode (model card)
  • • Context: 1M tokens; max output up to 384K on the API (pricing page)
  • • Modalities: image + text in, text out (model card)
  • • API: deepseek-flash at https://api.deepseek.com (OpenAI format) or https://api.deepseek.com/anthropic
  • • Price per 1M tokens (pricing page): peak $0.30 input (cache miss) / $1.20 output; off-peak $0.15 / $0.60; cache hit $0.006 peak, $0.003 off-peak
  • • Peak hours: 01:00–04:00 and 06:00–10:00 UTC, Monday to Friday, excluding Chinese public holidays

The 552B vs 763B discrepancy

The card text says 552B backbone parameters (plus the 196B Engram table). Hugging Face’s auto-generated safetensors metadata for the same repo shows about 763B. The card does not explain the gap; 552B + 196B is 748B, closer but not a match. The previous V4 Flash card shows the same pattern (284B in the text, 291B in the metadata), so my reading is that the metadata is a tensor count rather than a second official size, but DeepSeek has not said so. For planning, use the one figure that is unambiguous: roughly 510 GB on disk.

2. What changed vs V4 Flash

The previous generation is DeepSeek V4, launched April 24, 2026 with V4-Pro and V4-Flash. V4 Flash was a 284B-total, 13B-activated MoE whose card lists text generation; an experimental vision build (deepseek-v4-flash-vision-exp) followed on August 21. DeepSeek’s announcement calls V4.1 Flash the smallest model in a new architecture family, with native visual understanding.

The card lists a new encoder–decoder design, a compressed sparse attention variant, FP4 key-value caching, an Engram memory module and DSpark speculative decoding. The practical effects fall into three buckets, and the benchmark table below shows where the agentic-coding gains are.

The three things you will notice

šŸ‘ļø

Vision in the main model

Image + text input on deepseek-flash, with no separate experimental name. Output is text only. The card describes a vision encoder (DeepSeek-ViT) trained from scratch.

🧠

Cheaper long context

Global KV cache of 890 bytes per token, about a quarter of V4 Flash per the card; persistent KV cache roughly 1/8 with SWA bounded replay. The announcement says 1/4 the HBM and 1/8 the SSD.

šŸ’°

Lower price

The pricing page lists $0.30 / $1.20 per 1M tokens at peak. My earlier V4 guide recorded $0.44 / $1.32 for V4 Flash at peak; DeepSeek says only that prices were ā€œreduced accordinglyā€.

Self-reported benchmarks (model card)

Order: V4.1 Flash / V4 Flash / Opus-5.0, all at max reasoning effort (reasoning_effort=100, temperature 1.0, top_p 0.95), as published in DeepSeek’s own table.

  • • Terminal-Bench 2.1 (Pass@1): 90.6 / 82.7 / 89.1
  • • DeepSWE v1.1 (Resolved): 74.2 / 54.4 / 74.0
  • • AutomationBench (Pass@1): 54.8 / 37.7 / 50.3
  • • CyberGym (Pass@1): 88.1 / 76.7 / not listed
  • • Codeforces (rating): 3471 / 3289 / not listed
  • • GPQA Diamond (Pass@1): 90.9 / 89.9 / 93.4
  • • HLE (Pass@1): 36.8 (39.1 on the text-only subset) / 37.8 text-only / 56.3
  • • Terminal-Bench 4.0 (Pass@1): 31.2 / 7.0 / 51.8

How I read it

Large claimed gains over V4 Flash on agentic coding and terminal tasks, roughly flat on GPQA and HLE, and a clear gap to Opus-5.0 on the hardest reasoning and long-horizon rows. That is a promising profile for a cheap workhorse model, not proof of a frontier leap. Rank it on your own tasks.

3. API migration notes

The September 10 entry in DeepSeek’s changelog is the source of truth: set the model to deepseek-flash. The old names deepseek-v4-flash and deepseek-v4-flash-vision-exp are ā€œtemporarily routedā€ to V4.1 Flash, and the pricing page says those models are retired and their requests are served by V4.1-Flash. No removal date is given, so treat the aliases as a bridge, not a contract.

Two consequences. Any eval you pinned to V4 Flash behavior is now measuring a different model, and your bill moves without a code change. Re-run your evals and compare tokens per task before you trust last month’s numbers.

Name timeline (DeepSeek changelog)

  • • 2026-04-24: V4 launches with deepseek-v4-pro and deepseek-v4-flash; deepseek-chat and deepseek-reasoner announced for discontinuation on 2026-07-24
  • • 2026-08-13: V4-Pro GA update; reasoning effort low / high / max; peak and off-peak pricing from 2026-08-16 16:00 UTC
  • • 2026-08-21: deepseek-v4-flash-vision-exp, the experimental vision build
  • • 2026-09-10: V4.1-Flash and deepseek-flash; new pricing from 04:00 UTC; older Flash names routed to it

Behavior to check before you switch

  • • Thinking is on by default with effort high. Set thinking and reasoning_effort explicitly so the default does not set your spend.
  • • Documented effort values are low, high and max (minimal maps to low; medium and xhigh map to high; ultra maps to max).
  • • The model card’s scores use reasoning_effort=100 (an integer from 1 to 100). The hosted API docs I read list only low / high / max, so I would not assume the integer scale works on the API.
  • • In thinking mode, temperature, presence_penalty and frequency_penalty have no effect (no error), and top_p below 0.95 is treated as 0.95.
  • • With tools in thinking mode, pass back the reasoning_content of all previous turns or the API returns a 400. Appending the whole message object does this for you.
  • • Same API surface as before per the pricing page: JSON output, tool calls, Responses API, Anthropic-format endpoint, chat prefix completion (beta).

V4 Pro: two documents disagree

The September 10 announcement says that from 04:00 UTC on September 14 all deepseek-v4-pro requests would route to V4.1-Flash at Flash rates until a V4.1-Pro ships. The changelog entry for the same release says DeepSeek decided, ā€œin response to user demandā€, to keep providing V4 Pro API service after September 14 with billing unchanged, and the pricing page still lists deepseek-v4-pro (DeepSeek-V4-Pro-0813) at its own price. The changelog reads like the later word, but I cannot see timestamps, so base Pro decisions on the pricing page and watch the changelog. I found no sign that a V4.1-Pro has shipped.

4. Quickstart: two snippets from DeepSeek’s docs

The API is OpenAI-compatible, so you keep your SDK and change the base URL and model name. These are DeepSeek’s own samples (quick start and vision guide), lightly trimmed. Create a key at platform.deepseek.com/api_keys and export it as DEEPSEEK_API_KEY.

Python: OpenAI SDK, the one-line migration

Only the model string changes from V4 Flash. thinking goes inside extra_body with the OpenAI SDK.

# pip3 install openai
import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get("DEEPSEEK_API_KEY"),
    base_url="https://api.deepseek.com",
)

response = client.chat.completions.create(
    model="deepseek-flash",  # was: deepseek-v4-flash
    messages=[
        {"role": "system", "content": "You are a helpful assistant"},
        {"role": "user", "content": "Hello"},
    ],
    stream=False,
    reasoning_effort="high",
    extra_body={"thinking": {"type": "enabled"}},
)
print(response.choices[0].message.content)

Python: image input (new on the main model)

From the DeepSeek vision guide: a base64 data URL inside an image_url block, in a user message.

import base64
from openai import OpenAI

client = OpenAI(api_key="<DeepSeek API Key>", base_url="https://api.deepseek.com")

with open("image.jpg", "rb") as f:
    b64 = base64.b64encode(f.read()).decode("utf-8")

response = client.chat.completions.create(
    model="deepseek-flash",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "What is in this image?"},
                {
                    "type": "image_url",
                    "image_url": {"url": f"data:image/jpeg;base64,{b64}"},
                },
            ],
        }
    ],
)
print(response.choices[0].message.content)

Vision constraints from the guide

Accepted formats are JPEG, PNG, GIF and WebP. Images are supported in user messages only; system or assistant messages return a 400. There is an upper bound of 1024 tokens per image, and the optional detail field (low, high, original, auto) trades cost for fidelity: low downscales to 512Ɨ512.

What a job costs (my arithmetic from the pricing page)

10M input tokens (cache miss) plus 2M output tokens on deepseek-flash at peak is 10 Ɨ $0.30 + 2 Ɨ $1.20 = $5.40; the same job off-peak is $2.70. On deepseek-v4-pro at peak it is 10 Ɨ $1.32 + 2 Ɨ $3.96 = $21.12, about 3.9Ɨ more. Cache hits drop input to $0.006 per 1M at peak.

5. Self-hosting reality check

The MIT weights are real and the repo is large: 48 safetensors shards that add up to about 510 GB (475 GiB) in the file tree, with experts in FP4 and most other weights in FP8 per the config. The model card lists no hardware requirements at all, which is why the vLLM recipe page is the document to read.

That recipe sets a minimum of 614 GB of VRAM (including a 1.2 headroom factor) and names a GB200 NVL4 tray, an 8-GPU H200 node, an MI355X server and a DGX Station GB300 as configurations that fit. In other words, datacenter hardware. Hugging Face also lists third-party inference providers for the weights if you want the model without the hosted API’s terms.

What serving it involves (vLLM recipe and model card, Oct 14)

  • • vLLM 0.30.0 or newer; the recipe says no pip wheel serves this architecture, so Docker (nightly image) is the install path. The generic ā€œpip install vllmā€ snippet on the Hugging Face page does not match that, so follow the recipe.
  • • Parser flags named in the recipe’s script: --tokenizer-mode deepseek_v41, --reasoning-parser deepseek_v41, --tool-call-parser deepseek_v41, with --max-model-len 1048576 for the full window.
  • • The recipe warns to measure before assuming a given context and batch size fit, and sets a one-hour engine ready timeout because the first load is long.
  • • Sampling from the card: temperature 1.0, top_p 0.95 or 1.0, max_tokens of at least 256K when you run at max effort.
  • • Prompt format: the README says no Jinja chat template ships and points to an encoding folder, but the repo file listing I read includes chat_template.jinja (it accepts reasoning_effort as 1–100 or low / medium / high / max). The README line may simply be stale.

Golden rule

Unless data control or fine-tuning forces your hand, use the API. Self-hosting means buying and operating an 8-GPU-class node to avoid a bill that is $5.40 for 10M input plus 2M output tokens at peak.

6. Honest limits

Plan around these before you move production traffic.

Where I would be careful

  • • Benchmarks are DeepSeek’s own. The card does not say who produced the competitor scores, and its comparison set (Opus-5.0, GPT-5.6 Sol, K3, GLM-5.3) predates later releases such as Claude Opus 5.5 on September 22. TNW states it has not independently verified the figures, and I found no independent evaluation yet.
  • • The gaps are on the hardest rows: HLE 36.8 vs 56.3 for Opus-5.0, Terminal-Bench 3.0 30.0 vs 43.3, Terminal-Bench 4.0 31.2 vs 51.8, ProgramBench 20.3 vs 37.0, NL2Repo-Bench 64.0 vs 75.3.
  • • Scores depend on the harness. DeepSWE v1.1 is 74.2 under mini-SWE, 72.6 under DeepSeek Harness Minimal, 70.5 under DSH Standard and 69.8 under Claude Code; Terminal-Bench 2.1 is 90.6 under DSH Minimal and 88.0 under Claude Code. The headline is the best case.
  • • Text output only, images in user messages only, 1024 tokens per image at most. TNW, relaying The Decoder’s reading of the tech report, says it concedes weaker performance on complicated image reading and reward hacking during training; I could not open the PDF to confirm.
  • • Names and routing are still moving: the old Flash aliases are temporary, V4 Pro’s status differs between documents, and V4.1-Pro was only referenced as a future model.
  • • Prices are not locked: the pricing page says DeepSeek reserves the right to adjust them and shows no effective date.

Hosted API and data handling, stated neutrally

DeepSeek’s privacy policy (last updated February 10, 2026) says personal data is collected, processed and stored in the People’s Republic of China, that inputs are used to train and improve its models, and that users have a right to opt out of training use. Check how that applies to API traffic. The open-platform terms (effective April 29, 2026) are governed by mainland PRC law and specify no retention periods. This is a compliance input, not a verdict: if you handle personal, regulated or confidential data, have legal review both documents, or use the MIT weights under your own control.

Verdict

V4.1 Flash is an easy yes for a test: same OpenAI-format API, one model-name change, a lower listed price than V4 Flash and image input in the main model. The self-reported gains on agentic coding are large enough to justify an eval on your own tasks this week.

It is not an automatic yes for production. The benchmarks are the vendor’s, the Pro story is unsettled, and the hosted API’s data terms deserve a real read. Move one non-sensitive workload first, measure tokens and pass rate, then decide.

Migration checklist

  1. 1. Swap deepseek-v4-flash, deepseek-v4-flash-vision-exp and any leftover deepseek-chat or deepseek-reasoner for deepseek-flash in staging.
  2. 2. Set thinking and reasoning_effort (low, high or max) explicitly.
  3. 3. Re-run your eval suite and compare tokens per task against your V4 Flash baseline, since the model behind the name changed.
  4. 4. If you use tools in thinking mode, pass reasoning_content back (append the whole message) to avoid 400 errors.
  5. 5. Schedule batch work off-peak for half price and decide your Pro posture from the pricing page, not the launch post.
  6. 6. Have legal review the privacy policy and terms before sending anything sensitive.
Diego Rodriguez

Diego Rodriguez

Senior Full-Stack & AI Engineer

Diego has 10+ years of experience building production-grade AI-powered applications, from LLM orchestration and RAG pipelines to ML-driven risk detection and algorithmic trading systems.

Learn more about Diego →