DeepSeek Launches Search API and Fetch API for Agents and RAG

⏱️ Reading time: 10 min

DeepSeek just completed its API with two pieces it was missing: web search and live page reading. The DeepSeek Search API and its companion, the Fetch API, arrive under the same Bearer token developers already use for chat completions, running on the search engine the company operates in-house, without going through Google, Bing, or an external provider like SerpAPI or Tavily.

📑 En este artículo

1. TL;DR
2. What is DeepSeek’s Search API
3. What happened
4. Context and history
5. Technical details: how DeepSeek’s own search engine works
6. Impact and analysis
7. What’s next
8. Frequently Asked Questions
   1. What does DeepSeek’s Search API do that a normal Google search doesn’t?
   2. How does DeepSeek’s Fetch API authenticate?
   3. What does the rerank_score returned by DeepSeek’s own search engine mean?
   4. Does DeepSeek’s own search engine replace a full RAG pipeline?
   5. What happens if need_content is left at false when calling DeepSeek’s own search engine?
9. References

The official guide describes two REST endpoints: one searches the web and returns structured results, the other takes a specific URL and converts it into Markdown. Together they solve what previously required assembling third-party tools.

TL;DR

• DeepSeek launches the Search API and the Fetch API, two REST endpoints that let agents search and read the web.
• The Search API uses DeepSeek’s own search engine and accepts operators like site:, lang:, after:, and before:.
• Each result comes with a rerank_score from 0 to 3 that measures combined relevance, authority, and freshness.
• Fetch API converts a single web page into Markdown ready for the model to read without parsing HTML.
• Both endpoints authenticate with the same Bearer token used by the rest of the DeepSeek API.

What is DeepSeek’s Search API

DeepSeek’s Search API is a REST endpoint that returns structured web search results (title, URL, summary, and a relevance score) from a text query, using the search engine the company operates internally.

It is, in the words of the official documentation itself, a raw JSON API: there is no chat layer or automatic function calling involved. The developer decides when to call it, what to do with the results, and when to pass them to the model as context, just like with any hand-built RAG integration.

What happened

The documentation published by DeepSeek details two new routes under the same base as the rest of the platform: POST https://api.deepseek.com/v1/tools/search to search, and POST https://api.deepseek.com/v1/tools/fetch to read a specific page. Both use the Authorization: Bearer <DeepSeek API Key> header and Content-Type: application/json, exactly like chat completions calls.

It is not a new model or an update to V3 or R1: it is supporting infrastructure, designed so agents and retrieval-augmented generation (RAG) applications can query the current web without leaving the DeepSeek ecosystem or adding a separate search provider.

Context and history

DeepSeek built its reputation on open-weight models (V3, R1, and their variants) offered at prices well below the American competition. But a model, by itself, doesn’t solve the fact that information changes every day: to answer something from this week, an agent needs to search the web at query time, not just recall what it saw during training.

Other labs already solved this piece for their own models: OpenAI integrated web browsing into its Responses API, Anthropic offers a native web search tool for Claude, and Google connects Gemini to its own index through grounding. Until now, a developer who wanted the same thing with DeepSeek had to separately contract a search API like Bing, SerpAPI, Tavily, or Exa, and then merge those results into the prompt by hand. DeepSeek’s own search engine closes that gap without the developer having to leave the account they already have.

Technical details: how DeepSeek’s own search engine works

The query (query) accepts between 1 and 128 Unicode characters and is forwarded almost intact to the internal index, which means search operators aren’t processed by DeepSeek: the underlying engine interprets them. That includes site: and -site: to include or exclude domains, quotes for exact phrases or their negation with -"phrase", lang: to restrict language, and after:/before: to narrow by date. All of them combine into a single string, for example DeepSeek site:github.com OR site:huggingface.co lang:en after:2025.

💡 Tip: combining after: with lang:es is the most direct way to filter noise when the agent only needs recent news in Spanish.

Each result comes with a rerank_score field from 0 to 3 that combines relevance, authority, and freshness signals; according to the official documentation, a score of 1.5 or higher is already considered high quality. The snippet field is a short summary (between 100 and 200 characters) designed for a user interface, while summary is longer (between 600 and 800 characters) and meant to be read directly by the model.

The parameter that most changes the cost of the call is need_content. At false (the default value), the content field always arrives empty: the API only returns metadata and summaries. At true, DeepSeek also downloads the full page and delivers it in the same results array, which adds latency and context tokens if the agent is going to pass that content to the model. The Fetch API handles the case where the exact URL is already known: instead of searching, it directly requests that page and returns it converted to Markdown, without the rest of the fields from a search result.

sequenceDiagram
participant A as Agent or app
participant S as Search API
participant M as DeepSeek internal engine
participant F as Fetch API
A->>S: POST /v1/tools/search (query, count)
S->>M: executes the query with operators
M-->>S: results with rerank_score
S-->>A: results in JSON
A->>F: POST /v1/tools/fetch (url)
F-->>A: page converted to Markdown

curl https://api.deepseek.com/v1/tools/search \
  -H "Authorization: Bearer $DEEPSEEK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "DeepSeek Search API site:github.com after:2026",
    "count": 5,
    "need_content": false
  }'

The documentation illustrates the shape of the response with an example (not production data, just the schema): a results array where each element includes rerank_score, title, url, snippet, summary, site_name, and date. A search with no matches doesn’t throw an error: it returns results: [] with HTTP 200, which is also the simplest way to confirm an account has access enabled. A 401 on that same call indicates the Bearer token doesn’t have the search scope active.

📌 Note: being a raw JSON API rather than a function-calling tool, DeepSeek’s model doesn’t decide on its own when to search: it’s the agent’s code that calls /v1/tools/search and then builds the prompt with what it receives.

Impact and analysis

For a developer who already pays for DeepSeek’s models, the immediate gain is operational: one less provider to bill, one less token to rotate, and an API with the same authentication format as the rest of the platform. That simplifies the stack of an agent that previously needed DeepSeek’s key to generate text and another provider’s key just to search.

The trade-off is that result quality depends entirely on DeepSeek’s own index, which doesn’t have the publicly documented history or coverage of Google or Bing. The guide also doesn’t specify a separate price for these endpoints beyond what the API account already costs: as of this article there is no dedicated pricing section for Search and Fetch in the public documentation, so check the pricing section before putting DeepSeek’s own search engine into a flow with a high volume of calls.

There’s also a privacy angle rarely discussed: the localization parameter accepts an IP to adjust results by geography, which means that if an agent forwards the end user’s real IP, that address ends up in the request to DeepSeek just as it would with any search engine that geolocates queries.

What’s next

What remains to be confirmed is whether DeepSeek will expose these two endpoints as native function calling within chat completions, so the model decides on its own when to search instead of having the agent’s code orchestrate it, and whether it will publish rate limits and a dedicated pricing table. It also remains to be seen whether other open-weight labs with a similar cost-focused approach respond by bundling their own search engine instead of leaving it to third-party integrations.

Try it yourself: make a POST to https://api.deepseek.com/v1/tools/search with your API key and a query with site: to see the results array before connecting it to a production agent.

Frequently Asked Questions

What does DeepSeek’s Search API do that a normal Google search doesn’t?

It responds in structured JSON designed to be read by a model, not a person: each result includes rerank_score, summary, and, if requested, the full content of the page. It uses the same search operators (site:, lang:, after:) but under the account and billing the developer already has with DeepSeek.

How does DeepSeek’s Fetch API authenticate?

With the same scheme as the rest of the platform: an Authorization: Bearer <DeepSeek API Key> header and Content-Type: application/json. There is no separate key for search or fetch.

What does the rerank_score returned by DeepSeek’s own search engine mean?

It’s a number from 0 to 3 that combines the relevance, authority, and freshness of each page. According to the official documentation, 1.5 or higher indicates a high-quality result; lower values don’t mean the page is broken, only that the system considers it less relevant for that specific query.

Does DeepSeek’s own search engine replace a full RAG pipeline?

No. It covers the retrieval of current public web content, but it doesn’t replace embeddings, vector databases, or the chunking of private documents. For a company’s own data, it remains complementary to a traditional RAG pipeline, not a substitute.

What happens if need_content is left at false when calling DeepSeek’s own search engine?

The content field of each result arrives empty; it’s only filled in when need_content is sent as true, which also adds latency because DeepSeek has to download the full page before responding.

References

• DeepSeek API Docs: official guide to the Search and Fetch API, with request and response schemas.
• DeepSeek API Docs: complete catalog of the platform’s endpoints, including Bearer authentication.
• DeepSeek: the company’s official site and its models.
• Wikipedia: history and context of DeepSeek as an AI lab.

📱 Like this content? Follow @programacion on Telegram for daily tech content in Spanish: quick summaries, fresh content every day.

Featured image: Foto de Mitchell Luo en Unsplash