DeepSeek V4.1 Flash API Cost: Matches V4 Pro at 3-6x Less per Answer

DeepSeek V4.1 Flash costs $0.30 per million input tokens and $1.20 per million output at peak, half that off-peak, and on 11 tasks with a checkable answer, run three times each, it got 33 of 33 right, the same score as V4 Pro at 3 to 6x less per correct answer and 2.9x the output speed. Against the V4 Flash it retires, it is 26% cheaper per correct answer, 1.5x faster, and the first Flash that reads images. It also ships with two behaviours to design around: with thinking off it answers multi-step arithmetic with a single wrong token, and with thinking on it spends the whole output window, 16,384 tokens in three of five runs, on questions about things that do not exist. We measured all three builds, deepseek-v4.1-flash and deepseek-v4-pro-0813 in one batch (same hour, same gateway) four days after release and deepseek-v4-flash-0731 the same evening.

TL;DR

• V4.1 Flash is $0.30/$1.20 per million at peak, half off-peak; V4 Pro is $1.32/$3.96.
• All three builds scored 33 of 33 with thinking on; per correct answer V4.1 Flash cost $0.00097 to $0.00149, 3 to 6x under V4 Pro and 26% under V4 Flash.
• Thinking off drops all three to 21 of 33; V4.1 Flash then answers with one wrong token.
• On five fabricated entities V4.1 Flash with thinking on hit the 16,384-token cap three times and invented twice; thinking off declined all five.

What changed on September 10, and what does V4.1 Flash cost?

A new architecture at a new price, and a retirement. V4.1 Flash is “the smallest model in our new architecture family”: 552B parameters in a causal encoder-decoder (one 20-layer stack reads the prompt, another writes the answer), 8B active per token for input and 16B for output, with native image input, a 1M-token context and a 384K output cap, under an MIT license. DeepSeek’s pricing page lists it at $0.30 per million input tokens and $1.20 per million output at peak (01:00 to 04:00 and 06:00 to 10:00 UTC, Monday to Friday), $0.15 and $0.60 off-peak, with cache hits at $0.006 and $0.003. That sits between the two cards V4 Flash had, a flat $0.14/$0.28 at its July launch and $0.44/$1.32 peak from 2026-08-16, and well under V4 Pro at $1.32/$3.96 peak.

V4 Flash and the Vision Exp build are retired, and their names route to V4.1 Flash at the Flash price. DeepSeek had also planned to route V4 Pro traffic to V4.1 Flash from September 14; the change log dropped that plan the same day, “in response to user demand”, so Pro stays available at Pro prices.

The plumbing changed less than the price. The tokenizer is identical across the three builds (729, 452 and 528 tokens on the same English, Chinese and Python corpora), so token budgets port; cache pages halved from 1,024 tokens to 512, so a 549-token prompt now caches 512 of them; a 902K-token prompt with one planted value returned it, and a prompt past the 1M window returned a 400 rather than a silent truncation.

DeepSeek’s own numbers, from the model card, put the new Flash above the old one everywhere and above Pro on agent and coding work but not on knowledge:

The rest of this post is what we could check ourselves, which is the first half of that table (answers that can be verified), not the knowledge rows.

Does V4.1 Flash really match V4 Pro, and beat V4 Flash?

On tasks with a checkable answer all three builds score the same, so the differences are price, speed and how they fail. We ran 11 tasks whose answer is a single number we can check (sums of primes, digit counts, grid paths, coin combinations, a rule applied 40 times, 7 to the power 222 divided by 1000 with the remainder kept, a base conversion, a knapsack, and counting four-digit numbers under three constraints) three times each at reasoning_effort low, high and max, and with thinking off. Reasoning tokens are the hidden thinking the model writes before its answer, billed as output; cost per correct answer is total spend divided by correct answers, at each model’s peak card (V4 Flash at the $0.44/$1.32 card it was sold on until retirement); off-peak is half:

With thinking on, no build missed a task at any effort setting, so this suite cannot separate them on accuracy; it separates them on the bill (V4.1 Flash against Pro: 2.9x at low, 5.2x at the default high, 6.4x at max; against V4 Flash: 26% less at low) and on speed. Streamed with thinking off (so the clock measures answer generation, not thinking), V4.1 Flash decoded at 121 to 134 output tokens per second, with 1.4 s from request to first token; V4 Flash at 86 to 94 (2.3 s to first token); Pro at 46 to 49 (1.9 s). In a two-turn function-calling loop every build made exactly one call per turn; V4.1 Flash reasoned 27 and 13 tokens on the two legs, V4 Flash 30 and 19, Pro 61 and 29, at $0.00019, $0.00030 and $0.00103 per leg. The knowledge gap in DeepSeek’s table (HLE, GPQA) is the one thing this suite does not exercise.

What does the effort dial do, and can you turn thinking off?

The dial moves the bill on a few tasks and the answer on none, and turning thinking off costs 12 of 33 answers on every build. V4.1 Flash accepts reasoning_effort as low, high and max (DeepSeek maps minimal to low and medium and xhigh to high); on nine of the eleven tasks the three settings are within a few hundred reasoning tokens of each other, and only the counting task (four-digit numbers under three constraints) opens up: 5,650 at low, 9,714 at high, 6,763 at max, all correct. Every thinking_budget value from 0 to 1,024 was accepted and ignored. The model card’s “continuously controllable reasoning effort setting (integer 1-100)” is not on the API; integers are rejected. V4 Pro and V4 Flash behave the same way at their own counts, and the counting task is where max gets expensive on the older builds: 12,729 to 15,920 reasoning tokens on Pro, 17,866 to 24,010 on V4 Flash, for the same right answer V4.1 Flash reached in 6,763.

The two controls, and where the measured numbers come from in the response:

resp = client.chat.completions.create(
    model="deepseek-v4.1-flash",
    messages=[{"role": "user", "content": prompt}],
    reasoning_effort="low",                    # "low" | "high" | "max"; default "high"
    extra_body={"thinking": {"type": "enabled"}},  # {"type": "disabled"} turns it off
    max_tokens=4096,                           # always set one: see the next section
)
usage = resp.usage
reasoning_tokens = usage.completion_tokens_details.reasoning_tokens  # billed as output
thinking_text = resp.choices[0].message.reasoning_content            # returned on every thinking call

Thinking off is the cheap dial and the dangerous one, and each build loses a different set of tasks:

The five-step chain from our standard shapes is the clearest case: with thinking off V4.1 Flash answered it 1 of 3 (0 of 3 in a second set of runs), V4 Flash 2 of 3, Pro 3 of 3, because Pro writes the steps before the answer and the Flash builds do not. Two smaller facts for the budget: thinking mode adds a hidden template prefix billed as input, 26 prompt tokens on V4.1 Flash and 79 on V4 Flash and Pro (identical text, 729 tokens with thinking off on all three), and the reasoning_content you send back on the next turn is not re-billed (81 prompt tokens with and without it on V4.1 Flash, 134 on Pro).

What happens when you ask about something that does not exist?

V4.1 Flash with thinking on either exhausts your output cap or invents an answer; with thinking off it declines, and it declines more reliably than either other build. We asked five questions about entities we made up, so the only right answer is “I do not know” (a share price for “Verantis Dynamics”, the headcount of the “Kessler-Fanning Institute”, the melting point of “Oridium-7”, the winner of a “1987 Pan-Continental Robotics Prize”) with a 16,384-token cap:

Three of the five V4.1 Flash runs with thinking on cost $0.0197 each at peak and returned an empty message; with the 2,048-token cap we use elsewhere, all five did, and so did four of five on Pro. If a lookup can legitimately have no answer, run it with thinking off, or cap max_tokens and treat an empty message as “unknown”. Pro’s thinking-off failure is different and worth a regex of its own: it writes Let me check that reference for you. According to reference and then an invented number.

Is the V4 Flash JSON corruption fixed?

Under json_object there is nothing to fix on any build; under strict json_schema we could not test it. V4 Flash 0731 shipped with a defect: thinking on plus a strict json_schema corrupted integer fields in 8 of 13 runs. On V4.1 Flash a strict json_schema returned 400 on our path, and DeepSeek’s JSON guide documents only {"type": "json_object"}.

Under json_object, the same invoice (vendor, date, total, line items) came back with every value right in 8 of 8 runs with thinking on and 8 of 8 with it off, on all three builds. V4 Pro under strict json_schema still corrupts with thinking on: 0 of 8 runs had the right line-item count (45, 12, 47, 1, 2026), 8 of 8 with thinking off. For extraction, json_object with thinking off was right every time on every build, and on V4.1 Flash it costs 25 output tokens.

What does an image cost on V4.1 Flash?

184 input tokens for anything up to 512x512, 652 at one megapixel, 994 at four. Image input is new to the Flash line (the retired Vision Exp build was a separate model, and V4 Flash 0731 takes text only), so we sent generated PNGs to V4.1 Flash and subtracted the text-only prompt:

The floor matches the vision guide: “images with a total pixel count below roughly 544x544 are scaled up”, larger ones are scaled down “to roughly that of a 1300x1300 image”, and 1,024 tokens is the documented ceiling per image. Content (solid, noise, rendered text) and format (PNG, JPEG, WebP; 174 to 243 KB) did not change the count, so you are billed by geometry, not bytes. A thousand 1-megapixel images cost $0.20 in image tokens at peak, before the question and the answer.

How Synthorai handles it

V4.1 Flash is deepseek-v4.1-flash on the gateway (DeepSeek’s own id is deepseek-flash), billed at $0.30 input and $1.20 output per million around the clock, with cache reads at $0.03 per million and no off-peak rate; every number in this post is reported at DeepSeek’s list card so you can apply your own hours. V4 Flash 0731 and V4 Pro 0813 stay available as deepseek-v4-flash-0731 and deepseek-v4-pro-0813, at their own cards. Both /v1/chat/completions and /v1/responses carry the model, thinking: {"type": "disabled"} is the off switch that works on this path, and the reasoning text comes back in reasoning_content on every thinking call. Image input goes through as image_url content parts.

FAQ

Is DeepSeek V4.1 Flash cheaper than V4 Flash?

Cheaper than the August card it replaces, not than the July launch card. V4.1 Flash is $0.30/$1.20 per million at peak and $0.15/$0.60 off-peak; V4 Flash was $0.44/$1.32 peak from mid-August and $0.14/$0.28 before that. Per correct answer on our suite, V4.1 Flash at low cost $0.00097 against V4 Flash’s $0.00131 at its last card.

Can you turn thinking off on DeepSeek V4.1 Flash?

Yes, with thinking: {"type": "disabled"} (DeepSeek also documents reasoning_effort: "none"), and it costs accuracy on multi-step work: V4.1 Flash fell from 33 of 33 to 21 of 33 on our suite and answered a five-step chain with one wrong token. Keep it on for arithmetic and planning; turn it off for extraction and for lookups that may have no answer.

Does DeepSeek V4.1 Flash support image input, and what does an image cost?

Yes, natively. On V4.1 Flash an image costs 184 input tokens up to 512x512, 652 at 1024x1024 and 994 at 2048x2048, independent of content and format, which is $0.000055 to $0.000298 per image at peak list.

Related: DeepSeek V4 Flash cost, DeepSeek V4 Pro GA vs preview, LLM thinking controls, image input token cost, LLM structured outputs.

← Back to blog