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

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

Linkup charges $0.005 a search at `standard` depth and $0.05 at `deep`, with 10 queries a second. Parallel charges $1 per 1,000 in `turbo` and `fast` and $5 in `basic` and `advanced`, its default, with 600 a minute.

SpecStream answers both calls with one key. Change `https://api.linkup.so/v1` to `https://api.specstream.ai/linkup/v1` and `https://api.parallel.ai` to `https://api.specstream.ai/parallel`. Your code keeps its body and its parser.

A search of up to 10 results costs $0.001 on either path, page text included. 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-parallel)).

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

## SpecStream, Linkup and Parallel side by side

| | SpecStream | Linkup | Parallel |
|---|---|---|---|
| The call your code sends | Both, on one key. `POST https://api.specstream.ai/linkup/v1/search` in Linkup's JSON with the key as the Bearer token, and `POST https://api.specstream.ai/parallel/v1/search` in Parallel's JSON with the key in `x-api-key` | `POST https://api.linkup.so/v1/search` with `q`, `depth` and `outputType`, and a Linkup key as a Bearer token | `POST https://api.parallel.ai/v1/search` with `search_queries` and `mode`, and a Parallel key in `x-api-key` |
| Price of a search | $0.001 for up to 10 results at Linkup's `flash`, `fast` and `standard` with `searchResults`, and in Parallel's `turbo`, `fast` and `basic`. $0.005 at Linkup's `deep`, with `sourcedAnswer`, or in Parallel's `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 per 1,000 requests in `turbo` and `fast`, $5 in `basic` and `advanced`. A call with no `mode` runs `advanced` |
| More results in one call | Up to 100 on either path. Each started block of 10 more results adds $0.0012: 20 results cost $0.0022 and 100 cost $0.0118 | The price depends on `depth` and `outputType`, not on the number of results | 10 results included, then $1 per 1,000 more results. Public modes cap results at 20 |
| The text of each page | In the same search at no extra cost: Linkup's `standard` and `deep`, and Parallel's `basic` and `advanced`. 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 | Extract costs $1 per 1,000 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 on Search and Fetch | 600 requests a minute on Search |
| Calls that fail | A busy call answers `429` in that API's own error form with `Retry-After`, and charges nothing. A call that returns no results costs nothing | No charge on an error or an empty result. An empty balance answers `429` | `402` for insufficient credit in the account, `429` when rate limited or over quota |
| Free to start | $10 of credit, no card, which covers 10,000 searches. Credit you buy never expires | $20 of credit at sign up with a professional email address, and eligible accounts are topped back up to $20 each month | $5 free monthly with a card on file, plus up to $80 at signup |
| 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 | FindAll `base` costs $0.25 a run and $0.03 a match |

## Why teams choosing between Linkup and Parallel use SpecStream

### Keep both calls and change two lines

Your Linkup call and your Parallel 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"}'

# Parallel: was https://api.parallel.ai/v1/search
curl -X POST https://api.specstream.ai/parallel/v1/search \
  -H "x-api-key: $SPECSTREAM_KEY" -H "Content-Type: application/json" \
  -d '{"search_queries": ["Mistral AI founders"], "mode": "fast"}'
```

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-parallel) and the [Parallel migration guide](https://specstream.ai/migrate/parallel?utm_source=alternatives&utm_campaign=linkup-vs-parallel).

### 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 `/parallel/v1/search`, `search_queries`, `mode` (`turbo`, `fast`, `basic` or `advanced`), `advanced_settings.max_results` up to 100, and `advanced_settings.source_policy` with `include_domains`, `exclude_domains` and `after_date` work as on Parallel, with `excerpt_settings`, `max_chars_total` and `session_id`. The reply has `search_id`, `session_id` and `results[]` with `url`, `title`, `publish_date` when the page has a date, and `excerpts`. `warnings` and `usage` are not returned. In the `parallel-web` Python SDK, set `base_url` to `https://api.specstream.ai/parallel`.

### $1 per 1,000 searches, page text included

Linkup prices a search by depth and output, from $0.005 to $0.055. Parallel charges $1 per 1,000 in `turbo` and `fast` and $5 per 1,000 in `basic` and `advanced`. On SpecStream a search of up to 10 results is $0.001 at Linkup's `standard` and in Parallel's `basic`, page text included, and $0.005 at `deep` or `advanced`. Send `"mode": "fast"` or `"basic"` on the Parallel path: a call with no mode runs `advanced`, as on Parallel. 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-parallel).

### About one second a search, read live

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-parallel) at $0.80 per 1,000 pages, and a page with no text is not charged. It runs [Deep Search](https://specstream.ai/deep-search?utm_source=alternatives&utm_campaign=linkup-vs-parallel), 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

### Tavily

Search in credits at $0.008 a credit pay as you go, 1 credit for a basic search and 2 for an advanced one, with 1,000 free credits every month. SpecStream answers Tavily's `POST /search` at `https://api.specstream.ai/tavily`, in Tavily's JSON, at $0.001 a search.

### You.com

Search at $5.00 per 1,000 calls of up to 100 results, with 10 requests a second on `/v1/search`. SpecStream answers You.com's `/v1/search` at `https://api.specstream.ai/you`, in You.com's JSON, at $0.001 a search of up to 10 results.

### 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.001 a search.

### Brave Search API

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

## How to run your Linkup and Parallel calls on 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. Point each client at its SpecStream path. Linkup's call sends the key as the Bearer token, and Parallel's call sends it in `x-api-key`. In Python:

```
import requests

KEY = SPECSTREAM_KEY

# Linkup's call, was https://api.linkup.so/v1/search
linkup = requests.post(
    "https://api.specstream.ai/linkup/v1/search",
    headers={"Authorization": f"Bearer {KEY}"},
    json={"q": "Who founded Mistral AI and when?", "depth": "fast", "outputType": "searchResults", "maxResults": 10},
    timeout=60,
).json()
for result in linkup["results"]:
    print(result["name"], result["url"])

# Parallel's call, was https://api.parallel.ai/v1/search
parallel = requests.post(
    "https://api.specstream.ai/parallel/v1/search",
    headers={"x-api-key": KEY},
    json={"search_queries": ["Mistral AI founders"], "mode": "fast"},
    timeout=30,
).json()
for result in parallel["results"]:
    print(result["title"], result["url"])
```

3. With the SDKs, the change is the client line:

```
from linkup import LinkupClient
from parallel import Parallel

linkup = LinkupClient(api_key=SPECSTREAM_KEY, base_url="https://api.specstream.ai/linkup/v1")
parallel = Parallel(api_key=SPECSTREAM_KEY, base_url="https://api.specstream.ai/parallel")
```

4. Leave the rest. Each call is billed as one search from $0.001 for up to 10 results, and the reply's `specstream.price_usd` says what it cost. 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.

Companies that name [Linkup](https://specstream.ai/data/subprocessors/vendor/linkup) or [Parallel](https://specstream.ai/data/subprocessors/vendor/parallel) as a subprocessor on their own published list, each with the page and the day we read it.

## Frequently asked questions

### Is Linkup better than Parallel?

For an agent that needs search it can trust, SpecStream answers both Linkup's and Parallel's call with one key at $0.001 a search of up to 10 results, and $0.005 at Linkup's `deep` or Parallel's `advanced`. It scores 97.9 F-score on all 1,000 SimpleQA Verified questions, where Linkup reports 94%.

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

Linkup costs $0.005 a search at `standard` depth with raw results and $0.05 at `deep`. Parallel costs $1 per 1,000 requests in `turbo` and `fast` and $5 per 1,000 in `basic` and `advanced`, its default. SpecStream costs $0.001 a search on either path, page text included, with no monthly plan.

### Which one has a free plan?

Linkup credits $20 at sign up with a professional email address and tops eligible accounts back up to $20 each month. Parallel gives $5 free monthly with a card on file, plus up to $80 at signup. SpecStream gives $10 of credit with no card, which covers 10,000 searches.

### Can I use both Linkup and Parallel?

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

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

Yes: `linkup-sdk` takes `base_url="https://api.specstream.ai/linkup/v1"` and the `parallel-web` Python SDK takes `base_url="https://api.specstream.ai/parallel"`, 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 Parallel 600 requests a minute on Search.

## Sources

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

- [Linkup pricing](https://docs.linkup.so/pages/documentation/platform/pricing), read Nov 12, 2026
- [Linkup authentication](https://docs.linkup.so/pages/documentation/platform/authentication.md), read Nov 12, 2026
- [Linkup rate limits](https://docs.linkup.so/pages/documentation/platform/rate-limits.md), read Nov 12, 2026
- [Linkup Research](https://docs.linkup.so/pages/documentation/endpoints/research/overview), read Nov 12, 2026
- [Linkup introduction](https://docs.linkup.so/pages/documentation/get-started/introduction), read Nov 12, 2026
- [Linkup billing](https://docs.linkup.so/pages/documentation/platform/pricing.md), read Nov 12, 2026
- [Parallel pricing](https://parallel.ai/pricing), read Nov 12, 2026
- [Parallel pricing in the docs](https://docs.parallel.ai/getting-started/pricing.md), read Nov 12, 2026
- [Parallel search modes](https://docs.parallel.ai/search/modes.md), read Nov 12, 2026
- [Parallel search settings](https://docs.parallel.ai/search/advanced-search-settings.md), read Nov 12, 2026
- [Parallel rate limits](https://docs.parallel.ai/getting-started/rate-limits.md), read Nov 12, 2026
- [Parallel errors](https://docs.parallel.ai/resources/warnings-and-errors.md), read Nov 12, 2026
- [Parallel search quickstart](https://docs.parallel.ai/search/search-quickstart.md), read Nov 12, 2026
- [Tavily API credits](https://docs.tavily.com/documentation/api-credits.md), read Nov 12, 2026
- [You.com billing](https://you.com/docs/administration/billing.md), read Nov 12, 2026
- [You.com rate limits](https://you.com/docs/rate-limits.md), read Nov 12, 2026
- [Exa pricing](https://exa.ai/docs/admin/pricing.md), read Nov 12, 2026
- [Brave Search API](https://brave.com/search/api/), 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