DEV Community

Cover image for DeepSeek Search API: $0.75 per 1,000 Calls vs Tavily's $8. Here's the Catch
Alan West
Alan West

Posted on Originally published at blog.authon.dev

DeepSeek Search API: $0.75 per 1,000 Calls vs Tavily's $8. Here's the Catch

#ai #agents #python #webdev

If your research agent makes five web searches and three page fetches per run, the search bill can end up bigger than the model bill. DeepSeek just launched a search API and a fetch API, both at $0.75 per 1,000 successful requests. Tavily charges $8 per 1,000 basic searches pay-as-you-go, Brave charges $5, and Google's Gemini grounding charges $14.

I put DeepSeek's search API pricing next to Tavily, Brave, Exa, SerpAPI and the Google/Bing grounding tools, worked out what 10,000 agent runs would cost on each, then read the docs. The price is real: $60 on DeepSeek against $448 on Tavily. The fine print is a 5 QPS account cap, a 128-character query limit, and servers in China.

What DeepSeek launched

DeepSeek's Search & Fetch guide describes two raw JSON endpoints on https://api.deepseek.com:

  • POST /v1/tools/search returns structured results from DeepSeek's in-house search engine
  • POST /v1/tools/fetch takes one URL and returns the page as Markdown

They're plain JSON APIs behind your normal DeepSeek API key, so you can call them from an agent running on any model. Search accepts count from 1 to 50, plus operators like site:, -site:, lang:zh,en, after: and before:. Each result has a snippet (about 100 to 200 chars), a summary (about 600 to 800 chars, meant for the model to read), optional full content, a rerank_score from 0 to 3 and an authority score from 0 to 4.

Pricing per the docs:

API Price
Search $0.75 per 1,000 successful requests
Fetch $0.75 per 1,000 successful requests

count doesn't change the price. Asking for 50 results costs the same as asking for 1. Exa, by contrast, charges an extra $1 per 1,000 results above 10.

DeepSeek vs Tavily vs Brave vs Exa: price per 1,000 searches

Every number below is from the provider's own pricing page as of this week.

Provider Search price per 1,000 Page fetch / extract Free tier Published rate limit
DeepSeek $0.75 $0.75 per 1,000 none listed 5 QPS search, 5 QPS fetch
Tavily $8 PAYG basic (1 credit at $0.008), $16 advanced 1 credit per 5 extractions (basic) 1,000 credits/month not on pricing page
Brave Search API $5 no URL fetch endpoint listed $5 credit/month 50 QPS
Exa $4 instant, $7 fast/auto, $12 deep $1 per 1,000 pages per content type $10/month not listed
SerpAPI $25 (Starter) down to $7.25 (Searcher, 100k/mo) none 250 searches/month throughput per hour by plan
Gemini grounding (Gemini 3+) $14 n/a 5,000/month not listed
Grounding with Bing $14 per 1,000 transactions n/a none listed 150 TPS

Tavily's monthly plans bring the per-credit cost down to $0.005 on the $500 Growth plan, which works out to $5 per 1,000 basic searches. That's still almost seven times DeepSeek.

The math for 10,000 agent runs

Assume a typical research-agent run: 5 searches and 3 page fetches. 10,000 runs means 50,000 searches and 30,000 fetches. Free tiers are ignored unless they make a real dent.

Stack How it adds up Cost
DeepSeek search + fetch 80,000 × $0.75/1k $60
Exa instant + text contents $200 + $30 $230
Brave (search only) 50,000 × $5/1k − $5 credit $245, plus whatever you use for fetching
Exa auto + text contents $350 + $30 $380
Tavily basic search + basic extract, PAYG 50,000 + 6,000 credits × $0.008 $448
Gemini 3 grounding (50,000 − 5,000) × $14/1k $630
Grounding with Bing 50,000 × $14/1k $700
SerpAPI Searcher plan to cover 50k/month $725, search only
Tavily advanced search + advanced extract, PAYG 100,000 + 12,000 credits × $0.008 $896

DeepSeek comes in at about a quarter of the cheapest Exa setup, between a seventh and an eighth of Tavily basic, and under a tenth of the Google and Bing grounding tools. On price alone it isn't close. The problems are in the docs.

The catches: 5 QPS, 128-char queries, China servers

5 QPS per account

Search and fetch are limited separately at the account level, and adding more API keys doesn't raise the cap. Fetch also has a per-domain QPS limit. Five requests per second is 432,000 a day if you run at full speed nonstop, so plenty for a batch pipeline. A product where fifty users kick off deep-research jobs at once will hit 429s within seconds. Brave allows 50 QPS and Bing grounding allows 150 TPS.

What counts as a billable request

You're billed when the call returns HTTP 200 and produces something: a non-empty results array for search, page content for fetch. Empty results, timeouts and failed fetches (403 when a fetch is blocked by security policy, 404 when there's no usable content) are free. That's a fair deal, though "non-empty" can still mean ten irrelevant hits, and those count as a success. Use rerank_score (the docs call 1.5+ high quality) to filter before anything reaches your context window.

128-character query limit

Both query and ori_question are capped at 128 Unicode characters. Agents like to write long, chatty search queries, so truncate or rewrite them before you call, or expect 400s.

Your queries go to servers in China

The search guide doesn't mention it. DeepSeek's privacy policy says its servers are located in the People's Republic of China. Every query your agent sends, and every URL it fetches, goes there. For a hobby agent that's probably fine. For anything that searches on behalf of customers, ask your compliance people before you switch. Brave, for comparison, offers zero data retention on its Enterprise plan.

Free until November 1, 2026

Calls made through DeepSeek Harness, Claude Code or Codex are free for now. Per-request billing for those starts at 00:00 Beijing time on November 1, 2026. If you've been using it through one of those and your bill shows $0, that's why.

What Hacker News is arguing about: quality and scraping

In the Hacker News discussion, commenters listed alternatives (Ceramic at around $0.25 per 1,000, SerpAPI, Mojeek, LinkUp, Kagi) and then moved on to two harder questions.

The first is quality. One commenter's LLM-judged tests put Exa and Tavily on top and their own SearXNG instance at the bottom. Nobody in the thread had tested DeepSeek's engine against those, and a cheap search that returns worse results will cost you more in tokens and retries than it saves.

The second is fetch ethics. Someone asked what happens when you fetch a page behind Cloudflare's checkbox or Anubis, and the thread drifted into the usual argument about whether an agent fetching a page for a user is a crawler. Another commenter pointed out that a "courtesy backoff" on 429/503 only kicks in once the site is already in trouble: "By the time you get the error you have already crashed the site." If your product depends on fetching third-party pages, that argument will reach you eventually.

Calling the DeepSeek search API from Python

This follows the request shape in DeepSeek's docs, with a filter on rerank_score and a basic retry on 429, which the docs say is safe because the APIs are read-only.

import os
import time
import requests

API = "https://api.deepseek.com/v1/tools"
HEADERS = {"Authorization": f"Bearer {os.environ['DEEPSEEK_API_KEY']}"}


def call(endpoint, payload, retries=3):
    for attempt in range(retries):
        r = requests.post(f"{API}/{endpoint}", headers=HEADERS, json=payload, timeout=30)
        if r.status_code in (408, 429) or r.status_code >= 500:
            time.sleep(2 ** attempt)
            continue
        r.raise_for_status()
        return r.json()
    r.raise_for_status()


def search(query, count=10):
    data = call("search", {"query": query[:128], "count": count})
    return [x for x in data["results"] if x["rerank_score"] >= 1.5]


def fetch(url):
    return call("fetch", {"url": url})["content"]


for hit in search("DeepSeek V4 release site:github.com lang:en"):
    print(hit["title"], hit["url"])
    print(hit["summary"])
Enter fullscreen mode Exit fullscreen mode

Swap this in behind whatever search tool interface your agent already uses. Log the cost per run for a week before and after, and compare answer quality on the same prompts. Somebody else's benchmark won't tell you much about your own queries.

Should you switch from Tavily or Exa?

For batch jobs, evals, internal research agents and anything with low concurrency, DeepSeek is now the default I'd try first. At $60 per 10,000 runs, it's cheap enough to stop rationing searches.

For customer-facing products, I'd hold off. Five QPS is tight, PRC data residency needs a sign-off from compliance, and I haven't seen a quality comparison against Exa or Tavily yet. I'd keep Brave or Exa in place and run DeepSeek as a cheaper fallback until someone benchmarks it properly.

Which search API do your agents use today, and how much is it costing you per month? If you've switched from Tavily or Exa to anything cheaper, did quality hold up?

Sources

Top comments (1)

Collapse
 
pushpendra2011 profile image
Pushpendra Yadav •

Useful breakdown. The data-residency catch has a nuance worth adding: it depends on what’s in the query, not just who the provider is. On my project (a recommendation app), the case where cheap search fits is a batch job enriching catalog items that have thin metadata. The queries are public titles, concurrency is low, and 5 QPS doesn’t matter. What I’d never route through it is user-written text at request time. Splitting “public-data batch work” from “user-data live work” lets you take the $0.75 price where it’s safe without the compliance conversation.