DeepSeek opens its in-house Search and Fetch APIs at $0.75 per 1,000 calls

DeepSeek opened the search engine behind its own web app and API to outside developers on October 17, 2026, as two separately billed endpoints: Search (POST /v1/tools/search) returns ranked web results, and Fetch (POST /v1/tools/fetch) converts a single page to Markdown. The English announcement prices each endpoint at $0.75 per 1,000 calls; the Chinese announcement lists 5 yuan per 1,000 for both. Neither bills a request unless it returns HTTP 200 and actually produces results.

Key points

• DeepSeek bills Search and Fetch per successful request: Search must return a non-empty results array, Fetch must return page content. Failures, empty results and timeouts are free, and count does not change the price.
• Each endpoint is capped at 5 QPS per account, with separate quotas for Search and Fetch. The cap applies across API keys and is independent of model concurrency limits; exceeding it returns HTTP 429.
• The free window has a precise end: Search and Fetch calls made through server-side tools in DeepSeek Harness, Claude Code and Codex are unbilled until 00:00 Beijing time on November 1, 2026 (16:00 UTC on October 31).

Background

Until this week, DeepSeek’s search existed only inside its own products. The Chinese announcement says the DeepSeek search engine has long backed both the web app and the API, handling “hundreds of millions” of queries a day worldwide and indexing “hundreds of billions” of pages. Both figures are the company’s own; the post offers no third-party verification or regional breakdown.

The launch shares an announcement page with a model update. That page carries the benchmark claims for V4.1-Flash-1017 and the Hugging Face and ModelScope weight links; the model card itself lives on Hugging Face, and the deepseek-flash API alias we mentioned yesterday comes from IT之家’s reporting, not this page. Search and Fetch are a separate product line with their own prices, quotas and billing rules, and the two should not be read as one release.

For teams building agents, retrieval used to be an outside purchase: write your own crawler, or pay Brave, Exa or Tavily. When a model vendor folds the index into its own API, the bill, the rate limit and the error handling all land inside the same account you already use for inference. That consolidation is the actual change here.

Pricing and billing

The official price sheet, taken from the Chinese and English guides on October 17, prices each currency separately rather than converting one into the other:

Item	Chinese docs	English docs
Search	5 yuan per 1,000 successful requests	$0.75 per 1,000 successful requests
Fetch	5 yuan per 1,000 successful requests	$0.75 per 1,000 successful requests
Search billed when	HTTP 200 and non-empty results	HTTP 200 and non-empty results
Fetch billed when	HTTP 200 and page content returned	HTTP 200 and page content returned
Failures, empty results, timeouts	Not billed	Not billed
Account-level rate limit	5 QPS each, separate quotas	5 QPS each, separate quotas
Server-side tool calls	Billed from 00:00 Beijing time, Nov 1	Billed from 16:00 UTC, Oct 31

At the Chinese price, a successful call costs about half a fen. At the English price, a million successful searches run $750. Billing ignores tokens and result count: raising count from 5 to 50 does not change what a single call costs.

The free period has a narrower scope than the headline suggests. DeepSeek waives charges for Search and Fetch calls routed through server-side tools in DeepSeek Harness, Claude Code and Codex — not for every user of those clients. Startup Fortune made the same distinction in its launch coverage: only people pointing those tools at the DeepSeek API sit inside the free window.

Endpoints and limits

Both endpoints are read-only POST requests authenticated with a DeepSeek API key. Search takes a query of 1–128 characters, a count that defaults to 10 and ranges from 1 to 50, and a need_content flag that leaves content empty when false. Two optional fields, ori_question and localization, pass the original user question and an IP address for localizing results. Fetch takes one url of up to 8,192 characters, which must be HTTP or HTTPS with a host and must not carry a username or password.

Search accepts eight query operators: site:, -site:, -term, -"phrase", "phrase", lang:, after: and before:. Source and date filtering can go straight into the query instead of a client-side pass over the results.

Two scores in the response matter. rerank_score runs from 0 to 3 and combines relevance, authority and freshness; DeepSeek calls anything at or above 1.5 a high-quality result. authority runs from 0 to 4, with -1 meaning unknown and 3 or above “highly authoritative”. Snippets are typically 100–200 characters for display, and summaries 600–800 for feeding a model. Both scores are the vendor’s own ranking signals; DeepSeek has not published how they are computed, so they are not an independent quality rating.

The rate limit is account-level. Search and Fetch each allow 5 QPS per account, regardless of which API key you use, and independently of model concurrency limits — five requests a second works out to roughly 432,000 calls a day if sustained. Going over returns 429. Fetch carries an additional per-domain QPS cap that also returns 429, so a burst of fetches against one site can trip the limit even when the account-wide budget is unused.

Error codes decide your retry logic. For Fetch, 403 means the request was rejected by a security policy, and 404 covers everything from an unreachable URL and a site-policy block to an unsupported content type or a page with no extractable Markdown. DeepSeek advises retrying only after a wait on 408, 429 and 5xx, topping up the balance before retrying 402, and leaving other 4xx errors alone unless the request itself changes.

What others say

The Decoder’s October 17 report repeats the price and the free-window deadline, and carries the request-volume figure as a company claim without an independent evaluation of Search or Fetch. Nothing we read for this entry offers a third-party benchmark of retrieval quality on the two endpoints.

Startup Fortune’s October 18 piece adds two angles. It cites a single outlet’s launch-day snapshot putting rivals at roughly $5 per 1,000 calls for Brave, $4–7 for Exa, $1–5 for Perplexity and $8–16 for Tavily, while noting that the services are not equivalent and that the numbers are a rough guide. The same piece warns that a launch price can move, pointing out that DeepSeek raised prices on another product earlier this year. It also relays DeepSeek’s privacy policy as saying personal data is collected, processed and stored in the People’s Republic of China, with platform terms governed by Chinese law; user input appears among the data used to improve its technology, while the API terms do not clearly say whether API inputs are used for training. The search guide, the article notes, says nothing about retention or region. It further reports that regulators in Italy and Germany have acted against DeepSeek over data transfers to China.

On the Chinese side, QbitAI’s October 17 evening post repeats the 5 yuan per 1,000 figure and the “half a fen per call” arithmetic, confirms that failures, empty results and timeouts are free, and gives the free period only as “until November 1” without a time of day. It does not mention QPS, index size or competitors.

On Hacker News, the thread on the same day’s DeepSeek release (646 points and 548 replies when checked on October 18) drew hands-on reports. User ytxm reported mixed results from a trial: a search for a Microsoft product “couldn’t find its landing page,” and a search for a niche open-source package returned Debian repository pages in the top hits, though the project homepage appeared within the first ten. User alex-moon replied that he still uses Brave’s search API. These are individual impressions rather than a comparison, but they point at retrieval quality as the open question behind the low price.

Our take

For anyone maintaining a coding agent or a RAG pipeline, the immediate value is that retrieval now fits in a spreadsheet. At the English price, a million successful searches cost $750, and the success-only rule means retries after failures do not add to the bill. The 5 QPS account cap is the constraint that needs designing around, because it sets how many concurrent agents one account can serve. Retrieval is only one link in the chain: context engineering decides what happens to the results afterwards, and the two should be evaluated separately.

Data handling is the other half. The search guide documents no retention period and no storage region, and per Startup Fortune’s reading of the privacy policy, processing happens in China. For financial, health or EU-facing teams, that constraint may rule out adoption before price ever enters the discussion.

Quality has no independent evidence yet. The only hands-on report we found is one Hacker News comment. A low price does not make results good; running a batch of your own production queries against the endpoint and comparing with whatever Brave or Tavily setup you have today is the safer sequence.

Two unknowns remain: whether the launch price holds, given DeepSeek’s earlier increase on another product, and whether the documentation gains a retention and region section. Both affect long-term cost and compliance.

How to try it

With a DeepSeek API key, one curl call shows the Search response shape:

curl https://api.deepseek.com/v1/tools/search \
  -H "Authorization: Bearer $DEEPSEEK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query":"DeepSeek V4 release","count":5,"need_content":true}'

Swap the query for site:github.com DeepSeek lang:zh after:2025 to exercise the operators, then pass the first result’s url to Fetch:

curl https://api.deepseek.com/v1/tools/fetch \
  -H "Authorization: Bearer $DEEPSEEK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"url":"https://example.com/article"}'

Log three things during the test: the distribution of rerank_score and authority, the share of empty results, and how often 429 appears. The first two tell you about quality, and the third sets your concurrency design. The free window covers only server-side tool calls through the three named clients; the guide states per-call billing as the default and carves out that case, so a direct call to either endpoint is billed at the rates above.