What DeepSeek released

On 13 November 2026 DeepSeek released the features behind its consumer app to API customers. The release adds server-side tools to the deepseek-flash model. A server-side tool is one that DeepSeek's own service runs during generation. Your code never executes a search function or pastes results back into the prompt. According to the pricing page, deepseek-flash currently runs DeepSeek-V4.1-Flash-1017 with a 1M token context window. The tools work on three request formats: an Anthropic-style Messages endpoint, an OpenAI-style Responses endpoint and the older Chat Completions endpoint.

The updates log also lists standalone APIs for search, page fetching, OCR, speech-to-text (ASR) and text-to-speech (TTS), and DeepSeek has open-sourced a demo chat client alongside them. CASRAI's write-up lists the same features as the official announcement. CASRAI also points out that the announcement shows its tool rates only as an image, so the prices in this guide come from DeepSeek's pricing page.

How a request works

The Build a Chatbot guide covers the whole loop. You declare deepseek_web_search, deepseek_read_url or both in the tools array. The service decides when to search or open a link and streams back typed content blocks for your client to render. Your client then sends those blocks back unchanged in the next turn, which keeps the conversation's context intact.

Thinking mode changes how search behaves. With thinking disabled, the model runs a web search and answers with citations. With thinking enabled, the same tool becomes what DeepSeek calls deep thinking search: the model searches and reads pages across several reasoning steps before it answers. Two more options come from the guide. A safety_check object screens input and output, and a title option generates a short conversation title once the answer ends.

Step by step

  1. Create an API key and export it as DEEPSEEK_API_KEY, which is the variable the guide's examples read.
  2. Send a streaming request. This is the guide's Chat Completions example:
curl https://api.deepseek.com/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer ${DEEPSEEK_API_KEY}" \
  -d '{
    "model": "deepseek-flash",
    "thinking": {"type": "enabled"},
    "tools": [
      {"type": "deepseek_web_search"},
      {"type": "deepseek_read_url"}
    ],
    "safety_check": {"level": "high"},
    "title": {"enabled": true},
    "messages": [{"role": "user", "content": "What is new in DeepSeek V4.1?"}],
    "stream": true
  }'

On the Messages format the endpoint is https://api.deepseek.com/anthropic/v1/messages, the key goes in an x-api-key header, and each tool entry carries a name field next to its type. The Responses format sends the user turn as input in place of messages.

  1. Render the stream. The guide's block types are thinking, server_tool_use (a search step, with the queries the model issued), web_search_tool_result (result cards with title, URL, snippet and page age), web_fetch_tool_result (a page the model opened) and text. The text block streams citations_delta events, and each citation carries a url, a title and the cited_text. The generated title arrives in message_delta.delta.title.
  2. Handle refusals. When the safety check blocks a turn, stop_reason comes back as "refusal". The guide tells you to replace the answer with your own refusal message, and it doesn't document a separate refusal text field.
  3. Add documents. The Files API guide uploads files with a purpose field. user_data accepts images, plain text, spreadsheets and ebooks. PDF, Word and PowerPoint files need text_recognition (text only) or rich_layout_recognition (text and figures). The guide's upload example is:
curl https://api.deepseek.com/files \
  -H "Authorization: Bearer <DeepSeek API Key>" \
  -F purpose="user_data" \
  -F file="@image.jpg"

You then reference the returned ID in a file content block. The Files API guide sends queries about parsed documents to a separate File Parsing guide.

  1. Start from the demo if you'd rather not write a frontend. The chat-demo repository is MIT-licensed TypeScript, needs Node.js 22.12 or later, and runs with these commands from its README:
git clone https://github.com/deepseek-ai/chat-demo.git
cd chat-demo
pnpm install
pnpm dev

Parameters the service ignores

Builders porting existing code tend to miss this part. Once you declare a web tool, set safety_check to high or enable title, the service drops several sampling controls. On Chat Completions the ignored fields include temperature, top_p, seed, stop and n, and the Messages and Responses formats each have their own list in the chatbot guide. If your app depends on a fixed seed or a stop sequence, keep tool-enabled turns on a separate code path. max_tokens still applies, but it caps output for each inference step and doesn't limit the whole round.

What it costs

The pricing page lists deepseek-flash at US$0.15 per million input tokens on a cache miss and US$0.60 per million output tokens at off-peak rates, with peak rates double that. Peak hours are 01:00 to 04:00 and 06:00 to 10:00 UTC on weekdays. While New Zealand is on daylight time (UTC+13), those windows fall at 14:00 to 17:00 and 19:00 to 23:00 NZDT, Monday to Friday. Batch jobs scheduled for NZ mornings land in off-peak time.

The tools are billed on top of tokens. Web search and web fetch each cost US$0.75 per 1,000 calls, and file parsing and OCR cost US$0.225 per 1,000 pages. TTS and ASR are on a limited-time half-price offer. The stream's usage.server_tool_use object counts searches and fetches for each request, so you can meter tool costs per user without estimating them.

The standalone Search and Fetch APIs bill only HTTP 200 responses that return content. Search allows 100 queries per second per account, and Fetch allows 25 plus a per-domain limit. The chatbot guide doesn't publish rate limits for tool use inside chat requests.

Limits and obligations for NZ builders

DeepSeek's privacy policy (last updated 10 February 2026) says DeepSeek collects, processes and stores personal data in the People's Republic of China. The same policy treats developers on its open platform as the controllers of their own end users' data. A New Zealand app that sends customer messages or uploaded documents through this API should therefore be checked against Information Privacy Principle 12, which limits when personal information can be disclosed to a recipient overseas. The Search API's localization field takes an IP address to localise results. If you pass your users' IP addresses there, that data leaves New Zealand too.

The guide makes safety checks mandatory for public-facing apps. It also says the provider of a public service remains responsible for content review, model registration and AI-content labelling. DeepSeek doesn't spell out which jurisdictions' registration rules it means. Only "level": "high" appears in the chatbot guide's examples, and other levels are documented elsewhere.

What to build with it

The cheapest practical use is a research assistant that answers with live, cited sources. The citation objects already carry the URL and quoted text, so your interface can show users exactly where each claim came from. A document Q&A tool is another fit: upload PDFs with rich_layout_recognition, then let the model combine the parsed pages with web results when a question goes beyond the document. For internal tools that handle no personal information, the per-call search pricing makes small agents cheap to run. Anything that touches customer data needs the privacy review above before it ships. If you build something with the new tools, you can share it with other members on our projects page.

Sources

Build with people working on the same things

Join the Auckland Society for AI: NZ$599 a year with a ForgeBox and the members' projects area. Our Auckland meetups are open to everyone.

Become a member