How to Deploy DeepSeek 4.1 Flash — Including the Part That Deployed Itself

DeepSeek V4.1 Flash went live on 10 September 2026, and its deployment story is smaller and stranger than a model release usually is. Smaller, because the port is one string: put deepseek-flash in model and everything you already know about the OpenAI-shaped API still applies. Stranger, because of what happened to everyone who did nothing: the old Flash and the vision experiment are retired, their model names now silently route to V4.1 Flash, and the release notes originally scheduled every V4-Pro request to follow on 14 September — a plan the changelog then walked back. The weights are open, and they are 552 billion parameters. This guide covers the string, the migration you may have already received without noticing, the image limits no quickstart prints, and the honest arithmetic of serving this model yourself.

1. What actually shipped on September 10

Not a new protocol, not a new endpoint — a new model behind the same string-shaped slot. The release notes describe V4.1 Flash as the smallest model of a new architecture family: a 552B-parameter mixture-of-experts on a causal encoder–decoder design with 8B parameters active for input and 16B for output. The asymmetry is the pitch — more intelligence per active parameter, which is also why the API price dropped the same day.

For anyone operating serving infrastructure, the number that matters isn’t a benchmark: it’s that V4.1 Flash’s KV cache needs a quarter of the HBM and an eighth of the SSD storage of the previous generation, per the same notes. That is a serving-density claim — more concurrent users per node, cheaper cache-hit economics — and it is the reason a budget-tier model can carry 2500-way concurrency (§5). Performance claims, including “ahead of V4-Pro” on speed and total runtime, are the vendor’s, citing third-party tests; the full table lives in the release notes and we won’t re-paste it here. Prices were cut at 04:00 UTC on 10 September — run your own numbers rather than ours — and the off-peak window still bills at half of peak.

2. The deployment: one string, zero ceremony

If you followed our 3-minute port earlier this week, the deployment is a one-line diff — and if you never touched it, the diff happened to you anyway (§3):

-    model="deepseek-v4-flash",     # retired 2026-09-10, routes for now
+    model="deepseek-flash",         # V4.1 Flash — the current string

Everything around the string is unchanged: base URL https://api.deepseek.com for the OpenAI-compatible shape, https://api.deepseek.com/anthropic for the Anthropic shape; Responses API, Anthropic API, JSON output and tool calls are all listed as supported on the official model table. The envelope is the generous one: 1M context, 384K max output. Thinking mode still defaults to on, the effort dial still exists, and the sampling-parameter and tool-history traps we documented on the 3-minute guide still apply — we won’t repeat them here. Fill-in-the-middle remains a non-thinking-mode feature, which matters if you were counting on it.

3. The migration nobody announced to you

Retirement, in DeepSeek’s current usage, means the string keeps answering — it just answers with a different model. deepseek-v4-flash and deepseek-v4-flash-vision-exp are retired and “temporarily” routed to V4.1 Flash; requests are billed at Flash price. Your deployment upgraded itself on 10 September. The Monday-morning checklist:

• Grep your configs for the legacy strings. They work today; “temporary” is the vendor’s word for how long that’s guaranteed. Rename on your schedule, not theirs.
• Re-baseline your evals. The model behind the pointer changed generation. Log the served model version — the 3-minute guide’s pointer discipline exists exactly for weeks like this one.
• Re-run your token math. Rates moved the same day the pointer did; the calculator is the bill side of this page.
• If you used the vision experiment: your requests now run on the standard string. Check the limits in §4 before you assume nothing changed.

One correction of our own, in public and with dates: the 3-minute guide we published on 7 September shows deepseek-v4-flash in its samples. That was the current quickstart string when it was written. As of 10 September it is a legacy route. This page is the correction — our pages get dated amendments, not silent rewrites.

4. Vision, minus the experiment suffix

Images go to deepseek-flash as ordinary content blocks — the model is natively multimodal now. The mechanics, from the vision guide, are standard OpenAI shape:

resp = 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": "https://example.com/chart.png",
                           "detail": "low"}},   # 512x512 downscale — cheaper
        ],
    }],
)

Three input methods: base64 inline (simplest for local files), a public http(s) URL the model fetches for you, or a Files API upload you reference by id — the right choice when the same image recurs across requests. The limits that bite in production, all from the same page:

• Formats: JPEG, PNG, GIF, WebP — detected from file content, not from the filename or declared MIME type. Renaming chart.bmp to chart.png helps nobody.
• Request body limit 48 MiB; single images up to 32 MiB by base64 or URL, 64 MiB via Files API; at most 600 images per request; total image payload 64 MiB without file_id images, up to 200 MiB with them.
• Max dimension 8192 px per side — dropping to 4096 px once a request carries 15+ images.
• External URLs: at most 8192 characters, and the download must finish within 60 seconds.
• Images are allowed in user messages only — system or assistant images return a 400.

The cost model is the part worth internalizing: every image is automatically resized before inference — small ones scaled up, large ones down, to roughly a 1300×1300 pixel budget — so an image costs at most 1024 tokens, and a 2000×2000 screenshot bills the same as a 5000×5000 one. Each image in a multi-image request counts independently under the same rule. The detail dial (low / high / original / auto) trades resolution for cost; low downscales to 512×512, and auto currently behaves as original. Anthropic and Responses API shapes carry the same three input methods with different block names — see the guide for those spellings.

5. Production notes the quickstart skips

These come from the Rate Limit & Isolation page, and they’re the difference between a demo and a deployment:

• Concurrency is account-level: 2500 for deepseek-flash (500 for V4-Pro), counted across every API key on the account, from request start to response completion. Exceed it and you get 429s, not queuing. Need more? Capacity expansion is free on request — the vendor sizes it to your stated business need.
• user_id is the multi-tenant tool: it isolates content-safety handling, KV cache, and scheduling per downstream user. Values must match [a-zA-Z0-9\-_]+, max 512 chars, no personal data — and for expanded accounts each id gets its own concurrency cap, so one noisy tenant can’t eat the account’s whole budget.
• Keep-alive will look like garbage in your logs: while a request waits for the model, the connection emits blank lines (non-streaming) or SSE : keep-alive comments (streaming). Parsers that treat unexpected bytes as errors will die politely at 3 a.m. — tolerate them. And if inference hasn’t started within 10 minutes, the server closes the connection outright.

6. Self-hosting: open weights, datacenter math

The weights are open — on Hugging Face, with a technical report beside them, linked from the release notes. DeepSeek says it will “work closely with the open-source community on V4.1-Flash inference support and explore more deployment options” — which is release-day phrasing for: serving-stack support (vLLM, SGLang, and friends) is still landing, and the model card is the live truth for which commands work this week. We don’t quote serving commands we haven’t run; check the card.

Do the arithmetic before the README enthusiasm does it for you. 552B parameters at one byte per parameter is roughly 552 GB of weights — our arithmetic, not a vendor spec — before a single token of KV cache, before activations, before replication for throughput. The KV-cache compression helps density; it does not shrink the weights. For scale, DeepSeek’s own outreach line for big deployers is “a large-scale deployment with 2,000 GPUs + a storage cluster.” That is the honest unit of self-hosting this model. If your GPU count has two fewer digits, the practical deployment of V4.1 Flash this month is an API.

7. September 14: the page that contradicts itself

If you deploy deepseek-v4-pro, read this section twice. The release notes say: starting 04:00 UTC on 14 September 2026, all deepseek-v4-pro requests route to V4.1 Flash at V4.1-Flash rates, continuing until V4.1-Pro launches. The changelog and the live pricing page say the opposite, in response to user demand: V4 Pro service continues after 14 September with the billing method unchanged, further notice promised if that moves again.

We report both because both are currently published, dated 10 September, and one of them describes your requests being silently re-pointed in two days. Whichever is true on the 14th, the defensive posture is the same one §3 teaches: pin what you depend on, watch the changelog, and treat model strings as pointers that move. The Flash-vs-Pro question itself — whether you should be on Pro at all now that the tier math changed — is its own comparison, and we keep it on its own page.

8. Where to run it

FAQ

Sources

Checked 12 September 2026. All six are live official pages as they stood on that date.

• DeepSeek Change Log — 09-10 entry: release, model naming, legacy routing, the V4-Pro continuation, the price cut.
• DeepSeek-V4.1-Flash Release Notes — architecture numbers, KV-cache ratios, the original 14 September reroute text, open-weights links, partner tools.
• Models & Pricing — the model table: names, context and output limits, feature support, concurrency, the Pro continuation footnote.
• Vision Guide — image input methods, every limit in §4, resize and token rules, detail levels.
• Rate Limit & Isolation — concurrency semantics, user_id isolation, keep-alive behavior, the 10-minute cutoff.
• Hugging Face repository — linked from the release notes; the model card was not machine-checked from our environment, so treat it as the live truth for serving commands.
• Internal: OpenAI SDK 3-minute guide · Flash 4.1 vs Pro 4 · cost calculator · off-peak discount · cheapest provider — the pages this one deliberately doesn’t restate.

One honesty note, in keeping with how this site reports: this is a deployment guide built from six official documentation pages as they stood on 12 September 2026 — two days after the release it covers. It is not a first-hand benchmark; nothing here measures latency, quality, or uptime, and the one thing we checked and did not find — a V4-series listing on a reseller’s public model page — is reported as not found rather than assumed. The September-14 contradiction in §7 is reported exactly as published, both sides cited. Model strings, routes, and dates move; treat the linked pages as live truth, and if a future update changes any fact above, this page gets a dated correction, not a silent rewrite.