Search the web with DeepSeek's index. Returns titles, URLs, dates, authority and rerank scores.

Use this for discovery and ranking. Set need_content=True to get full page text inline in the same call (billed as one request, no per-page charge) — this is usually cheaper and more reliable than calling deepseek_fetch afterwards.

For non-English queries set lang to the appropriate code (e.g. 'es', 'de', 'ja'). Without it results may be mixed-language; for named entities test with and without the operator. Each result carries date (RFC 3339) and authority (0-4, -1 unknown).

Responses are cached in memory for a few minutes and identical concurrent calls share one upstream request; the envelope's cached flag tells which happened. Calls are rate-limited locally per endpoint: if no slot frees up within a short wait the error code is rate_limited_local. A response larger than 8 MiB fails with response_too_large.

Args: query: Search query, max 128 characters. Supports site:, -site:, "phrase", lang:, after:, before:. count: Number of results to return, 1-50 (default 10). With dedupe on, extras are requested upstream so duplicates do not leave you short. ori_question: Original natural-language question, max 128 characters; improves ranking. need_content: Return full page text per result (recommended for reading). lang: Language operator, e.g. 'es', 'de' or 'ja'. For non-English queries set it to the appropriate code; without it results may be mixed-language. For named entities test with and without the operator. max_chars_per_result: Content cap per result when need_content is set. max_total_chars: Total content budget across all results. dedupe: Collapse near-duplicate results (same canonical URL or same title+site), default on. rewrite: Rewrite the query via deepseek-flash before searching, default off. Skipped when lang is set; falls back silently to the original query on failure. refresh: Bypass the response cache and query upstream again (the envelope's cached flag says whether the results came from the cache).

Search and return full page content in one request — the recommended retrieval path.

This is search with need_content=True. Measured on 14 benchmark questions it returned content for PDFs and Reddit threads where deepseek_fetch returned HTTP 404, in about 0.7s per call.

Responses are cached in memory for a few minutes and identical concurrent calls share one upstream request; the envelope's cached flag tells which happened. Calls are rate-limited locally per endpoint: if no slot frees up within a short wait the error code is rate_limited_local. A response larger than 8 MiB fails with response_too_large.

Args: query: Search query, max 128 characters. count: Number of results to return, 1-50 (default 5). With dedupe on, extras are requested upstream so duplicates do not leave you short. ori_question: Original natural-language question, max 128 characters. lang: Language operator, e.g. 'es', 'de' or 'ja'. For non-English queries set it to the appropriate code; without it results may be mixed-language. For named entities test with and without the operator. max_chars_per_result: Content cap per result. max_total_chars: Total content budget across all results. dedupe: Collapse near-duplicate results (same canonical URL or same title+site), default on. rewrite: Rewrite the query via deepseek-flash before searching, default off. Skipped when lang is set; falls back silently to the original query on failure. refresh: Bypass the response cache and query upstream again (the envelope's cached flag says whether the results came from the cache).

Fetch one known URL and return its title and Markdown content.

Caveat measured on 2026-10-20: this endpoint returns HTTP 404 for PDFs and for Reddit, and times out on some sites. When the URL is a document or a blocked site, call deepseek_search_and_read with the page title or a site:-scoped query instead.

The response contains only title and content — no final URL, status code or publication date, so keep the provenance on your side.

Pages are cached in memory for about half an hour and identical concurrent calls share one upstream request; the envelope's cached flag tells which happened. Calls are rate-limited locally per endpoint: if no slot frees up within a short wait the error code is rate_limited_local. A response larger than 32 MiB fails with response_too_large.

URLs that point at internal hosts or literal private addresses, or that embed credentials (user:pass@host), are rejected locally with ssrf_blocked before any request is made.

Args: url: Absolute http(s) URL, max 8192 characters. clean: Remove DeepSeek's spurious Markdown escaping (# at line start, , , etc.). max_chars: Content cap, applied after cleaning. refresh: Bypass the response cache and fetch the page again (the envelope's cached flag says whether the page came from the cache).

Fetch up to 10 known URLs concurrently and return each page's title and Markdown content.

Each URL goes through the same validation, cache, rate limiter and SSRF checks as deepseek_fetch. Empty entries are skipped and duplicates (same canonical URL) are fetched once. Results keep the input order; a failing URL yields an item with ok=false and an error instead of failing the batch. All fetches share one deadline (120 s by default); URLs still pending then are cancelled and reported with error code deadline_exceeded.

Each page gets min(max_chars_per_url, max_total_chars // count) characters and the total content never exceeds max_total_chars; a note says when any content was truncated. The envelope reports count (unique URLs), requests_used (upstream fetches attempted), cached_count (items served from the cache), failed_count (items with ok=false), partial (true when any item failed), results and notes. The top-level ok only says the batch ran; check partial or each item's ok for per-URL failures. Each result carries its own cached flag.

Args: urls: 1-10 absolute http(s) URLs, max 8192 characters each. max_chars_per_url: Content cap per page, applied after cleaning. max_total_chars: Total content budget across all pages. clean: Remove DeepSeek's spurious Markdown escaping (# at line start, , etc.). refresh: Bypass the response cache and fetch every page again.

Gather source material for a question: one search with page content, then fetch the gaps.

Runs a single search with need_content=True (no query rewrite, no model call, no summary). Results whose content is missing or shorter than 200 characters and whose URL passes validation are fetched directly with deepseek_fetch_many (at most 5 per call); a fetched page replaces the search content of that source. A URL that fails validation (for example an internal address) is not fetched. Failed or rejected sources keep the search content and set the source's error; the call still succeeds with partial=true.

Each source has id, title, url, authority, rerank_score, content, chars, origin ('search' or 'fetch'), error (null or {code, message}) and cached (whether its content came from the cache). Content is capped at per_page_chars per source and total_chars overall, in source order; a note says when any content was truncated. requests_used counts upstream requests made (the search plus each fetch; cache hits are free) and cached_count counts responses served from the cache. failed_count counts sources whose error is set and partial is true when it is non-zero. Synthesis is left to the caller.

Args: question: Search query, max 128 characters. Supports site:, -site:, "phrase", lang:. max_pages: Number of search results to use, 1-50 (default 5). per_page_chars: Content cap per source. total_chars: Total content budget across all sources. refresh: Bypass the response caches for the search and the fetches.

Check the DeepSeek account balance (granted and topped-up, in CNY and USD).