DeepSeek is set to raise prices, but third-party platforms like DeepInfra still offer DeepSeek V4 Flash at lower rates than the official API. Analysts suggest the increase is a traffic control measure rather than a response to losses. While third parties like OpenCode provide cheaper access through self-hosted models, actual user costs may be higher.
SynthePulse Insight · AI deep reading
Version 1 · 1 source
For the same DeepSeek V4 Flash, third-party platforms can list prices about 36% lower than the official rate, but one developer's real-world test shows that in long sessions, the cost of calling through OpenCode Go can be more than ten times that of the official API. The gap isn't in the list price—it's in the two invisible layers of cache hit rate and Harness adaptation.
The starting point of this round of discussion was not an official announcement, but a post by dax, an engineer at the third-party platform OpenCode. He discussed DeepSeek's impending price hike and speculated that it was likely not because DeepSeek is losing money, but rather more like a traffic-control measure—raising prices to suppress demand and ease overload. This speculation is a personal judgment and has not been confirmed by DeepSeek officially.
dax also said he had found a way to reproduce DeepSeek's current price even when renting GPUs, but later revealed that this was not reproduced by his own team, but by another team he collaborates with. OpenCode is currently pushing to use low-cost DeepSeek outside China through OpenCode Go. These claims likewise remain at the source_claim level.
The question truly worth asking thus emerges: if third parties really can push the price below the official one, will users' actual spending be lower?
According to the DeepSeek V4 Flash 0423 provider data listed on OpenRouter, DeepInfra's input and output prices are $0.09 and $0.18 per million tokens respectively, while DeepSeek's official corresponding prices are $0.14 and $0.28. Calculated by list price, DeepInfra is about 64% of the official price, or about 36% cheaper. Other third-party platforms such as GMICloud and Baidu Qianfan also quote prices lower than the official one.
This low price is not loss-making reselling. DeepSeek has publicly released the V4-Flash weights, and the license permits third parties to use, modify, redistribute, and even commercially sell them, so third-party vendors can directly download the weights and run the model on their own GPU or other accelerator clusters, producing tokens themselves. This is completely different from the path of closed-source models, where tokens must be purchased from the original vendor.
But there is a premise gap in price comparability: DeepInfra explicitly labels its V4-Flash as FP4, while DeepSeek's official open model repository includes BF16, FP8, and others, and exactly what precision and inference strategy the official API uses is not fully disclosed on the pricing page. In other words, the two prices may not correspond to the same kind of service.
OpenCode Go is positioned as a low-cost AI coding subscription service for open models, at $5 for the first month and $10 per month thereafter, with access to multiple models including DeepSeek V4 Pro, DeepSeek V4 Flash, GLM-5.2, Kimi K3, MiMo-V2.5, MiniMax M3, and Qwen3.8 Max. The official limits given are a maximum of $12 of usage quota every 5 hours, $30 per week, and $60 per month.
OpenCode officially states that for most models, it hopes to let users get up to about 6 times the model usage value from a $10 subscription through means such as bulk purchasing and reserving GPU capacity. It is precisely this "$10 for $60" discount structure that has led many users to form the intuition that calling DeepSeek through Go should be clearly more cost-effective than buying the official API directly.
Here two things need to be distinguished: the "dollar" quota shown in the interface is not directly equivalent to the cash the user actually pays. Go is essentially a fixed monthly fee exchanged for internal usage quota, and the interface showing several dollars consumed does not mean the user paid that amount again. Therefore, directly comparing interface consumption with actual charges may exaggerate the true cash cost.
A developer verified this with a real AI Coding task: selecting a codebase containing more than 100 code repositories, opening two terminals at the same time, one going through OpenCode Go and one connecting directly to the DeepSeek official API, entering the same Prompt and executing the same investigation task.
According to the results he published, across multiple short tasks the amount shown as spent by OpenCode Go averaged about 4 times that of the official API, with the gap exceeding 10 times in some longer sessions and about 2 times in a few tasks. His conclusion was: in short tasks OpenCode Go may still be convenient, but for longer sessions, especially when multi-turn interaction accumulates model runtime beyond about 5 minutes, the final cost of using DeepSeek through OpenCode Go may be clearly higher than calling the official API directly.
This set of data comes from a single developer's self-test, the sample and method were not disclosed, and the universality of the conclusion is uncertain, so it should be regarded as a source_claim rather than an industry conclusion.
The developer believes the main difference lies in the cache hit rate: the DeepSeek official API is clearly better than OpenCode Go at cache handling, and the longer a session continues, the more cache misses OpenCode Go accumulates, and the higher the multiple by which cost is amplified.
He also mentioned a detail: when using GLM, the cache hit rate can be improved through model-specific settings, for example setting the model not to rewrite previous messages and not to delete the reasoning content of previous turns, but OpenCode has not exposed similar settings for DeepSeek.
In the price comparison table, DeepSeek's official $0.0028 cache price is the lowest price in the list. If a 95% or 99% cache hit rate can be achieved, this official price is almost equivalent to giving away input tokens. For a Coding Agent, the model needs to continuously read code, call tools, return results, and then bring the large amount of accumulated context into the next round of inference; once the historical Prompt is cached, repeated context is billed at the extremely low Cache Hit price, while when a prefix change invalidates the cache, hundreds of thousands or even more historical tokens must be recalculated at the normal input price. The longer the session, the faster this difference amplifies.
The Zhihu author "苏迟但到" conducted a test with 20,000 trials lasting 3 days, covering DeepSeek, Kimi, Zhipu GLM, MiniMax, and OpenAI models called through OpenRouter. The method was to send 27 random requests to each model every 40 minutes, and then send the same content again after 1 minute to 720 minutes (up to 12 hours), recording whether the cache still hit.
The results showed that DeepSeek's cache hit rate always remained 100% whether during working hours or non-working hours, with no obvious invalidation even at an interval of 12 hours. MiniMax ranked second, with a hit rate of about 90% during non-working hours and dropping to about 70% during working hours; Kimi and OpenAI were in the middle; GLM was the weakest, with a hit rate of about 80% after 2 minutes, dropping to 50% at 3 minutes, and only 25% left at 5 minutes, and almost no cache survival beyond 15 minutes was observed.
The author gave two explanations for GLM's weaker performance: first, KV Cache relies more on VRAM and lacks the ability to persist to lower-cost storage media, causing frequent cache eviction; second, the actual request volume is too large, exceeding cacheable capacity and accelerating the invalidation of old caches. Both explanations are currently only speculation.
It must be emphasized that this set of data comes from personal testing and is a source_claim; and how long DeepSeek's official cache hit rate advantage can last is something the article itself also considers worth pondering.
V4-Flash-0731 did not expand the base model scale and remains the original model architecture; the main changes come from retraining and Agent adaptation. In other words, when DeepSeek demonstrates V4 Flash's Coding Agent capabilities, it binds the model's retraining together with its own Harness.
Some developers have concluded through repeated testing that the context window of DeepSeek V4 Flash routed through OpenCode is actually only about 600k, and beyond that OpenCode performs some kind of compression or truncation, whereas the official site has the full 1M context. The developer believes this may also be one reason why many people's evaluations of DeepSeek's capabilities vary greatly.
The performance difference of the same V4 Flash in different tools is also attributed to the Harness: in this developer's experience, V4 Flash in Codex can basically match Fable 5, while in the OpenCode environment it can only perform at about half its true level. The difference shows in two aspects—the ability to comprehensively understand the problem, and memory coherence in long-horizon tasks. In Codex the model has a better grasp of code reading and the overall problem, and can still maintain understanding of the original goal in long-chain tasks; in OpenCode it more easily gets stuck in local details, and may even give a solution that does not hold up at the end of the task.
These experiences come from individual developers and lack systematic evaluation. But behind a mature Harness lies a large number of mechanisms involving message routing, memory management, optimization and invocation of long- and short-term memory, and tool calling; these capabilities often come from long-term repeated engineering experimentation, and the relevant SDKs do not fully disclose implementation details. Therefore, the Harness system built around a model may become a moat one layer deeper than the model itself.
This article is compiled based on an original analysis by AI Frontline, does not represent the platform's views, and does not constitute investment advice. In the article, dax's speculation that the price hike is a traffic-control measure, and his claim that his collaborating team can reproduce DeepSeek's current price, have not been confirmed by DeepSeek officially; the cost comparison between OpenCode Go and the official API comes from a single developer's self-test, with the sample and method undisclosed; the Zhihu author's two explanations for GLM's weaker cache performance are both speculation; and the specific magnitude, effective time, and official reasons for DeepSeek's price hike are not given in official terms in the sources.
Third-party platforms can push DeepSeek's list price below the official one by relying on open weights and self-built inference; but how much users ultimately pay depends on the two capabilities not written on the pricing page: cache hit rate and Harness adaptation. In long sessions and multi-turn Agent tasks, a platform with a lower list price is not necessarily cheaper.
Primary report
Primary source