Back to Explore
NewsVibeFix editorialUpdated Nov 20, 2026

DeepSeek Put Its Whole App Into the API: Search, Files, and Voice for deepseek-flash

DeepSeek moved its whole app toolkit into the API on 13 November: five built-in tools for deepseek-flash plus standalone Search, Fetch, OCR, ASR, and TTS — with tool fees stacking on top of token fees, from $0.75 per 1,000 searches.

A person holding up a phone showing a news page while holding a coffee at an outdoor cafe (real photo)

One boundary first: DeepSeek did not release a new model this time. The site already covered DeepSeek-V4.1-Flash-1017 in October (the 17 October changelog entry: standalone Search and Fetch APIs went live, and the model was upgraded to V4.1-Flash-1017). The 13 November update is something else: DeepSeek moved the whole set of conversation capabilities from its own app — web search, reading files, reading links, voice, safety checks — into the API in one go, so developers can give their own products the same features as the app with a few parameters. The primary sources are DeepSeek's official API documentation changelog (Change Log, entry dated 2026-11-13) and its pricing page, with the key figures checked one by one; prices follow the pricing page, and the limited-time voice discount follows the pricing page's own wording.

What arrived: five built-in tools, plus five standalone APIs

The changelog's title states the scope plainly: "Releasing the full suite of application APIs." In the DeepSeek App (including the web version), web search, file input, URL reading, voice interaction, and safety work together with model inference to form the conversation experience users know. From 13 November, developers can get the same conversation features by enabling the corresponding parameters in the existing APIs, with tool calls and context assembly handled by the service.

For the deepseek-flash model (currently served by DeepSeek-V4.1-Flash-1017), five built-in capabilities are supported across the Messages, Responses, and Chat Completions APIs. First, web search: with thinking disabled and the deepseek_web_search tool enabled, the model runs web or image searches as the question requires and answers with citations. Second, deep thinking search: with thinking enabled and the same search tool enabled, the model searches the web and reads links on its own over multiple reasoning steps. Third, file input: upload PDFs, Office files, images, and more; after plain-text extraction or rich-layout parsing, they are added to the conversation context for the model to answer from. Fourth, URL reading: with the deepseek_read_url tool enabled, the model detects links in the user message, fetches the pages, and answers with them in context. Fifth, model safety: with the safety check parameter enabled, the model input and output are reviewed, and a refusal marker is returned when a risk is found.

Beyond those five built-in capabilities, the underlying capabilities are also split out as standalone APIs: Search and Fetch (search and page retrieval), OCR (images and documents into text), ASR (speech to text), and TTS (text to speech). The standalone APIs matter for jobs that do not need a model at all — turning a stack of scanned receipts into text, or turning a voice message into words, without running a large model for the sake of it. DeepSeek also open-sourced a demo chat client built on these APIs, which can import a user's DeepSeek chat history (per the changelog; see its repository for the licence).

One scope limit is worth noting: the changelog lists only deepseek-flash as supporting the five built-in capabilities, with no mention of deepseek-v4-pro. If your product runs on the Pro model, this update does not apply to you, at least for now. The documentation site's front page also mentions that DeepSeek Harness (a harness for agent-framework developers) is in developer preview — a separate track, outside this update.

How to use it: flip a parameter, keep the same calls

The friendliest part of this update for developers is that nothing needs to change: no new endpoint, no new SDK. The same three endpoints (Messages, Responses, Chat Completions) work as before, and the capabilities are switched on with parameters: to let the model search the web, enable deepseek_web_search in the request; to let it read links, enable deepseek_read_url; to add files, upload them the documented way; to add safety checks, enable the safety parameter. Tool calls and context assembly are handled server-side, so developers do not have to write the glue code that searches first, stitches results into the prompt, and then calls the model.

This follows the same path as OpenAI and Anthropic: built-in tools run server-side, and developers only flip the switch. DeepSeek's version has two traits of its own. First, all three endpoints support it, so developers do not have to migrate to one new endpoint to get search; a team used to Chat Completions can switch it on where they are. Second, the standalone APIs and the built-in tools are the same capabilities with two exits: use them inside a conversation by flipping a parameter, or call them directly in a pipeline. Both exits cost the same (see the next section) — choose by the scenario, not by the price.

For vibe projects, "switch it on" matters in a very practical way. A common vibe-project shape is "a chat box plus your own knowledge": to make the model search the web first and then answer, developers used to connect a search API themselves, stitch results into the prompt, and format citations by hand. Now the service does all of that. What gets saved is not a few lines of code but the debugging time around questions like "how do search results get stitched in without blowing up the context, and how are citations marked so they don't point at the wrong source." Small teams are exactly the ones short on that kind of time.

What it costs: tool fees stack on top of token fees — don't look at the model price alone

Prices are the part of this update most worth checking word for word, and all of them follow DeepSeek's official pricing page (Models & Pricing). The model itself first: deepseek-flash (DeepSeek-V4.1-Flash-1017) costs $0.30 per million input tokens at peak hours and $0.15 off-peak (cache miss), $1.20 per million output tokens at peak and $0.60 off-peak; cache-hit input is cheaper still, $0.006 at peak and $0.003 off-peak. Peak hours are 01:00–04:00 and 06:00–10:00 UTC, Monday to Friday excluding Chinese public holidays; all other hours are off-peak, at half the peak price.

Tool fees are charged separately, on top of token fees. Search (text, image) costs $0.75 per 1,000 searches, web fetch $0.75 per 1,000 fetches; file parsing and OCR cost $0.225 per 1,000 pages; speech to text (ASR) costs $0.116 per hour of audio, with a limited-time price of $0.058; text to speech (TTS) costs $0.45 per 10,000 characters, with a limited-time price of $0.225. Both voice services are half price for a limited time, and the pricing page gives no end date. The billing rules are stated plainly: model usage is charged by token count, search and fetch by use, and the fees are deducted directly from the topped-up or granted balance, with the granted balance used first when both are available.

Here is a sample calculation (from the pricing page's prices, not a real bill): suppose a small product runs 10,000 searches, 10,000 fetches, 10,000 OCR pages, 100 hours of speech to text, and 1 million characters of speech synthesis in a month — search $7.50, fetch $7.50, OCR $2.25, speech to text at the limited-time price $5.80, speech synthesis at the limited-time price $22.50, for a total of $45.55 in tool fees, with token fees on top. Two points come out of that arithmetic: first, the tool fees themselves are modest — a few dozen dollars a month buys the full set of search, files, and voice; second, the fees use four different units (per search, per page, per hour, per character), so a cost budget has to be calculated per item, not from one lump sum.

Sample monthly cost of DeepSeek application APIs, calculated from the pricing page: 10,000 searches $7.50, 10,000 fetches $7.50, 10,000 OCR pages $2.25, 100 hours of speech to text $5.80, 1 million characters of speech synthesis $22.50

Two pricing details are worth flagging. First, search and fetch cost the same whether called directly as standalone APIs or used by the model through built-in tools — there is no surcharge for "the model called it for you." Second, the 50% voice discount has no end date, so budget at the list prices to be safe: ASR $0.116 per hour, TTS $0.45 per 10,000 characters. The discount is a bonus, not the cost floor.

A concrete scenario: how a small-shop assistant strings the five capabilities together

A feature list alone does not show the value, so here is one concrete scenario. Suppose you build a customer-service assistant for a small shop, with a price-list PDF, a supplier's web page, and the questions regular customers keep asking. The old way: the assistant answers "how much is this bouquet, can it arrive tomorrow" from whatever price list it memorised during training, and gets it wrong the moment a price changes. The new way: file input reads the price-list PDF into the conversation, web search checks the supplier's page for tomorrow's delivery schedule, URL reading fetches the supplier announcement in full, the safety check reviews the output, and the answer carries citations. All five capabilities are used in a single conversation, and the developer's code is just "enable five parameters."

The part of this scenario most worth noticing is deep thinking search. Ordinary search is one question, one answer: the model searches once and answers once. Deep thinking search is multi-step reasoning: the model searches once, finds that the supplier's page says "holiday delivery times will be announced separately," reads the link to confirm which day "separately" means, and then assembles both steps into one answer. For a customer-service assistant, that is the difference between "answered correctly" and "answered approximately." The cost is more tokens and more time, which is why DeepSeek made it a separate switch: simple questions use ordinary search, hard questions use deep thinking search, and the developer decides when to spend the money.

File input has a detail that is easy to miss: there are two parsing modes, plain-text extraction and rich-layout parsing. Plain-text extraction suits documents that are mostly words — fast and cheap. Rich-layout parsing suits documents with tables and formatting, like price lists and quotations, where the numbers in a table must keep their rows and columns. Choose by the document: a price list wants rich-layout parsing, a plain-text notice wants text extraction. The price is the same either way ($0.225 per 1,000 pages), so the difference is in the result, not the bill.

The standalone APIs have their place in the same scenario: the shop's stack of paper delivery notes goes straight through the OCR API into the database without touching a model; a customer's voice message goes through the ASR API into text before entering the support flow; a voice notification for a customer is generated directly by the TTS API. These jobs do not need a model, and paying per use is cheaper and faster than paying per token. The split is clean: things needed inside a conversation go through built-in tools, things needed inside a pipeline go through standalone APIs.

Building it yourself: five capabilities, five services behind them

To feel the value of this update, calculate the reverse: without DeepSeek's built-in tools, how much would you have to connect to build the same thing? Web search means connecting a search provider; reading links means writing your own fetching and parsing (and handling anti-scraping and every page structure); file input means connecting a document-parsing service; speech to text and text to speech each mean a voice provider; safety checks mean writing your own rules or connecting yet another content-moderation service. Five capabilities, at least four or five providers, five billing methods, five kinds of error handling.

The glue code is the harder part. Search results come back, and you have to decide "which results go into the prompt, how many, in what order" — too many and the context overflows, too few and the model answers incompletely. A parsed file has to become text the model can read without losing the table structure. Speech-to-text errors (homophones, proper nouns) need correcting, and you have to decide at which layer. None of these questions has a standard answer; every team steps through the same pitfalls. DeepSeek taking these jobs server-side takes the pitfalls with them — developers no longer write code for "how search results get stitched in" or tune prompts for "how citations get formatted."

Handing it to the server has a cost, of course: less control. Search runs on DeepSeek's own search engine (the 17 October changelog entry says it handles hundreds of millions of search requests a day and indexes hundreds of billions of pages), and you cannot swap in a search engine you prefer; the safety check's rules are DeepSeek's, and you cannot tune the thresholds; file parsing quality depends on DeepSeek's parser, not your code. For most small teams the trade is worth it: control for convenience. But if your product has special requirements for search quality or parsing accuracy (legal documents, medical records), test the results yourself before deciding — do not decide on the words "switch it on" alone.

One more comparison is worth making: cache-hit pricing. Input for deepseek-flash with a cache hit costs $0.003 per million tokens off-peak — one fiftieth of the cache-miss price. Content reused across turns (a price list, a shop introduction, frequently asked questions) is likely to hit the cache, so the token bill falls the more you use it. This design works together with the built-in tools: once file input has read the price list into context, later turns with the same price list are likely to hit the cache and get cheaper. When budgeting, do not forget to count the cache-hit rate — it may be the largest discount on the token bill.

Safety checks and compliance: required for public services, and the responsibility is yours

One passage in the changelog is easy to skip, but it is a requirement placed on developers, and it deserves its own section. It says: with the safety check parameter enabled, basic risk control is provided — the model input and output are reviewed, and a refusal marker is returned when a risk is found. If you provide a service to the public, enable this parameter and fulfil obligations such as content safety review, large model registration, and AI labelling.

In plain language, that is two things. First, the safety check is something DeepSeek provides, but it is only "basic" — it catches some risks, not all of them. For a public-facing service, the safety check must be on; that is DeepSeek's requirement, not a suggestion. Second, compliance is the developer's job: content review, registration, AI-generated content labelling — DeepSeek does not do those for you. If your product serves users in China, none of those obligations can be skipped; if it serves users elsewhere, follow the local rules there too. Turning the safety check on is only the first step; the full compliance chain has to be built by you.

The requirement also explains why DeepSeek made the safety check a parameter instead of a default: built-in tools are for developers, and a developer's internal tool or test environment may not need a safety check. But the moment a service is offered to the public, it must be on. The switch itself is a reminder to tell "for my own use" apart from "for other people to use."

What it means for vibe developers: capability for everyone, but don't look at the unit price alone

Seen in a wider frame, DeepSeek is turning "the same capabilities as the app" into a standard API offering. Until now, web access, file reading, and voice were selling points of each company's own app; developers who wanted them in their own products had to connect one service after another and write glue code for each. Now DeepSeek folds them into the API, switched on with a few parameters. For a small team, that means connecting three or four fewer providers and maintaining three or four fewer sets of glue code.

But the other side is visible too: cheaper capabilities do not mean lower costs. Tool fees stack on top of token fees, and search, fetch, OCR, and voice each bill in their own unit — once a product starts getting volume, the tool fees can easily pass the model's token fees. Budget with both bills together, "model + tools," and do not stare only at the $0.30 per million input tokens. Prices can move as well; DeepSeek says so at the bottom of the pricing page — "product prices may vary" and to check the page for the latest prices. Looking at the pricing page once more before launch is a good habit.

One more thing worth flagging: the changelog also notes that DeepSeek's open-sourced demo chat client can import a user's DeepSeek chat history. For developers, the client's value is not that it "works" but that it can be read — its code shows the officially recommended way to connect: which parameters to enable, how to upload files, how tool-call results are handled. Following it is faster than guessing from the documentation. It is open source, so when something breaks you can read the source instead of waiting for support.

One judgement to close with: the most instructive part of this update is not any single feature but DeepSeek's product thinking — taking capabilities proven inside the app and moving them into the API as they are, so developers stand on the app's shoulders. For vibe projects, that lowers the bar for "building an assistant that can search the web, read files, and listen and speak" another notch. With the bar lower, the contest is no longer who can build it, but who builds it closest to what their users actually need.

Views 4Comments 0

Comments (0)

ME
0/1000
Loading comments...

Sources

Browse projectsPublish your project

Related articles

A developer with glasses types on a laptop at a wooden desk, an external monitor to the left showing C code on a dark background, a small plant on the desk
News
Microsoft's Coding Model Stops Playing Second Fiddle: MAI Code 2 Scores 96% of Opus 5.5 for 5% of the Cost — Read the Three Caveats First

On 17 November 2026, Microsoft launched MAI Code 2 and Code 2 Flash: the larger model has 77 billion active parameters and a one-million-token context, averaging 63.2% across four benchmarks — close to GPT-6.1 Sol and Claude Opus 5.5 — at $0.309 per task. Read the three caveats first: promotional pricing, the lowest score of the three, and no long-horizon work.

Developer WorkflowProduct LaunchModel Updates
Against a black background, a conductor seen from behind raises a baton, with swirling trails of light circling beneath him like an orchestra being conducted
News
One API for 45 Models, and It Switches Providers When One Fails: Perplexity's Orchestrator Wants to Be the Switchboard

On 17 November 2026, Perplexity launched the Orchestrator API: one interface reaching OpenAI, Anthropic, Google, xAI and open-weight models such as GLM, Kimi and DeepSeek, billed at the answering model's published rate with no platform fee. When one provider fails, the same model retries on another deployment, and preview routing assigns requests to models by task.

Developer WorkflowProduct LaunchModel Updates
A developer types at a dual-monitor workstation; the left screen shows a dark code editor, the right a testing dashboard with green checkmarks and bar charts
News
Did Your Agent Get Better or Worse? AWS Open-Sources UAEF to Measure Agents from Every Framework with One Ruler

On 11 November 2026, AWS open-sourced UAEF: adapters turn traces from LangGraph, LangChain, Strands and Bedrock AgentCore into one format, then 36 metrics across 7 dimensions score them, flagging regressions past 5%. The judge model is hardened too — scores must cite verbatim evidence, and never decide safety.

Developer WorkflowProduct LaunchTesting & Quality