For Agent Builders Using DeepSeek's New App Suite API, the Real Gems Are the Standalone Tool Endpoints
Until recently, many developers found DeepSeek’s official web and
mobile apps far more practical than its developer API. The official
client offered built-in web search, URL reading, multi-page document
parsing, and text-to-speech playback, whereas the developer API only
handled plain-text chat. On November 13, 2026, DeepSeek published its full
application API suite announcement, opening up all of those
client-side features as APIs at once alongside a ready-to-use
open-source web frontend, chat-demo.
This release offers two distinct ways to call those capabilities. The
first is a set of built-in suite switches: when chatting with the
lightweight deepseek-flash model, you turn on web search or
document reading flags directly inside the chat request, and DeepSeek’s
servers automatically search the web, read links in the background, and
return a synthesized answer. The second is a set of standalone tool
endpoints: DeepSeek unbundled its underlying web search, web fetching,
optical character recognition (OCR), speech recognition (ASR), and
speech synthesis (TTS) into 5 separate endpoints that you can use as a
standalone search engine, web-to-Markdown scraper, or document parser
without calling DeepSeek’s language model at all. Most developers
instinctively reach for the convenient built-in suite switches first.
Yet once you open DeepSeek’s technical documentation and try wiring them
into an agent codebase, you quickly discover that the built-in switches
are a closed black box that forbids mixing in custom tools—meaning
standard agents cannot use them. What actually delivers real value to
developers is the set of low-cost standalone tool endpoints that
DeepSeek unbundled and priced separately.
Why Can’t Standard Agents Use the Convenient Built-In Chat Switches?
When developers see that the built-in suite switches only require adding a parameter to a chat request to get automatic web search and document reading, their first instinct is to flip that switch in their existing agent code and save a few lines of tool-calling glue. Earlier, both OpenAI’s Responses API and Anthropic’s Messages API introduced similar server-side web search tools. If overseas providers’ built-in tools plug right into agents, why can’t DeepSeek’s built-in suite switches do the same?
The reason comes down to platform architecture. OpenAI designed the
Responses API as a general-purpose cloud runtime that preserves
conversation state on the server and mixes official built-in tools like
web search and code sandboxes alongside a developer’s own business
functions (custom tools). Although DeepSeek made its endpoint compatible
with the Responses API request format, it did not build a
general-purpose cloud runtime. DeepSeek’s API documentation explicitly
states that it does not store server-side conversation history and
silently ignores parameters for code sandboxes or vector file search.
Instead, its engineers took a more pragmatic shortcut: they directly
exposed the fixed backend pipeline trained via reinforcement learning
for DeepSeek’s own consumer web app, restricted exclusively to the
lightweight deepseek-flash model. Exposing that internal
consumer pipeline directly creates three strict engineering
constraints.
First, enabling any built-in switch forbids custom tools in the same
request. Real-world agent applications almost always rely on custom
tools—such as querying internal databases or reading and writing local
files. However, DeepSeek’s chatbot
building guide states explicitly that if you enable built-in web
search, URL reading, high-watermark safety moderation, or session title
generation, the request cannot include any custom tools; otherwise, the
API immediately returns a 400 error code. That restriction
makes the built-in suite switches unusable for any business system that
needs to execute external actions.
Second, model sampling parameters and output formats are locked down.
Once these built-in switches are active, sampling temperature, top-p
nucleus sampling, stop sequences, and thinking token budgets passed in
the request are all silently ignored. If your application code relies on
structured JSON output or assistant prefix continuation, turning on web
search or safety moderation will likewise trigger an error. Even the way
you pass the current date and user location must strictly follow the
internal protocol of DeepSeek’s consumer web app. Normally, developers
put the current date into the top-level system prompt; however,
modifying the system prompt every day invalidates the entire KV prefix
cache accumulated across conversation history. To preserve prefix cache
hit rates, DeepSeek requires developers to insert a fixed-format
latest_reminder role message immediately before each user
message to pass the date and city—and placing it anywhere else throws an
error.
Third, webpage text is encrypted and scrubbed from conversation
history across turns. To prevent external developers from using built-in
chat tools as a free web scraper, the search result blocks returned by
built-in web search and thinking search encrypt all webpage content into
ciphertext, leaving the client with no plaintext access. On the next
conversation turn, those search results are stripped from the model’s
context memory, leaving only the previous assistant reply. Similarly,
the built-in URL reader always returns an empty string for its content
field and hides the encrypted payload inside a signature field,
requiring the client to pass the entire block back verbatim on
subsequent turns so the server can stitch it together internally.
Together, these guardrails mean the built-in suite switches are only
suited for pairing with the open-source chat-demo frontend
to clone a pure consumer chat website.
How Do Unbundled Standalone Tool Endpoints Drive Down Search and Parsing Costs?
If the built-in suite switches are a closed black box, where is the actual upside for agent builders in this release? The answer lies in the second half of the announcement. Precisely because the built-in switches cannot coexist with custom tools, even OpenAI’s official coding agent Codex could not use DeepSeek’s built-in search. To resolve that conflict, DeepSeek simultaneously exposed its underlying web search, web fetching, OCR, ASR, and TTS as standalone tool endpoints decoupled from LLM chat. In the official Codex one-click configuration script updated the same day, DeepSeek’s engineering team enabled the standalone web search channel by default, letting Codex bypass the built-in mode and call the underlying search and fetch endpoints directly.
Selling underlying tools as unbundled endpoints goes in the exact opposite direction of overseas AI labs. In OpenAI’s and Anthropic’s ecosystems, web search is permanently welded to model inference: you cannot call their search engines without invoking GPT or Claude, and you pay $10 per 1,000 searches in tool fees on top of the model token fees for every retrieved passage injected into context. DeepSeek’s standalone tool endpoints do not require calling DeepSeek’s language models at all. Even if your agent uses GPT or Claude as its core reasoning brain, you can use a DeepSeek API key to call its search and fetch endpoints directly. As the price comparison below shows, DeepSeek charges just 5 RMB ($0.75) per 1,000 search or fetch calls—and charges nothing when a search fails or returns empty results—putting its unit price at less than one-tenth that of overseas incumbents.
What saves even more money is that DeepSeek’s in-house search engine
includes full-text webpage extraction at no extra charge. In its web search and
fetch guide, DeepSeek disclosed for the first time that its
standalone search endpoint is powered by an in-house search engine built
specifically for agents. When issuing a search request, you can pass not
only search keywords but also the user’s original question to help the
engine understand intent. Each returned result includes a relevance
score, site authority score, short snippet, and an approximately
800-character high-density summary tailored to the user’s question.
Furthermore, if you include the need_content parameter in
the search request, the endpoint returns the complete Markdown body of
each result page. Whether a query returns the default count or up to 50
results, enabling full-text Markdown extraction does not increase the
price of the search call—it still costs just 0.005 RMB per search. By
comparison, third-party search and scraping tools like Firecrawl charge
credits per scraped page, making a single search followed by full-text
extraction across a dozen pages more than ten times as expensive.
Beyond search, the standalone OCR document endpoint supports uploading PDF, Word, PowerPoint, and common image formats directly, offering both fast plain-text extraction and page-by-page layout-preserving recognition for just 1.5 RMB ($0.225) per 1,000 pages. And if developers upload plain text, source code, or spreadsheet files via the Files API to inline into chat context, document parsing is completely free of tool fees.
How Does Compliance Shift to Developers Show Up in Billing and Code?
After examining tool capabilities and pricing, many developers noticed another detail. The announcement prominently warns that developers offering external services should enable the high-watermark safety moderation parameter and bear primary legal responsibility for algorithm filing and content moderation. Is that merely boilerplate legal disclaimer text, or does it actually materialize in engineering code and API bills?
A closer look at the Open Platform Terms of Service shows that the clauses defining the platform as a neutral API provider and requiring downstream developers to handle their own LLM regulatory filings and content moderation were revised on April 22, 2026 and took effect days later. Why did this November announcement emphasize them so heavily? Previously, the API only supported plain-text chat; once real-time web search, arbitrary URL fetching, and a turnkey frontend repository were opened up, anyone could spin up a live web-connected chat site in minutes. DeepSeek wants to sell these building blocks without assuming downstream regulatory liability or subsidizing the compute required for content moderation. To enforce that boundary, the official content safety guide lays out a strict split of responsibilities and billing rules that turns content moderation into a developer-paid line item.
The first cost is that safety moderation compute is billed at the
model’s output token rate. When a developer sets the safety moderation
switch to the recommended high-watermark level, the server-side compute
spent inspecting inputs and outputs is converted into safety tokens
(safety_tokens) and added directly to the total output
token bill, charged at deepseek-flash’s output rate of 4
RMB per million tokens. The second cost is that blocked requests are
still billed. If a user’s prompt fails safety moderation and the API
returns a 400 content-risk error, the input tokens are
still billed at the cache-hit rate; similarly, if the built-in URL
reader fetches a target webpage that subsequently fails moderation and
returns a forbidden block, the 0.005 RMB fetch fee is still
charged in full.
The third engineering requirement lands on the frontend during
streaming output. In streaming mode, tokens arrive incrementally one
chunk at a time. If safety moderation triggers mid-stream—for example,
because half-generated model output or an uploaded image fails
inspection—the server cannot claw back text chunks already sent over the
wire. Instead, the server halts generation, emits a
finish_reason: "content_filter" refusal signal at the end
of the stream, and bills for all tokens generated up to that point,
while requiring the client application to immediately wipe the
already-rendered content from the user interface. Inspecting the
open-source chat-demo repository confirms how this works in
practice: the frontend streaming handler explicitly watches for the
refusal signal and, the moment it catches content_filter,
clears both the reasoning trace and the partial answer from the DOM and
replaces them with a refusal notice.
What Is the Most Cost-Effective Way to Integrate These APIs Today?
Once you see the coupling restrictions of the built-in suite
switches, the steep price cuts on the standalone tool endpoints, and the
developer-paid streaming wipe mechanism for safety moderation, you can
choose among three practical integration paths depending on what you are
building. If you are building your own AI agent or wiring tools into an
orchestration workflow—even if your primary reasoning model is GPT or
Claude—the most cost-effective move is to bypass the built-in chat
switches altogether. Grab a DeepSeek API key and wrap just the
standalone search, web fetch, and OCR endpoints as standard custom tool
functions. That way, you avoid the 400 error ban on custom
tools while using DeepSeek’s fraction-of-the-market retrieval and OCR
pricing to cut your third-party tool bill by over 90%.
If you use Claude Code or Codex for daily software engineering, you can upgrade directly to DeepSeek’s newly updated integration scripts. DeepSeek has already routed around the built-in switch limitations under the hood for both tools: the latest Codex configuration script defaults to calling the standalone search and fetch endpoints, while DeepSeek’s Anthropic-compatible endpoint includes server-side adaptation so that when Claude Code triggers its native web search tool, it routes seamlessly to DeepSeek’s underlying search engine.
Finally, if you simply want to spin up a pure chat web app for
domestic users in China without attaching custom business tools, pairing
deepseek-flash’s built-in suite switches with the
chat-demo frontend is the fastest route. Before launching,
however, you need to accept two constraints: locked model sampling
parameters with zero custom tools, and high-watermark safety moderation
that bills safety_tokens to your account and requires your
frontend to wipe the screen automatically whenever a mid-stream refusal
signal arrives.
Because these standalone tool endpoints just launched on November 13, public documentation and early testing primarily validate their API ergonomics and billing rules. How well DeepSeek’s in-house search engine holds up on long-tail English technical queries, heavily anti-scraped vertical communities, and high-concurrency production traffic spikes will still need to be proven through large-scale production workloads and independent third-party benchmarks.