DeepSeek Permanently Cuts Cache Price to One-Tenth, and Slashes API Prices Again

DeepSeek has lowered its prices once more.

On April 26, DeepSeek officially updated its API pricing policy, permanently reducing the input cache hit price for all model series to one-tenth of the original launch price. Keyword: permanent. This isn’t a limited-time promotion or an off-peak discount — it’s a permanent change written into the price table.

Just yesterday, DeepSeek launched a limited 75% off (2.5-fold) event for the V4 Pro series, and developers were still wondering “how long this deal will last.” Today, cache prices dropped straight to 10% of the original, with no expiration date. Some in the community joked, “Yesterday was a limited 75% off, today it’s permanently 90% off — you’re being too generous; it’s getting embarrassing.”

To be honest, this new pricing is almost absurd.

How much cheaper is it exactly?

Let’s do the math.

DeepSeek’s API pricing consists of three parts: input (cache miss), input (cache hit), and output. This adjustment only affects the middle part — the input token price for cache hits.

Based on the previously announced base price of 1 RMB per million cache-hit tokens, one-tenth of that is 0.1 RMB per million tokens — roughly $0.014 per million tokens.

What does that mean in practice?

Here’s a cross-comparison:

| Model | Input Price (Cache Hit) | Input Price (No Cache) | |--------|--------------------------|------------------------| | DeepSeek V4 Pro (After Adjustment) | ≈ 0.1 RMB / million tokens | Original launch price | | GPT-4o | $1.25 / million tokens (cached) | $2.50 / million tokens | | Claude 3.5 Sonnet | $1.50 / million tokens (cached) | $3.00 / million tokens | | Gemini 1.5 Pro | $0.315 / million tokens (cached) | $1.25 / million tokens |

Even accounting for exchange rate differences, DeepSeek’s cache-hit price is one to two orders of magnitude cheaper than mainstream closed-source models. Gemini 1.5 Pro already has some of the lowest cache prices in the industry — DeepSeek’s is roughly 1/30 of that.

Of course, model performance isn’t just about price. But DeepSeek V4 Pro has already shown competitive strength against GPT-4o-level models in multiple benchmarks. At this price-to-performance ratio, there’s not much to complain about.

Why are cache hits so important?

If you’re just making occasional API calls for fun, cache hit rates might feel irrelevant. But for developers in production environments, this number directly determines how thick the monthly bill is.

In real-world API use, input token repetition is far higher than most people think:

Scenario 1: Reusing system prompts. Most applications have a fixed system prompt, maybe several hundred to several thousand tokens long. It gets sent every time, even though the content is identical. Once cached, that portion directly drops to one-tenth of the cost.

Scenario 2: Multi-turn conversations. This is the main battleground for caching. In a 10-turn chat, the 10th request needs to resend all previous 9 rounds. If each round averages 500 tokens, by the 10th turn you’re sending 4500 repeated tokens and only a few new ones. Cache hit rates can easily exceed 80%.

Scenario 3: Document references in RAG applications. Many RAG systems inject retrieved document snippets into the prompt, and the same document fragments are often referenced repeatedly by multiple users.

Scenario 4: Batch processing. When processing large datasets with the same prompt template, the template tokens are repeated every time.

DeepSeek’s technical blog previously shared an extreme case: a 128K-token input request with mostly repeated tokens saw first-token latency drop from 13 seconds to 500 milliseconds. That’s not just cost savings — it’s a direct improvement in user experience.

So the real impact of this price cut depends on how high your cache hit rate is. For multi-turn chat apps, overall cost reductions of 50–70% are entirely feasible. For bulk processing with fixed prompts, the drop could be even greater.

DeepSeek’s caching mechanism: How does it work technically?

To understand how DeepSeek dares to cut cache prices this low, we need to look at how its caching mechanism works.

DeepSeek uses disk-level KV Cache caching, which is quite unique in the industry. Most vendors cache data in GPU memory or system RAM, which is limited and costly. DeepSeek moved its cache to distributed storage, leveraging a key advantage of its MLA (Multi-head Latent Attention) architecture: its KV Cache is extremely compact.

In traditional Transformers, KV Cache grows linearly with context length, leading to high storage and transfer costs. DeepSeek V2’s MLA architecture compresses the KV Cache size several times over using low-rank compression, making cheap disk storage viable for caching.

From a developer’s perspective, the caching system is completely transparent:

• No code changes required, no API endpoint switch
• Automatic prefix matching and cache hits
• Billing based on actual hit rate
• Cache storage itself is free

One limitation to note: cache matching uses prefix matching from the first token. That means only if requests share the same prefix from the very start will that portion be cacheable. If you insert different content in the middle of a prompt, even identical tokens afterward won’t hit the cache.

This implies that to maximize cache hits, you should put fixed content at the front of your prompt and variable content at the end. For example, place the system prompt first, followed by conversation history, then the current user input. This already aligns with how most developers structure prompts.

Additionally, the caching system uses 64 tokens as the smallest storage unit — anything under that isn’t cached. The official docs also clarify that caching is “best-effort” and not guaranteed to hit 100%.

In the API response usage field, two parameters let you monitor caching in real time:

• prompt_cache_hit_tokens: number of tokens that hit the cache
• prompt_cache_miss_tokens: number of tokens that missed

These fields are very helpful for cost tracking and prompt optimization. If your hit rate remains low, it’s probably worth reviewing how you structure prompts.

The reasoning behind the price cut

You might ask: why is DeepSeek doing this?

From a business perspective, there are several possible explanations.

First, the marginal cost of cache hits is genuinely low. A cache hit means those tokens don’t require GPU computation — just a read from disk. Disk storage and read operations are orders of magnitude cheaper than GPU inference, so even at one-tenth price, DeepSeek still has profit margin — or at least, it’s not losing money.

Second, it’s a strategy to grow the developer ecosystem. API pricing is psychological warfare. When developers evaluate tech stacks for new products, cost is always a major factor. By drastically lowering entry costs, DeepSeek encourages developers to try its API — and once they’ve built on it, switching becomes sticky.

Third, it’s sustained pressure on competitors. In the domestic market, players like Qwen, ERNIE Bot, and GLM are all vying for API users. Globally, OpenAI, Anthropic, and Google have been cutting prices, too. DeepSeek pushing cache pricing to its limit is, in effect, saying: “Are you going to match this or not?”

Looking at DeepSeek’s pricing history over the past year, price cuts have become something of a tradition:

• Aug 2024: Introduced disk-based cache, priced at 1 RMB per million tokens
• Feb 2025: Launched off-peak discounts with up to 75% API cost reduction at night
• Sept 2025: New model launch drove API prices down by over 50%
• Apr 2026: V4 Pro limited 75% off + permanent 90% off cache pricing

Each cut was substantial — and increasingly frequent. This either means DeepSeek’s inference optimization is improving rapidly, or that they’re trading prices for market share — likely both.

Real impact on developers

Let’s be practical: this price cut affects developers differently depending on scale.

For individual developers and small teams: The impact is limited but positive. If your monthly usage is in the low millions of tokens, your bill is already small — dropping from a few RMB to mere cents. It feels great but won’t affect your tech choices.

For mid-sized SaaS products: Very significant. Suppose your app handles 100,000 chat turns daily, each with 2000 input tokens and a 70% cache hit rate. The monthly cost difference before vs after the cut could be in the thousands to tens of thousands of RMB — enough to influence pricing or profit margins.

For large enterprises and high-frequency use cases: Even more dramatic. If you’re running customer service, document processing, or code assistant scenarios consuming billions of tokens daily, dropping cache-hit cost to one-tenth could save six-figure sums monthly.

It’s also worth noting this cut amplifies DeepSeek’s cost advantage for Agent and long-chain reasoning use cases. Multi-step reasoning systems re-inject prior context at every step, meaning cache hit rates are naturally high. In these cases, DeepSeek’s total cost per call might be just 1/50th of GPT-4o’s — or even lower.

Competitive landscape: How long can the price war last?

The LLM API price war has been ongoing for over a year. Since mid-2024, nearly every month has brought a new price cut from some vendor. DeepSeek isn’t the only one lowering prices — just the most aggressive and frequent.

This price war reflects the ongoing reduction in inference costs. More efficient architectures (like MLA and MoE), better inference frameworks (such as vLLM and TensorRT-LLM), and cheaper hardware (as domestic AI chips mature) are all pushing down the per-token cost.

But there’s a downside. When API prices fall too far, revenue may not cover R&D. For a company like DeepSeek, backed by quantitative fund giants like High-Flyer, short-term profitability might not be critical — but long-term, sustainability still matters.

For developers, the price war is a good thing — but beware of one risk: if your business model depends entirely on one provider’s ultra-low prices, any change (price hike, quota limit, service shutdown) could hit hard. Supporting multiple models and keeping your options open is always wise.

Most mainstream APIs are now OpenAI-compatible, and aggregator platforms like OpenAI Hub allow using one key across multiple providers (including DeepSeek). So maintaining flexibility while enjoying low prices is a pragmatic strategy for now.

Conclusion

DeepSeek’s permanent 90%-off cache pricing is, on its own, a pricing policy update — but in the broader context, it’s another milestone in the continuous drop of LLM API prices industry-wide.

For developers, the takeaway is simple: if your use case involves lots of repeated input (multi-turn chat, fixed prompts, batch processing), your costs with DeepSeek just dropped significantly again.

As for when “Liang Sheng” will drop prices next — at this pace, probably not too long.

---

References

• DeepSeek API Price Cut Again: Cache Hit Price Dropped to 1/10 — Linux.do community confirms cache-hit prices for all models reduced to 1/10 of the original.
• What’s Liang Sheng Doing? Cache Permanently at One-Tenth! — Community discussion confirming the permanent nature of the price change.
• DeepSeek Official Discount Update: Cache at 10% (Updated: Permanent) — Earliest thread confirming the permanent price reduction.
• DeepSeek V4 Series Input Cache Price Reduced to 1/10 Launch Price — Discussion referencing official documentation.
• DeepSeek API Prices Halved, Benefiting Enterprises and Individuals — Zhihu column reviewing DeepSeek’s past cuts.
• DeepSeek API Introduces Context Caching on Disk — Reddit community discussion on DeepSeek’s caching technology.