DeepSeek V4 Flash Pricing: What You Pay in 2026

If you are budgeting for “DeepSeek V4 Flash,” start with an identity check: as of September 10, 2026, the old V4 Flash model is retired. DeepSeek still accepts deepseek-v4-flash for compatibility, but routes it to DeepSeek-V4.1-Flash. New API integrations should use deepseek-flash, and the current bill is the V4.1 Flash rate card, not the July card you may still find in reviews.

That is the answer most price snippets leave out. The name survived; the model and price did not. This guide turns the current official rules into a budget you can inspect. If you want to see the model’s available tasks first, open the DeepSeek V4 Flash model page, then compare the prompt library with the review evidence. If you use a browser client, Tabbit is a separate access path, not a DeepSeek API billing account.

Key takeaways

• Use deepseek-flash for new API calls. Treat deepseek-v4-flash as a temporary compatibility alias to V4.1 Flash.

• Current Flash pricing is $0.003 per million cache-hit input tokens, $0.15 per million cache-miss input tokens, and $0.60 per million output tokens off-peak. Peak rates are $0.006, $0.30, and $1.20.

• Peak hours are 01:00–04:00 and 06:00–10:00 UTC, Monday through Friday. Off-peak is everything else under the published schedule.

• Cache hits are cheap only when a previously persisted prefix matches. A 1M context limit is not the same thing as a 1M cache hit.

• The cheapest token is not automatically the cheapest completed task. Retries, review time, tool calls, and failed runs belong in the budget.

DeepSeek V4 Flash pricing at a glance

The table below is the current API card from DeepSeek’s Models & Pricing documentation, collected on 2026-09-20. Rates are per one million tokens.

The current API model is deepseek-flash, identified as DeepSeek-V4.1-Flash. It supports thinking and non-thinking modes, JSON output, tool calls, the Responses API, the Anthropic API, and vision according to the same official table. The old deepseek-v4-flash and deepseek-v4-flash-vision-exp names are still accepted temporarily and billed at the Flash price, but that routing is a compatibility measure, not a promise that the old model remains available.

The one number that changed: the model name is not the price card

The confusing part is not a decimal. It is the alias. On July 31, DeepSeek told developers to keep using deepseek-v4-flash for the 0731 post-training update. On September 10, DeepSeek retired V4 Flash and introduced V4.1 Flash under deepseek-flash; requests sent to the old name now route to the new model. The official changelog records both steps.

That means a codebase can keep working while its cost assumptions become stale. A request that still contains model: "deepseek-v4-flash" is not proof that it is running the July model, and a pricing article quoting $0.14 input or $0.28 output is not a current budget. Pin the model name you intend to use, save the collection date for your rate card, and re-check it after a model migration.

Cache hits are the real cost lever

DeepSeek’s context-caching guide says caching is enabled by default. A cache hit requires a previously persisted prefix to match the current request. Request boundaries create cache prefix units, so “I sent a long prompt before” is not enough to assume that the next request will be charged at $0.003.

Use this formula for a single request:

cost = (cache_hit_input_tokens × hit_rate ÷ 1,000,000)
     + (cache_miss_input_tokens × miss_rate ÷ 1,000,000)
     + (output_tokens × output_rate ÷ 1,000,000)

For a month, multiply the average request cost by the number of requests, then add separate estimates for retries and tool calls. Keep the three input buckets separate in your logs. If your provider reports prompt_cache_hit_tokens, use that field instead of guessing a cache ratio.

Two budgets you can reproduce

These are estimates, not a DeepSeek invoice. They use the current official rates and explicit token assumptions so you can substitute your own numbers.

The short extraction calculation is 0.8 × 0.003 + 0.2 × 0.15 + 0.1 × 0.60 = $0.0924 off-peak. The long loop is 9 × 0.003 + 1 × 0.15 + 0.5 × 0.60 = $0.477. Peak rates are exactly double these examples under the published schedule.

The calculator runs entirely in this browser. It uses the official V4.1 Flash rates checked on 2026-09-20 and does not send your inputs anywhere. Its estimate excludes retries, tools, taxes, provider markups, and human review; check the live official rate card before committing a budget.

This is why “per task” anecdotes need context. One Reddit user reported 11.5k API requests for $4.12 while using Flash as a reward judge. That is useful evidence that high request counts can remain inexpensive, but without token counts it cannot tell you what your own workload will cost. Another Reddit user reported 30 minutes of debugging with almost no visible rolling usage increase. Both accounts describe experience; neither replaces the rate card.

What the rate card does not tell you

Cheap tokens can still create expensive work

One Reddit user described a workflow that reduced a five-hour task to about one hour and cost about $1.63, while still saying the model was below a stronger frontier model. Another LocalLLaMA user reported a rules-heavy local setup where instruction-following remained the main problem. The trade-off is practical: if a cheap run needs repeated repairs, the bill may stay low while the human cost rises.

Use the model’s source reviews for the conditions behind benchmark and field-test claims. Do not convert a vendor score into a guaranteed task-success rate. The DeepSeek V4 Flash benchmarks are a starting point for evidence, not a replacement for a fixed sample of your own work.

Peak scheduling is useful, not magic

The official schedule makes off-peak rates half of peak rates. This is a clear lever for queued evaluations, overnight indexing, and non-urgent batch work. It is not a reason to delay user-facing requests, and it does not remove rate limits. DeepSeek documents a 2,500 concurrency limit for deepseek-flash; the limit is account-level and an expansion request may be needed for a larger workload.

API access is not the same as browser access

If you need a key, token accounting, retry policy, and an auditable request log, budget for the API. If you need to read pages, keep research tabs open, or run a browser-shaped workflow, the practical question is different. Agentic reasoning explains why a model call is only one part of a tool loop, and the DeepSeek Harness browser plugin guide covers a separate browser-control path.

What people actually paid, and what they learned

The community evidence splits into value and caution.

On the value side, one Reddit poster used 11.5k calls for an RL reward-judge project and reported a $4.12 bill. Another described Flash as fast enough to turn a five-hour analysis into roughly one hour at about $1.63. A YouTube field report by AICodeKing, published on July 31, described a feature and benchmark run costing $0.14 compared with roughly $20 on two larger models. These are concrete workload stories, not universal rates; the YouTube run predates the V4.1 migration.

On the caution side, the LocalLLaMA report said the model still failed to follow rules and skills in a local setup. The DeepSeek experience thread praised the price and debugging ability but worried that demand could change capacity. Those objections matter because a billing guide that counts only tokens will miss repair loops, queue time, and supervision. These are dated personal reports from July–August 2026 and cannot prove current V4.1 pricing, capacity, or general model quality.

A decision table for your budget

A practical browser route: Tabbit Browser

If the goal is to try the model against live pages rather than operate an API budget, Tabbit Browser is a different kind of decision. Choose DeepSeek V4 Flash in the in-product selector when it is available for your edition and account, then use the model prompt collection or a page-based task. The model page keeps the resource boundary visible, and the roleplay guide shows how a task-specific workflow can stay separate from a broad pricing answer.

The trade-off is important: Tabbit availability, product terms, and API pricing are separate. Do not assume that selecting a model in a browser creates a DeepSeek API charge in your account, and do not assume that a direct API key grants every browser feature. For a browser-first decision, see how agentic browsers work and keep a human approval step for actions that change data or accounts.

Tabbit Browser

Download Tabbit Browser

Verdict

DeepSeek V4 Flash pricing is attractive when your workload has repeated prefixes, flexible timing, and a measurable success check. The most important budgeting step is not multiplying a headline rate: it is identifying whether your requests now run on V4.1 Flash, separating cache hits from misses, and recording peak versus off-peak time.

Use the current official card as the source of truth. Use community reports to find realistic workloads and failure modes. If your next step is browser work rather than API integration, try the appropriate model route in Tabbit’s model workspace and verify availability before planning around it.

Sources

Current rates, peak windows, alias routing, and feature limits come from the DeepSeek Models & Pricing documentation, V4.1 Flash release note, API changelog, context caching guide, and rate-limit documentation, checked or collected on 2026-09-20. Community evidence is linked at the point of use: DeepSeek experience thread, reward-judge spend report, LocalLLaMA rules report, complex-workflow thread, and AICodeKing’s YouTube field report. These are dated personal tests, not independent proof of current price, capacity, or performance.

Secholar.L

Growth & Content at Tabbit

Secholar.L writes hands-on guides about AI browsers and agent workflows, comparing tools with real research and citing verifiable sources.