On September 10, 2026, the model name deepseek-flash stopped pointing at the model it used to point at. DeepSeek shipped V4.1-Flash, retired V4-Flash and V4-Flash-Vision-Exp, and told everyone to “set your model to deepseek-flash“ (DeepSeek’s release post). If you kept the old string in your config, you are now calling a different model at a different price and were never asked to change anything.
The headline from that week was “prices have been reduced.” The rate card says something narrower. Against the previous Flash generation as this catalog lists it, input is 24% cheaper and output is 1% more expensive, so whether your bill falls depends on the shape of your traffic — specifically on how many output tokens you generate per cache-miss input token. This guide gives you that dividing line, both rate cards with a capture date on every figure, and a way to check what your own requests were actually billed. Every number below was read from a first-party page on September 15, 2026.
One disclosure before the numbers: we run Modellix, a gateway that carries DeepSeek models alongside 8 other providers, so we have a commercial interest in the rows further down. On the newest DeepSeek Flash row our catalog price equals DeepSeek’s own peak rate — there is no discount to sell you, which makes this the rare guide where our commercial interest points at the boring answer.
What DeepSeek Flash is now, and what changed on September 10
For a reader arriving from an older page: deepseek-flash is DeepSeek-V4.1-Flash, a 552B-parameter mixture-of-experts model on a new Causal Encoder–Decoder architecture that activates 8B parameters per token during prefill and 16B during decode, with native image input (model card). deepseek-v4-pro is still served under its own name.
The changes that matter to someone with the model string already in production, not to someone reading a benchmark chart:
| V4-Flash (retired) | V4.1-Flash (current) | |
|---|---|---|
| Model name to call | deepseek-v4-flash (temporarily routed) |
deepseek-flash |
| Architecture / active params | previous MoE generation | 552B MoE, Causal Encoder–Decoder, 8B prefill / 16B decode |
| Image input | separate -vision-exp model with its own ID |
native — one ID, no vision variant to choose |
| KV cache footprint | baseline | 1/4 the HBM, 1/8 the SSD storage |
| Context / max output | 1,050,000 in the gateway catalog; the vendor no longer lists the row | 1M context, 384K max output |
| Cached-read rate (gateway row) | $0.0126 per 1M | $0.006 per 1M |
The KV cache compression is the release’s own explanation for why the cached lane moves further than the headline rate: DeepSeek writes that cache-hit charges “often account for a large share of agent costs” and that compressing the cache cuts those costs, which is the thread that runs through the rest of this article.
How much stronger the new generation is, is the vendor’s own claim rather than an independent finding: the release post says the new pretraining and larger-scale reinforcement post-training “deliver benchmark results ahead of flagship models, including DeepSeek-V4-Pro,” and the API changelog lists the scores behind that sentence — GPQA Diamond 90.9, Terminal-Bench 2.1 at 90.6, DeepSWE v1.1 at 74.2. None of those numbers is reproduced here, and none of them moves a rate card, which is why this article stays on the billing side of the change.
Three of those are operational rather than technical. First, the vision decision disappeared: before September 10 you chose between a text-only Flash and a separate deepseek vision model, and the two were separate IDs; now image input is part of the base model. Second, the retired names still resolve — DeepSeek’s pricing page states the legacy names “are still accepted, but the corresponding models have been retired, their requests are served by the DeepSeek-V4.1-Flash model and billed at the Flash price.” Both legacy names now return v4.1 generation output, even though a client on the old string never asked for it. Third, and least comfortably, the two DeepSeek pages do not agree about V4-Pro.
The release post still says: “Starting at 04:00 UTC on Sept 14, 2026, all deepseek-v4-pro requests will route to V4.1-Flash at V4.1-Flash rates. This will continue until V4.1-Pro launches.” The pricing page and the API changelog, both live on September 15, 2026, say the opposite in a footnote: “In response to user demand, we have decided to continue providing API services for DeepSeek V4 Pro after September 14, 2026, with the billing method remaining unchanged.”
The line that launched a thousand migration plans, still live on the release page on September 15, 2026 — five days after it was written, and contradicted by DeepSeek’s own pricing footnote. Captured from deepseek.com.
Both statements are on DeepSeek’s domain, both were readable on the same afternoon, and we are not going to pick a winner for you. If you build routing assumptions on V4-Pro today, read the pricing page first and confirm with the vendor — that is what we did, and it is why this article stops at Flash.
Why cheaper input is not the same as a cheaper bill
Here is the other card. This is the Modellix catalog, filtered to the DeepSeek rows, captured September 15, 2026, in USD per 1 million tokens:
| Model ID | Context | Input | Output | Cached read | Discount |
|---|---|---|---|---|---|
deepseek/deepseek-v4-flash |
1.05M | $0.44 → $0.396 | $1.32 → $1.188 | $0.014 → $0.0126 | 10% OFF |
deepseek/deepseek-v4-flash-vision |
1.05M | $0.44 | $1.32 | $0.014 | — |
deepseek/deepseek-v4-pro |
1.05M | $1.33 → $1.197 | $3.96 → $3.564 | $0.044 → $0.0396 | 10% OFF |
deepseek/deepseek-v4.1-flash |
1M | $0.30 | $1.20 | $0.006 | — |
Two display details, because they change the arithmetic. The source page prints the discounted figures as $1.19, $1.20 and $3.56 (from $1.188, $1.197 and $3.564), while values that need no rounding keep their form — $0.396 and $0.0126, for instance. Each billed figure is exactly 90% of its list price ($0.44 × 0.9 = $0.396, $1.32 × 0.9 = $1.188), and the break-even below is computed from the unrounded pair, because $1.20 − $1.188 is the whole margin. The other detail is the cached-write column, which reads $0 for every DeepSeek row and is dealt with in the next section.
Four DeepSeek rows on one key, captured September 15, 2026. Two carry a 10% discount and two do not — and the newest row is one of the two that do not. The catalog table paginates six rows at a time, so these four rows were captured on two pages and stitched under the unchanged header. Captured from modellix.ai/llm.
Read the two Flash rows against each other and the newer model is cheaper on input and slightly more expensive on output. Input falls from $0.396 to $0.30 per million (24% lower); output rises from $1.188 to $1.20 (1% higher). Cached reads halve, from $0.0126 to $0.006. The direction of the saving therefore depends entirely on your mix, and it is arithmetic rather than opinion:
- Every cache-miss input token you send on the new row saves $0.096 per million tokens and pays for 8 output tokens at the new output rate.
- Every cached input token saves only $0.0066 per million and pays for 0.55 of an output token.
So the rule of thumb is: V4.1-Flash is cheaper than the older Flash row as long as your output tokens stay below 8× your cache-miss input tokens, with cached tokens adding about half a token of headroom each. Put two requests through it, at Modellix’s own rates:
A request with 500 cache-miss input tokens and 4,000 output tokens — a short prompt and a long answer — costs $0.00495 on either row. That is the line exactly. Send 16,000 output tokens from the same 500-token prompt and the older row is cheaper: $0.019206 against $0.01935, about a hundredth of a cent apart, but in the direction opposite to the announcement.
Now the shape most agent workloads actually have. Take 1,000,000 input tokens of which 900,000 hit the cache, plus 10,000 output tokens. The new row bills $0.0474; the older row bills $0.06282. V4.1-Flash is 24.5% cheaper on that request, and everything in that saving comes from the input lane. Same tokens, same model family, opposite conclusion — which is why “did prices go down” has no answer without a workload attached.
Three request shapes, the three rates above, run through both rows:
| Request shape | Cache-miss input | Cached input | Output | Cheaper row | Difference on the bill |
|---|---|---|---|---|---|
| Short prompt, long answer | 500 | 0 | 16,000 | older Flash row | old row 0.7% cheaper |
| Exactly on the line | 500 | 0 | 4,000 | either — identical | $0 |
| Cache-heavy agent session | 100,000 | 900,000 | 10,000 | deepseek-v4.1-flash |
new row 24.5% cheaper |
DeepSeek’s own card, captured September 15, 2026: three billing lanes — cache-hit input, cache-miss input and output — each split into an off-peak and a peak figure, with the peak window, the legacy model names and the V4-Pro note carried in footnotes further down the same page rather than inside this frame. Captured from api-docs.deepseek.com.
One more thing about the vendor’s card, since it is the one your team will screenshot: it prices the same tokens by the clock. Off-peak rates are half of peak, and peak is defined verbatim as “Peak hours are 01:00 - 04:00 and 06:00 - 10:00 UTC, Monday through Friday (all other hours are off-peak).” The gateway table above carries a single rate per model and does not mention peak windows at all — a text search of that page for “off-peak” returns nothing. On the newest Flash row our listed rate sits exactly on DeepSeek’s peak tier: $0.30, $1.20, $0.006. If your workload can be scheduled into DeepSeek’s off-peak hours, that lever exists on the vendor’s side of the fence, and it is worth asking your provider what happens to it.
The lanes that decide it: cache hits, cache misses, and a $0 column nobody explains
The input lane is where the two cards look most different and where the differences matter least per token, because DeepSeek prices cached input so aggressively that most of a production prompt can bill below one cent per million. Third-party telemetry shows how far that goes: OpenCode’s public dashboard for this model, read on September 15, 2026, reports 7.3M average tokens per session, $0.08 average cost per session, and a cache ratio of 98% of input tokens (OpenCode data). We are citing that as an observation from someone else’s traffic, not ours, and one dashboard is not a benchmark — but it is the only published cache ratio we could find for this model, and 98% changes the arithmetic: if almost all input bills at the cached rate, then the input lane’s rate barely moves a bill, and the output ratio decides nearly everything.
That also explains why the cached-read figure matters more than it looks. At $0.006 per million, deepseek/deepseek-v4.1-flash has the lowest cached-read rate of any paid row in our catalog — but the saving it delivers is bounded by how much of your prompt repeats. A workload with a stable system prompt and a long tool schema caches well; a workload that feeds fresh documents every call does not, and for that workload the cache lane is not a lever at all.
One column has no explanation available. Our price table lists a cached-write figure for every model, and for all four DeepSeek rows it reads exactly $0. DeepSeek’s own card has no cache-write line to cross-check against, and neither DeepSeek’s documentation nor ours states whether cache writes are unsupported or simply not charged. The honest reading is that the cell is blank in substance: do not build a cost model on it, and if you need it filled in, ask the provider.
The other accounting question is images. Every page about this release leads with native visual understanding, and none of the pages we read for this article says how image tokens are billed — DeepSeek’s card prices input and output and does not itemise image input. If your prompts contain pictures, that is a second reason to read your own logs rather than a rate table.
Check what your own traffic was billed at
Every guide on this keyword says the new model is cheaper. None of them tells you whether your requests came out ahead, which is the only version of the question that reaches a budget. On a gateway with per-request logging that check is arithmetic rather than faith: GET /v1/logs returns one row per request with prompt_tokens, completion_tokens, cached_tokens, cost, the model that served it as { provider, model_name }, plus status, latency_sec and tps.
1 | curl -sS "https://llm.modellix.ai/v1/logs?start_time=1788739200&end_time=1789430400&page_size=100" \ |
start_time and end_time are required UNIX seconds and the window may span at most 30 days; page_size defaults to 10 and caps at 100. Three steps turn the output into an answer. First, divide cached_tokens by prompt_tokens per request — that is your real hit rate, and it is the number to hold against the 98% above. Second, reprice the same requests at the other Flash row’s three rates and compare, which is the calculation in the previous section run on real traffic instead of an example. Third, read model.model_name: it names the model that actually answered, which is how you find out whether a legacy string or a stable alias resolved to the row you expected.
That last check matters more since September 10, because the catalog now ships a stable alias: ~deepseek/deepseek-flash-latest, which on September 15, 2026 resolves to deepseek/deepseek-v4.1-flash. The mechanism is worth internalising beyond this model — how a gateway alias gets retargeted covers the same behaviour for OpenAI’s family. The alias page is explicit that “when a new version ships, the alias changes target and your client stays unchanged,” and that pricing and capabilities “follow the current target.” An alias is a subscription to the vendor’s next release, and the next release’s rates. If your budget needs a frozen number, pin a concrete model ID — the same page says exactly that for evaluation and regression work. Documentation for request bodies, model-name form and the log endpoint is on the LLM API guide; the DeepSeek V4.1 Flash API is reached over the same base URL as every other text model in the catalog, and for the same tokens measured per agent run, what one agent run is actually billed walks through the token side.
Thirteen stable aliases on the gateway catalog, captured September 15, 2026. The highlighted row is the one that matters here: the Flash alias follows the newest concrete model in the family, which is why a client can stay unchanged while its bill cannot. Captured from modellix.ai/llm.
DeepSeek Flash Model IDs and Request Logs
Read the LLM gateway guide for model IDs and the /v1/logs reference for cached_tokens, the cost unit and the query parameters you need to price your own DeepSeek Flash traffic.
View DocsWhen the older Flash row is still the cheaper one
Three conditions, and they are the whole decision:
- Your output tokens exceed 8× your cache-miss input tokens. Long generations from short prompts — the shape of summarisation, rewriting and “produce a document” tasks — sit on this side of the line, and so does anything that lets the model reason at length: DeepSeek’s thinking mode is on by default, and the tokens it generates land in the output lane, which your own logs will show as
completion_tokens. - Your cache-hit rate is low. Caching pays you $0.0066 per million tokens on the new row against $0.0126 on the old one. If nothing repeats, there is very little caching to be paid for, and the input-lane advantage shrinks to whatever your miss tokens are worth.
- You are calling the older row through a catalog that still lists it separately. DeepSeek’s own card no longer carries a Flash row for the previous generation at all — it bills the legacy name at the current Flash price. So the cheap-old-row option is a property of the gateway catalog you are on, not of the vendor, and it can disappear from a catalog the way it disappeared from the vendor’s card.
If none of those three holds — a cache-heavy agent workload, ordinary output ratios — the newer row is the cheaper one, usually by a wide margin, and the September 10 change did what the announcement said.
What we cannot tell you is which side you are on. Our own numbers here are catalog rates, not measured traffic: we have not published an internal benchmark of the two rows on a shared workload, and this article does not pretend the examples above are one. Two more limits worth naming, because they are the ones people get burned by: the catalog lists the older rows with a 1,050,000-token context while the current row and DeepSeek’s own card both say 1M — we are reporting the two printed values rather than claiming a documented reduction, and the 1.05M window for the retired generation is not something we could verify on DeepSeek’s site; and neither card explains the $0 cached-write column. Treat both as open questions to put to your provider, not as settled facts.
Price Your Own DeepSeek Flash Traffic
Log in to see the live DeepSeek rows and the rest of the catalog on one key, and to read cached_tokens and cost per request in your own traffic before you change a model string.
LoginFrequently Asked Questions
What is DeepSeek Flash?
deepseek-flash is DeepSeek’s current small-model API name. As of September 15, 2026 it serves DeepSeek-V4.1-Flash, a 552B-parameter mixture-of-experts model with native image input, a 1M-token context window and a 384K maximum output, billed per token from a topped-up balance with peak and off-peak rates.
What changed between DeepSeek V4 Flash and V4.1 Flash?
Four things with consequences. The architecture moved to a Causal Encoder–Decoder design with 8B active parameters during prefill and 16B during decode; image input moved into the base model instead of a separate vision ID; the KV cache footprint dropped to roughly a quarter of the previous generation’s HBM and an eighth of its SSD storage; and the price shape flipped, with a lower input rate and a marginally higher output rate than the previous Flash listing.
Did DeepSeek Flash get cheaper on September 10, 2026?
Yes on input, marginally no on output, against the previous generation as our catalog lists it: input $0.396 → $0.30 per million tokens, output $1.188 → $1.20, cached read $0.0126 → $0.006. That makes “cheaper” true for input-heavy or cache-heavy traffic and false for output-heavy traffic — the dividing line is output tokens above 8× cache-miss input tokens.
What happens if I keep calling deepseek-v4-flash?
On DeepSeek’s API the name still resolves: the pricing page states that the legacy names “are still accepted, but the corresponding models have been retired, their requests are served by the DeepSeek-V4.1-Flash model and billed at the Flash price.” What you are billed for is the current model, so the question is not whether it works but whether your logs show the model you think you are calling — model.model_name answers that.
Is DeepSeek V4 Flash free, or open source?
Two different questions with two different answers. The weights are open — the model card states it is “licensed under the MIT License” — but the hosted API is pay-per-token, billed against a topped-up or granted balance, and DeepSeek’s pricing page publishes no signup allowance. Self-hosting is a hardware commitment measured in GPUs, not a free tier.
Can DeepSeek Flash read images?
Yes, natively and under the same model ID. That is one of the real simplifications in this generation: V4-Flash and its vision experiment were separate models with separate names, so image work meant choosing a second ID, while V4.1-Flash takes text and image input on deepseek-flash. How image tokens are billed is not itemised on either rate card, so confirm that against your own logs.
What is DeepSeek Flash’s context window?
1M tokens, with a maximum output of 384K tokens — both printed on DeepSeek’s pricing page and captured on September 15, 2026. Our catalog lists the two older DeepSeek Flash rows at 1,050,000, and we are reporting that as the catalog’s own figure rather than as a documented change from the vendor.
How do I tell which model served a request?
From the request log. On this gateway GET /v1/logs returns model.model_name per request alongside prompt_tokens, cached_tokens and cost, which is how you confirm that a legacy ID or the stable alias ~deepseek/deepseek-flash-latest resolved to deepseek/deepseek-v4.1-flash rather than to something else.
Model availability and per-token rates change without notice. Every figure in this guide was captured on September 15, 2026 from DeepSeek’s Models & Pricing page, the DeepSeek release post, the DeepSeek API changelog, the DeepSeek-V4.1-Flash model card, the Modellix LLM price page and OpenCode’s usage data; the wider catalog is in our cross-vendor LLM price table. DeepSeek has moved its Flash rate card twice since mid-August, so verify current figures before committing spend. Modellix is an API aggregator with a commercial interest in the gateway rows above: on the newest DeepSeek Flash row its billed price equals the vendor’s peak rate, and the two rows that carry a discount are the older ones. It is not affiliated with DeepSeek. Route text models through one key at modellix.ai.
