October 18, 2026

# DeepSeek Search API vs. Parallel: pricing, data handling, and model lock-in

The DeepSeek Search API and its companion Fetch API cost $0.75 per 1,000 successful requests, less than Parallel Search at $1 per 1,000 on Turbo and Fast. Parallel’s case is model independence. It works with any model, DeepSeek’s included, on an account separate from your model vendor. Every DeepSeek claim here comes from DeepSeek’s own documentation, and where those docs are silent, the article says “not documented.”

Author: By Parallel

Tags:Comparison

## Quick answer

At list price Parallel costs more than the DeepSeek Search API. DeepSeek charges $0.75 per 1,000 successful requests for Search and the same for its Fetch API. Parallel Search costs $1 per 1,000 requests on Turbo and Fast and $5 per 1,000 on Basic and Advanced, according to Parallel’s pricing page[Parallel’s pricing page] on October 17, 2026.

The reason to pay more is model independence. Parallel Search is a REST API, an SDK, and a free hosted MCP server that any model can call, DeepSeek’s included. DeepSeek’s endpoints are plain REST too and take no model parameter, but calling them requires a DeepSeek account with a prepaid balance, and DeepSeek’s built-in server-side search works with DeepSeek models alone.

DeepSeek’s privacy policy says it stores personal data in China and may use personal data, including inputs, to train its models, and it doesn’t mention Search or Fetch. Parallel stores data in US data centers by default and offers zero data retention under an enterprise agreement. Its optional EU data residency covers Search API requests in Basic mode sent to its EU endpoint. EU residency doesn’t cover Extract, and Parallel is a US company, so it doesn’t change Parallel’s jurisdiction.

Which API returns better results is unknown. No authenticated DeepSeek calls were made for this comparison, and no independent benchmark of the DeepSeek Search API was found as of October 17, 2026, so this article makes no quality claim in either direction.

## What does the DeepSeek Search API cost?

Search and Fetch each cost $0.75 per 1,000 successful requests. These list prices were checked on October 17, 2026, and exclude model tokens.

Item	DeepSeek	Parallel
Search	$0.75 per 1,000 successful requests	$1 per 1,000 on Turbo or Fast, $5 per 1,000 on Basic or Advanced
Page content	Fetch: $0.75 per 1,000 successful requests	Extract: $1 per 1,000 URLs
Results per search	1 to 50, same price at any count	10 included, extra results $1 per 1,000
Free allowance	Not documented for direct calls	Up to $80 at signup, plus $5 in credits a month

At 100,000 searches, DeepSeek costs $75, Parallel Fast costs $100, and Parallel Advanced costs $500.

DeepSeek bills a Search request when it returns HTTP 200 with a non-empty results array, and a Fetch request when it returns page content. Failed requests, empty results, and timeouts are free. The `count` parameter doesn’t change the price, so 50 results cost the same as 1. Charges come out of a topped-up or granted balance, and the granted balance is used first.

Request price is one part of an agent’s bill. One r/DeepSeek user[One r/DeepSeek user] analyzed a week of their own DeepSeek Harness logs and reported that 353 searches cost $0.64 of a $9.90 bill for the week, or 6.4%, and that model output tokens alone cost 6.5 times more than all the searches combined. Those searches ran on DeepSeek’s older search tool, which bills in model tokens, and the post says it benchmarked no production system.

### When does DeepSeek start billing Claude Code and Codex calls?

DeepSeek’s pricing page[pricing page] and release notes[release notes] say billing starts at 00:00 Beijing time on November 1, 2026, which is 16:00 UTC and 9:00 a.m. Pacific time on October 31. Until then, Search and Fetch calls made through DeepSeek Harness, Claude Code, or Codex are free.

The Search & Fetch guide[Search & Fetch guide] gives a different rule. It says Search requests through Claude Code and Codex are free for the first two weeks after launch and that the billing start date will be announced in a separate notice, and it doesn’t mention Harness. The pages disagree as of October 17, so confirm the date before you budget.

## Does the DeepSeek Search API lock you into DeepSeek models?

In part. The raw endpoints take no model parameter, so any model can call them through function calling, but they require a DeepSeek account, and DeepSeek’s built-in server-side search works with DeepSeek models alone.

### What does “server-side tools” mean in DeepSeek’s announcement?

It means DeepSeek runs the search itself for a client that talks to a DeepSeek model. The announcement says Search and Fetch are available “via server-side tools” in DeepSeek Harness, Claude Code, and Codex, and each integration has its own setup:

- **Claude Code.** Point Claude Code at DeepSeek’s Anthropic-compatible endpoint, and its built-in Web Search tool performs the search through DeepSeek’s API. DeepSeek’s guide says each use also generates extra model requests to summarize what was retrieved, so you pay model tokens on top of the search fee.
- **Codex.** Codex’s `web_search` feature works with `deepseek-v4-pro` and no other model. The setup script disables it, and `web_search = "live"` in `~/.codex/config.toml` turns it back on. The Responses API ignores `web_search` for `deepseek-flash`.
- **DeepSeek Harness.** DeepSeek’s pricing page says Harness server-side tool calls already hit the Search and Fetch APIs. Harness has not been tested against the new endpoints for this article. The October 11 guide to Harness search[The October 11 guide to Harness search] predates them and describes the older built-in tool, which spent a full model call per search.

Outside those integrations, a function-calling loop with any model can call the raw endpoints. A missing or invalid key returns HTTP 401, and an empty balance returns HTTP 402. The Search & Fetch guide doesn’t address storing results or using them with other vendors’ models. The Open Platform Terms[Open Platform Terms] say you can use the Inputs and Outputs of DeepSeek’s services for purposes that include training other models, but they don’t say whether that covers search results, which contain third-party web content.

### Which models can call Parallel Search?

Parallel Search works with any model. It is an HTTP API with Python and TypeScript SDKs and a hosted Search MCP server[hosted Search MCP server] at `https://search.parallel.ai/mcp`. The MCP server is free, needs no API key, and exposes `web_search` and `web_fetch` tools. Changing models leaves your search integration untouched. The guide to adding web search to Kimi K3 and other open-weight models[adding web search to Kimi K3 and other open-weight models] walks through the same loop on any chat-completions endpoint.

In a test on October 17, 2026, DeepSeek-V4.1-Flash-1017 called Parallel Search as a function tool through OpenRouter. It was asked for the DeepSeek Search API price and the Claude Code billing start date. The model issued one `web_search` call, the script ran Parallel Search in `fast` mode, and the model answered from the results. It reported $0.75 per 1,000 successful requests and a billing start of 16:00 UTC on October 31, citing DeepSeek’s pricing page and the Search & Fetch guide. It credited the date to the guide, but the date comes from the pricing page, so check citations either way. OpenRouter’s usage report put the two model turns at about $0.0007. That was a single run, so treat it as a smoke test.

### parallel search with a deepseek model python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
import json
import os
from openai import OpenAI
from parallel import Parallel

llm = OpenAI(base_url="https://openrouter.ai/api/v1", api_key=os.environ["OPENROUTER_API_KEY"])
search_client = Parallel(api_key=os.environ["PARALLEL_API_KEY"])

tools = [
    {
        "type": "function",
        "function": {
            "name": "web_search",
            "description": "Search the web and return ranked URLs with excerpts.",
            "parameters": {
                "type": "object",
                "properties": {
                    "objective": {"type": "string"},
                    "search_queries": {"type": "array", "items": {"type": "string"}},
                },
                "required": ["objective", "search_queries"],
            },
        },
    }
]

messages = [
    {"role": "user", "content": "What is the per-request price of DeepSeek's Search API, and when does billing start for calls made through Claude Code? Cite URLs."}
]

for turn in range(4):
    resp = llm.chat.completions.create(model="deepseek/deepseek-v4.1-flash-1017", messages=messages, tools=tools)
    msg = resp.choices[0].message
    messages.append(msg.model_dump(exclude_none=True))
    if not msg.tool_calls:
        break
    for tc in msg.tool_calls:
        args = json.loads(tc.function.arguments)
        result = search_client.search(objective=args["objective"], search_queries=args["search_queries"], mode="fast")
        text = "\n\n".join(f"{r.title} {r.url}\n" + "\n".join(r.excerpts)[:2500] for r in result.results[:5])
        messages.append({"role": "tool", "tool_call_id": tc.id, "content": text})

print(messages[-1].get("content"))``` import json
import os
from openai import OpenAI
from parallel import Parallel
 
llm = OpenAI(base_url="https://openrouter.ai/api/v1", api_key=os.environ["OPENROUTER_API_KEY"])
search_client = Parallel(api_key=os.environ["PARALLEL_API_KEY"])
 
tools = [
    {
        "type": "function",
        "function": {
            "name": "web_search",
            "description": "Search the web and return ranked URLs with excerpts.",
            "parameters": {
                "type": "object",
                "properties": {
                    "objective": {"type": "string"},
                    "search_queries": {"type": "array", "items": {"type": "string"}},
                },
                "required": ["objective", "search_queries"],
            },
        },
    }
]
 
messages = [
    {"role": "user", "content": "What is the per-request price of DeepSeek's Search API, and when does billing start for calls made through Claude Code? Cite URLs."}
]
 
for turn in range(4):
    resp = llm.chat.completions.create(model="deepseek/deepseek-v4.1-flash-1017", messages=messages, tools=tools)
    msg = resp.choices[0].message
    messages.append(msg.model_dump(exclude_none=True))
    if not msg.tool_calls:
        break
    for tc in msg.tool_calls:
        args = json.loads(tc.function.arguments)
        result = search_client.search(objective=args["objective"], search_queries=args["search_queries"], mode="fast")
        text = "\n\n".join(f"{r.title} {r.url}\n" + "\n".join(r.excerpts)[:2500] for r in result.results[:5])
        messages.append({"role": "tool", "tool_call_id": tc.id, "content": text})
 
print(messages[-1].get("content"))
```

To call DeepSeek’s own API instead, change the base URL to `https://api.deepseek.com` and the model to `deepseek-flash`. That route was not tested.

## How do DeepSeek and Parallel handle your data?

DeepSeek documents storage in China and nothing specific to Search or Fetch. Parallel documents US storage, zero data retention, and an optional EU endpoint, each with limits. A search API sees every query your agent writes, and a fetch call shows which URLs it reads. This summary of public documents is not legal advice.

### DeepSeek

- **Who runs it.** Hangzhou DeepSeek Artificial Intelligence Co., Ltd., registered in China, is the data controller named in the privacy policy[privacy policy].
- **Where data is stored.** The privacy policy says DeepSeek collects, processes, and stores personal data in the People’s Republic of China, and that it will use appropriate safeguards for transfers “where required.” A Search- or Fetch-specific location is not documented, and neither is a region choice, an EU endpoint, or a data residency commitment.
- **Retention.** The policy says input data is kept for as long as you have an account, and longer where needed for legal obligations or legitimate business interests. A retention period for Search queries or fetched content is not documented, and neither is a zero-retention option.
- **Training.** The policy says DeepSeek uses personal data, including inputs, to train and improve its models, and it lists a right to opt out of that use. The Open Platform Terms[Open Platform Terms] say you keep your rights in the Inputs you submit. A training policy specific to API, Search, or Fetch traffic is not documented.
- **Third parties.** The privacy policy says DeepSeek integrates third-party APIs to provide search services and shares input keywords with them. The privacy policy and the Open Platform Terms were last modified on 2026-07-15, before the launch, and describe DeepSeek’s services in general. Whether Search API queries reach third parties is not documented. DeepSeek says the API runs on its in-house search engine.
- **Law and disclosure.** The Open Platform Terms are governed by the laws of mainland China, with disputes heard in the court where DeepSeek’s registered office is. The privacy policy says DeepSeek may share data with law enforcement and public authorities as required.
- **Your role.** The Open Platform Terms make you the controller for your end users’ personal data and ask you to disclose your own privacy policy to them. Processor terms or a data processing addendum for API customers are not documented. The privacy policy says the services aren’t designed to process sensitive personal data and asks you not to provide it.

### Parallel

- **Who runs it.** Parallel Web Systems Inc. is a Delaware corporation, and its Customer Terms[Customer Terms] are governed by California law.
- **Where data is stored.** Parallel’s FAQ[FAQ] says data is encrypted in transit with TLS 1.2 or later and at rest in US-based data centers. EU data residency is optional and has its own limits, covered in the next section.
- **Retention and zero data retention.** The retention period for standard Search requests is not documented in the public pages reviewed for this article. Parallel’s glossary[glossary] defines zero data retention (ZDR) as a mode in which Parallel does not retain request or response data after a run completes. ZDR is offered under an enterprise agreement (contact sales@parallel.ai), through a separate ZDR listing on Google Cloud Marketplace for Gemini grounding, and by default on the EU endpoint. Parallel’s docs don’t list it as a self-serve setting. Under ZDR, features that depend on retained context, such as Task API Interactions and Responses API `previous_response_id`, are unavailable. For the Search MCP server, Parallel’s docs point ZDR setups to the authenticated `/mcp-oauth` endpoint instead of the anonymous one.
- **Training.** The FAQ says Parallel does not use customer data to train models. The agreement text varies. The Google Cloud Marketplace Master Customer Agreement[Master Customer Agreement] (v2026.10) says Parallel won’t use Customer Content to train foundation or general-purpose large language models, while allowing processing to operate and improve the services. The standard Customer Terms on parallel.ai say Parallel may use Customer Inputs and Outputs to train and improve the machine learning models it uses to provide the Services. Read the agreement you will sign.
- **Personal data.** Parallel acts as a processor for business customers under a Data Processing Addendum, and the Customer Terms require you to sign it before processing personal data.

### What does Parallel’s EU data residency cover?

It covers Search API requests in Basic mode sent to the EU endpoint. EU data residency is an optional feature, with the commitments set out in the customer’s DPA. For those requests, the endpoint, the full search index, and inference run in the EU, and EU traffic has zero data retention by default. Parallel routes traffic to the United States unless you use the dedicated EU endpoint and have a separate written agreement with Parallel. The limits are:

- Minimal billing metadata, such as IDs, the SKU, and a timestamp, goes to the US. It never includes inputs or outputs.
- Live fetch, which retrieves public pages at request time, runs worldwide. It’s optional and can be turned off.
- The Extract API isn’t covered and runs on the default endpoint.
- Your model call runs wherever your model provider hosts it.
- Parallel is a US company, so EU residency doesn’t change its jurisdiction. A US company can offer EU residency but stays subject to US law, including the US CLOUD Act.

The guides to web search APIs with EU data residency[web search APIs with EU data residency], building an EU research agent[building an EU research agent], and data residency vs. data sovereignty[data residency vs. data sovereignty] have the details, and the data residency entry[data residency entry] defines the terms.

### What does this mean in practice?

Whichever search API you use, the model vendor sees your prompts and any search results you pass back to it. With a DeepSeek model, DeepSeek sees them under its terms, and adding Parallel for search adds a second party that sees the queries the model writes. Parallel documents zero data retention and an optional EU endpoint for Search, with the limits above, and DeepSeek documents neither. Neither DeepSeek’s privacy policy nor its Open Platform Terms covers Search and Fetch traffic yet, so ask DeepSeek for terms before you send sensitive queries.

## What are the technical differences?

DeepSeek takes a short query with inline operators and returns scored results. Parallel takes a natural language objective with filter parameters and returns excerpts sized to a character budget.

Dimension	DeepSeek Search and Fetch	Parallel Search
Endpoints	POST /v1/tools/search and /v1/tools/fetch	POST /v1/search, plus /v1/extract for page content
Input	Query of 1 to 128 characters, with operators	Natural language objective up to 5,000 characters, plus optional keyword queries
Output	Title, URL, snippet, summary, optional content, date, rerank score, authority	URL, title, publish date, excerpts
Rate limit	5 requests per second per endpoint, per account	600 requests per minute for Search and Extract
Domain and date controls	site:, -site:, lang:, after:, before: in the query	include_domains, exclude_domains, after_date
Location	localization, an IP address	location, an ISO country code
Authentication	Authorization: Bearer with a DeepSeek key	x-api-key header, or the keyless MCP server

### Output format and excerpts

Each DeepSeek Search result carries a title, URL, date, and site name, plus several fields an agent will read. `snippet` runs 100 to 200 characters and is meant for a UI. `summary` runs 600 to 800 characters and is meant for a model. `content` holds full page text and stays empty unless you set `need_content` to `true`, and it can be empty even then when the page is unavailable. `rerank_score` runs from 0 to 3 and combines relevance, authority, and freshness, and DeepSeek treats 1.5 and above as high quality. `authority` is a tier from 0 to 4, with -1 for unknown. How these signals are computed is not documented.

The Fetch API returns the title and a Markdown body for one URL per request. It returns 404 when no usable content can be extracted and 403 when DeepSeek’s security policy rejects the request, and it is subject to the target site’s access policies.

Parallel Search returns ranked URLs, titles, publish dates where known, and excerpts selected against your objective. You size the output with `max_chars_per_result` and `max_chars_total`, so the token cost of a call is a setting. The response has no per-result score or authority field. Extract returns page content as Markdown for a list of URLs.

### Can you filter results by date?

Both APIs filter by publish date, but DeepSeek can also exclude recent pages and Parallel can’t. DeepSeek supports `after:` and `before:` with a year or a full date, and each result carries a `date` in UTC that is null when unknown. Index recrawl frequency, whether Search can serve a live-fetched page, and how Fetch caches are not documented.

Parallel’s `after_date` limits results to content published on or after a date, and there is no before-date filter. By default Parallel returns cached content from its index. A fetch policy with `max_age_seconds` (minimum 600) triggers a live fetch when the cached copy is older, and Parallel’s docs say live fetching adds significant latency.

### Controls

DeepSeek puts its controls in the query string: `site:` with `OR` for several sites, `-site:`, exact phrases, excluded terms, `lang:` with comma-separated codes, `after:`, and `before:`. The query is capped at 128 characters, so an agent that passes a long user prompt has to shorten it first. The optional `ori_question` field carries the original question and has the same cap. `localization` takes an IP address. An explicit country parameter and a limit on `site:` clauses are not documented.

Parallel’s `include_domains` accepts plain domains, domain and path prefixes such as `docs.python.org/3`, and bare top-level domains such as `.gov`. `exclude_domains` takes the same forms and is ignored when `include_domains` has entries, and the two lists share a 200-entry cap. `location` takes an ISO 3166-1 alpha-2 country code. Turbo handles English and Japanese queries and no other languages, so use Basic or Advanced for the rest. DeepSeek’s docs show `lang:zh,en` but don’t list the languages it supports.

### What are the rate limits?

DeepSeek allows 5 requests per second each for Search and Fetch, which is 300 requests per minute per endpoint. Parallel’s default for Search and Extract is 600 requests per minute each, with custom limits on enterprise plans.

DeepSeek counts its limit per account across all API keys, with separate quotas for the two endpoints. Fetch also has a per-domain limit whose value is not documented. Going over returns HTTP 429. For one agent, 5 per second is plenty. For a pool of workers that each fan out several queries, it is the first limit you’ll hit. DeepSeek’s capacity expansion form covers model concurrency, and the guide doesn’t describe a way to raise search limits.

DeepSeek’s errors follow the OpenAI-compatible format. Retry 408, 429, and 5xx after a wait, top up on 402, and change the request before retrying other 4xx errors.

### Authentication

DeepSeek uses `Authorization: Bearer <key>` with a key from the DeepSeek platform. Test requests sent to both endpoints with no key and with an invalid key each returned HTTP 401 with an `authentication_error`, which matches the documented behavior. Parallel uses an `x-api-key` header, and the hosted Search MCP server works without a key.

## Is there an independent benchmark of the DeepSeek Search API?

No. DeepSeek publishes no quality numbers for its Search API, and no independent benchmark of it was found as of October 17, 2026.

On the independent Artificial Analysis Search Index[Artificial Analysis Search Index] (data dated September 28, 2026, before DeepSeek’s launch), Parallel Search Advanced scores 75 and Basic scores 73 out of 100, behind Perplexity Search (medium) at 80 and Octen Search (highlights) at 77. The index runs the same answer model and harness for every provider and changes nothing but the search API, and its methodology[methodology] is public. Parallel’s benchmarks page[benchmarks page] reports SimpleQA Verified, BrowseComp, and WideSearch results from runs on September 9, 2026 that pair a GPT-5.6 agent with each provider. DeepSeek is in neither. Until someone runs the DeepSeek Search API through the same harness, any statement about its answer quality relative to Parallel is a guess, and this article makes none.

## When to pick DeepSeek

- You want the lowest list price, $0.75 per 1,000 for Search and for Fetch, with failed and empty requests unbilled.
- You already run DeepSeek models and want one account and one balance, plus the native Claude Code, Codex, and Harness integrations, which are free until the billing date above.
- You need `before:` date filtering, up to 50 results per request, or a `summary` and `rerank_score` in the same response.
- Your workload fits under 5 requests per second per endpoint.
- Your data policy allows DeepSeek’s documented terms, including storage in China.

## When to pick Parallel

- You want one search integration that works with any model, DeepSeek’s included, and keeps working when you change models.
- You want published benchmark numbers with methodology, such as the Artificial Analysis index and Parallel’s own evals.
- You need documented zero data retention, optional EU data residency for Search in Basic mode (not Extract), or US-based storage under a Data Processing Addendum.
- You need higher default throughput (600 requests per minute), domain and path allowlists, or an ISO country code for location.
- You want Extract, Task, Responses, Monitor, or FindAll on the same API key.

## How to run your own comparison

Sample 50 to 100 questions from your real traffic, including some that need pages published in the last week.
Fix the model, prompt, and tool loop, and change nothing but the search call.
Give both sides a similar amount of text per call. Set `need_content` or call Fetch on the DeepSeek side, and set `max_chars_total` on the Parallel side.
Record correctness against a reference answer, searches per question, tokens, seconds, and failed calls.
Compare cost per correct answer with model tokens included, instead of price per call.
Re-run at your real concurrency to see whether you hit HTTP 429.

The evaluation guide[evaluation guide] covers the method in more detail.

## FAQ

### Is the DeepSeek Search API free?

No. DeepSeek prices Search and Fetch at $0.75 per 1,000 successful requests each. Calls made through DeepSeek Harness, Claude Code, and Codex are free until billing starts at 00:00 Beijing time on November 1, 2026, according to DeepSeek’s pricing page. The Search & Fetch guide describes a shorter window for Claude Code and Codex, so confirm the date.

### Is Parallel cheaper than the DeepSeek Search API?

No. At list price Parallel costs more ($1 vs $0.75 per 1,000 on Turbo and Fast, and $5 per 1,000 on Basic and Advanced). Price per call excludes model tokens and retries, so the cost per correct answer depends on your workload.

### Can I use the DeepSeek Search API with models other than DeepSeek’s?

Yes, through function calling, as long as you have a DeepSeek API key and balance. The endpoints are documented as standalone JSON APIs with no model parameter. The built-in search in Claude Code, Codex, and the Responses API works with DeepSeek models alone, and Codex search needs `deepseek-v4-pro`.

### Can I use Parallel with DeepSeek models?

Yes. Parallel Search is a REST API and a keyless MCP server with no model coupling. In a test on October 17, 2026, DeepSeek-V4.1-Flash-1017 called Parallel Search as a function tool, completed the search, and answered from the results.

### Where does DeepSeek store search queries?

DeepSeek’s privacy policy says it collects, processes, and stores personal data in the People’s Republic of China, and its Open Platform Terms are governed by mainland China law. Neither document mentions Search or Fetch, so a Search-specific location and an EU option are not documented.

### Does Parallel offer EU data residency?

Yes, as an optional feature with commitments set out in the customer’s DPA. It covers Search API requests in Basic mode sent to the EU endpoint, where the endpoint, the full search index, and inference run in the EU and zero data retention is the default. Billing metadata such as IDs, the SKU, and a timestamp goes to the US, and live fetch runs worldwide unless turned off. Extract isn’t covered, and Parallel is a US company, so its jurisdiction doesn’t change.

### Does Parallel offer zero data retention?

Yes, under an enterprise agreement, through a ZDR listing on Google Cloud Marketplace for Gemini grounding, and by default on its EU endpoint. Parallel’s docs define it as not retaining request or response data after a run completes. It isn’t listed as a self-serve setting, so contact sales@parallel.ai.

### How many requests per second does the DeepSeek Search API allow?

It allows 5 requests per second for Search and 5 for Fetch, counted per account, and returns HTTP 429 above that. The Search & Fetch guide doesn’t describe a way to raise the limit.

### Which API returns better results?

No public evidence answers that yet. No independent benchmark covers the DeepSeek Search API, and no authenticated DeepSeek calls were made for this comparison.