<!-- twin of https://specstream.ai/compare/linkup-vs-tavily -->
# Linkup vs Tavily in 2026: one key answers both calls

Compared on Nov 10, 2026. The page: https://specstream.ai/compare/linkup-vs-tavily

Linkup charges $0.005 to $0.055 a search by depth and output, and Tavily $0.008 a credit pay as you go, with 2 credits for an advanced search. Each has its own request and JSON. SpecStream answers both calls with one key.

Change `https://api.linkup.so/v1` to `https://api.specstream.ai/linkup/v1` and `https://api.tavily.com` to `https://api.specstream.ai/tavily`. Your Linkup and Tavily code keeps its body and its parser, and both send the same SpecStream key as the Bearer token.

A search of up to 10 results costs $0.005 on either path, at every depth. SpecStream scores 97.9 F-score on all 1,000 SimpleQA Verified questions and 64.0 item F1 on all 200 WideSearch tasks ([benchmarks](https://specstream.ai/benchmarks?utm_source=alternatives&utm_campaign=linkup-vs-tavily)).

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

## SpecStream, Linkup and Tavily side by side

| | SpecStream | Linkup | Tavily |
|---|---|---|---|
| The call your code sends | Both, on one key. `POST https://api.specstream.ai/linkup/v1/search` in Linkup's JSON and `POST https://api.specstream.ai/tavily/search` in Tavily's JSON, with the SpecStream key as the Bearer token | `POST https://api.linkup.so/v1/search` with `q`, `depth` and `outputType`, and a Linkup key as a Bearer token | `POST https://api.tavily.com/search` with `query`, `search_depth` and `max_results`, and a Tavily key as a Bearer token |
| Price of a search | $0.005 for up to 10 results, at every Linkup `depth`, `deep` included, with `searchResults` or `sourcedAnswer`, and on Tavily `basic` or `advanced` | $0.005 at `flash`, `fast` or `standard` with raw results and $0.006 with a sourced answer. `deep` costs $0.05, or $0.055 with an answer | 1 credit for a basic search and 2 for an advanced one, at $0.008 a credit pay as you go or $0.0075 to $0.005 on monthly plans |
| The text of each page | In the same search at no extra cost: Linkup's `standard` and `deep` and Tavily's `include_raw_content`. The Extract API reads any page at $0.80 per 1,000 pages | Fetch costs $0.001 a call in standard mode, up to $0.011 with a schema | A basic extract costs 1 credit for every 5 successful URLs |
| Volume | No limit per key and no daily limit. Production answered 718 of 720 searches at up to 20 a second on November 9, 2026 | 10 queries a second per organization | Requests stop when the monthly credits run out, until they reset on the first day of the month |
| Calls that fail | A busy call answers `429` in the API's own error form with `Retry-After`, and charges nothing | No charge on an error or an empty result. An empty balance answers `429` | A failed URL extraction or a failed map is not charged |
| Free to start | $10 of credit, no card, which covers 2,000 searches. Credit you buy never expires | $20 of credit at sign up with a professional email address | 1,000 free credits every month, no credit card |
| Every match as structured rows | Deep Search: a request in plain words returns every match on the live web as rows that meet each condition you wrote, at 5¢, 15¢ or $1 a row, plus 5¢ for an email and 15¢ for a phone. The most a run can cost is quoted before it starts | Research costs $0.25 to $2.50 a request and takes from 2 to 20 minutes | Research takes 4 to 110 credits a request on `mini` and 15 to 250 on `pro` |

## Why teams choosing between Linkup and Tavily use SpecStream

### Keep both calls and change two lines

Your Linkup call and your Tavily call keep their bodies, their headers and their parsers. Each one changes its address, and both carry the same key.

```
# Linkup: was https://api.linkup.so/v1/search
curl -X POST https://api.specstream.ai/linkup/v1/search \
  -H "Authorization: Bearer $SPECSTREAM_KEY" -H "Content-Type: application/json" \
  -d '{"q": "Who founded Mistral AI and when?", "depth": "fast", "outputType": "searchResults"}'

# Tavily: was https://api.tavily.com/search
curl -X POST https://api.specstream.ai/tavily/search \
  -H "Authorization: Bearer $SPECSTREAM_KEY" -H "Content-Type: application/json" \
  -d '{"query": "Who founded Mistral AI and when?", "max_results": 10}'
```

A team that has not chosen yet writes to either format and moves nothing later. The parameter by parameter tables are in the [Linkup migration guide](https://specstream.ai/migrate/linkup?utm_source=alternatives&utm_campaign=linkup-vs-tavily) and the [Tavily migration guide](https://specstream.ai/migrate/tavily?utm_source=alternatives&utm_campaign=linkup-vs-tavily).

### What each path reads and returns

On `/linkup/v1/search`, by `POST` or `GET`, `q`, `depth`, `maxResults` from 1 to 100, `includeDomains`, `excludeDomains`, `fromDate` and `toDate` work as on Linkup. `outputType` takes `searchResults`, which returns `results[]` with `type`, `name`, `url` and `content`, and `sourcedAnswer`, which returns `answer` and `sources[]`. `structured` gets `400` with the reason. In `linkup-sdk`, set `base_url` to `https://api.specstream.ai/linkup/v1`.

On `/tavily/search`, `query`, `search_depth`, `max_results` from 0 to 20, `include_answer` and `include_raw_content` work as on Tavily. The reply has `query`, `answer` when asked, `results[]` with `title`, `url`, `content`, `score`, `raw_content` when asked and `published_date` when the page has a date, `response_time` and `request_id`. `favicon` and images are not returned. In the Tavily Python SDK, set `api_base_url` to `https://api.specstream.ai/tavily`.

### $5 per 1,000 searches at every depth, from credit that does not expire

Linkup prices a search by depth and output, from $0.005 to $0.055. Tavily prices it in credits that reset each month, and an advanced search takes two. On SpecStream every search of up to 10 results is $0.005 on either path, `deep`, `advanced`, a sourced answer and page text included. There is no monthly plan, a top-up never expires, and a call stopped by a `429` charges nothing.

### 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. Linkup reports a 94% F-score on the same benchmark. On WideSearch SpecStream 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 and the method are at [specstream.ai/benchmarks](https://specstream.ai/benchmarks?utm_source=alternatives&utm_campaign=linkup-vs-tavily).

### About one second a search, read live

Both paths run the fast search unless the call asks for page text or results past the first ten, and every search reads the live web at the moment of the call. On November 9, 2026 production took 1 to 20 fast searches a second and answered 718 of 720: the median was 0.82 s at 1 search a second and 1.07 s at 20 a second, and the 95th percentile stayed between 1.09 and 1.73 s. There is no limit per key and no daily limit.

### 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.

```
curl -X POST https://api.specstream.ai/v1/account/keys \
  -H "Authorization: Bearer $SPECSTREAM_API_KEY" -H "Content-Type: application/json" \
  -d '{"name": "production", "scopes": ["account:read", "finds:spend"], "spend_cap_cents": 500000, "zero_retention": true}'
```

### Search, pages, crawls 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=linkup-vs-tavily) at $0.80 per 1,000 pages, answers Tavily's extract and map calls on the Tavily path, maps and crawls whole sites, and runs [Deep Search](https://specstream.ai/deep-search?utm_source=alternatives&utm_campaign=linkup-vs-tavily), which returns every match on the live web as structured rows at 5¢, 15¢ or $1 a row. 10,000 rows with 5 facts each cost $500, and the most a run can cost is approved before it starts.

## Other search APIs for AI agents

### Exa

Search on its own index at $4 per 1,000 requests on `lite` and $7 on `auto`, for up to 10 results. SpecStream answers Exa's `POST /search` at `https://api.specstream.ai/exa`, in Exa's JSON, at $0.005 a search.

### Parallel

Search from $1 per 1,000 requests, with 600 requests a minute on the Developer plan. SpecStream answers Parallel's `POST /v1/search` at `https://api.specstream.ai/parallel`, in Parallel's JSON, with no limit per key.

### Brave Search API

Results from Brave's own index at $5 per 1,000 requests, with $5 in free credits every month and 50 queries a second. SpecStream answers Brave's `GET /res/v1/web/search` at `https://api.specstream.ai`, at $5 per 1,000 searches.

### Serper

Google results as prepaid credits, from $1.00 per 1,000 on the 50k pack, and credits valid for 6 months. SpecStream answers Serper's `POST /search` at `https://api.specstream.ai/serper`, and a SpecStream top-up never expires.

## How to run your Linkup and Tavily calls on SpecStream

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

2. Point each client at its SpecStream path and send the SpecStream key as the Bearer token. In Python:

```
import requests

HEADERS = {"Authorization": f"Bearer {SPECSTREAM_KEY}"}
QUESTION = "Who founded Mistral AI and when?"

# Linkup's call, was https://api.linkup.so/v1/search
linkup = requests.post(
    "https://api.specstream.ai/linkup/v1/search",
    headers=HEADERS,
    json={"q": QUESTION, "depth": "fast", "outputType": "searchResults", "maxResults": 10},
    timeout=60,
).json()
for result in linkup["results"]:
    print(result["name"], result["url"])

# Tavily's call, was https://api.tavily.com/search
tavily = requests.post(
    "https://api.specstream.ai/tavily/search",
    headers=HEADERS,
    json={"query": QUESTION, "max_results": 10},
    timeout=30,
).json()
for result in tavily["results"]:
    print(result["title"], result["url"])
```

3. In JavaScript:

```
const headers = { Authorization: `Bearer ${process.env.SPECSTREAM_KEY}`, "Content-Type": "application/json" };
const question = "Who founded Mistral AI and when?";

// Linkup's call, was https://api.linkup.so/v1/search
const linkup = await fetch("https://api.specstream.ai/linkup/v1/search", {
  method: "POST",
  headers,
  body: JSON.stringify({ q: question, depth: "fast", outputType: "searchResults" }),
}).then((r) => r.json());

// Tavily's call, was https://api.tavily.com/search
const tavily = await fetch("https://api.specstream.ai/tavily/search", {
  method: "POST",
  headers,
  body: JSON.stringify({ query: question, max_results: 10 }),
}).then((r) => r.json());

for (const result of linkup.results) console.log(result.name, result.url);
for (const result of tavily.results) console.log(result.title, result.url);
```

4. Leave the rest. Each call is billed as one search at $0.005 for up to 10 results. On a `429` with `Retry-After`, wait those seconds and send the call again; nothing was charged.

When your agent needs every match in place of a results page, write the request in plain words. SpecStream reads it back as the conditions every row must meet and the facts to bring back, quotes the most it can cost, and delivers the rows after you approve.

## Frequently asked questions

### Is Linkup better than Tavily?

For an agent that needs search it can trust, SpecStream answers both Linkup's and Tavily's call with one key at $0.005 a search. It scores 97.9 F-score on all 1,000 SimpleQA Verified questions, where Linkup reports 94%, and a team keeps whichever format it already wrote.

### Linkup vs Tavily pricing: what does each cost?

Linkup costs $0.005 a search at `standard` depth with raw results and $0.05 at `deep`. Tavily costs $0.008 a credit pay as you go, 1 credit for a basic search and 2 for an advanced one. SpecStream costs $0.005 a search at every depth, with no monthly plan.

### Can I use both Linkup and Tavily?

Yes, with one key: SpecStream answers Linkup's call at `https://api.specstream.ai/linkup/v1` and Tavily's at `https://api.specstream.ai/tavily`, each in its own JSON. One balance, one request log and one spending limit cover both.

### Which one has a free plan?

Tavily gives 1,000 free credits every month, and Linkup credits $20 at sign up with a professional email address. SpecStream gives $10 of credit with no card, which covers 2,000 searches, and credit you buy never expires.

### Do the Linkup and Tavily SDKs work with SpecStream?

Yes: `linkup-sdk` takes `base_url="https://api.specstream.ai/linkup/v1"` and the Tavily Python SDK takes `api_base_url="https://api.specstream.ai/tavily"`, with the SpecStream key in place of theirs. The calls and the replies stay as they are.

### How many searches a second can I run?

SpecStream has no limit per key and no daily limit, and it answered 718 of 720 searches at up to 20 a second on November 9, 2026. Linkup allows 10 queries a second per organization, and Tavily stops requests when the month's credits run out.

## Sources

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

- [Linkup pricing](https://docs.linkup.so/pages/documentation/platform/pricing), read Nov 10, 2026
- [Linkup authentication](https://docs.linkup.so/pages/documentation/platform/authentication.md), read Nov 10, 2026
- [Linkup rate limits](https://docs.linkup.so/pages/documentation/platform/rate-limits.md), read Nov 10, 2026
- [Linkup Research](https://docs.linkup.so/pages/documentation/endpoints/research/overview), read Nov 10, 2026
- [Linkup introduction](https://docs.linkup.so/pages/documentation/get-started/introduction), read Nov 10, 2026
- [Tavily API credits](https://docs.tavily.com/documentation/api-credits.md), read Nov 10, 2026
- [Tavily pricing](https://tavily.com/pricing), read Nov 10, 2026
- [Tavily Search API reference](https://docs.tavily.com/documentation/api-reference/endpoint/search.md), read Nov 10, 2026
- [Exa pricing](https://exa.ai/docs/admin/pricing.md), read Nov 10, 2026
- [Parallel pricing](https://parallel.ai/pricing), read Nov 10, 2026
- [Brave Search API](https://brave.com/search/api/), read Nov 10, 2026
- [Serper homepage and pricing](https://serper.dev/), read Nov 10, 2026
- [SpecStream pricing](https://specstream.ai/pricing), read Nov 10, 2026
- [SpecStream for agents](https://specstream.ai/agents.md), read Nov 10, 2026
- [SpecStream benchmarks](https://specstream.ai/benchmarks), read Nov 10, 2026