DeepSeek Search and Fetch API Launches: Just $0.75 per Thousand Requests

DeepSeek has recently launched a Search and Fetch API, opening it to developers at a price of $0.75 per 1,000 successful requests. This pricing has sparked discussion on Hacker News and has made the combined "search + fetch" capability a new infrastructure option for AI application development.

One API Solves Two Needs

Judging by the name, DeepSeek^Ad's service is divided into two layers of capability: Search handles retrieval, and Fetch handles fetching web page content. Developers no longer need to separately integrate a search engine API and a scraping tool; a single interface can complete the full "search first, then fetch" pipeline.

The practical value of this combination lies in the fact that large models themselves cannot access real-time web pages, and RAG (Retrieval-Augmented Generation) applications need to obtain external content first. The traditional approach is to integrate a third-party search interface and then handle anti-scraping, parsing, and cleaning yourself. DeepSeek packages these two steps together, reducing engineering complexity.

According to the related Hacker News discussion, what developers care about most is not the feature itself, but how a "successful request" is defined—whether failed or empty-result requests are billed directly determines the actual cost.

RAG (Retrieval-Augmented Generation) is a technical paradigm that combines external knowledge retrieval with large model generation. Its basic workflow is: after a user asks a question, the system first retrieves relevant content from a knowledge base or the internet, then inserts the retrieval results as context into the prompt, and hands it to the large model to generate an answer. The core value of RAG is mitigating the knowledge cutoff and hallucination problems of large models, enabling the model to answer with the latest information beyond its training data. In engineering implementation, RAG usually includes five stages: document chunking, vectorization, similarity retrieval, reranking, and generation, and "search + fetch" is precisely the preceding step for obtaining raw corpus. For real-time information applications, retrieval quality directly determines the accuracy of the final answer, so the stability and coverage of the search and fetch API are key variables in RAG system design.

Pricing Logic: The Appeal of Paying per Success

At $0.75 per 1,000 successful requests, the cost per request works out to less than $0.001. Compared with similar search APIs, this pricing is in a lower range, but what matters more is the "pay per success" rule.

For developers, not being billed for failed requests means cost predictability is stronger. In scraping scenarios, target site timeouts, anti-scraping blocks, and empty content are not uncommon. If billing were based on the number of calls, actual spending would deviate significantly from expectations. By choosing successful results as the unit of measurement, DeepSeek is effectively retaining part of the failure risk itself.

However, HN comments also raised questions: who defines the criteria for determining a failed fetch? If content is returned but the quality is poor, is it still counted as success? These details need to be further clarified in the official documentation.

Impact on AI Application Development

The spread of search and fetch APIs may change how AI applications obtain data. In the past, real-time information applications needed to build their own scraping teams or rely on multiple third-party services; now, a low-cost interface can cover basic needs.

This is consistent with DeepSeek's recent product cadence: entering the developer market with a low-price strategy and using APIs as an entry point to build an ecosystem. Combining search and fetch capabilities with its own models can form a closed loop of "retrieval—fetch—generation," providing underlying support for agents and deep research applications.

It should be noted that low price does not mean unlimited use. Scraping behavior involves the target site's robots protocol and copyright boundaries, and service providers usually limit usage in their terms. Developers should confirm the scope of compliance before integrating, to avoid using the interface for large-scale commercial scraping.

Agent refers to a form of large model application capable of autonomous planning, tool invocation, and multi-step task execution. Unlike single-turn question answering, an agent typically has the ability to decompose goals, invoke tools, observe results, and iteratively correct itself, and search and fetch are among its most commonly used external tools. In deep research agents, the model first breaks down the research question, generates multiple retrieval queries, fetches web pages, reads and summarizes them, and then decides whether to continue searching. This loop is highly sensitive to the search interface's latency, success rate, and per-call cost—a low-cost API billed per success can significantly reduce the economic burden of repeated tool calls by agents, making multi-step reasoning economically feasible. Therefore, the pricing model of search and fetch APIs directly affects the design space and commercial viability of agent applications.

The robots protocol (Robots Exclusion Protocol) is a set of crawler access rules declared in the robots.txt file in a website's root directory, used to tell automated programs which paths can be crawled and which should be avoided. It is not a legal statute, but in most jurisdictions it is regarded as an important reference for judging whether scraping behavior is in good faith. In addition to the robots protocol, web scraping also involves constraints such as copyright, database rights, and website terms of service: mass copying of copyrighted content, bypassing technical protection measures, or violating terms of service may all trigger legal risks. For developers using search and fetch APIs, compliance responsibility usually does not transfer completely just because a third-party service is used, and the usage restrictions and prohibited scenarios in the service provider's terms need to be carefully checked before integration.

How Developers Should Evaluate It

Whether to adopt this service depends on three factors: first, the scraping success rate, especially coverage of Chinese-language sites and target vertical domains; second, the degree of structure in the returned content, and whether it saves parsing costs; third, the difficulty of integration with the existing technology stack.

At present, public information is limited, and the hands-on feedback in the HN discussion is also rather scattered. Developers are advised to first use small-scale requests to verify the scraping performance on target sites, and then evaluate costs at scale. For scenarios with high search quality requirements, it may still be necessary to build a retrieval layer yourself or use multiple data sources in combination.

Search and fetch APIs are becoming a standard capability of AI infrastructure. DeepSeek is entering with low pricing and pay-per-success billing, offering developers a new option worth testing. Whether it can ultimately gain a firm foothold depends on the actual performance of scraping quality and compliance boundaries.

One-line Summary

DeepSeek launches a search and fetch API at $0.75 per thousand successful requests, with pay-per-success billing drawing developer attention.

Paragraph Summary

DeepSeek has launched a Search and Fetch API that combines retrieval and web scraping into a single interface, priced at $0.75 per 1,000 successful requests. The article argues that this combination reduces the engineering complexity of RAG applications, so developers no longer need to separately integrate a search interface and a scraping tool. The pay-per-success rule makes costs more predictable, with failed or empty results not billed, effectively meaning the service provider bears part of the scraping failure risk. However, details such as the success criteria and whether low-quality content is billed still need to be clarified by the official documentation. The article also points out that combining this capability with DeepSeek's own models can form a closed loop of "retrieval—fetch—generation," supporting agents and deep research applications, while reminding developers to verify scraping success rates and confirm robots protocol and copyright compliance boundaries before integrating.