DeepSeek Search API pricing: what $0.75 per 1,000 calls really costs

What does the DeepSeek Search API cost?

I'm Rama, and I build the integrations and API plumbing at eesel. I've spent a lot of time wiring search tools into agents, and the pattern is always the same: the price per call looks tiny, then the real bill turns up somewhere else. So I read DeepSeek's own docs end to end before doing any maths.

DeepSeek shipped Search and Fetch on October 17, 2026, the same day as DeepSeek V4.1 Flash 1017. Both are standalone JSON endpoints on api.deepseek.com, using the same API key as the models. Here is the full rate card from the Models & Pricing page:

Per call, that is $0.00075. A thousand searches cost less than a coffee, and a million cost $750.

There is no peak and off-peak split on these two rows. The DeepSeek models halve their token prices outside peak hours, but Search and Fetch are a flat per-request price at any time of day.

The Search & Fetch guide says Search runs on DeepSeek's in-house engine, which the changelog describes as indexing "hundreds of billions of web pages". Each result comes back with a title, URL, a short snippet, a longer summary written for a model to read, a date, an authority score from 0 to 4, and optional full page content.

What exactly gets billed?

This is the part of DeepSeek Search API pricing that is more generous than it looks, so it is worth reading slowly. Per the billing section of the guide, a request is billable only when it returns HTTP 200 and actually produces something: a non-empty results array for Search, page content for Fetch.

Three details here have real money attached:

• Empty searches are free. If your agent fires a narrow query with site: and after: filters and gets nothing back, you pay nothing. Perplexity's Search API does the opposite: its pricing page says a successful response is billed even when it returns no results.
• count does not change the price. Asking for 50 results costs the same $0.00075 as asking for 1. Exa charges $1 per 1,000 requests for every result past 10, and Firecrawl charges 2 credits per 10 results.
• need_content: true is included. Turning it on returns the page text inside each search result, at no extra cost. One search with content can stand in for a search plus several Fetch calls.

Failed Fetch calls are free too. A 403 from DeepSeek's security policy, a 404 because the page had no extractable Markdown, or a 504 timeout all cost nothing. The only way to pay for a bad call is if it technically succeeds with junk content, which is the same risk you carry with any scraper.

When does the free period end?

Short answer: November 1, 2026, at 00:00 Beijing time, which is 16:00 UTC on October 31.

The detail that trips people up is what the free period covers. DeepSeek's note, repeated on the pricing page and the guide, says that when you use the API through DeepSeek Harness, Claude Code, or Codex, "server-side tool calls already hit the Search and Fetch APIs. These calls are currently free of charge". The free window names those three clients. Direct calls to /v1/tools/search from your own code are standalone billed APIs from launch.

Here is how server-side search shows up when Claude Code runs on DeepSeek. One question, two searches:

After November 1, those two searches cost $0.0015. The Claude Code integration page is upfront that the search fee is not the whole bill: invoking the tool "generates additional LLM API requests to summarize the retrieved search content, additional model token costs will be incurred."

Which model can search server-side also varies by surface:

So if your agent runs on Flash through the Responses API, the built-in tool is silently ignored. You would call the standalone Search API yourself and pass results back as tool output, which is cheaper on tokens anyway.

What does one agent task really cost?

A Reddit user put the real question better than I could:

"At $0.75 per 1000 requests, I want to know how many calls an agent makes in the background. Has anyone calculated the cost for typical research task?"

u/Glum-Guitar-5083, Reddit

So here is my working. Take a research-style task where the agent runs 20 searches and opens 10 pages. That is 30 billable calls, or $0.0225 in fees.

Now the reading cost. The guide says each summary runs "typically 600 to 800 characters", roughly 200 tokens, so 10 results is about 2,000 tokens per search. I assumed 5,000 tokens per fetched page. That adds up to about 90,000 input tokens. At DeepSeek's off-peak cache-miss rates, $0.15 per million on Flash and $0.66 on V4 Pro:

This is the shift worth taking away. On most search tools the per-call fee is the small part and the model tokens dominate. On Flash it flips: the search fees are about 60% of what the task costs to research, because Flash input tokens are so cheap. On V4 Pro, tokens take over again. During peak hours (01:00 to 04:00 and 06:00 to 10:00 UTC on weekdays) the token half doubles while the fee half stays put.

Output tokens and the model's own reasoning are not in those numbers, and on agent work they are often the biggest line. My DeepSeek V4.1 Flash pricing breakdown covers that side.

If you are building the agent loop yourself rather than leaning on Claude Code, my DeepSeek V4 Flash API guide covers tool calls and the Responses API setup, and Claude Code's MCP tools are the other common way to hand an agent a search tool.

How does it compare with other search APIs?

I pulled every price below from each vendor's own pricing page, on the same day. The billing units differ, so the "per 1,000" column is the default search on each.

Scale that to a product doing 100,000 searches a month and the gap gets hard to ignore:

Brave's figure nets out its $5 monthly credit, and Gemini's nets out the 5,000 free searches. Even then, DeepSeek comes in at about 1/7 of Brave and 1/18 of Gemini. Commenters on the launch thread lined it up against the tools they already pay for:

"For comparison that's $5 with Brave Search API and $12 with Kagi API"

thombles, Hacker News

Another builder who had already rolled their own search stack put the gap with the model vendors' built-in tools this way:

"About a year ago I built my own search and fetch MCP tools for agents based on third-party scraping providers. It is about 15-20x more cost-effective than what OpenAI and Anthropic is offering with their integrated web search and fetch tools. Very impressive that DeepSeek has such a competitive offering today."

suncemoje, Hacker News

Where the cheaper price does not win:

• Throughput. 5 QPS is the lowest stated cap on this list. Brave allows 50 per second, Exa up to 25 on pay-as-you-go, and Tavily 1,000 per minute on production keys.
• Data handling. Brave sells zero data retention as part of its architecture, and Exa and Firecrawl offer it on Enterprise. DeepSeek's Search docs don't mention retention, and its privacy policy says personal data may be stored in the People's Republic of China. For regulated data, read that before you wire it in.
• Free tier for prototyping. Tavily, Exa, Brave, and Firecrawl all give you a monthly allowance with no card. DeepSeek is pay from the first successful call, though a dollar of credit covers about 1,333 searches.

If you would rather not pick one vendor, Cloudflare's web search API routes to several providers with a wide price spread. For the scraping side of the stack, I'd also look at Firecrawl alternatives and Perplexity alternatives.

Estimate your own bill

Plug in your monthly volume and the model you pair it with. The defaults match the worked example above: 2,000 tokens to read one search and 5,000 to read one fetched page.

The comparison column shows search fees only, because the other vendors' fetch and content pricing works differently (Exa bills Contents per page, Anthropic's web fetch has no fee, Tavily bills Extract in credits).

Where does the rate limit bite?

5 queries per second sounds fine until you do the multiplication. It works out to 432,000 searches a day per account, or roughly 13 million a month if traffic were perfectly flat. Spend-wise, that caps one account at about $324 a day on Search.

The guide is specific about how the limit works:

• It is per account, not per API key, so spinning up more keys doesn't help.
• Search and Fetch have separate 5 QPS budgets, and traffic on one doesn't eat the other.
• Fetch has an extra per-domain cap, so an agent hammering one site gets HTTP 429 before the account limit.
• The search limit is separate from model concurrency (2,500 on Flash, 500 on V4 Pro).

For one developer or a batch job, 5 QPS is plenty. If you're weighing other low-cost model APIs to pair with it, Kimi K3 pricing and Qwen 3.8 Max pricing are the closest rivals. For a customer-facing product where 30 people ask questions at the same second, it is the first wall you hit. Traffic is bursty, so plan around peaks, not averages. A queue with retry on 429 is the minimum. The docs say to wait and retry on 408, 429, and 5xx, and not to retry other 4xx errors without changing the request.

How do you keep the bill down?

Because DeepSeek bills per successful call rather than per result or per token, the usual cost tricks change shape. What I would do:

1. Ask for more results, less often. Set count to 20 or 50 on the first search instead of running three narrow ones. Same price, fewer calls.
2. Use need_content before reaching for Fetch. If the search content is enough, you skip a $0.00075 Fetch and a second round trip.
3. Lean on query operators. site:, -site:, lang:, after: and exact-phrase matching all pass through intact. A precise query that returns nothing is free; a vague one that returns junk is billed.
4. Filter on rerank_score and authority before the model reads. DeepSeek calls a rerank_score of 1.5 or above high quality, and an authority of 3 or above highly authoritative. Dropping weak results before they reach the model cuts the token half of the bill.
5. Send ori_question. It passes the user's original question to improve query understanding, so the agent needs fewer follow-up searches.
6. Schedule batch jobs off-peak. The search fee doesn't change, but the model reading the results costs half outside peak hours.

If you route Claude Code through DeepSeek, check your model selection too, and remember the DeepSeek bill replaces your usual Claude Code pricing rather than adding to it. DeepSeek maps claude-opus model names to V4 Pro and claude-sonnet and claude-haiku to Flash, so the same search can cost about 4x more to read depending on which name your config sends.

Is it worth it for a support or RAG setup?

For a developer building one of the best AI agents for research or coding, yes. At this price, web search stops being a line item you ration, and it makes DeepSeek Harness and Codex on DeepSeek cheaper to run than the same loop on GPT-5.6. Pair it with Flash and a typical research task costs a few cents.

For customer support, I'd pause before wiring it in. In my experience most support questions are answered by your own help center, macros, and past tickets, not by the public web. A web search API is the right tool for "what does this carrier's tracking status mean", and the wrong tool for "what's our refund policy". The second one belongs in retrieval over your own content, and that's where support bots actually go wrong. A cheap search call doesn't fix an agent that confidently pulls a blog post over your actual policy, which is why hybrid search over your own docs matters more here than web reach.

That's also where most of the cost lives. The API bill for a support bot is small next to the time spent building the retrieval pipeline, connecting the helpdesk API, writing escalation rules, and testing it before customers see it. I broke down where that money goes in AI customer service cost.

A support teammate instead of a search pipeline

The DeepSeek Search API is infrastructure, and very good value infrastructure. eesel is the employee. Its AI helpdesk teammate plugs into Zendesk, Freshdesk, Gorgias and others, learns from your help center and past tickets, and drafts or sends replies inside the queue you already work in. Before it touches a live ticket, you can run it against your historical tickets and see what it would have said, which is the step I'd never skip after watching a confident bot give a wrong answer on a real queue.

If you are the kind of team that reads API pricing pages for fun, the eesel CLI will feel familiar. It puts the same teammate in your terminal: eesel init chat-bubble --site https://your-site.com creates an agent that starts reading your site, eesel files upload adds a policy doc, eesel integrations connect zendesk wires up the helpdesk, and eesel approvals lists actions held for a human. Every command prints JSON, so Claude Code or Codex can run the whole setup for you, and every workspace is also an MCP server. Anything you set up in the terminal shows up in the dashboard, because it's the same agent.

You can try eesel without a card. It's the faster route if what you actually need is answered tickets rather than a search pipeline.