On October 17, 2026, DeepSeek opened its Search and Fetch APIs as standalone products, billed per successful request at five yuan per thousand calls. Search returns structured results; Fetch converts a web page to Markdown. Both are driven by DeepSeek's in-house search engine. Failed, timed-out or empty requests are not charged, and each account is capped at five queries per second for Search and Fetch separately.
The pricing itself is not the story. The structural change is: perception now has a unit price, and agent frameworks still assume search is free.
Five QPS is not a limit. It is a filter.
Most coverage glosses over the five queries per second cap. It defines the product's real position.
A mid-sized agent application running 10,000 searches a day averages under 0.12 queries per second. Five QPS is plenty. A consumer-facing, high-concurrency product will hit the ceiling at peak. Pandaily notes the rate limit is counted per account, with Search and Fetch tracked separately.
The customer profile DeepSeek is selecting is clear: batch jobs, internal research agents, evaluation pipelines, low-concurrency experiments. It is not selling a general-purpose search infrastructure. It is selling an entry point that lets developers run agents at very low cost. When those agents grow and concurrency rises, five QPS becomes a bottleneck — and the fix is likely migration to another provider, or waiting for a tiered plan DeepSeek has not announced.
That is not a flaw. It is a strategy. Low price plus a hard rate limit pulls in developers who are cost-sensitive and data-residency-insensitive, into one API key, one billing page, one documentation set. Friction is minimized by design.
Failure is free. That is a bet, not a discount.
The "failed requests are not charged" rule has been repeated in Chinese coverage, but the behavioral consequence is rarely examined.
If a failed search costs nothing, developers have an incentive to let the agent search more aggressively. Miss, rephrase, retry — no bill. Agent behavior can slide from careful retrieval to brute-force enumeration. DeepSeek can offer this rule only if it believes its failure rate is low enough that the giveaway does not become a financial drag.
That is a public endorsement of its own search quality, paid for in real money. At a 10% failure rate, DeepSeek is effectively giving developers a 10% discount. At 30%, the rule loses money. Internal data supports the decision; the data is not public. For developers, the rule lowers the cost of trial and error. For DeepSeek, it is a wager on its own index.
Perception has a price tag. Agents have no budget line.
This is the real problem.
The price is tiny. An agent that confirms one fact with three searches and eight page fetches spends about 0.055 yuan. Negligible per task. But once an agent is authorized to act autonomously and decide whether to search again, every search becomes a financial decision that needs authorization, a budget, and a stop condition.
Current agent frameworks handle this unevenly. LangChain's recursion_limit caps node visits, not cost. Token budget callbacks track model calls, but per-request search billing is outside their view. LangChain itself deployed an LLM Gateway to govern coding-agent spend in production — but that is enterprise infrastructure, not a framework primitive. CrewAI's execution hooks can trace tool calls, but the developer has to implement the cost logic.
Third-party libraries are filling the gap. shekel accepts a tool_prices argument that assigns a per-call price to web_search and folds it into a total budget. floe-guard offers a reserve_tool mechanism that reserves budget before a call and settles after. These are bolt-ons, not first-class citizens. A research agent built on LangGraph does not know, by default, that its search calls are generating a bill — let alone when to stop.
Alibaba Cloud's developer community asked the right question: "AI acts on your behalf — can it decide how much to spend?" It did not answer, because the answer does not exist yet. DeepSeek turned perception from an invisible cost into a line item. The frameworks have not caught up.
Who decides how many times an agent searches
This is a governance problem, not a technical one.
When an agent's operating cost expands from "model tokens" to "model tokens plus perception calls," teams gain a new variable to optimize. It is variable, agent-decided, and billed per request. A well-designed agent should stop when it has enough information to decide, not when the budget runs out. But "enough information" is a fuzzy judgment, and "budget exhausted" is a precise threshold.
There is no standard answer. LangChain's approach is centralized governance through a gateway, with budgets set at the organizational level. Third-party libraries assign prices and caps to tool calls. Both assume the developer already knows search costs money and has configured controls. For most developers starting on DeepSeek's cheap API, that awareness will not appear on its own.
DeepSeek's search API is not the problem. Five yuan per thousand is a fair price, free failures are an honest rule, and five QPS is a precise filter. The problem is that it opens a new cost dimension that the agent ecosystem is not built to manage.
P.S. One detail in the docs is easy to miss: Search accepts an ori_question field so the engine can better understand intent. That parameter exists for agents — a human search does not need to tell the engine why they are searching, but an agent can. DeepSeek is optimizing the perception layer for agents while agent frameworks still manage cost with human-era models.
Frequently Asked Questions
Q: What exactly did DeepSeek release?
A: Two standalone APIs. Search returns structured results (title, link, summary, date) for a query; Fetch retrieves a web page and converts its body to Markdown. Both are billed per successful request at five yuan per thousand calls, with failed or empty requests uncharged.
Q: Why does the five QPS limit matter more than the price?
A: It defines the customer. Five queries per second is ample for batch jobs and internal research agents but a hard ceiling for consumer-facing, high-concurrency products. DeepSeek is selecting cost-sensitive, low-concurrency developers rather than selling general-purpose search infrastructure.
Q: What does "failed requests are not charged" imply for agent behavior?
A: If failures cost nothing, developers have an incentive to let agents retry aggressively, shifting behavior from careful retrieval toward brute-force searching. DeepSeek can absorb this only if its own failure rate is low — an implicit bet on its search quality.
Q: Why is it a problem that agents can search on their own?
A: Each search now carries a price. An agent authorized to decide "search again" is making a financial decision, but mainstream frameworks do not track per-request search billing. LangChain's recursion limit caps node visits, not cost; third-party tools like shekel and floe-guard fill the gap but are not framework primitives.
Q: Does this mean agents will run up large bills?
A: Not at DeepSeek's prices — a task with three searches and eight fetches costs about 0.055 yuan. The issue is structural: agent operating cost now includes a variable, agent-decided, per-request line item that no framework budgets for by default.
Q: What should teams building on these APIs do now?
A: Treat perception as a cost line. Set per-task search and fetch caps, log per-request spend, and define a stop condition based on sufficiency rather than budget exhaustion. Until frameworks ship native support, that control has to be built into the agent's own loop.
