DeepSeek V4.1 Flash: The Fast Tier, Its Real Price, and the Free Question Answered

DeepSeek V4.1 Flash is the fast tier of DeepSeek's V4.1 line: a multimodal mixture-of-experts model with a 1,048,576-token context window, image input, MIT-licensed weights on Hugging Face, and an off-peak list price of $0.15 per million input tokens and $0.60 per million output. It went into general availability on 2026-09-10, so the release is a fact that dates the model, not an event this page is reporting — and two questions bring readers here long after that date: whether it is free, and how it behaves against whatever model is already in front of them. The first has a short answer, so it goes first.

Is DeepSeek V4.1 Flash free? The answer you came for

No. On DeepSeek's own platform there is no free API tier for this model — no free monthly quota and no free endpoint. Billing is pay-as-you-go against a topped-up balance, at the rates on the same card as the rest of the line. The model id you call for it is deepseek-flash, and every request against that id is billed at the published Flash rates. The consumer app is free to use; the API behind it is not, and the two are separate products.

What is genuinely close to free is the cache. A cache-hit input token costs $0.003 per million against $0.15 for a fresh input token off-peak — one fiftieth. Any workload with a large, stable prefix (system instructions, tool schemas, a repository map) pays almost nothing for the repeated part of the prompt while the new tokens carry the cost. The exact conditions under which the discount applies are DeepSeek's to set, not the client's, so read the current documentation before you build a budget on the number.

There is a second reason the free question comes up, and it is worth separating from the first. Third-party platforms advertise free or trial access to this model, and those routes are real; they are also the kind of terms that change without notice, and none of them carry DeepSeek's own rate card behind them. Treat them as prototyping surfaces rather than production backends. Our own catalogue does carry a zero-cost entry — but it is deepseek/deepseek-v4-flash-free, the retired V4 Flash, not this model. The two are one version number apart and they are not the same thing.

Where Flash sits in the V4.1 line

V4.1 is a new architecture family, not a point release of V4. Flash is its small, fast member — the tier built for throughput and cost rather than for the top of the leaderboard. The flagship sibling is DeepSeek-V4-Pro-0813, served under the model id deepseek-v4-pro, which lists at $0.66 per million input and $1.98 per million output off-peak: about four and a half times Flash on input and a little over three times on output, with a concurrency cap of 500 against Flash's 2,500. DeepSeek itself reports that V4.1 Flash comprehensively surpasses V4 Pro on performance, cost, speed and total task time — that is the vendor's own claim on its own benchmarks, not an independent measurement, and it is the reason the tier naming reads upside down to anyone who assumes "Pro" is always the better buy.

One boundary to hold: DeepSeek V4.1 Pro is not released. It appears in DeepSeek's material only as a future model. Nothing on this page applies to it, and neither does anything we serve.

The specification, as DeepSeek publishes it

Everything below is read from the model card on Hugging Face, at deepseek-ai/DeepSeek-V4.1-Flash. Where a figure is a vendor claim rather than a settled measurement, it says so.

• Parameters — 552B backbone, vendor-reported. The card states 8B parameters activated per token during prefill and 16B during decode, across a mixture-of-experts layout with 1 shared expert and 384 routed experts per MoE layer, six of them active per token. • Architecture — a 40-layer Causal Encoder-Decoder: a 20-layer causal encoder feeding a 20-layer decoder. • Context — 1,048,576 tokens, which the card rounds to one million. • Output ceiling — 384K tokens maximum on the vendor's API, so set the cap explicitly rather than trusting the default. • Modality — text and images in, text out. Vision runs through a DeepSeek-ViT encoder plus a two-layer MLP projector. • Precision — the published weights are safetensors in BF16, F32, F8_E4M3 and I8, with FP8 flagged on the card. The KV cache is quantised to FP4 (E2M1 with an E4M3 scale per 16 channels). • Licence — MIT, for the repository and the weights alike. • Release — general availability on 2026-09-10; 48 safetensors shards, about 510 GB in the repository.

Flash against Pro: the question the tier name creates

If you are choosing between the two, the rule is not "Pro is stronger". The Flash tier exists for volume: high-concurrency, cost-sensitive traffic where a token bill that is a quarter of Pro's matters more than the last few points of capability, and where the 2,500-request concurrency ceiling is itself the reason to be here. The Pro tier exists for the hardest reasoning and agentic work, where you are paying for the top of the range and the throughput ceiling is a constraint you accept. That is the whole shape of the choice — the head-to-head evidence, including where Pro still wins, lives in our own DeepSeek V4.1 Flash vs DeepSeek V4 Pro comparison rather than here, and the two pages are deliberately not restating each other.

Running it: API, weights, or both

Both routes are open. DeepSeek serves the model on its own API under the id deepseek-flash, on an OpenAI-compatible base URL and on an Anthropic-compatible one, so an existing client usually needs only the model string changed. Separately, the weights are downloadable: MIT-licensed, 48 safetensors shards, roughly 510 GB, which puts them outside any single-GPU machine and squarely inside the "rent a node or don't bother" category. DeepSeek also ships an official inference recipe inside the repository — a readable reference implementation rather than a production serving engine — and its worked example converts the weights to fp4 experts at a model-parallel size of eight, which is the closest thing the repository offers to a sizing statement. The practical detail that decides whether self-hosting is pleasant is a different one: the model supports a continuously selectable reasoning effort from 1 to 100, and it will happily keep generating long after the work is done if you do not tune that dial. The measured rigs, the throughput numbers people actually report, and the overthinking failure mode with mitigations that work are all in our DeepSeek V4.1 Flash local-deployment playbook; the honest summary is that the API route is cheaper until your volume is large, and the weights route is a capacity decision rather than a cost one.

What is not settled

Two things, and neither is minor. The parameter count does not reconcile with the weights. DeepSeek's card says 552B; the repository's own safetensors index — the Model size field on the Hugging Face model page — totals 763B across the 48 shards, in a repository of about 510 GB. Both numbers are published, they are not the same number, and nobody has adjudicated the gap in public, so treat 552B as vendor-reported rather than measured. And DeepSeek's own material is inconsistent about the older V4 Flash identifiers — the pricing page says the retired names are accepted and routed to this model at Flash rates, while other pages describe the routing differently. Read the model back from the response rather than assuming which model answered.

Availability on OrcaRouter, checked today

OrcaRouter serves this model. It is listed in our live catalogue as deepseek/deepseek-v4.1-flash — note that the identifier spells the version with a dot, v4.1, while our blog slugs hyphenate it. Copy the string exactly as the list has it or a client will find nothing. The listing carries a 1,048,576-token context window, a 384K maximum output, text and image input, and the vendor's own off-peak figures of $0.15 per million input and $0.60 per million output with $0.003 per million on cache hits, passed through at 0% markup — DeepSeek's rate is what you pay, and DeepSeek's weekday peak windows still double it. Automatic failover means you can put an unproven model behind a route that falls back when it errors or rate-limits, which is a cheap way to find out whether it holds up before it reaches a production path. That statement covers this identifier and this model only; DeepSeek V4 Pro and the wider V4 line are separate listings and separate facts.

The comparison set: what to open next

This is where the readers actually are. In our own Search Console data, pulled on 2026-10-13, the DeepSeek V4.1 Flash family took 9,444 impressions and 418 clicks across 198 queries — and its single largest row by impressions was not the model name but a head-to-head, deepseek v4.1 flash vs glm 5.3 flash, at 1,372 impressions. The bare term was 2,025 impressions over 33 queries. Ten comparison pages sit under this stem, and each one is written to answer its own question rather than to repeat this page:

• DeepSeek V4.1 Flash vs GLM-5.3-Flash — the price competition, and the startup-latency penalty that comes with winning it. • DeepSeek V4.1 Flash vs DeepSeek V4 Flash — the migration question, which DeepSeek partly answered by retiring the older model's identifiers. • DeepSeek V4.1 Flash vs DeepSeek V4 Pro — the handover DeepSeek scheduled and then cancelled, and what that leaves you choosing between. • DeepSeek V4.1 Flash vs Gemini 3.8 Flash — two cheap prices attached to two very different kinds of expiry. • DeepSeek V4.1 Flash vs GPT-5.6 Sol — the price gap next to the time-to-first-token gap. • DeepSeek V4.1 Flash vs GPT-5.6 Terra — where a context threshold changes the rate mid-request. • DeepSeek V4.1 Flash vs Claude Opus 5 — two scoreboards that disagree about which model won. • DeepSeek V4.1 Flash vs Grok 4.6 — a small capability delta against a large recurring bill. • DeepSeek V4.1 Flash vs Kimi K3 — the vendor's own head-to-head claim, checked against the evidence behind it. • DeepSeek V4.1 Flash vs Qwen3.8-Max — the same context window at twenty times the token price.

If you only have time for one, take the GLM-5.3-Flash comparison: it is the row readers type most, and the two models are close enough in price that the decision turns on how fast you need the first token rather than on how much each token costs.