Why DeepSeek V4 Flash Can Stay Cheap After a Major Price Increase

DeepSeek V4 Flash’s apparent price advantage comes from a detail that headline comparisons often miss: cached and uncached input are billed very differently. Under the earlier published schedule, cache-miss input was $0.14 per million tokens, cache-hit input was $0.0028, and output was $0.28. 12

That makes Flash especially attractive for coding agents that repeatedly send the same system instructions, tool definitions, repository context, or other long prompt prefixes. It does not guarantee the lowest bill for every user or every provider route.

The unit that matters is effective task cost

A token price is only one part of an agent’s bill. For a workload with cache-hit fraction h, the blended input rate is approximately:

h × cache-hit rate + (1 − h) × cache-miss rate

At the earlier rates, 99% cached input works out to about $0.00417 per million tokens—roughly 34 times below the $0.14 cache-miss rate. The calculation excludes output tokens, which remain separately billed and can dominate a workload that generates long code, explanations, or tool results.

This creates two very different experiences on the same API:

• A light user with short sessions may spend very little because total token volume is small.
• A large deployment may process enormous context volumes, but pay far less for the repeated portion when the prefix remains stable.
• An agent that continually rewrites its system prompt, tool list, or context can lose the benefit and pay close to the miss rate for repeated material.

DeepSeek describes its API caching as automatic prefix caching, with repeated prompt prefixes billed at the lower cache-hit rate. 12 The practical requirement is strict reuse: changes near the beginning of a prompt can prevent later content from benefiting.

Why cheaper third-party prices do not settle the comparison

Third-party providers can list lower prices than the first-party API. For example, DeepInfra’s current pricing page lists V4 Flash variants around $0.08–$0.09 per million input tokens and $0.18 output, with separate cached-input rates. 29 OpenRouter also lists multiple providers for V4 Flash snapshots, with pricing that varies by version and route. 2122

Those offers are not necessarily identical products. A meaningful comparison should check:

• the exact model snapshot and output quality;
• whether the model is quantized or otherwise served differently;
• cache-hit pricing, retention, and prefix-matching rules;
• routing behavior, latency, uptime, and rate limits;
• context-window and concurrency policies; and
• data-handling terms and operational controls.

A lower sticker price can therefore be genuinely cheaper for a workload with little cache reuse, while a first-party route may win for a long session whose prefix stays intact. The relevant question is not “Which provider has the lowest input number?” but “Which route produces the completed result at the lowest reliable cost?”

What a 30× increase would—and would not—mean

The 30× scenario is useful as a sensitivity test, not as a forecast. Multiplying the earlier $0.0028 cache-hit rate by 30 produces $0.084 per million tokens. That would still be below the earlier $0.14 cache-miss rate.

But this comparison isolates only one line item. If output also rose 30×, the earlier $0.28 output rate would become $8.40 per million. A workload with heavy generation could become much more expensive even while cached input remained relatively cheap. Similarly, a workload with frequent cache misses would feel the higher input price directly.

The conclusion is conditional:

DeepSeek V4 Flash could preserve a cache-driven advantage after a very large nominal increase, but it would not remain cheapest for every mix of cache hits, misses, output tokens, and provider fees.

Peak pricing points to capacity management—but does not prove the motive

Later reported schedules introduced off-peak and peak rates. V4 Flash was listed at $0.22 per million cache-miss input, $0.007 cached input, and $0.66 output off-peak; peak pricing doubled those figures to $0.44, $0.014, and $1.32. 1020

These rates are substantial increases from the earlier $0.14/$0.0028/$0.28 schedule, but they are not a uniform 30× increase. Time-based pricing can help shift batchable demand away from busy periods or ration scarce capacity. It does not, on its own, demonstrate whether serving costs increased, demand remained unusually high, or both factors mattered.

For buyers, the operational lesson is simpler: the time at which an agent runs can become part of its cost model. If jobs can be scheduled, compare peak and off-peak bills rather than relying on a single nominal rate.

The cache experiment is a signal, not a universal benchmark

A community-reported 20,000-request experiment attributed a 100% cache-hit rate to DeepSeek across a 12-hour window, while reporting a much lower result for GLM after five minutes and intermediate performance for other models. 31

That observation is interesting because it illustrates why long-running agents may rank providers differently from short prompts. However, it is not an independently replicated cross-model benchmark. Cache results depend on exact-prefix construction, eviction, routing, concurrency, retention settings, and the client’s prompt formatting.

Developers should reproduce the test with their own agent trajectory and log cache-hit and cache-miss tokens separately. A stable prompt architecture—static instructions first, changing task data later—can make the economics much more favorable, but the result should be measured rather than assumed.

Where OpenCode Go fits

OpenCode Go is a different product from direct API access: its documentation describes a $10 monthly subscription that includes DeepSeek V4 Flash and uses rolling dollar-based limits, including $12 over five hours, $30 weekly, and $60 monthly. 1

That subscription cannot be compared fairly with a direct API by looking only at the monthly fee or the provider’s token rate. OpenCode controls routing and the effective allowance, while the direct API exposes token-level billing and cache behavior. Reporting on the plan also indicates that the usage value assigned to V4 Flash changed after the price increase. 6

A claim that Go is two to ten times more expensive during long sessions would require the same prompt stream to be run through both routes while recording:

1. cached-input tokens;
2. uncached-input tokens;
3. output tokens;
4. model and provider route;
5. retries and latency; and
6. subscription limits or throttling.

Without that controlled comparison, the stronger conclusion is narrower: a subscription can look cheaper on paper while producing a higher effective cost if its route loses reusable context, but that outcome is workload-dependent.

How to benchmark DeepSeek V4 Flash correctly

For a realistic comparison, measure cost per completed task rather than cost per million input tokens. Use the same model snapshot and prompt sequence across providers, then record:

• total input tokens;
• cache-hit and cache-miss input separately;
• output tokens;
• peak versus off-peak pricing;
• latency and failed requests;
• retries and routing changes; and
• whether the task actually completed successfully.

Run both a cache-friendly workflow and a cache-hostile workflow. The first shows the upside of stable prefixes; the second shows what happens when the agent constantly changes its context.

Bottom line

DeepSeek V4 Flash can remain one of the lowest-cost choices for long-running coding agents because prefix caching changes the economics of repeated context. A third-party route may still offer a lower headline price, and a large price increase may still leave cached input competitive. Neither fact proves that Flash is universally cheapest.

The decisive variables are cache-hit rate, output volume, peak-time pricing, provider implementation, and the cost of completing the task reliably. For production systems, those measurements matter more than any single list-price comparison.