---
title: "Parallel FindAll API Pricing: Base vs Core vs Pro"
category: "pricing"
url: https://keirolabs.cloud/blog/parallel-findall-api-pricing
---

Parallel's FindAll API bills every job as a fixed cost per run plus a per-match fee, and the tier changes both numbers: Preview is $0.10 flat, Base is $0.25 plus $0.03 per match, Core is $2.00 plus $0.15 per match, and Pro is $10.00 plus $1.00 per match. Everything else you need is below: the per-1k math, a 500-domain worked example, the rate limits, and the alternatives.

## Parallel FindAll API Pricing - Base vs Core vs Pro Tiers

FindAll is Parallel's list builder. You give it a query in the shape "find all the...", it runs an asynchronous search loop, and it returns matches: entities or URLs that satisfy the criteria, each with citations, source excerpts, reasoning, and confidence scores. The marketing framing is "build verified lists and databases," and that is accurate. The pricing docs put run latency at 10 seconds to 2 hours, asynchronous, with reasoning effort scaling by tier.

Pricing is per generator, and the formula is printed on the page, which puts Parallel in rare company: [total cost = fixed cost + (cost per match x number of matches)](https://docs.parallel.ai/getting-started/pricing).

| Generator | Fixed cost per run | Cost per match | Parallel's stated best for |
|---|---|---|---|
| `preview` | $0.10 | $0.00 | Testing queries (about 10 candidates) |
| `base` | $0.25 | $0.03 | Broad, common queries where you expect many matches |
| `core` | $2.00 | $0.15 | Specific queries with moderate expected matches |
| `pro` | $10.00 | $1.00 | Highly specific queries with rare or hard-to-find matches |

Three things about that table deserve attention before the tier-by-tier breakdown.

First, the fixed cost and the per-match cost move in different proportions. Base to Core is an 8x jump on the fixed fee and a 5x jump on the match fee. Core to Pro is 5x on the fixed fee and about 6.7x on the match fee. Neither tier is uniformly "more expensive per unit"; Pro is expensive to start and expensive per item, which is the point.

Second, a match is not a search result. It is a candidate the system evaluated and decided actually satisfies your query, with a citation and a confidence score attached. That is closer to a research analyst's output line than to a SERP row, and the pricing reflects it.

Third, [enrichments](https://docs.parallel.ai/findall-api/features/findall-enrich) bill separately. If you ask FindAll to extract structured columns for every match, each enrichment costs the per-run rate of the Task API processor you choose, multiplied by your match count, and multiple enrichments bill separately. A findall run with three task-core enrichments is a different invoice than the bare run.

### What the fixed cost actually buys

The fixed fee pays for the search loop, not the results. The system generates candidate sources, evaluates each one against your criteria, attaches reasoning and confidence, and decides when the pool is exhausted. That loop runs whether the query returns 400 matches or zero, which is why a failed-feeling run is still a billable one.

Pool size is the hidden variable between tiers. The docs note that each generator evaluates a different number of candidates, and their troubleshooting advice for zero-match runs is to upgrade the generator before rewriting the query, because the problem is often pool size rather than query wording. In practice the tiers are less like speed settings and more like how hard the system is willing to look. Preview peeks at about ten candidates. Pro keeps digging for up to two hours.

Two features soften the fixed fee. [Extend runs](https://docs.parallel.ai/findall-api/features/findall-extend) raises the match limit on an existing run without charging the fixed cost again; you pay only the per-match rate on new matches, plus enrichment costs on those new matches if you use them. And cancellation bills only for work completed, which is fair, though on Pro the completed work can already exceed the entry fee.

### Preview: the $0.10 dry run

Preview costs $0.10 per run, charges nothing per match, and evaluates roughly 10 candidates. It exists to answer one question: does my query shape return anything sensible?

**Pros:** It is the cheapest experiment in Parallel's catalog, and the cheapest way to learn that a query is malformed before it costs real money. The [FindAll docs](https://docs.parallel.ai/findall-api/core-concepts/findall-generator-pricing) recommend running it first to validate your approach and get a sense of how many matches to expect.

**Cons:** It is not a production tier. Ten evaluated candidates tell you nothing about recall at scale. A preview that returns 8 matches does not mean the full run would return 8; on a broad query it might return 800, and on a bad query 0.

### Base: $0.25 a run plus $0.03 a match

Base is the tier the summary pricing row quotes ("$0.25/run + $0.03/match"), and the tier most high-volume jobs should start on.

**Pros:** The entry fee is 40x cheaper than Pro's. The match fee is 33x cheaper than Pro's. On Parallel's own benchmark it finds 1,000 correct matches for about $60 on average, which already beats Exa, OpenAI Deep Research and Anthropic Deep Research on both cost and recall in the same table. The [extend-runs feature](https://docs.parallel.ai/findall-api/features/findall-extend) raises the match limit without charging the fixed cost again, so a Base run can grow without a new entry fee.

**Cons:** Recall is 30.3% on the benchmark Parallel publishes, against a ground truth built from the union of every system's correct matches. Nearly 70% of the true matches are missed. The docs position Base for "broad, common queries where you expect many matches," and separately note that the low fixed cost matters most when you expect fewer than 20 matches. Rare, hard-to-find entities are not its job.

### Core: $2.00 a run plus $0.15 a match

Core is the middle tier, and in our experience the one most production workloads actually settle on.

**Pros:** Recall jumps to 52.5%, about 1.7x Base, on the same benchmark. It is priced for "specific queries with moderate expected matches," which describes most real list-building jobs: not every company in an index, but every company in one sector with one attribute. Extend runs works here too.

**Cons:** The fixed fee is 8x Base and the match fee is 5x Base, so at high match counts the per-match rate dominates the bill. A Core run that returns 500 matches costs $77.00 where Base would cost $15.25 for the same count. Per Parallel's CPM math, Core finds 1,000 correct matches for about $230, nearly 4x Base's cost per correct match.

### Pro: $10.00 a run plus $1.00 a match

Pro is the tier you use when the entity is rare and the value of finding it is high.

**Pros:** 61.3% recall, which Parallel says is roughly 3x higher than the external alternatives in its benchmark. For queries like "find all companies doing X in Y that were founded after Z," where the answer set is scattered across pages no index ranks well, Pro is the tier designed to keep searching when Base and Core would have stopped. Every match still carries citations, excerpts, reasoning and confidence.

**Cons:** The $10.00 fixed fee is an entry charge, and you pay it even for a run that finds nothing. The docs are explicit that cancelled runs are billed for work completed. At $1.00 per match, a 500-match run costs $510.00 before enrichments. On the CPM math, Pro finds 1,000 correct matches for about $1,430, which is 24x Base's cost per correct entity. That is the price of the last 30 points of recall, and sometimes it is worth exactly that and often it is not.

> Recall is the product. The per-match fee is just how it is metered.

### A findall job over 500 URLs, priced at every tier

Here is the worked example, using the shape most teams actually run: a watchlist of 500 domains, one FindAll job per domain, each job expected to surface around 20 matches.

| Tier | Math per job | 500 jobs | Per 1,000 jobs |
|---|---|---|---|
| Preview | $0.10 + 20 x $0.00 | $50.00 | $100.00 |
| Base | $0.25 + 20 x $0.03 = $0.85 | $425.00 | $850.00 |
| Core | $2.00 + 20 x $0.15 = $5.00 | $2,500.00 | $5,000.00 |
| Pro | $10.00 + 20 x $1.00 = $30.00 | $15,000.00 | $30,000.00 |

A sensible rollout spends $0.50 on five preview runs to sanity-check the query, then runs the remaining 495 domains on Base for $420.75, and reserves Core or Pro for the specific domains where Base returned nothing but you suspect matches exist.

The other shape is one big job instead of many small ones. A single FindAll run that returns 500 matches costs $0.25 + (500 x $0.03) = $15.25 on Base, $2.00 + (500 x $0.15) = $77.00 on Core, and $10.00 + (500 x $1.00) = $510.00 on Pro. One run amortizes the fixed cost, so the per-match rate is almost the whole bill.

Then there is the rate limit, which is its own cost. FindAll runs are capped at 300 new runs per hour per the [rate limit docs](https://docs.parallel.ai/getting-started/rate-limits), so a 500-run batch needs about 1.7 hours just to enqueue. Budget the wall-clock time along with the dollars.

### Cost per 1k, tier by tier

| Meter | Preview | Base | Core | Pro |
|---|---|---|---|---|
| Variable cost per 1,000 matches | $0.00 | $30.00 | $150.00 | $1,000.00 |
| 1,000 runs averaging 20 matches | $100.00 | $850.00 | $5,000.00 | $30,000.00 |
| 1,000 runs averaging 100 matches | $100.00 | $3,250.00 | $17,000.00 | $110,000.00 |
| Parallel's own cost per 1,000 correct matches | n/a | $60 | $230 | $1,430 |

The last row is the honest one. Parallel benchmarks its own tiers at [parallel.ai/products/findall](https://parallel.ai/products/findall) using the average cost to find 1,000 correct matches, which is the number that includes all the misses. Base looks 33x cheaper than Pro on sticker and 24x cheaper per correct answer. The gap between those two ratios is the cost of recall.

## Parallel Search API Pricing and Rate Limits

FindAll is one product on a page of six, and readers pricing one usually end up pricing the rest. Here is the whole sheet.

The Search API returns 10 results with excerpts per request, synchronously, in a quoted 200 ms to 3 s band. Pricing is by [mode](https://docs.parallel.ai/getting-started/pricing):

| Mode | Per 1,000 requests | Results included | Additional results |
|---|---|---|---|
| `turbo` | $1.00 | 10 | $1.00 per 1,000 each |
| `fast` | $1.00 | 10 | $1.00 per 1,000 each |
| `basic` | $5.00 | 10 | $1.00 per 1,000 each |
| `advanced` | $5.00 | 10 | $1.00 per 1,000 each |

The cost formulas are published, which is rarer than it should be: turbo and fast cost $0.001 + ($0.001 x extra results) per request, and basic and advanced cost $0.005 + ($0.001 x extras). The site's own cost chart carries Parallel Turbo at $1.00 per 1,000, and that is the figure to compare against other APIs' headline numbers.

The extras line changes the comparison at depth. At 30 results per request, turbo costs $0.021 per request ($21.00 per 1,000) and basic costs $0.025 ($25.00 per 1,000), so the 5x headline gap compresses to 1.2x once you ask for depth. If your agent routinely wants 30 results, the mode choice matters less than the results tax, which is $1.00 per 1,000 per extra result on every mode. At 10 results, mode choice is the whole decision; at 30, it is a rounding error.

Around it:

- **Extract**: $1 per 1,000 URLs, synchronous, 1-20 s (1-3 s on cached pages). The cheapest meter in the catalog.
- **Entity Search**: $5 per 1,000 requests with 100 results included, extras at $0.05 per 1,000, 1-3 s. It is the synchronous, real-time counterpart to FindAll for people-and-company lookups.
- **Responses**: cited answers in an OpenAI-compatible shape, at $10 per 1,000 for `low` reasoning (about 5-10 s), $50 for `medium` (15-20 s), and $250 for `high` (30-60 s). Failed responses are not billed.
- **Monitor**: scheduled checks at $3 per 1,000 executions for `lite` (narrow queries) and $10 per 1,000 for `base` (wide queries).
- **Task**: the deep research ladder, covered in the next section, from $5 to $2,400 per 1,000 runs.

Rate limits are documented separately from pricing, and the FindAll number is the one that surprises people:

| Product | Default quota | What counts |
|---|---|---|
| Search | 600 per min | Each POST to `/v1/search` |
| Extract | 600 per min | Each POST to `/v1/extract` |
| Tasks/TaskGroups | 2,000 per min | Each task run created |
| Chat | 300 per min | Each POST to `/v1beta/chat/completions` |
| FindAll | 300 per hour | Each POST to `/v1beta/findall/runs` |
| Entity Search | 600 per min | Each POST to the entity-search endpoint |
| Monitor | 300 per min | Each POST to `/v1alpha/monitors` |

GET requests, including polling a run's status, do not count against the limits. Higher limits require emailing support@parallel.ai. The practical read: search and extract are throughput products, and FindAll is not. At 300 runs per hour, a nightly sweep of 2,000 domains needs about seven hours of queue time no matter what you pay.

The free side is real but card-shaped. Third-party roundups document up to $80 in signup credit for work-email signups, and Parallel's own pages confirm the other two: qualified startups can apply for up to $250, and since July 15, 2026, [every eligible organization with a credit card receives $5 in free credits each month](https://parallel.ai/blog/free-tier-parallel). That $5 covers up to 5,000 Search API requests, 5,000 Extract requests, 1,000 Task runs, or 1,666 Monitor executions, and any unused balance expires at the end of the month. Compare Keiro's free tier: 1,250 credits per month with no card required, worth 12,500 lite searches at the 0.1-credit plan rate.

## Compare Deep Research APIs: Parallel Task API, Exa Research, Tavily Extract

The Task API is where Parallel's "base vs core vs pro" language also appears, on a longer ladder. Task pricing is per 1,000 successful runs, one charge per run regardless of how many output fields you request, and failed runs are not billed.

| Task processor | Cost per 1,000 runs | Latency | Strengths |
|---|---|---|---|
| `lite` | $5 | 10 s - 60 s | Basic metadata, fallback, low latency |
| `base` | $10 | 15 s - 100 s | Reliable standard enrichments |
| `core` | $25 | 60 s - 5 min | Cross-referenced, moderately complex outputs |
| `core2x` | $50 | 60 s - 10 min | High-complexity cross-referenced outputs |
| `pro` | $100 | 2 min - 10 min | Exploratory web research |
| `ultra` | $300 | 5 min - 25 min | Advanced multi-source deep research |
| `ultra2x` | $600 | 5 min - 50 min | Difficult deep research |
| `ultra4x` | $1,200 | 5 min - 90 min | Very difficult deep research |
| `ultra8x` | $2,400 | 5 min - 2 hr | The most difficult deep research |

Fast variants (`lite-fast` through `ultra8x-fast`) cost the same and trade the latency bands down, with `ultra8x-fast` running 1 min to 1 hr. Exa's research endpoints, for comparison, run $12-15 per 1,000 at the deep end per Exa's pricing docs, and Tavily's extract-style work rides its $8 per 1,000 advanced search meter. Parallel's ladder is wider in both directions: cheaper at the floor, dramatically more expensive at the ceiling.

The most useful scoreboard for this section is the one Parallel publishes for FindAll itself, measured as average cost to find 1,000 correct matches (CPM) against a ground truth built from the union of all correct matches across the competitor set:

| System | Cost per 1,000 correct matches | Recall |
|---|---|---|
| FindAll Base | $60 | 30.3% |
| FindAll Core | $230 | 52.5% |
| FindAll Pro | $1,430 | 61.3% |
| Exa | $110 | 19.2% |
| OpenAI Deep Research | $250 | 21% |
| Anthropic Deep Research | $1,000 | 15.3% |

Read that table with one hand tied behind your back, because it is a vendor benchmark and the ground truth is defined by the union of all systems' matches, which structurally favors the family that defines the ceiling. Even so, the shape is informative. FindAll Base beats Exa on both axes in Parallel's own numbers, Anthropic Deep Research is the worst value in the table at $1,000 per 1,000 correct matches for 15.3% recall, and no external system passes 21%.

On independent-flavored reading comprehension, Keiro's SimpleQA run scores 95.3% retrieval on 1,000 seeded questions with the full pipeline included at $4.44 per 1,000 requests ([methodology and leaderboard](https://keirolabs.cloud/Deep-search)). Parallel appears on the same leaderboard at 91.0 via a GPT-5.4 agent harness, priced at $1.00 per 1,000 for its turbo search in the site's cost chart. On FinanceBench, Keiro scores 78% against Parallel's 67%. Different harnesses measure different things; the pattern across all three is that Parallel's cheapest meters are excellent for retrieval breadth and the accuracy crown sits elsewhere.

### The math at 10k, 100k and 1M calls

Monthly spend if every call is the same type:

| Workload (calls per month) | Task base | Task core | Task pro | FindAll Base (20 matches/run) | Keiro batch (Essential) | Keiro lite (Startup) |
|---|---|---|---|---|---|---|
| 10,000 | $100 | $250 | $1,000 | $8,500 | $24 | $0.80 |
| 100,000 | $1,000 | $2,500 | $10,000 | $85,000 | $240 | $8 |
| 1,000,000 | $10,000 | $25,000 | $100,000 | $850,000 | $2,400 | $80 |

The Keiro columns use plan credit rates and are not equivalent products, and pretending otherwise would be dishonest. Essential is $30 for 12,500 credits ($0.0024 per credit; batch costs 1 credit per query), and Startup is $100 for 125,000 credits ($0.0008 per credit; a million lite searches cost 100,000 credits, inside one month's allowance). A batch query returns ranked results; a FindAll run loops until it believes the list is complete, evaluates candidates, and attaches confidence scores. The FindAll column is buying recall, and the table shows what recall costs at volume.

There is also a clock column the table cannot show. At 300 FindAll runs per hour, 10,000 runs need 33 hours of enqueue time, 100,000 need about 14 days, and a million need about 139 days. If your workload is genuinely millions of find-shaped jobs per month, the rate limit, not the budget, is the binding constraint, and you should be talking to Parallel about raised limits before you architect anything.

## Parallel Extract API vs Firecrawl Pricing for High-Volume Extraction

Parallel's Extract API is the simplest product in the lineup: $1 per 1,000 URLs, synchronous, 1-20 s, with cached pages landing in 1-3 s. At 10,000 URLs a month the bill is $10. At a million URLs it is $1,000. There is no per-result surcharge because there are no results, just pages.

Firecrawl is the frequent comparison, and the honest answer is that they price different things. Firecrawl bills credits: search costs 2 credits per 10 results, its Hobby plan runs $16/month (annual) for 5,000 credits, which works out to about $6.40 per 1,000 searches at that credit price, and in Keiro's [deep-search cost chart](https://keirolabs.cloud/Deep-search) Firecrawl's full deep-research workload lists at $10.00 per 1,000. What the credits buy is a live crawl with full page markdown behind every result, which is a different deliverable than Parallel's compressed excerpts. On Keiro's SimpleQA leaderboard Firecrawl scores 94.7, second only to Keiro's 95.3, with Parallel at 91.0.

Two traps in this comparison. First, Parallel's extract rate covers the URL fetch, so if you want structured columns rather than page contents, the enrichment path bills at Task API processor rates per match, from $0.005 (task lite) to $2.40 (ultra8x) per item. Bulk extraction through findall enrichments can run 5x to 2,400x the raw extract rate per item. Use `/v1/extract` for pages and reserve enrichments for the matches that deserve columns.

Second, "high-volume extraction" at a million pages a month is a $1,000/month line item on Parallel and a rate-limit conversation. Extract allows 600 requests per minute, which is about 864,000 URLs a day of headroom, so throughput is not the constraint here. The constraint is deciding whether you need the page or just the excerpt.

On Keiro, the same extraction job runs on `/extract` at 3 credits per request, so 10,000 extractions burn 30,000 credits. That fits inside the $100 Startup plan's 125,000 monthly credits with room for 31,666 more extractions or a lot of lite searches, and on the $30 Essential plan it would exceed the 12,500-credit allowance, which is the plan boundary doing its job.

## Compare AI Search APIs: Parallel, Tavily, Exa, Perplexity Sonar, You.com

Here is the field on the two meters that matter most: what a request costs and whether the right fact comes back. Prices are from the vendors' own pages as carried in [Keiro's deep-search cost chart](https://keirolabs.cloud/Deep-search); SimpleQA scores are from that page's leaderboard, which links every harness.

| Provider | Price per 1,000 | SimpleQA | What the meter buys |
|---|---|---|---|
| Keiro deep search | $4.44 | 95.3 | Full pipeline: live-web resolution, full-page reads, proof scoring, re-rank |
| Parallel (turbo) | $1.00 | 91.0 | 10 ranked URLs with compressed excerpts |
| Tavily | $8.00 | 93.3 | Chunks tuned for RAG, advanced tier 2x |
| you.com | $5.00 | 92.1 | Search with open-source harness |
| Exa | $7.00 | 91.9 | Neural results, 10 included |
| Perplexity Sonar | $5.00 | 85.9 | Grounded answers |
| Claude Search | $10.00 | 90.5 | Native search tool |
| Google (via Serper) | $5.00 | 82.2 | SERP + answering pipeline |
| Brave | $5.00 | 76.1 | Independent index, 5 snippets |

The harness caveat is real: Keiro's 95.3 is a retrieval-only judged check on its own harness, Tavily's 93.3 is GPT-4.1 answering on the official classifier over the full 4,326-question set, and the 90-92 cluster mostly comes from third-party GPT-5.4 agent runs. Cross-table comparisons are directional. Within-table, the interesting fact is that Parallel's $1.00 row scores 91.0, which makes turbo search the best value in that table by points per dollar, and Keiro's deep search is the accuracy ceiling at less than half of Tavily's price.

The two rows people ask about by name: you.com publishes an open-source harness and scores 92.1, which makes it the most auditable number in the table, and its $5.00 per 1,000 is mid-pack. Perplexity Sonar is the reverse case: a household name, grounded answers, 85.9 on the classifier, and the same $5.00 per 1,000. Brand recognition and benchmark position do not always travel together, which is the whole reason to keep a scorecard.

Our own head-to-head is more direct: on the same 100 queries, [Keiro /search/lite beat Parallel's turbo tier 91 to 9](https://keirolabs.cloud/bench/keiro-lite-vs-parallel-turbo), with composites of 341.6 to 170.4 and 6 of 9 query archetypes won. Lite carries a $0.25 per 1,000 headline, and on monthly plans it bills at 0.1 credit: $0.24 per 1,000 on Essential, $0.13 on Pro, $0.08 on Startup.

> The cheapest row with a 90-plus accuracy score is usually where the market's real price lives, and in this table that row is $1.00.

## Parallel vs SerpAPI for Building AI Applications

SerpAPI is the mature way to buy Google's results: $75 per month for 5,000 searches ($15.00 per 1,000), 250 free searches monthly, coverage of Google's verticals (Maps, News, Jobs, Trends), and a polished SLA. It is also built on scraped SERPs, and Google has sued SerpAPI over exactly that, which is a risk profile you inherit when you build on it.

Parallel is built for a different contract. You get per-request pricing printed as formulas, published latency bands, citations and confidence on outputs, and none of your pipeline's correctness depends on Google's servers staying scrapeable. For AI applications specifically, the findall and task products return evaluated matches with reasoning, which is a shape a SERP row never has.

When SerpAPI still wins: keyword-fidelity work where you need Google's exact ranking, vertical data Google uniquely has, or mature tooling for a hundred Google surfaces. When Parallel wins: any agent workload where "web" means "the live web" rather than "the SERP," and every dollar of predictability matters. And if you just want cheap ranked results, Serper runs $1.00 per 1,000 with the same scraped-Google dependency, or Keiro's /search/lite at $0.25 per 1,000 list on an owned index.

At volume the gap stops being academic. Ten thousand queries a month costs $150 on SerpAPI's entry plan, $10 on Parallel turbo or Serper, and $2.40 on Keiro lite at the Essential plan rate. If the queries are entity sweeps rather than keyword lookups, the SERP premium buys you ranking fidelity you may not need, and the scraping dependency you definitely do.

## Exa Alternatives Parallel

This query shape (61 impressions in our Search Console data, at position 17.8) is usually an Exa customer evaluating Parallel as a replacement. Here is the honest scorecard.

Where Parallel beats Exa:

- **Headline price.** Parallel search is $1-$5 per 1,000 for 10 results. Exa is $7.00 per 1,000 for 10 results, and results 11+ add $1 per 1,000 each, so a 30-result search is $27 per 1,000.
- **An exhaustive find-all primitive.** Exa has no equivalent. In Parallel's own benchmark, Exa manages $110 per 1,000 correct matches at 19.2% recall against FindAll's tiered 30.3% to 61.3%.
- **Extract at parity.** Both bill $1 per 1,000 for page contents, a rare tie in this market.
- **Free tier size.** Up to $80 signup credit and $5 monthly with a card, versus Exa's $20 signup plus $10 monthly.

Where Exa wins: semantic search without keywords, `find_similar` for "pages like this one," and neural re-ranking that a keyword-shaped pipeline cannot fake. If your queries are meaning-shaped rather than entity-shaped, Exa's $7 per 1,000 buys something Parallel's modes do not sell.

The third option in this comparison is the one we sell. Keiro's /search/lite has a $0.25 per 1,000 headline, bills at 0.1 credit on plans ($0.24 per 1,000 on Essential down to $0.08 on Startup), and the free tier is 1,250 credits per month with no card. One honest catch: if you buy one-time credit packs instead of a plan, lite bills at 0.5 credit, $2.50-$3.33 per 1,000, so the monthly plan is the cheap path.

### Migrating a findall workload to a cheaper pipeline

If your bill is growing and most of your findall jobs are broad queries that Base handles, a two-meter pipeline is worth pricing. The endpoint mapping looks like this:

| Parallel endpoint | Keiro equivalent | Keiro cost |
|---|---|---|
| Search (turbo, $1/1k) | `/search/lite` | 0.1 credit ($0.24/1k Essential, $0.08/1k Startup) |
| Search (basic/advanced, $5/1k) | `/search/fast` | 1 credit ($2.40/1k Essential, $0.80/1k Startup) |
| Extract ($1/1k URLs) | `/extract` or `/search/content` | 3 credits |
| FindAll (broad, Base) | `/batch` + `/extract` + your verification | 1 credit per query + 3 per page |
| Task (base/core) | `/agentic` deep research | 20 credits |
| Responses (low/medium) | `/answer` with citations | 5 credits |

Worked on the same 500-domain sweep: 500 batch queries cost 500 credits ($1.20 at Essential's credit rate), and extracting the 500 matched pages costs another 1,500 credits ($3.60), for a total near $4.80. The comparable FindAll Base run was $425. The difference is that FindAll is buying a recall loop with evaluated, confidence-scored matches, and the pipeline is buying ranked results plus your own verification code. You trade about $420 for a verification layer you write and maintain. For some teams that trade is obviously good. For teams whose matches must be defensible, it is obviously bad, and the right move is the hybrid: run Core or Pro FindAll quarterly to discover the list, then maintain it on cheap meters.

## Parallel vs Exa vs Tavily - Which AI Search API Is Best?

The question has a boring answer: it depends on what the meter is metering. Here is the decision table.

| Your workload | Pick | The number that decides it |
|---|---|---|
| Cheap ranked URLs at volume | Keiro /search/lite, then Parallel turbo | $0.25/1k list ($0.08 on Startup) vs $1.00/1k |
| Verified lists of rare entities | Parallel FindAll Pro | 61.3% recall vs alternatives at 15-21% |
| Broad entity sweeps | Parallel FindAll Base | $0.25 + $0.03/match, 30.3% recall |
| Deep research with citations | Keiro deep search, or task ultra tiers | $4.44/1k pipeline included vs $300-$2,400/1k runs |
| Full page markdown behind results | Firecrawl, or Keiro /search/content | ~$6.40/1k vs 3 credits/request |
| Google verticals and SERP fidelity | SerpAPI or Serper | $15.00/1k vs $1.00/1k, same dependency |
| Meaning-shaped queries | Exa | $7.00/1k, and find_similar has no cheap substitute |

### Failure modes worth pricing in

**The zero-match run.** A FindAll run that returns nothing still costs its fixed fee, $10 on Pro. The docs' own advice is to upgrade the generator before editing the query, because the problem is often pool size rather than query quality. Run Preview at $0.10 first. One hundred avoided Pro dry runs pay for 10,000 previews.

**The enrichment multiplier.** Enrichments bill at Task processor rates per match, per enrichment. Three core enrichments over 100 matches add 100 x 3 x $0.025 = $7.50 to a $0.25 Base run. Enrichment is where findall bills quietly double.

**The 300-per-hour queue.** Rate limits apply to run creation, and FindAll's is the tightest in the catalog. Design around webhooks and SSE streaming, batch what you can into fewer, bigger runs, and use extend-runs to raise match limits without new fixed costs.

**The expiry tax.** Parallel's $5 monthly credit expires at month's end, and one payment card can activate monthly credits for one organization only. Keiro's 1,250 monthly credits do not require a card, but one-time packs expire in 6 months, which is why the monthly plan is the cheap path on both platforms.

**Vendor benchmarks with union ground truths.** Parallel's recall table defines the ceiling as the union of all systems' correct matches, which flatters the family that defines it. The numbers are internally consistent and still worth reading, but benchmark on your own queries before you commit a quarter's budget to any of them, including ours.

### The boring takeaway

Parallel's FindAll pricing is unusually legible: a printed formula, published recall numbers, and tiers that map cleanly to expected match counts. Base at $0.25 plus $0.03 is the workhorse for broad sweeps, Core at $2.00 plus $0.15 is the default for specific lists, and Pro at $10.00 plus $1.00 is a scalpel for rare entities that justifies $1,430 per 1,000 correct matches only when each match is worth more than that. Preview costs a dime; spend the dime first. And when the workload underneath the findall job is really search-plus-read, price a pipeline on cheaper meters before you marry the recall loop. Every number here links to its source and was checked on September 23, 2026. Prices change; check them again before you sign anything, including with us.