Five capabilities switched on in one release, but the bill arrives in two separate lines. That is the part of DeepSeek's November 13, 2026 changelog entry that is easy to skim past and worth doing the arithmetic on. The things the App could already do, search the web, open a file, follow a link, are now hanging off the cloud API, and the official wording is blunt about what that costs: when a user calls the DeepSeek API with extended capabilities, tool usage fees are charged in addition to standard token charges. Capabilities fully handed over, fees on top of tokens. This article checks only what the official announcement, guides, pricing page, and demo repository support verbatim, and it keeps two questions apart: what was opened up, and where the money and the boundaries sit. It does not fill in conclusions on the company's behalf, and it does not line up prices from other vendors for comparison.
One release date, three separate calendars
The official Chinese changelog dates the entry 2026-11-13, and the English changelog line reads "Releasing the full suite of application APIs." The date comes from the changelog itself and from the news261113 marker in the official news page URL. It is not the date an aggregator stamped on a repost, and it is not a press pickup date. The verification point for this article is written, verbatim, as "As of November 15, 2026," which is a third and separate calendar from both the release date and any repost date. Collapsing the three into one day blurs the difference between when the company announced something and when someone else repeated it.
Identity is a second thing to keep straight. The announcement describes the change as App capabilities being attached to the existing deepseek-flash. The model is V4.1-Flash, the API model id is deepseek-flash, the MODEL VERSION column on the pricing page reads DeepSeek-V4.1-Flash-1017, and the context is 1M with a maximum output of 384K. The official wording stays on capability attachment, interface shapes, and billing, so this article stays on that same layer and does not add conclusions about a model launch or a price adjustment on the company's behalf. The shorter label used throughout is the DeepSeek App APIs, and the release is the full suite of application APIs those words refer to.
Five Tools, Fees on Top of Tokens: the capabilities named exactly
The official Chinese announcement groups the App capabilities into five named items, and the English names are Web Search, Deep Thinking Search, File Input, URL Reading, and Safety Checks. These are the official entry names. The fifth one in the Chinese list is "model safety," not the "content safety review" phrasing that gets swapped in elsewhere, and the count is five, neither six nor four. Getting the names and the count right matters, so each item is laid out below with its boundary as the official text gives it, and nothing is added to the list.
Web Search. With the deepseek_web_search tool enabled in non-thinking mode, the model can start web or image searches on its own and answer with citations attached. The point is that the model goes and finds material and brings the sources back; the citation behavior is stated explicitly in the official text, not supplied here as an inference.
Deep Thinking Search. The same deepseek_web_search tool, this time in thinking mode, lets the model search the web and read links autonomously across multi-step reasoning. It shares a tool name with the previous item, and the difference is the multi-step reasoning: searching is no longer a one-off action but something that recurs inside a reasoning chain.
File Input. A user uploads PDF, Office, or image files; plain-text extraction or mixed text-and-image parsing happens, and the result is assembled into the conversation context. The official boundary is specific: plain-text extraction or mixed parsing, with the result then placed into context, rather than the raw file being handed to the model unchanged.
URL Reading. With the deepseek_read_url tool enabled, the model recognizes links in the user message automatically and fetches the page content. Recognition and fetching both belong to this tool, so the user does not have to paste page text into the chat box first.
Safety Checks. Once the safety check parameter is on, baseline risk control is provided, model inputs and outputs are reviewed, and a refusal marker is returned when risk is hit. The official text adds a note for anyone serving an application publicly: enable the parameter and take on obligations such as content safety review, large-model registration, and AI labeling. This item is both a capability and a short responsibility list written into the announcement.
Read together, the first four widen what the model can reach, and the fifth governs whether an output should be allowed through. Five Tools, named exactly, with the boundaries left where the official text leaves them.
Five more standalone APIs: Search, Fetch, OCR, ASR, TTS
The list does not stop at five. The official Chinese line says the underlying capabilities and voice capabilities are all available as standalone APIs for custom workflows, and it names them: Search, Fetch, OCR, ASR, and TTS. The English wording is "standalone APIs for custom workflows," and the opening of the announcement adds that they can be called separately or in combination. So these five lower-level pieces can be pulled into the model's tool chain, or called directly by a developer who wants to assemble the workflow alone.
Two layers are worth separating here. The five named capabilities are finished switches aimed at a conversation; Search, Fetch, OCR, ASR, and TTS are the parts underneath. By naming them as standalone APIs, the official text leaves both routes open: letting the model orchestrate, or writing the orchestration yourself. This article does not reach for specification numbers from third-party retellings to fill out parameter sheets for these interfaces. It is responsible only for the names and the calling modes the official text actually lists.
Who does the work: tool calls and context assembly run server-side
The line that saves the most plumbing is the official one: once the matching parameter is enabled, the relevant tool calls and context assembly are handled server-side. The guide is more concrete: "The service runs the searches and URL reading. Your client only shows the returned blocks and passes them back unchanged in the next round." Who issues the search, who reads the link, and how the result is assembled into context are none of the client's concern. The client displays the returned blocks and passes them back unchanged on the next round, and that is the whole of its job in that exchange.
The trade is control over parameters. The official text lists Ignored Parameters: when deepseek_web_search or deepseek_read_url is declared, when safety_check=high is set, or when title is enabled, values such as temperature and top_p are decided server-side and any values sent in the request are ignored. The habit of reaching for temperature to tighten or loosen output stops being the caller's decision once those switches are on. Tool calls and context assembly handled server-side buy a large reduction in orchestration code; what they take away is the final say over those sampling parameters. One gain, one concession: less code to write, and less room to tune.
Fees on Top of Tokens: a token line and a tool line
The contrast lands on money. The official Chinese sentence says that when a user calls the DeepSeek API with extended capabilities, tool usage fees are charged in addition to standard token charges. The pricing page adds the formula in words: model call cost equals token consumption times the model unit price, while search (text, image) and web fetch are billed per use according to the table. The English line makes the scope explicit: "Search (text, image) and web fetch are billed per use, whether you call the Search and Fetch APIs directly or the model uses them through tools such as the web tools." Token is one line, tools are another, and neither is folded into the other. That is the weight of the phrase Fees on Top of Tokens in the title: charges land on top of the standard token line rather than inside it.
The official tool pricing table can be quoted verbatim, and this article does no conversion and no comparison with any other vendor:
| Capability | Billing unit | Official price |
|---|---|---|
| Search (text, image) | per 1,000 uses | $0.75 |
| Web fetch | per 1,000 uses | $0.75 |
| File parsing, OCR API | per 1,000 pages | $0.225 |
| TTS | per 10,000 characters | list price $0.45, limited-time discount price $0.225 |
| ASR | per hour of audio | list price $0.116, limited-time discount price $0.058 |
Two details in that table are easy to read past. First, per use, per page, per character, and per hour sit side by side, which means the tool fee is not a floating item that tracks token volume; each line has its own counting unit. Reading "in addition to standard token charges" as a polite aside rather than a second bill is the quick way to undercount a budget. Second, TTS and ASR list both a list price and a limited-time discount price, but the end date of that limited-time discount has not been announced, so this article does not invent one. The official text also notes that product prices may change and that DeepSeek reserves the right to modify them, so the numbers are not pinned down as permanent. Read those two details alongside the billing sentence and the consequence is plain: the estimate splits into two columns instead of staring at the model unit price alone.
Three API shapes, one model id
Capability talk has to end at a request. The official release gives three API shapes: Messages, Responses, and Chat Completions, with these verbatim endpoints, all pointing at the same deepseek-flash:
POST https://api.deepseek.com/anthropic/v1/messages
POST https://api.deepseek.com/responses
POST https://api.deepseek.com/chat/completionsMessages takes the Anthropic-compatible route, while Responses and Chat Completions each have their own endpoint. In the chat-demo, the default deepseek-flash goes through the Anthropic-compatible Messages and Files APIs, and voice falls to the ASR and TTS endpoints. Three shapes are not three sets of capabilities; they are the same batch of five capabilities behind different protocol shells. Which one to pick depends on which protocol a client already speaks, not on any difference in what the capabilities can do. This article is not a step-by-step integration guide; that work belongs to a separate in-site write-up.
chat-demo: MIT, static, and wired straight to the API
The release also ships something runnable. The official announcement says a lightweight front-end demo was built on the new API and open-sourced, with support for importing DeepSeek conversation history directly. The repository is chat-demo, its license is MIT, and the copyright line reads Copyright (c) 2026 DeepSeek. The README states, verbatim, "A static chat demo powered by the DeepSeek API. No application backend is required: the browser connects directly to the configured API service." There is no application backend; the browser connects straight to the configured API service, whose default address is https://api.deepseek.com.
Where the data lands is spelled out too. The API key and settings live in localStorage, conversations and original attachments live in IndexedDB, and the guide adds: "Your API key, conversations and uploaded images are stored only in your browser. The demo is for demonstration only." To open it locally, a user can download the Releases archive, unzip it, and double-click index.html; the latest release is v0.1.1, dated November 13, 2026. Static, direct to the API, browser-only storage, and explicitly for demonstration only: those four together make it a sample for checking calling shapes rather than a production setup. Keeping it separate from cloud API billing matters, because a sample with no backend is a different question from whether a tool call carries a separate charge.
What can be checked and what cannot
To close, the boundary. This article covers only what can be checked verbatim in the official announcement, guides, pricing page, and the chat-demo repository: the November 13, 2026 release, the five capabilities on deepseek-flash, the standalone APIs Search, Fetch, OCR, ASR, and TTS, tool calls and context assembly handled server-side, tool usage fees charged in addition to standard token charges, and the MIT-licensed static sample. Interface specifications that have not been published, third-party price comparisons, and model capability evaluations are outside the scope of this article and are not filled in on the company's behalf. The end date of the limited-time discount has not been announced, so it is written as not announced rather than given a date.
The angle is worth separating from neighboring write-ups. The integration article and the pricing selection article are about how to wire an API and how to choose between options; this one stays on the capability boundary of a single event and on where its charges land. The tool-calling article covers orchestration itself, while here orchestration is already done server-side and the question is what remains. The local deployment article puts capabilities on a machine the reader owns, with its own memory budget to plan, which is a different road from a cloud API. As of November 15, 2026, what can be checked is what is written above; the rest is left blank.
Related reading