<!-- twin of https://specstream.ai/compare/openai-web-search-vs-parallel-vs-exa-vs-tavily -->
# OpenAI web search vs Parallel vs Exa vs Tavily in 2026: one key

Compared on Nov 12, 2026. The page: https://specstream.ai/compare/openai-web-search-vs-parallel-vs-exa-vs-tavily

Per 1,000 searches: OpenAI's web search tool costs $10 plus the search content tokens, Parallel $1 to $5 by mode, Exa $4 to $7 by type, and Tavily $8 to $16 pay as you go.

SpecStream answers Parallel's, Exa's and Tavily's calls with one key at $1 per 1,000 searches of up to 10 results, and gives any model a search tool with no tokens billed. Its Search API scores 97.9 F-score on SimpleQA Verified.

[Get an API key](https://specstream.ai/signup?src=alternatives-openai-web-search-vs-parallel-vs-exa-vs-tavily&utm_source=alternatives-md&utm_campaign=openai-web-search-vs-parallel-vs-exa-vs-tavily&returnTo=%2Fworkspace%2Fagents%3Ftab%3Dkeys) New accounts get $10 of credit, no card. It covers 10,000 searches.

## SpecStream, OpenAI web search, Parallel, Exa and Tavily side by side

| | SpecStream | OpenAI web search | Parallel | Exa | Tavily |
|---|---|---|---|---|---|
| The call your code sends | Parallel's, Exa's and Tavily's own calls at `/parallel/v1/search`, `/exa/search` and `/tavily/search` on `https://api.specstream.ai`, on one key. For any model, `GET /v1/web-search` or the MCP server at `https://api.specstream.ai/mcp` | A `web_search` tool in a Responses API request | `POST https://api.parallel.ai/v1/search` with `search_queries`, which is required, and a `mode` | `POST https://api.exa.ai/search` with `query`, `numResults` and a `type`, the key in `x-api-key` | `POST https://api.tavily.com/search` with `query` and a `search_depth` |
| Price per 1,000 searches | $1 for up to 10 results on every path. $5 for Parallel's `advanced` (its default), Exa's `deep` types, Tavily's `advanced` depth or the default search on `/v1/web-search` | $10 per 1,000 calls for web search. $25 per 1,000 for web search preview on models that do not reason | $1 on `turbo` and `fast`, $5 on `basic` and `advanced`. A call that names no mode runs `advanced` | $4 on `lite`, $7 on `auto` and `fast`, $12 on `deep`, for up to 10 results | 1 credit for a basic search and 2 for an advanced one, at $0.008 a credit pay as you go: $8 and $16 |
| Tokens on top | None. The reply's `price_usd` is what the call cost | Search content tokens billed at the model's rates. On some mini models, a fixed block of 8,000 input tokens per call | None. Excerpt length does not change the price | None. Priced per request | None. A request costs its credits |
| Results in one call | Up to 100 on the Parallel and Exa paths and on `/v1/web-search`, 20 on Tavily's. Each started block of 10 more adds $0.0012 | The model reads the results. The sources it read come back when you add `web_search_call.action.sources` to `include` | 10 included. Public modes cap results at 20, and each result beyond the first 10 adds $1 per 1,000 | `numResults` 1 to 100. Each result above 10 adds $1 per 1,000 | `max_results` 0 to 20 |
| What comes back | Each API's own JSON on its path. `/v1/web-search` returns the `answer` with the page it was read from and its read time, `rows` and the ranked `sources` | The model's answer with `url_citation` annotations: the URL, title and location of each cited source | Ranked URLs with excerpts from each page | Title, URL, published date and author for each result. Page text through Contents at $1 per 1,000 pages per content type | Ranked results, each with its content |
| Models and MCP | Any model, through the API, the Python and TypeScript SDKs or the MCP server | OpenAI models. The Agents SDK offers it among its built-in tools with `OpenAIResponsesModel` | Any model through the API, and a hosted MCP server whose `web_search` needs no key at lower rate limits | Any model through the API, and a hosted MCP server at `https://mcp.exa.ai/mcp` | Any model through the API, and a remote MCP server |
| Published accuracy | 97.9 F-score on all 1,000 SimpleQA Verified questions (978 correct), 64.0 item F1 on all 200 WideSearch tasks | Not in Parallel's September 2026 search run | 97% on SimpleQA Verified for `advanced`, in its own September 2026 run | 91% on SimpleQA Verified in the same Parallel run | 92% on SimpleQA Verified in the same Parallel run |
| Free to start | $10 of credit, no card, which covers 10,000 searches. Credit you buy never expires | No free tier in Parallel's November 2026 comparison table | $5 free monthly with a card on file, plus up to $80 at signup | $10 in credits on sign up, reset to $10 on the first of every month. No payment method | 1,000 free API credits every month |

## Why teams choosing between OpenAI web search, Parallel, Exa and Tavily use SpecStream

### Run the same question through all four

Each API keeps its own request and its own JSON on SpecStream. This script sends one question in Parallel's, Exa's and Tavily's format and to the SpecStream Search API, with one key, and prints the result count, the seconds each call took and the first link.

```
import os
import time
import requests

KEY = os.environ["SPECSTREAM_API_KEY"]
BASE = "https://api.specstream.ai"
Q = "who maintains the requests library for Python"
BEARER = {"Authorization": f"Bearer {KEY}"}

calls = {
    "Parallel": lambda: requests.post(f"{BASE}/parallel/v1/search", headers={"x-api-key": KEY},
                                      json={"search_queries": [Q], "mode": "fast"}, timeout=30).json()["results"],
    "Exa": lambda: requests.post(f"{BASE}/exa/search", headers={"x-api-key": KEY},
                                 json={"query": Q, "numResults": 10}, timeout=30).json()["results"],
    "Tavily": lambda: requests.post(f"{BASE}/tavily/search", headers=BEARER,
                                    json={"query": Q, "max_results": 10}, timeout=30).json()["results"],
    "SpecStream": lambda: requests.get(f"{BASE}/v1/web-search", headers=BEARER,
                                       params={"q": Q, "speed": "fast"}, timeout=30).json()["data"]["sources"],
}

for name, call in calls.items():
    start = time.perf_counter()
    results = call()
    seconds = time.perf_counter() - start
    print(f"{name}: {len(results)} results in {seconds:.2f} s, first: {results[0]['url']}")
```

The four calls cost $0.004 together, from the $10 of credit a new account gets. Change `Q` to a question from your own logs and run it again.

### Replace OpenAI's web search tool in an agent

In the OpenAI Agents SDK, remove `WebSearchTool` from the agent's tools and pass SpecStream in `mcp_servers`. The agent calls `search_web` and `read_pages` like its other tools, and the same code runs with any model the SDK supports.

```
import asyncio, os
from agents import Agent, Runner
from agents.mcp import MCPServerStreamableHttp

async def main():
    params = {"url": "https://api.specstream.ai/mcp",
              "headers": {"Authorization": f"Bearer {os.environ['SPECSTREAM_API_KEY']}"}}
    async with MCPServerStreamableHttp(name="SpecStream", params=params, cache_tools_list=True) as server:
        agent = Agent(name="Researcher", instructions="Search the web with SpecStream.", mcp_servers=[server])
        print((await Runner.run(agent, "Who is the CEO of Mistral AI?")).final_output)

asyncio.run(main())
```

Code that calls a model directly defines a function tool that calls `GET https://api.specstream.ai/v1/web-search`, and passes the reply's `data` to the model as the tool result. The [Agents SDK guide](https://specstream.ai/docs/integrations/openai-agents-sdk?utm_source=alternatives&utm_campaign=openai-web-search-vs-parallel-vs-exa-vs-tavily) and the [framework docs](https://specstream.ai/docs/frameworks?utm_source=alternatives&utm_campaign=openai-web-search-vs-parallel-vs-exa-vs-tavily) have both.

### What 100,000 searches cost on each

Take an agent that makes 100,000 searches a month of 10 results each, at list prices.

SpecStream: $100 on any of the three paths or with `speed=fast`, and $500 on the default search of `/v1/web-search`, which adds the answer and rows. No tokens on top.

OpenAI web search: $1,000 in tool calls, then the search content tokens at the model's rates.

Parallel: $100 on `turbo` or `fast`, $500 on `basic` or `advanced`.

Exa: $400 on `lite`, $700 on `auto`.

Tavily: $800 for basic searches pay as you go, or $500 a month on the Growth plan of 100,000 credits. Advanced searches take 2 credits each.

### The most accurate web search API in the world

The SpecStream Search API scores a 97.9 F-score on all 1,000 official SimpleQA Verified questions, with 978 correct. On WideSearch it scores 64.0 item F1 and 43.4 row F1 on all 200 official tasks, and the Extract API scores 0.908 F1 on WCXB. The scores, the method and the other APIs' published scores are at [specstream.ai/benchmarks](https://specstream.ai/benchmarks?utm_source=alternatives&utm_campaign=openai-web-search-vs-parallel-vs-exa-vs-tavily).

The Parallel, Exa and Tavily figures in the table come from Parallel's own run of September 2026. OpenAI's built-in search was not in that run.

### What each path reads and returns

Parallel: `POST /parallel/v1/search` reads `search_queries`, `mode`, `advanced_settings.max_results` up to 100, `source_policy` and `excerpt_settings`, and returns `results[]` with `url`, `title`, `publish_date` and `excerpts`. The search runs on `search_queries`; `objective` is accepted and does not change it. The `parallel-web` SDK takes `base_url="https://api.specstream.ai/parallel"`.

Exa: `POST /exa/search` reads `query`, `numResults` up to 100, `includeDomains`, `excludeDomains`, the published date range, `includeText`, `excludeText` and `contents.text`, and returns `results[]` with `id`, `url`, `title`, `publishedDate` and `text`. In `exa-py`: `Exa(api_key=<key>, base_url="https://api.specstream.ai/exa")`.

Tavily: `POST /tavily/search` reads `query`, `max_results` up to 20, `search_depth`, `include_raw_content`, `include_answer`, the domain lists, the time range and `topic`, and returns `results[]` with `title`, `url` and `content`. In `tavily-python`: `TavilyClient(api_key=<key>, api_base_url="https://api.specstream.ai/tavily")`.

Every parameter and reply field, with what we measured, is in the [Parallel](https://specstream.ai/migrate/parallel?utm_source=alternatives&utm_campaign=openai-web-search-vs-parallel-vs-exa-vs-tavily), [Exa](https://specstream.ai/migrate/exa?utm_source=alternatives&utm_campaign=openai-web-search-vs-parallel-vs-exa-vs-tavily) and [Tavily](https://specstream.ai/migrate/tavily?utm_source=alternatives&utm_campaign=openai-web-search-vs-parallel-vs-exa-vs-tavily) migration guides.

### Zero retention on any key

Set `zero_retention` when you create a key, or later. A search made with that key keeps no request text and no answer after the reply. The charge keeps the account, the key, the request ID, the price and the time. Set `eu_egress_only` and the key's searches leave only from our server in Madrid.

### Search, pages and rows on the same key

The same key reads up to 20 pages a call with the [Extract API](https://specstream.ai/extract-api?utm_source=alternatives&utm_campaign=openai-web-search-vs-parallel-vs-exa-vs-tavily) at $0.80 per 1,000 pages, a page with no text not charged, and runs [Deep Search](https://specstream.ai/deep-search?utm_source=alternatives&utm_campaign=openai-web-search-vs-parallel-vs-exa-vs-tavily), which returns every match on the live web as structured rows at 5¢, 15¢ or $1 a row. The most a Deep Search run can cost is approved before it starts.

## Other search APIs for AI agents

### Perplexity Search API

Ranked web results with no model: $5.00 per 1,000 requests, $1.00 with Fast Search. SpecStream answers Perplexity's `POST /search` at `https://api.specstream.ai/perplexity`, at $0.001 a search.

### Brave Search API

Web search at $5 per 1,000 requests. SpecStream answers Brave's `GET /res/v1/web/search` at `https://api.specstream.ai`, at $0.001 a search.

### Claude's web search tool

Web search on the Claude API costs $10 per 1,000 searches, plus standard token costs for the content it returns. SpecStream's MCP server and Search API give a Claude agent the same tool at $1 to $5 per 1,000, with no tokens billed for the search.

## How to move from each to SpecStream

1. Create a key under Agents & API in the workspace. A new account gets $10 of credit, no card, which covers 10,000 searches.

2. Change the host where your code calls each API, and send the SpecStream key where that API takes its key:

Parallel: `https://api.specstream.ai/parallel` in place of `https://api.parallel.ai`, the key in `x-api-key`.

Exa: `https://api.specstream.ai/exa` in place of `https://api.exa.ai`, the key in `x-api-key` or as a Bearer token.

Tavily: `https://api.specstream.ai/tavily` in place of `https://api.tavily.com`, the key as a Bearer token.

OpenAI web search: drop the `web_search` tool and give the model SpecStream's MCP server or a function tool that calls `/v1/web-search`, as in the code above. The [OpenAI web search alternatives](https://specstream.ai/alternatives/openai-web-search?utm_source=alternatives&utm_campaign=openai-web-search-vs-parallel-vs-exa-vs-tavily) page covers the Responses API in full.

3. Leave the parser as it is. On a `429`, wait the seconds in `Retry-After` and send the call again. Nothing was charged.

## Frequently asked questions

### Which is best for an AI agent: OpenAI web search, Parallel, Exa or Tavily?

SpecStream answers Parallel's, Exa's and Tavily's calls at $1 per 1,000 searches, works with any model, and scores 97.9 F-score on all 1,000 SimpleQA Verified questions. OpenAI's tool costs $10 per 1,000 plus tokens and runs inside OpenAI models.

### How much does each cost per 1,000 searches?

$1 on SpecStream for up to 10 results on every drop-in path. OpenAI web search is $10 per 1,000 calls plus search content tokens. Parallel is $1 on `turbo` and `fast` and $5 on `basic` and `advanced`. Exa is $4 on `lite` and $7 on `auto`. Tavily is $8 for basic and $16 for advanced at $0.008 a credit.

### Can I use a search API in place of OpenAI's web search tool?

Yes: remove `web_search` and give the model a function tool or an MCP server. SpecStream's MCP server at `https://api.specstream.ai/mcp` gives an OpenAI Agents SDK agent `search_web` and `read_pages`, at $1 to $5 per 1,000 searches with no tokens billed for the search.

### Can I keep my Parallel, Exa or Tavily code?

Yes, with 1 line changed per API: the base address. The `parallel-web`, `exa-py` and `tavily-python` SDKs each take it as a setting, the request body stays the same, and the reply comes back in the same JSON.

### How many results does one call return?

Up to 100 on SpecStream's Parallel and Exa paths and 20 on its Tavily path, at $0.0012 for each started block of 10 above 10. Parallel's public modes cap at 20, Exa returns 1 to 100, and Tavily up to 20.

### Which one is free to start?

SpecStream gives $10 of credit with no card, which covers 10,000 searches. Exa gives $10 a month with no payment method, Tavily 1,000 credits a month, and Parallel $5 a month with a card on file plus up to $80 at signup. Parallel's November 2026 table lists no free tier for OpenAI's tool.

## Sources

SpecStream wrote this page. Each figure for OpenAI, Parallel, Exa, Tavily and the other APIs comes from that company's own page.

- [OpenAI API pricing](https://developers.openai.com/api/docs/pricing), read Nov 12, 2026
- [OpenAI web search guide](https://developers.openai.com/api/docs/guides/tools-web-search), read Nov 12, 2026
- [OpenAI Agents SDK tools](https://openai.github.io/openai-agents-python/tools/), read Nov 12, 2026
- [Parallel search modes](https://docs.parallel.ai/search/modes), read Nov 12, 2026
- [Parallel pricing](https://docs.parallel.ai/getting-started/pricing), read Nov 12, 2026
- [Parallel advanced search settings](https://docs.parallel.ai/search/advanced-search-settings), read Nov 12, 2026
- [Parallel MCP quickstart](https://docs.parallel.ai/integrations/mcp/quickstart), read Nov 12, 2026
- [Parallel plans and free credit](https://parallel.ai/pricing), read Nov 12, 2026
- [Parallel: OpenAI web search vs Parallel vs Exa vs Tavily](https://parallel.ai/articles/openai-web-search-vs-parallel-vs-exa-vs-tavily-how-to-choose), read Nov 12, 2026
- [Exa pricing](https://exa.ai/docs/admin/pricing), read Nov 12, 2026
- [Exa search reference](https://exa.ai/docs/reference/search), read Nov 12, 2026
- [Tavily API credits](https://docs.tavily.com/documentation/api-credits), read Nov 12, 2026
- [Tavily search reference](https://docs.tavily.com/documentation/api-reference/endpoint/search), read Nov 12, 2026
- [Tavily MCP](https://docs.tavily.com/documentation/mcp), read Nov 12, 2026
- [Perplexity pricing](https://docs.perplexity.ai/docs/getting-started/pricing), read Nov 12, 2026
- [Brave Search API](https://brave.com/search/api/), read Nov 12, 2026
- [Claude web search tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/web-search-tool), read Nov 12, 2026
- [SpecStream pricing](https://specstream.ai/pricing), read Nov 12, 2026
- [SpecStream for agents](https://specstream.ai/agents.md), read Nov 12, 2026
- [SpecStream benchmarks](https://specstream.ai/benchmarks), read Nov 12, 2026