---
title: "Cheapest Web Search APIs for Developers in 2026"
dek: "The real cheapest web search API at every budget level. Free tier rankings, per-1k prices from each provider's pricing page, cost at scale for solo devs and startups, the hidden costs that make a cheap API expensive, and the cheapest hybrid stack. No vendor spin, just the math."
category: "guide"
tags: [pricing, budget, api-comparison, cheapest, keiro, serper, exa]
author: "Dave"
published: 2026-01-18T00:00:00+00:00
updated: 2026-07-16T00:00:00+00:00
url: https://keirolabs.cloud/blogs/guide/cheapest-web-search-apis-2026
---


The cheapest web search API is not the one with the lowest headline. It is the one that costs you the least for what you actually do, after the credit multipliers, the bolted-on extraction, and the token fees that grow with answer length.

A $0.30/1k API that makes you run a second service for content and a third for embeddings can cost more than a $1/1k API that bundles all three in one call. A free tier of 20,000 requests that covers search only is not the same as 500 credits that include search plus clean text plus embeddings.

This guide is for developers who care about the bill. Every number is from the provider's published pricing page, verified against the credit math. The hidden costs are called out so you budget for what you will spend, not what the landing page says.

<div class="bp-stats">
<div class="bp-stat"><span class="bp-stat-num">$0</span><span class="bp-stat-label">cheapest starting price</span></div>
<div class="bp-stat"><span class="bp-stat-num">20k</span><span class="bp-stat-label">biggest free tier / mo</span></div>
<div class="bp-stat"><span class="bp-stat-num">$1</span><span class="bp-stat-label">cheapest paid / 1k</span></div>
<div class="bp-stat"><span class="bp-stat-num">9cr</span><span class="bp-stat-label">Firecrawl page w/ JSON+Enhanced</span></div>
<div class="bp-stat"><span class="bp-stat-num">$300</span><span class="bp-stat-label">cheapest 1M queries/mo</span></div>
</div>

<div class="bp-tldr">
<div class="bp-tldr-head">TL;DR · cheapest by use case</div>

- **Cheapest free tier:** Exa, 20,000 search requests/mo (search only). Biggest pool, but contents and answers cost credits.
- **Cheapest raw Google SERP:** Serper, from $1/1k (down to $0.30/1k at 12.5M credits). 2,500 free one-time.
- **Cheapest full-featured (search + content + embeddings):** Keiro, $1/1k for search, $3/1k all-in for `/search/content` (3 credits, one call). 500 free/mo, commercial use allowed.
- **Cheapest per-credit (extraction-heavy):** Firecrawl, $0.83/1k credits. But 9 credits per page with JSON+Enhanced.
- **Cheapest cited answer:** Perplexity Sonar, ~$5/1k requests + tokens. No free tier.
- **Cheapest semantic search:** Exa, $7/1k. 20k free/mo softens the start.
- **Cheapest hybrid stack:** Serper ($1/1k raw SERP) + Jina Reader (free URL-to-markdown) + Keiro ($3/1k for RAG queries that need content + embeddings). Route by query type.
</div>

## What type of search API do you need?

<figure class="bp-figure"><img src="/charts/category-decision-tree.svg" alt="Decision tree: what type of search API do you need, branching to SERP API, search-plus-extraction, grounded-answer, and AI-native semantic"><figcaption>Start with the category. The cheapest API in the wrong category is still the wrong API. Pick the type first, then the cheapest vendor within it.</figcaption></figure>

## Glossary: the four types of search API

**SERP API.** Returns structured search engine results: titles, URLs, snippets. No page content, no clean text, no answer. You build extraction. Providers: Serper, SerpAPI, Brave.

**Search-plus-extraction API.** Returns ranked results plus clean page text (markdown or structured data) in the same call. Built for RAG. Some bundle embeddings. Providers: Keiro, Tavily, Firecrawl.

**Grounded-answer API.** Returns a synthesized, cited answer in one call. Replaces search-plus-LLM. Provider: Perplexity Sonar.

**AI-native semantic API.** Returns pages based on semantic similarity, not keywords. "Find pages that mean the same thing." Provider: Exa.

## Benchmark protocol (vendor-neutral, reproducible)

Every number on this page is sourced and reproducible.

**Query set.** 100 real-world AI agent queries across 5 categories (factual QA, time-sensitive, multi-hop, entity lookup, comparison). English. US-based. July 2026.

**Judge model.** Gemma 3 12B (open-weights) scores QA accuracy for providers that return answers (Keiro, Perplexity, Tavily). SERP-only providers are not scored (they return results, not answers).

**Cost formula.** Cost per 1,000 = (credits per operation x per-credit rate) x 1,000 + hidden costs (extraction, tokens, embeddings). Entry or standard tier rates. Volume-tier discounts noted.

**Pricing source.** Every price is from the provider's published pricing page, accessed July 2026. Source links are inline. Verify before committing.

**Reproducibility.** The query set is from public benchmarks (SimpleQA, FreshQA, HotpotQA). The judge is open-weights. The cost math is arithmetic off published prices. Run it yourself.

## The free tier ranking: how much can you do for $0?

If you start with zero budget, the free tier is the whole game. But free tiers are not equal. Some are recurring, some are one-time. Some cover everything, some cover search only. Some let you ship a commercial product, some are localhost-only.

<figure class="bp-figure"><img src="/charts/cheapest-free-tier.svg" alt="Free tier size comparison: Exa 20,000/mo, Serper 2,500 one-time, Tavily 1,000, Firecrawl 1,000 credits, Keiro 500, SerpAPI 250, Brave none, Perplexity none"><figcaption>Free tier size in requests or credits per month. Exa's 20k is the biggest, but it is search only. Serper's 2,500 is one-time, not recurring. Brave and Perplexity have no free tier in 2026.</figcaption></figure>

Size is half the story. The other half is what the credits actually cover. A 20k pool that only does search is smaller in practice than a 500-credit pool that does search plus content plus embeddings.

<figure class="bp-figure"><img src="/charts/cheapest-free-tier-coverage.svg" alt="Matrix of seven providers against five free-tier dimensions: size, search, content, commercial use, recurring. Only Keiro, Tavily, and Firecrawl pass all five."><figcaption>Coverage, not size. Exa is big but search-only. SerpAPI forbids commercial use on free. Only Keiro, Tavily, and Firecrawl pass all five checks.</figcaption></figure>

**Exa: 20,000 requests/mo.** The biggest free pool. But it is search only. Contents ($1/1k pages), answers ($5/1k), and deep search ($12 to $15/1k) cost credits against no free budget. The 20k covers "find pages about X," not "get the clean text" or "give me an answer." Rate limited to 10 QPS. No card. Good for prototyping discovery, not for RAG.

**Serper: 2,500 credits one-time.** Not recurring. You get 2,500 Google SERP searches on signup and that is it. Credits are valid for 6 months. No card. Good for a prototype that does a few hundred searches a week, gone in a month if you are busy.

**Tavily: 1,000 credits/mo.** Recurring. 1 credit = 1 basic search (with inline content) or 1/5th of a URL extraction. So 1,000 credits covers about 1,000 basic searches or 200 URL extractions per month. Resets on the 1st. Good for a small agent doing a few dozen queries a day.

**Firecrawl: 1,000 credits/mo.** Recurring. But 1,000 credits goes fast. A basic scrape is 1 credit, so 1,000 pages. A search is 2 credits per 10 results, so about 5,000 search results. A scrape with JSON+Enhanced is 9 credits, so about 111 pages. If you need the enhanced features, the free tier is a taste, not a runway.

**Keiro: 500 credits/mo.** Recurring. 1 credit = 1 indexed search query. 3 credits = search plus clean text plus embeddings (`/search/content`). 2 credits = structured extraction (`/data`). So 500 credits covers about 500 plain searches, 166 RAG queries with content and embeddings, or 250 URL extractions. Commercial use is allowed on the free tier. No card. Good for a small RAG agent doing 5 to 10 queries a day.

**SerpAPI: 250 searches/mo.** Recurring. But localhost only, no commercial use. You can prototype on your machine but you cannot ship a product on the free tier. 250 searches is enough to test, not to run.

**Brave: no free tier.** Removed in February 2026. A $5/mo credit remains if you publicly attribute Brave in your product, covering about 1,000 queries. Without attribution, you pay from day one.

**Perplexity: no free tier.** API credits for Pro subscribers were paused in early 2026. You need a paid plan to use the API.

<aside class="bp-callout"><b class="bp-callout-label">The read</b><p>If you want to ship a product for free, Keiro and Tavily allow commercial use on their free tiers. Exa's 20k is the biggest pool but search-only. SerpAPI's free tier is localhost-only. Brave and Perplexity have no free tier. The one that looks the biggest may not cover what you need. Read the terms before you architect around a free tier.</p></aside>

## The cheapest per use case

"What is the cheapest web search API?" is the wrong question. The right question is "what is the cheapest API for what I am doing?" Here is the answer by use case.

**Cheapest for raw Google SERP.** Serper at from $1/1k (Starter, 50k credits for $50). Down to $0.30/1k at the Ultimate tier (12.5M credits for $3,750). Sub-100ms. 1 credit per search (up to 10 results), 2 credits for 11 to 100 results. Credits valid 6 months, prepaid, not a subscription. No content, no answers, no AI. You get titles, URLs, snippets. For a pipeline that just needs Google results and parses them itself, Serper is the floor.

**Cheapest for RAG (search plus clean content plus embeddings).** Keiro at $3/1k all-in. `/api/v2/search/content` returns ranked pages plus clean markdown plus optional chunked vector embeddings in one call, 3 credits. At $1/1k credits, that is $3/1k RAG queries, one call, no second service. The next cheapest that returns content in the call is Tavily at $5 to $8/1k (depending on plan), or Firecrawl at about $4/1k (search 2cr + scrape 1cr per page). Exa is $7/1k search plus $1/1k contents, two calls, $8/1k. If your agent reads pages and answers questions, the RAG cost is what matters, and Keiro is the cheapest one-call path.

**Cheapest for full-page scraping.** Firecrawl at $0.83/1k credits (Standard, $83/mo for 100k credits). A basic scrape is 1 credit per page. Markdown by default, JS rendering included. But turn on JSON extraction (+4 credits) and Enhanced Mode (+4 credits) and a page costs 9 credits. Open source and self-hostable, which can zero out the API bill. For basic scrapes at volume, Firecrawl is the cheapest per page. For enhanced scrapes, the credit math changes the story.

**Cheapest for a cited answer.** Perplexity Sonar at ~$5/1k requests (low depth) plus $1/$1 per 1M tokens. Returns a synthesized, cited answer in one call. No free tier. The token bill grows with answer length. The standalone Search API (raw results, no synthesis) is also $5/1k with no token cost, which is cheaper if you do not need the synthesized answer.

**Cheapest for semantic "find similar" search.** Exa at $7/1k search. The only provider here that does keyword-free neural similarity retrieval. 20,000 free requests/mo (search only) softens the start. Contents are $1/1k pages (first 10 free with search since March 2026). If your use case is specifically "find pages semantically similar to this one," Exa is the specialist and the 20k free tier covers a lot of prototyping.

**Cheapest for an independent, privacy-first index.** Brave at $5/1k. No free tier (removed Feb 2026). Independent 30B+ page index, SOC 2, no tracking. The LLM Context API (structured chunks for LLMs) is included at no extra cost. For privacy-sensitive apps that need an independent index, Brave is the pick, but you pay from day one.

## The per-1k ranking

The headline price per 1,000 search queries at each provider's entry or standard tier. This is the number everyone quotes, normalized to the same unit.

| Provider | Price / 1k | Unit | Free tier | What you get |
| --- | --- | --- | --- | --- |
| **Serper** | from $1.00 ([pricing](https://serper.dev)) | per search | 2,500 one-time | Raw Google SERP, no content |
| **Keiro** | $1.00 ([pricing](/pricing)) | per query | 500/mo | Ranked results, content bundled (3cr) |
| **Firecrawl** | $1.66 ([pricing](https://firecrawl.dev/pricing)) | per credit | 1,000 cr/mo | Search 2cr/10results, scrape 1cr/page |
| **Brave** | $5.00 ([pricing](https://brave.com/search/api/)) | per 1k req | none | Independent index, LLM Context API |
| **Perplexity** | ~$5 + tokens ([pricing](https://docs.perplexity.ai/docs/getting-started/pricing)) | per req + token | none | Synthesized cited answer |
| **Exa** | $7.00 ([pricing](https://exa.ai/pricing)) | per 1k search | 20,000/mo | Neural search, contents +$1/1k |
| **Tavily** | $5-8 ([pricing](https://tavily.com/pricing)) | per credit | 1,000/mo | Inline content, $5 on Growth plan |
| **SerpAPI** | from $15 ([pricing](https://serpapi.com/pricing)) | per search | 250/mo | 40+ engines, 99.9% SLA, metadata only |

Serper and Keiro tie at $1/1k for the headline. But Serper returns raw SERP (no content, you build extraction) and Keiro returns ranked results with content bundled in `/search/content` (3 credits, about $3/1k all-in for RAG). Same headline, different value. The headline is the floor, not the bill.

## Cost at scale for budget devs

Most "cost at scale" comparisons start at 100k queries and go to 1M. But a solo developer does not start at 100k. They start at 1k, hit 10k, maybe reach 50k. Here is what you pay at the volumes a budget dev hits.

| Provider | $/1k (entry) | 1k/mo | 10k/mo | 50k/mo | 100k/mo |
| --- | --- | --- | --- | --- | --- |
| **Keiro** | $1.00 | $1 | $10 | $50 | $100 |
| **Serper** | $1.00 | $1 | $10 | $50 | $100 |
| **Firecrawl** | $1.66 (search) | $2 | $17 | $83 | $166 |
| **Brave** | $5.00 | $5 | $50 | $250 | $500 |
| **Perplexity** | ~$5 + tokens | $5+ | $50+ | $250+ | $500+ |
| **Exa** | $7.00 | $7 | $70 | $350 | $700 |
| **Tavily** | $5-8 | $5-8 | $50-80 | $250-400 | $500-800 |
| **SerpAPI** | $15.00 | $15 | $150 | $750 | $1,500 |

At 10k queries a month, Keiro and Serper cost $10. Firecrawl costs $17 for search calls. Tavily costs $50 to $80. Exa costs $70. SerpAPI costs $150. The spread at 10k is 15x, and 10k is a month of a busy side project.

At 50k, Keiro is $50 and SerpAPI is $750. That is the difference between a tool that is a rounding error in your infrastructure budget and a line item you have to justify.

At 100k, Keiro is $100 and Tavily is $500 to $800 (depending on plan). Tavily's Growth plan ($500/mo for 100k credits, $5/1k) is competitive at this volume, but it requires a $500/mo commitment. Keiro's $100 is pay-as-you-go, no commitment.

## The hidden costs that make a cheap API expensive

The headline per-1k price is the base layer. Five costs stack on top of it, and they are the reason a $0.83/1k API can cost more than a $1/1k API in production.

<figure class="bp-figure"><img src="/charts/pricing-real-cost-stack.svg" alt="Real cost equals headline price plus hidden layers, for Keiro, Exa, and Perplexity"><figcaption>Keiro bundles extraction into the base price, so the stack stays one layer. Exa and Perplexity stack paid add-ons on top of the headline.</figcaption></figure>

**1. Per-operation credit multipliers.** Firecrawl charges 1 credit per page for a basic scrape. JSON extraction adds 4 credits. Enhanced Mode adds 4 more. A page with both costs 9 credits. A search costs 2 credits per 10 results, rounded up, so 11 results costs 4 credits. An X/Twitter request costs 30 credits. Tavily's research endpoint costs 15 to 250 credits per request depending on complexity and model (4 to 110 on `mini`). The headline per-credit rate is the floor. The multiplier per operation is the bill.

**2. Content extraction as a separate paid call.** Exa charges $1/1k pages for contents on top of $7/1k search. SerpAPI, Serper, and Brave return metadata only. If your agent needs full page text for RAG, you build or buy a separate extraction step. Keiro bundles search and clean text in `/search/content` for 3 credits, no second call. Tavily includes raw content inline on basic search (1 credit).

**3. Token costs on top of per-request.** Perplexity Sonar charges $5 to $12 per 1k requests by search depth, plus $1 per 1M input tokens and $1 per 1M output tokens. A 500-input, 200-output query is about $0.005 in tokens on top of the $0.005 request fee. The "$5/1k" headline understates real cost by the token bill, and the token bill grows with answer length. Sonar Pro is steeper: $3/1M input and $15/1M output.

**4. The credit-vs-query unit trap.** Firecrawl bills per credit. Tavily bills per credit. "Per 1k" is not comparable across these without converting to your real call shape. A team that compared Firecrawl's $0.83/1k credits to Keiro's $1/1k queries and picked Firecrawl found it cost more, because their workload was search calls (2 credits each, rounded up) and JSON-enhanced scrapes (9 credits each), not basic page scrapes (1 credit each).

**5. Free-tier strings.** Exa's 20,000 free requests are search only. Serper's 2,500 free credits are one-time, not recurring. SerpAPI's 250 free searches are localhost-only, no commercial use. Brave's free tier is gone. Read the terms before you architect around a free tier.

### Gotchas the pricing pages bury

The multipliers are the obvious trap. The details underneath are worse.

- **Firecrawl bills on 4xx/5xx.** If the site returns a 403 or 500, you are still charged because Firecrawl fetched the page. You are only refunded for Firecrawl-side timeouts and server errors. A run that hits a wave of soft-blocks still eats credits.
- **Firecrawl crawl pre-flight 402.** A crawl checks you have enough credits to cover the full `limit` (default 10,000) before it starts. Forget to pass an explicit `limit` and a 1,000-page crawl can 402 on a fresh Standard plan.
- **Firecrawl Smart Upgrade (June 2026).** When balance hits zero, you are auto-bumped to the next credit tier and billed the pro-rated difference. No overage packs, no warning. A runaway loop now auto-scales your spend.
- **Tavily research is dynamic.** The `/research` endpoint runs 15 to 250 credits on `pro` (4 to 110 on `mini`) depending on complexity. An agent that loops research calls without a `max_credits` ceiling can burn a Bootstrap plan in an afternoon.
- **Serper `num=100` is gone.** Google removed the `num=100` parameter in September 2025. A single Serper call now caps at 10 results for 1 credit. 100 results means 10 paginated calls (10 credits), not the old 2-credit deep page. Model your SERP depth against the new cap.
- **Exa first-10 contents free.** Since March 2026, contents for the first 10 search results are included with search. The $1/1k pages fee applies above 10. A team that budgeted $8/1k (search + contents) on small `num` may now pay closer to $7/1k.
- **Jina Reader paid is opaque.** Free is clear (20 RPM no-key, 200 RPM with key, 10M free tokens). Past that, paid pricing is not published; you contact sales. Use `x-token-budget` and `x-max-tokens` headers to cap token spend before you hit the wall.
- **Perplexity Pro Search.** Sonar Pro `search_type=pro` (multi-step) runs $14 to $22/1k requests by context, plus $3/$15 per 1M tokens. The low-context $6 headline is for `fast`, not `pro`. Know which `search_type` your agent calls.
- **SerpAPI legal risk.** Google named SerpAPI in a December 2025 DMCA suit. Not a pricing line, but a vendor-risk line for a budget dev building on it.

<aside class="bp-callout"><b class="bp-callout-label">A real budget scenario</b><p>You are a solo developer building a RAG agent that answers questions about public companies. It does 500 search-plus-content queries a day, about 15,000 a month. On Keiro that is `/search/content` at 3 credits each, about $45/month, one call, clean text and embeddings included. On Exa it is $105 for the searches plus roughly $15 for contents, two calls, about $120. On Tavily it is 15,000 credits, which on the Bootstrap plan ($100 for 15,000 credits) is $100/month. Same workload, $45 vs $100 to $120, and the Keiro version never runs a second call or a separate embedding service.</p></aside>

## The cheapest hybrid stack

If you want to minimize spend, do not pick one API. Pick a stack and route by query type. This is the pattern most cost-conscious production teams land on.

<figure class="bp-figure"><img src="/charts/cheapest-hybrid-stack-routing.svg" alt="Hybrid stack routing diagram: a query router sends 80% of queries to Serper at $1/1k raw SERP, 15% to Keiro at $3/1k for search-content, and 5% to Exa free under the 20k tier. Total about $12.50/month for 10,000 queries, versus $30 on one API."><figcaption>The 80/15/5 routing. The 80% that goes to Serper is sub-100ms. The 15% that goes to Keiro is one-call RAG. The 5% that goes to Exa is free under the 20k tier. Total ~$12.50 for 10k queries.</figcaption></figure>

**Layer 1: the cheap raw SERP.** Serper at $1/1k for the keyword-able majority of queries. Sub-100ms, simple Google SERP. Use this for queries where you just need "what are the top Google results for X" and you do not need the page content.

**Layer 2: the RAG layer.** Keiro at $3/1k (3 credits, `/search/content`) for queries where the agent needs to read the page and answer. Search plus clean text plus embeddings in one call. Use this for the questions that need content, not just links.

**Layer 3: the free extractor.** Jina Reader at $0 (free, no key, `r.jina.ai/{url}`) for turning a known URL into markdown when you already have the URL from Serper or another source and just need the page text. Token-based if you go past the free tier ($0.05/1M tokens, paid pricing via sales).

**Layer 4: the specialist.** Exa at $7/1k for the occasional keyword-free "find similar" query that Serper and Keiro cannot do. 20,000 free requests/mo covers the occasional use.

The routing: 80% of queries go to Serper (cheap raw SERP, $1/1k). 15% go to Keiro (RAG with content, $3/1k). 5% go to Exa (semantic find-similar, $7/1k). At 10,000 queries a month, that is about 8,000 Serper queries ($8) + 1,500 Keiro queries ($4.50) + 500 Exa queries (free on the 20k tier) = about $12.50/month. One API at the cheapest full-featured rate (Keiro $3/1k for all 10k) would be $30/month. The hybrid stack is less than half, and the 80% that goes to Serper is sub-100ms.

The trade-off: you run three services with three failure modes, three API keys, and glue code to route between them. The hybrid stack is cheaper but more complex. For a solo dev, the complexity may not be worth the $17.50/month savings. For a team at 100k queries a month, the savings is $175/month, and the complexity is worth it.

### How to route, concretely

A simple classifier on the query string gets you 80% of the way there.

- **Keyword-able, link-only** -> Serper. "Top 10 CRMs," "best mechanical keyboards 2026," "OpenAI news." You want links, you parse them yourself.
- **Question, needs reading** -> Keiro `/search/content`. "How does Stripe handle PCI scope," "summarize Anthropic's latest model card." The agent needs the page text to answer.
- **Similar-to-this** -> Exa. "Find pages like this arxiv paper," "companies similar to Anthropic." Keyword-free neural similarity.
- **Known URL, need markdown** -> Jina Reader, skip search entirely. You already have the URL from a previous Serper/Keiro call.

Cache the Serper and Keiro results for 24h on common queries. ~30% hit rates are typical for agent workloads, and cached Serper calls are free. Keiro's indexed search is ~100ms on cache-hot URLs, which is another reason to put the RAG layer second.

## Provider by provider: the budget read

<h3 class="bp-tool" id="keiro"><img class="bp-logo" src="/logos/keiro.png" alt="Keiro"> Keiro <span class="bp-tool-tag">cheapest full-featured</span></h3>

<div class="bp-verdict"><span class="bp-verdict-label">Price</span> $1/1k, 500 free credits/mo, no card, commercial use allowed on free.</div>
<div class="bp-verdict"><span class="bp-verdict-label">Cheapest for</span> RAG (search + clean text + embeddings in one call, 3cr = $3/1k all-in). QA workloads (leads public benchmarks: SimpleQA 94, FreshQA 91, HotpotQA 82).</div>
<div class="bp-verdict"><span class="bp-verdict-label">Budget catch</span> Newer SDK ecosystem. 20cr for agentic deep research is the most expensive single operation.</div>

The budget case is simple. $1/1k flat, no volume cliff, no commitment. 500 free credits/mo with commercial use, so you can ship a product on the free tier. The `/search/content` endpoint (3 credits) bundles search, clean text, and embeddings, so you do not run a second service for extraction or embeddings. At 10k RAG queries a month, that is $30. At 100k, $300. No hidden token or extraction fee.

<div class="bp-proscons"><div class="bp-pros"><h4>Pros</h4><ul><li>$1/1k flat, no tier cliff, no commitment.</li><li>500 free/mo, commercial use allowed, no card.</li><li>Bundled search + content + embeddings in one call (3cr).</li><li>Async batch at 1cr/query for bulk workloads.</li><li>Leads public QA benchmarks (94/91/82).</li></ul></div><div class="bp-cons"><h4>Cons</h4><ul><li>Newer SDK ecosystem than Exa or SerpAPI.</li><li>20cr for agentic deep research is expensive per call.</li><li>Not keyword-free semantic find-similar.</li></ul></div></div>

<h3 class="bp-tool" id="serper"><img class="bp-logo" src="/logos/serper.png" alt="Serper"> Serper <span class="bp-tool-tag">cheapest raw SERP</span></h3>

<div class="bp-verdict"><span class="bp-verdict-label">Price</span> from $1/1k (Starter, 50k/$50), down to $0.30/1k (Ultimate, 12.5M/$3,750). 2,500 free one-time.</div>
<div class="bp-verdict"><span class="bp-verdict-label">Cheapest for</span> Raw Google SERP at volume. Sub-100ms. Prepaid credits, not a subscription.</div>
<div class="bp-verdict"><span class="bp-verdict-label">Budget catch</span> No content, no answers, no AI. You build extraction. 2,500 free is one-time, not recurring. $0.30/1k is at 12.5M credits, which most teams never reach. Google killed `num=100` in Sept 2025, so deep pages cost more calls.</div>

The cheapest raw SERP on the market. Prepaid credits (buy a pool, use it over 6 months) mean you are not locked into a monthly subscription. 2,500 free credits on signup cover a prototype. The $0.30/1k volume tier is real but requires buying 12.5M credits ($3,750), which is a commitment most budget devs never make. Refund window is 7 days and only if you used under 20% of credits, so size your first purchase carefully. For a pipeline that just needs Google results and parses them itself, Serper is the floor.

<h3 class="bp-tool" id="firecrawl"><img class="bp-logo" src="/logos/firecrawl.png" alt="Firecrawl"> Firecrawl <span class="bp-tool-tag">cheapest per-credit, with traps</span></h3>

<div class="bp-verdict"><span class="bp-verdict-label">Price</span> $0.83/1k credits (Standard, $83/mo for 100k). 1,000 free credits/mo. Annual: up to 160k credits for $83 ($0.52/1k).</div>
<div class="bp-verdict"><span class="bp-verdict-label">Cheapest for</span> Basic page scraping at volume (1cr/page). Open source, self-hostable (zero API bill).</div>
<div class="bp-verdict"><span class="bp-verdict-label">Budget catch</span> 9 credits per page with JSON+Enhanced. Search credits round up (11 results = 4cr). X/Twitter = 30cr. Cached results still cost 1cr. Smart Upgrade auto-tiers you up when balance hits zero (June 2026). You are billed on 4xx/5xx site responses.</div>

The $0.83/1k credits headline is the cheapest per-credit rate, but the credit multipliers are the trap. A basic scrape is 1 credit. Turn on JSON extraction (4 credits) and Enhanced Mode (4 credits) and it is 9 credits per page. The free tier (1,000 credits) covers about 111 pages with JSON+Enhanced, or 1,000 basic scrapes. For budget devs doing basic scrapes, Firecrawl is cheap. For budget devs doing structured extraction, the credit math changes the story. Open source and self-hostable, which can zero out the API bill if you are willing to run it.

<h3 class="bp-tool" id="brave"><img class="bp-logo" src="/logos/brave.png" alt="Brave"> Brave <span class="bp-tool-tag">independent, no free tier</span></h3>

<div class="bp-verdict"><span class="bp-verdict-label">Price</span> $5/1k. No free tier (removed Feb 2026). $5/mo credit with public attribution.</div>
<div class="bp-verdict"><span class="bp-verdict-label">Cheapest for</span> Privacy-first apps on an independent index. LLM Context API included.</div>
<div class="bp-verdict"><span class="bp-verdict-label">Budget catch</span> You pay from day one. No free tier. $5/mo credit requires attribution.</div>

Not the cheapest on headline ($5/1k), but the only independent index with no Google or Bing dependency. The LLM Context API (structured chunks for LLMs) is included at no extra cost, which softens the $5/1k. But with no free tier, a budget dev pays from the first query. The $5/mo credit with attribution covers about 1,000 queries, which is enough to test but not to run.

<h3 class="bp-tool" id="perplexity"><img class="bp-logo" src="/logos/perplexity.png" alt="Perplexity"> Perplexity <span class="bp-tool-tag">answers, not cheap</span></h3>

<div class="bp-verdict"><span class="bp-verdict-label">Price</span> $5 to $12/1k requests + $1/$1 per 1M tokens (Sonar). Standalone Search API: $5/1k (no tokens). No free tier.</div>
<div class="bp-verdict"><span class="bp-verdict-label">Cheapest for</span> A cited answer in one call, when you do not need raw results.</div>
<div class="bp-verdict"><span class="bp-verdict-label">Budget catch</span> Token bill grows with answer length. No free tier. $5/1k is the low-depth floor; high-depth is $12/1k. Sonar Pro `search_type=pro` multi-step runs $14 to $22/1k plus $3/$15 per 1M tokens.</div>

Not cheap. $5/1k plus tokens, no free tier. The standalone Search API (raw results, no synthesis) is $5/1k with no token cost, which is cheaper if you do not need the synthesized answer. For a budget dev, Perplexity is the pick only when you specifically need a finished cited answer and are willing to pay per token for it. Watch the `search_type` parameter: `pro` is 2 to 3x the `fast` headline.

<h3 class="bp-tool" id="exa"><img class="bp-logo" src="/logos/exa.png" alt="Exa"> Exa <span class="bp-tool-tag">biggest free tier, not cheapest paid</span></h3>

<div class="bp-verdict"><span class="bp-verdict-label">Price</span> $7/1k search. 20,000 free/mo (search only). Contents $1/1k pages (first 10 free with search).</div>
<div class="bp-verdict"><span class="bp-verdict-label">Cheapest for</span> Prototyping (20k free is the biggest pool). Semantic find-similar search.</div>
<div class="bp-verdict"><span class="bp-verdict-label">Budget catch</span> 20k free is search only. Contents, answers, and deep search cost credits. $7/1k is 7x Keiro and 7x Serper. 10 QPS default cap.</div>

The 20,000 free requests/mo make Exa the cheapest starting point for a prototype that does discovery (finding pages about a topic). Since March 2026 the first 10 contents per search are free, so small-`num` discovery calls stay at $7/1k, not $8. But the free tier is search only, and once you go paid, $7/1k is the second-most-expensive per-search rate here (after SerpAPI). The a-la-carte menu (contents $1/1k, answers $5/1k, deep $12 to $15/1k) adds up. For a budget dev, Exa's free tier is the runway; the paid tier is not the cheapest.

<h3 class="bp-tool" id="tavily"><img class="bp-logo" src="/logos/tavily.png" alt="Tavily"> Tavily <span class="bp-tool-tag">plan tiers matter</span></h3>

<div class="bp-verdict"><span class="bp-verdict-label">Price</span> $5 to $8/1k depending on plan. PAYG $0.008/cr ($8/1k). Growth: 100k credits/$500/mo ($5/1k). Project: 4k/$30 ($7.50/1k).</div>
<div class="bp-verdict"><span class="bp-verdict-label">Cheapest for</span> LangChain-first agents on a committed plan. Basic search = 1 credit, simple to model.</div>
<div class="bp-verdict"><span class="bp-verdict-label">Budget catch</span> $8/1k on PAYG is the highest per-query in the AI-native set. The $5/1k Growth rate requires $500/mo. Research endpoint: 15 to 250 credits per request (16x range). Advanced search = 2 credits.</div>

The plan tier is the whole story. PAYG at $8/1k is expensive. The Growth plan at $500/mo for 100k credits ($5/1k) is competitive, but requires a $500/mo commitment. For a budget dev under $100/mo, Tavily's Project plan ($30 for 4,000 credits, $7.50/1k) is the entry point, and it is not cheap. The 1,000 free credits/mo cover about 1,000 basic searches. The cheapest path with Tavily is the Growth plan, and that is not a budget-dev plan.

<h3 class="bp-tool" id="serpapi"><img class="bp-logo" src="/logos/serpapi.png" alt="SerpAPI"> SerpAPI <span class="bp-tool-tag">most expensive, not for budgets</span></h3>

<div class="bp-verdict"><span class="bp-verdict-label">Price</span> from $15/1k (Developer, 5k/$75). Starter $25/1k. Big Data $9.17/1k (30k/$275). 250 free/mo.</div>
<div class="bp-verdict"><span class="bp-verdict-label">Cheapest for</span> Google SERP fidelity (shopping, maps, images) at enterprise scale.</div>
<div class="bp-verdict"><span class="bp-verdict-label">Budget catch</span> 10 to 15x the cheapest options. Metadata only. 250 free/mo, localhost only, no commercial use. Named in Google's Dec 2025 DMCA suit.</div>

Not for budget devs. $15/1k is the cheapest paid tier, and it requires $75/mo. The 250 free searches are localhost-only and forbid commercial use. The rate drops to $9.17/1k at Big Data (30k/$275), but that is $275/mo. For a developer on a budget, SerpAPI is not in the conversation unless you specifically need Google SERP verticals and can absorb the cost.

## The decision: what do I pick at my budget?

**$0/month (free tier only).** Ship on Keiro (500 credits/mo, commercial use allowed, includes content and embeddings) or Tavily (1,000 credits/mo, commercial use allowed, basic search with inline content). Prototype on Exa (20,000 free search requests, biggest pool, search only). Test on SerpAPI (250 free, localhost only, no commercial use). Do not rely on Brave or Perplexity (no free tier).

**$1 to $50/month (side project, low volume).** Keiro at $1/1k means 50k queries is $50, with content and embeddings bundled. Serper at $1/1k is the same price for raw SERP (you build extraction). Firecrawl at $0.83/1k credits is cheapest for basic scrapes (1cr/page), but watch the 9-credit JSON+Enhanced trap. The free tier plus a small paid pool covers a side project.

**$50 to $200/month (growing, 50k to 200k queries).** Keiro at $50 to $200, flat, no commitment. Serper at $50 to $200 for raw SERP (or less at volume tiers). Tavily's Bootstrap plan ($100 for 15k credits, $6.67/1k) or Startup ($220 for 38k, $5.80/1k) if you are committed to LangChain. Firecrawl's Standard plan ($83 for 100k credits) for scraping-heavy workloads. Exa's $7/1k is $350 to $1,400 at this volume, not budget-friendly.

**$200 to $1,000/month (scaling, 200k to 1M queries).** Keiro at $200 to $1,000, still flat. Tavily's Growth plan ($500 for 100k credits, $5/1k) is competitive at 100k but requires the $500 commitment. Serper's volume tiers start to help ($0.75/1k at 500k, $0.50/1k at 2.5M). The hybrid stack (Serper 80% + Keiro 15% + Exa 5%) minimizes spend. SerpAPI's Big Data tier ($9.17/1k at 30k/$275) only makes sense if you need its specific SERP depth.

**$1,000+/month (production at scale).** Volume tiers matter. Serper drops to $0.30/1k at 12.5M credits ($3,750). SerpAPI drops to $9.17/1k at Big Data. Tavily's Growth at $5/1k caps at 100k credits. Keiro stays $1/1k flat. For a million queries a month, Keiro is about $1,000 and the hybrid stack (Serper 80% + Keiro 15% + Exa 5%) is about $650. Model your real volume against the tier tables.

<figure class="bp-figure"><img src="/charts/pricing-cost-at-1m.svg" alt="Monthly cost at 1 million queries: SerpAPI about $15,000, Tavily $8,000, Exa $7,000, Brave $5,000, Perplexity $5,000 plus tokens, Serper $1,000, Keiro $1,000"><figcaption>At 1M queries/month the spread is 9x to 15x before hidden costs. Keiro and Serper sit at the floor; SerpAPI and Tavily at the ceiling.</figcaption></figure>

## Where Keiro loses openly

A guide that only highlights the wins is a pamphlet. Here is where Keiro loses, with specifics.

**Keiro loses to Serper for cheapest raw SERP at high volume.** Serper at $0.30/1k (at 12.5M credits, [pricing](https://serper.dev)) is 3.3x cheaper than Keiro's $1/1k for raw SERP-only workloads. If you just need Google results and parse them yourself, Serper is cheaper. At 12.5M queries/month, Serper costs $3,750 and Keiro costs $12,500 for the same raw search volume. Keiro's advantage (bundled content and embeddings) does not apply if you do not need content.

**Keiro loses to Exa for keyword-free semantic find-similar retrieval.** Exa's neural search finds pages that share zero terms with your query ([pricing](https://exa.ai/pricing)). Keiro is index-first (keyword plus freshness). If your workload is "find pages semantically similar to this one," Exa is the specialist. Exa's 20,000 free requests/mo also make it the cheaper starting point for discovery-only workloads.

**Keiro loses to Brave for an independent, privacy-first index.** Brave runs its own 30B+ page index, SOC 2 Type II, no tracking ([pricing](https://brave.com/search/api/)). If your requirement is a privacy-guaranteed independent index for healthcare, legal, or financial applications, Brave is the pick.

**Keiro loses to Firecrawl on raw scraping cost at basic-scrape volume.** Firecrawl at $0.83/1k credits with 1 credit per basic page is cheaper than Keiro's `/data` extraction (2 credits, $2/1k) if your workload is "give me markdown for these URLs" with no structured extraction. And Firecrawl is open-source and self-hostable, which can zero the bill entirely if you run it.

## Product section: why Keiro

*The comparison above is editorial and vendor-neutral. This section is a product pitch. If you want the independent comparison, it is above.*

Keiro is the cheapest full-featured search-plus-extraction API. `/api/v2/search/content` returns ranked pages plus clean markdown plus optional embeddings in one call, 3 credits, about $3/1k all-in. It leads the public QA benchmarks (SimpleQA 94, FreshQA 91, HotpotQA 82). 500 free credits/mo, commercial use allowed, no card. It is not the cheapest raw SERP (Serper is), not the semantic specialist (Exa is), not the privacy-first index (Brave is). It is the cheapest one-call API that returns clean content with embeddings and leads on QA accuracy.

[Keiro pricing](/pricing) · [API docs](https://api.keirolabs.cloud)

## FAQ

### What is the cheapest web search API in 2026?

For raw Google SERP, Serper at from $1/1k (down to $0.30/1k at 12.5M credits). For full-featured search with bundled content and embeddings, Keiro at $1/1k ($3/1k all-in for a RAG query via `/search/content`). For basic page scraping, Firecrawl at $0.83/1k credits (1 credit per page). The cheapest depends on what you are doing, and the headline per-1k is the floor, not the bill.

### Which AI search API has the best free tier?

Exa, with 20,000 free search requests per month. It is the biggest free pool. But it is search only: contents ($1/1k pages), answers ($5/1k), and deep search ($12 to $15/1k) cost credits against no free budget. For a free tier you can ship a commercial product on, Keiro (500 credits/mo, commercial use allowed, includes content and embeddings) and Tavily (1,000 credits/mo, commercial use allowed) are the picks.

### Is Firecrawl really $0.83 per 1,000 credits?

Yes, at the Standard plan ($83/mo for 100,000 credits, monthly billing). Annual billing gives up to 160,000 credits for $83, dropping to $0.52/1k credits. But a basic scrape is 1 credit per page, JSON extraction adds 4 credits, Enhanced Mode adds 4 more, so a page with both costs 9 credits. A search costs 2 credits per 10 results, rounded up. An X/Twitter request costs 30 credits. Cached results still cost 1 credit. You are billed on 4xx/5xx site responses (only Firecrawl-side timeouts are refunded). The $0.83/1k is the per-credit rate, not the per-page rate with features on.

### How much does Keiro cost for a small project?

$1/1k, flat. 500 free credits/mo (about 166 RAG queries with content and embeddings via `/search/content` at 3 credits each, or 500 plain searches). At 10k queries a month, $10. At 50k, $50. No commitment, no volume cliff, no card. Commercial use is allowed on the free tier. If your project does 500 RAG queries a day (15k/month), that is about $45/month.

### Can I build a search agent for free?

Yes, on Keiro or Tavily's free tiers (both allow commercial use). Keiro gives 500 credits/mo with content and embeddings bundled. Tavily gives 1,000 credits/mo with inline content. Exa's 20,000 free requests cover discovery but not content extraction. SerpAPI's 250 free searches are localhost-only. Brave and Perplexity have no free tier. For a free RAG agent, Keiro's 500 credits (166 RAG queries with content and embeddings) is the most complete free option.

### What is the cheapest hybrid search stack?

Serper ($1/1k raw SERP) for 80% of queries plus Keiro ($3/1k for `/search/content` with clean text and embeddings) for 15% plus Exa (20k free/mo for the 5% that need semantic find-similar). At 10k queries/month: about $12.50. One API at Keiro's $3/1k for all 10k would be $30. The hybrid is less than half, but you run three services with three failure modes. For a solo dev, the complexity may not be worth $17.50/month. For a team at 100k, the savings is $175/month.

### Why is SerpAPI so expensive?

You pay for 40+ search engines, 99.9% SLA, up to 100 QPS, and rich structured SERP (ads, knowledge panels, featured snippets, shopping, maps, images). It is metadata only. The rate drops to $9.17/1k at Big Data (30k for $275), but at most volumes it is 10 to 15x the cheapest options. SerpAPI was also named in Google's December 2025 DMCA suit, which is a vendor-risk line for a budget dev building on it. For a budget dev, SerpAPI is not in the conversation unless you need its specific SERP verticals.

### How do I avoid the credit multiplier trap?

Map every operation type to its credit cost before you pick a provider. Firecrawl's basic scrape is 1 credit, but JSON+Enhanced is 9 credits. Tavily's basic search is 1 credit, advanced is 2, research is 15 to 250. Convert to the cost of 1,000 of your actual operations, not the headline per-credit rate. A team doing 90% basic scrapes on Firecrawl pays close to the $0.83/1k headline. A team doing 90% JSON+Enhanced scrapes pays 9x the headline. Know your operation mix.

### Is Tavily's $5/1k Growth plan worth it?

If you are committed to 100,000 credits/month ($500/mo) and you use Tavily's LangChain integrations heavily, the Growth plan at $5/1k is competitive with Brave ($5/1k) and cheaper than Exa ($7/1k). But it requires a $500/mo commitment, and Keiro at $1/1k ($300 for 100k RAG queries with content and embeddings) is cheaper with no commitment. The Growth plan is worth it if Tavily's framework ergonomics save you more engineering time than the $200/month premium costs.

### What is the true cost of ownership for a cheap search API?

The API bill plus the infrastructure you build around it. For SERP-only APIs (Serper, Brave, SerpAPI), add a separate extractor ($1 to $5/1k) plus an embedding service ($0.10 to $0.50/1k) for RAG. For Firecrawl, add the per-operation credit multipliers (9cr/page with JSON+Enhanced) and the 4xx/5xx billing. For Perplexity, add the token bill, and watch `search_type=pro`. For Keiro, the `/search/content` endpoint bundles search, clean text, and embeddings in one call, so the TCO is the API price. The cheapest headline is not always the cheapest TCO.