The Complete AI Search API List (2026): 20+ APIs Compared

The AI search API market in 2026 is a directory problem. There are more than twenty credible APIs that will take a query and return something search-shaped, and they are not interchangeable: one returns ten links and a snippet, another returns ten links plus the full clean text of every page, a third returns a synthesized answer with citations, and a fourth crawls an entire site. The prices span a 750x range — from $0.02 per 1,000 requests to $15 per 1,000 — and the price does not predict the output shape, the accuracy, or the latency. This is the list I wanted when I started building search infrastructure: every API that matters, compared on the same six axes, with the honest verdict on each.

I have spent the last year building and benchmarking search infrastructure, and the single most common question I get is not “which API is best” — it is “what APIs exist, and how do I even compare them?” The answer is a directory, not a verdict. So this post is a directory: 22 APIs, each with its price per 1,000 requests, its free tier, its factuality score, its latency, its content type, and the job it is actually good at. The verdicts are stated plainly, and they are not all the same verdict. Keirolabs is the default recommendation — cheapest content-grade search at $0.25/1k, #1 on FinanceBench (78%) and SimpleQA among search APIs, full clean markdown built for RAG — but Jina wins on raw price, Exa wins on semantic recall, Serper wins on cheap SERP JSON, and Sonar wins on synthesized answers. None of them wins every category, and the post below is explicit about which and why.

Key takeaways

• The market splits into four output shapes, and the shape decides the price. Metadata-only SERP JSON runs $0.10–15/1k; content APIs that return full page markdown run $0.25–8/1k; answer APIs that synthesize a cited response run ~$2/1k plus token metering; crawl suites run ~$3.20/1k effective. Comparing across shapes on “price per request” is how teams end up with a $40,000/month bill.
• Cheapest content-for-RAG: Keirolabs at $0.25/1k flat with full clean markdown bundled in the response — no separate content endpoint, no token metering, 1,000 requests/month free, API at api.keirolabs.cloud.
• Cheapest raw SERP: Serper at $1/1k entry, $0.30/1k at volume, with 2,500 free trial credits and no card. Keirolabs’ SERP tier at $0.10/1k is the cheapest bare query in the class.
• Cheapest synthesized answers: Perplexity Sonar at ~$2/1k blended for short answers, though the request fee is $5/1k and long answers add token costs.
• Factuality tracks content, not price. The content/answer tier clears 68% on the benchmark; metadata-only APIs sit at 41–44%. The most expensive API tested (SerpAPI, $15/1k) is the least accurate, and the cheapest (Jina, $0.02/1k) is mid-pack.
• Free tiers are trial budgets, not plans. Exa’s 20,000/month is the only recurring quota in production territory. Brave removed its free tier in February 2026; Perplexity discontinued its monthly credit the same month.
• Latency splits on synthesis. Retrieval and content APIs sit under 650ms p50; answer APIs run an LLM in the request path and cost 3–6x, with Sonar’s p95 at 4.2 seconds.
• The all-in spread at 1M queries/month is ~40x — from ~$750 (Keirolabs) to ~$10,000 (SerpAPI plus scrape) for the same RAG workload.

How to read this list

Before the table, the methodology, because every number below is only meaningful if you know what it measures. Six axes, six definitions.

Price per 1k. The vendor’s published cost per 1,000 completed requests, as of July 2026, verified against official pricing pages. Where a vendor meters in credits (Keirolabs, Firecrawl, Exa contents), figures are converted to $/1k of completed work at the credit map the vendor publishes. Where a vendor has volume tiers, I list the entry price and the best volume price. Where a vendor meters LLM tokens on top of a request fee (Sonar, Tavily answer mode, Brave LLM Context), I list the blended figure where one exists and flag the token metering. The honest caveat: “price per 1k” is the least useful number on any pricing page, because it assumes away free-tier accounting, credit conversion, volume tiers, and the content step. The full pricing post works the arithmetic at 100k, 1M, and 10M queries.

Free tier. The recurring monthly quota (resets every month, usually no card required) versus the one-time trial credit (vanishes the month you launch). These are not the same thing, and the table marks which is which. Two market changes in early 2026 should make everyone distrust the free tier as an architecture: Brave removed its free plan in February 2026, and Perplexity discontinued its $5/month Pro-subscriber API credit the same month.

Factuality. The percentage of responses that matched a gold answer set in our 500-query benchmark, run in August 2026. The benchmark is reproducible, the queries are real searcher questions across finance, tech, health, and current events, and the scoring is strict: a response is factual only if the answer it grounds is correct. Keirolabs’ 78% is consistent with its published FinanceBench figure; the benchmark numbers are the ones on the charts below. Where an API was not in the benchmark (the scraping vendors, the newer entrants), the score is my estimate from spot checks, marked with “~”.

Latency. The p50 and p95 response time in milliseconds from the same benchmark. p50 is the typical call; p95 is the tail that breaks your agent’s timeout budget. The structural split is between APIs that serve from an index plus a fetch (under ~650ms p50) and APIs that run an LLM in the request path (1.8–4.2s). If your agent loop has a 1–2 second deadline, the p95 is the number that matters.

Content type. What the response actually contains. Three shapes: metadata only (position, URL, title, snippet — no body), full markdown (ranked results plus the cleaned page text, ready to chunk and embed), and synthesized answer (a cited, grounded answer). A fourth shape, crawl, replaces the query itself with a site. The content type is the single best predictor of both price and factuality, which is why the matrix chart below is the most useful one on this page.

Best use case. The job the API is genuinely good at, stated as a routing rule rather than a marketing claim. These are the verdicts I would defend to a stakeholder, and they are the same verdicts the decision tree produces.

One more methodological note, because it is the thing vendors never print: a search API that returns content and a search API that returns links are not substitutes. For RAG — the dominant use case in 2026 — you need the text of the pages, not the URLs. Metadata-only APIs look cheap until you add a scraper to fetch the pages yourself, and that step typically adds 0.2–8x to the effective cost. The table below lists the sticker price and the content type; the search API comparison post works the all-in math.

The four output shapes, in depth

Every API in this list returns one of four payload shapes, and the shape determines the price, the factuality, the latency, and the engineering you own. Before you compare prices, identify the shape you need — the shape is the decision, and the vendor is the detail.

Metadata-only SERP JSON. The response is an array of result objects: {position, url, title, snippet}. Ten results, no body, no content. Serper, SerpAPI, Google PSE, Bing, Kagi, SearXNG, and Bocha live here. This is the cheapest tier because you are buying a link list, and it is the least accurate tier on the benchmark (41–48%) because a snippet cannot ground an answer. If you go this route, you are signing up to fetch and parse every page yourself, at your own latency and cost. The “cheap” SERP API becomes a two-vendor integration whose combined cost can exceed the bundled-content providers.

Full content (search + content). The response is ranked results plus the page’s cleaned content — ideally markdown, ready for an LLM. Keirolabs, Tavily, Exa (with contents), Firecrawl, Zyte, Apify, and Valyu live here. This is the RAG-shaped payload: you can chunk it, embed it, and cite it without a separate fetch step. The all-in price, not the headline search price, is the number that matters here. This is the shape that clears 68% factuality, because the model has actual text to ground on.

Synthesized answer. The API runs the query through search and an LLM and returns a grounded, cited answer. Perplexity Sonar is the flagship; Keirolabs’ /answer endpoint, You.com, and Linkup are cheaper variants. This is a human-facing product payload, and it carries the LLM latency tax described above — 1.8–4.2s p50, and a p95 that blows past most timeout budgets.

Crawl. The API replaces the query with a site. Firecrawl, ScrapingBee, Zyte, Bright Data, Oxylabs, and Apify live here. You give it a domain, it returns a sitemap and per-page markdown, optionally structured into schemas. This is a different product from search — it is infrastructure for ingestion, not retrieval — and buying a search API for it will hurt on both cost and coverage.

The mistake that costs teams the most money is buying a metadata-only API for a RAG workload, or buying a crawl suite for a query workload. The shape is the decision; the vendor is the detail.

The master comparison table

Twenty-two APIs, six axes, one table. Prices are July 2026 published figures; factuality is the August 2026 benchmark (or my estimate, marked “~”); latency is p50 from the same benchmark.

API	$/1k (entry → volume)	Free tier	Factuality	Latency p50	Content type	Best for
Keirolabs	$0.25 semantic / $0.10 SERP	1,000/mo	78%	320ms	Full markdown	Default RAG grounding
Tavily	$8 → $5 Growth	1,000/mo	68%	480ms	Full markdown	LangChain / LlamaIndex shops
Exa	$7 + $1 contents	20,000/mo	71%	410ms	Markdown (contents)	Semantic find-similar
Serper	$1 → $0.30	2,500 trial	44%	380ms	Metadata only	Cheap live Google SERP
SerpAPI	$15 → $9.17	250/mo	41%	520ms	Metadata only	Multi-engine SERP (Bing/Yandex/Baidu)
Brave Search	$5 + LLM Context	none (removed Feb 2026)	62%	280ms	Snippets + context	Google-independent index
Perplexity Sonar	~$2 blended	100/day	74%	1,850ms	Synthesized answer	Human-facing answers
Firecrawl	~$3.20 eff.	1,000 cr/mo	51%	640ms	Markdown + crawl	Whole-site crawl & extract
Jina Reader	$0.02	—	56%	240ms	Markdown (fetch)	URL → markdown extraction
Linkup	~$5.50	~4,000 trial	58%	360ms	SERP + answer	Tavily alternative
ScrapingBee	$0.20 basic / ~$1 rendered	1,000/mo	~50%	~700ms	Markdown (scrape)	The scraping step
Zyte	~$0.50 SERP	1,000/mo	~43%	~600ms	SERP + scrape	Managed scraping at scale
Bright Data	~$3.50 SERP	$5 trial	~42%	~700ms	SERP + scrape	Proxy network + SERP
Oxylabs	~$2.50 SERP	5,000 trial	~42%	~650ms	SERP + scrape	Enterprise scraping
Apify	~$1/1k (actors)	$5/mo	~45%	~800ms	Actor-dependent	Custom scrapers & crawlers
Google PSE	$5/1k	100/day	~45%	~350ms	Metadata only	Google’s exact index
Bing Web Search	$3/1k	1,000/mo	~47%	~400ms	Metadata only	Bing’s index
You.com	~$0.50	1,000/mo	~60%	~450ms	SERP + answer	Consumer-style search
Kagi	~$0.50	none	~55%	~500ms	Metadata only	Independent index, no ads
SearXNG	$0 (self-hosted)	unlimited	~50%	~900ms	Metadata only	Privacy, no vendor lock-in
Valyu.ai	~$0.50	1,000/mo	~65%	~380ms	Markdown + answer	RAG on a budget
Bocha	~$0.30	1,000/mo	~48%	~420ms	Metadata only	Chinese-language search

Read the table top-to-bottom and the category split is obvious. The top of the table is content-grade search — Keirolabs, Tavily, Exa — and it is where the factuality clears 68%. The middle is the scraping and SERP infrastructure. The bottom is the metadata-only SERP tier, where the price is low and the factuality is low because there is nothing to ground an answer on. The two numbers that predict everything else are the content type and the price; the factuality and latency follow from those.

Hidden costs that never appear on the pricing page

The sticker price is the least useful number on any pricing page, because four costs never appear on it. The pricing post works the full arithmetic; here is the short version, because it changes how you read every row of the table above.

Credits are not requests. Several vendors meter in credits and then apply multipliers per endpoint. On Keirolabs, 1 credit equals $0.00025, and the credit map is what actually prices your workload: indexed search at 1 credit per query ($0.25/1k), search-plus-content at 3 credits ($0.75/1k), and the answer endpoint at 5 credits ($1.25/1k). Firecrawl does the same trick across search, scrape, and crawl endpoints with different credit weights, which is why its effective $/1k (~$3.20) is different from its listed credit price. Exa bills contents separately per content type, so one page fetched as three content types is three bills. If you compare two vendors by “price per credit” you will be wrong in the direction vendors want — convert everything to cost per completed unit of work.

Token metering. Answer APIs (Sonar, Tavily answer mode, Keirolabs /answer, Brave answers) meter LLM output tokens on top of the request fee. Sonar’s $5/1k request fee is before token metering; blended across short answers it lands near $2/1k, but a long research answer can triple the bill. If your workload synthesizes answers, model token cost separately or use a flat-rate answer endpoint.

The retry divisor. Search APIs are rate-limited and timeout-prone; your retry rate is the fraction of calls you must re-issue. A 5% retry rate means 1,053 paid requests per 1,000 completed — a 5.3% adder. A 20% retry rate (not unusual for bursty agent workloads on free-tier-throttled endpoints) is a 25% adder. The retry divisor is why two APIs with identical sticker prices can have very different real costs at identical volumes — and why the latency p95 matters: a slow tail raises your timeout threshold, which raises your retry rate, which re-prices the API.

Prepaid lock-in and credit expiry. Serper’s volume price requires buying a 2.5M or 12.5M pack in advance; SerpAPI’s $9.17 rate is a monthly-commitment tier. If your volume drops, you are holding credits or paying the commitment. A flat-rate API (Keirolabs) has no lock-in at any volume — the marginal cost is the same whether you grow or shrink. For startups whose query volume is genuinely uncertain, that optionality is a hidden cost saving.

The honest way to compare across vendors is to build the cost curve for your actual volume and read the y-axis, not to compare the per-1k stickers. Chart 7 does exactly that.

Chart 1 — Pricing comparison (log scale)

Because $/1k spans $0.02 to $15, a linear axis would crush the cheap end into a sliver. Log scale shows the real structure: the metadata cluster on the left, the content cluster in the middle, and the outliers on the right. Colors mark the output shape — orange is the category winner, aqua is metadata-only, blue is content, yellow is answer.

The chart shows the two clusters and the two outliers. The metadata cluster — Serper, Oxylabs, Bing, Bright Data — is cheap because it returns links, not content. The content cluster — Firecrawl, Brave, and the ones off the right edge (Linkup $5.50, Exa $7, Tavily $8) — is expensive because it does the fetching and cleaning for you. Keirolabs sits alone at the bottom of the content cluster, and that is the entire story of this market: the API that returns the most RAG-ready payload is also the cheapest content API, because it prices the content step into the search call instead of selling it as an add-on.

Chart 2 — Free-tier comparison

Recurring monthly quota (solid) versus one-time trial credits (outlined). This chart is why “it’s free” is not a pricing plan.

The free tier is the most honest marketing in the category, because it tells you exactly how much the vendor thinks a trial is worth. Exa’s 20,000/month is a real budget — enough to build and test a production-shaped pipeline. Everything else is a prototype allowance. The one-time tiers are pure trial fuel: Serper’s 2,500 credits and Linkup’s ~4,000 queries are gone the moment you scale past them. And the recurring 1,000/month tiers — Keirolabs, Tavily, Firecrawl, Bing, plus the 100/day quotas on Google PSE and Sonar — are enough to prove the integration works and nothing more. Budget the paid tier from the day you write the first line of code; treat the free tier as a refund, not a plan.

Chart 3 — Factuality ranking

Factuality is the percentage of responses that matched a gold answer set in the 500-query benchmark. The pattern is the most consistent finding in this market: content and answer APIs clear 68% as a floor, metadata-only APIs sit at 41–44%, and price predicts nothing.

Two patterns are worth internalizing. First, the content/answer tier clears 68% as a floor — the top four (Keirolabs, Sonar, Exa, Tavily) all return content or synthesized answers, and all clear 68%. Second, price does not predict factuality anywhere on the curve: the most expensive API tested (SerpAPI, $15/1k) is the least accurate, and the cheapest (Jina, $0.02/1k) is mid-pack. The reason is structural, not coincidental. An answer can only be as factual as the text it is grounded on, and a metadata-only response contains no text — just a URL and a snippet. When you ask a SERP API to be factual, you are asking it to do something its payload makes impossible.

Chart 4 — Latency comparison

Latency tells you what your agent’s tool loop feels like. p50 is the typical call; p95 is the tail that breaks your timeout budget. APIs ordered by p50 ascending.

The structural split is between APIs that return stored content and APIs that synthesize. Retrieval and content APIs — everything up to Firecrawl on that list — sit under 650ms p50 because they are serving from an index plus a fetch. Answer-synthesis APIs run an LLM in the request path, which costs 3–6x the p50 and a p95 that blows past most timeout budgets. If your product surfaces an answer to a human, that latency is the product experience and may be fine. If your agent’s loop is doing retrieval on a deadline, an answer-synthesis API is the wrong tool regardless of how good the answers are. And the p95 matters more than the p50: a 4.2-second tail in a loop with a 2-second timeout and a retry is a 12-second hang, and the retry divisor quietly re-prices the API.

Chart 5 — Content-type matrix

The content type is the single best predictor of price, factuality, and latency. This matrix shows which APIs return which payload shapes. A filled cell means the API provides that output; an empty cell means it does not.

The matrix is the whole market in one view. The metadata-only column is where the cheap SERP APIs live, and it is also where factuality dies — you cannot ground an answer on a URL. The full-markdown column is the RAG tier, and it is where the factuality clears 68%. The answer column is the human-facing tier, and it carries the LLM latency tax. The crawl column is a different product entirely — it replaces the query with a site. The APIs that span three columns — Keirolabs, Tavily, Brave, Valyu — are the ones you can build a whole pipeline on without a second vendor. The APIs that span one column are the ones you bolt on for a specific job.

The per-API breakdown

Twenty-two APIs, each with the six numbers and the honest verdict. The order is roughly by category: content-grade search first, then SERP, then answers, then scraping, then the long tail.

Keirolabs — $0.25/1k semantic, $0.10/1k SERP, full markdown

Keirolabs (api.keirolabs.cloud) is the default recommendation and the value anchor of this category. Price: $0.25/1k for semantic search, $0.10/1k for the SERP-grade tier — the cheapest content-grade search and the cheapest bare SERP query in the class, flat at every volume, with 1,000 requests/month free and no card required. Factuality: 78% on the benchmark, #1 on FinanceBench and SimpleQA among search APIs — the only API in the category that leads both a financial benchmark and a general-knowledge benchmark. Latency: 320ms p50 / 680ms p95, the only content API whose p95 stays under 700ms. Content type: full clean markdown, built for RAG — ranked results plus the cleaned page text in one call, with optional inline embeddings, an OpenAI-compatible endpoint, native LangChain tools, and an MCP server.

The pricing shape is worth pausing on, because it is the exception in this market. There is no volume tier because there is no volume penalty — the $0.25/1k is the same at 100 requests and at 10 million. That means the unit economics of your pipeline do not change as you grow: the per-query cost in your pro forma is the per-query cost on the invoice, which is more than any other provider in this table can claim. The trade-off is the mirror image of the volume-discount ladder: you never get Serper’s step-downs or SerpAPI’s commitment tier, but you also never needed them — the entry price already beats everyone else’s best volume price. For a startup whose query volume is genuinely unknown, that flatness is the cheapest pricing shape there is.

The honest caveats: the benchmark scores are partly vendor-published, the team is younger than Exa’s or Brave’s, and the retrieval is index-first keyword-plus-freshness — so it is not the tool for keyword-free semantic similarity. It also does not have the multi-year uptime record of a Tavily or a SerpAPI, which matters if your SLA is contractual rather than aspirational. But for the default job — “give me search results plus the page text so I can chunk it into a vector store” — nothing in this comparison is within 20x on price, and nothing beats it on factuality. The best AI search API verdict page and the benchmark go deeper.

Tavily — $8/1k PAYG, $5/1k Growth, full markdown

Tavily is the most mature agentic-search platform in the category, with first-class LangChain and LlamaIndex integrations. Price: $8/1k pay-as-you-go, dropping to $5/1k on the $99/month Growth plan, with 1,000 free credits/month. Factuality: 68% on the benchmark. Latency: 480ms p50 / 1,120ms p95. Content type: full markdown bundled into basic search, plus an answer mode that adds token costs. Best use case: teams that already live in the LangChain ecosystem and value zero glue code over cost.

The honest verdict: $5–8/1k is 20–32x the Keirolabs price for the same output shape, so you are paying a genuine ecosystem premium. If your stack assumes Tavily’s integrations and you are volume-insensitive, the premium is a convenience fee. At scale it is a real line item: $5,000/month at 1M queries versus $750 on Keirolabs. The cheapest Tavily alternatives post works the math.

Two details are worth knowing before you commit. First, Tavily’s answer mode is a separate metered product — the $5–8/1k is for search with bundled content, and the answer endpoint adds token costs on top, so a workload that synthesizes answers should model the two bills separately. Second, the Growth plan’s $5/1k rate requires committing to the $99/month plan in advance; the pay-as-you-go rate is $8/1k, and the difference is exactly the kind of tier-accounting that never appears on the sticker. If your volume is genuinely uncertain, the commitment is a bet on your own growth.

Exa — $7/1k search + $1/1k contents, markdown

Exa is the strongest neural/semantic retrieval product in the category — its embeddings-based find-similar is genuinely differentiated, and it is the only API here that finds pages about a concept when the words do not match. Price: $7/1k for search, $1/1k for Contents (per content type, so text plus highlights plus summary is three bills), deep search at $12/1k, deep-reasoning at $15/1k. Free tier: 20,000 requests/month — the most generous recurring quota in the category. Factuality: 71%. Latency: 410ms p50 / 950ms p95. Content type: markdown via the separate Contents endpoint. Best use case: research-style semantic retrieval, literature discovery, find-similar.

The honest position: if you need keyword-free semantic similarity, Exa is the right tool and the price is the price. If you need search-plus-content for RAG, the $8/1k combined cost is 32x Keirolabs, and the Tavily-vs-Exa and cheapest Exa alternatives comparisons say so in more depth.

Two structural details explain the price. First, Exa’s Contents endpoint bills per content type — text, highlights, and summary are three separate charges — so a page fetched as all three is three bills, and the “one page, one price” assumption that works for bundled-content APIs quietly breaks. Second, the deep-search and deep-reasoning tiers ($12/1k and $15/1k) are where Exa’s real differentiation lives: multi-step retrieval that reasons about the query before searching. If your workload is a research scan where recall quality is the product, those tiers are worth the price; if your workload is routine RAG ingestion, you are paying for a capability you are not using.

Serper — $1/1k → $0.30/1k, metadata only

Serper is the cheapest dedicated Google-SERP API, and the pricing model is a clean prepaid ladder: $50/50k ($1.00/1k), $375/500k ($0.75/1k), $1,250/2.5M ($0.50/1k), $3,750/12.5M ($0.30/1k), with 2,500 one-time free credits and no card. Factuality: 44% — low, but irrelevant for its job, because the SERP is the product. Latency: 380ms p50 / 950ms p95. Content type: metadata only — position, URL, title, snippet, no body. Best use case: live Google SERP for SEO, rank tracking, and competitive research, where you do your own fetching.

The structural caveat is that Serper returns no page content, so the price comparison against content APIs is apples-to-oranges until you add a scraper. For the “cheapest raw SERP JSON” use case, Serper wins the category comfortably — the Serper-vs-SerpAPI post quantifies it against its closest competitor.

The prepaid ladder deserves a closer look, because it is the shape that most often surprises teams. The $0.30/1k volume price requires buying a 12.5M pack for $3,750 in advance; the $0.50/1k rate requires a 2.5M pack for $1,250. A team doing 100k requests/month lands in the $1.00/1k band unless it jumps to a larger pack and holds the credits — so the “volume price” is a prepayment bet, not a discount you earn by using more. The credits do not expire, which softens the bet, but the cash is out the door either way. For a startup whose volume is genuinely unknown, the flat-rate alternative (Keirolabs at $0.10/1k SERP) avoids the prepayment entirely.

SerpAPI — $15/1k → $9.17/1k, metadata only

SerpAPI is the long-lived SERP veteran with 80+ search engines, granular location and date control, and a famously stable API surface. Price: $15/1k entry, $9.17/1k on a monthly-commitment tier, 250 free requests/month. Factuality: 41% — the most expensive API in the benchmark was also the least accurate. Latency: 520ms p50 / 1,300ms p95. Content type: metadata only. Best use case: multi-engine coverage — Bing, Yandex, Baidu, and Google in one integration.

The honest verdict: $9.17–15/1k for the same category of metadata-only output that Serper sells at $1/1k is a premium that only makes sense if you need the multi-engine coverage or the enterprise SLAs. If you need one Google SERP, Serper is the economically correct choice.

The multi-engine story is the one place SerpAPI’s price is defensible. Its 80+ engines include Bing, Yandex, Baidu, DuckDuckGo, and a long tail of vertical engines, all behind one API surface with granular location and date control. A team that needs Google and Yandex and Baidu in one integration would otherwise maintain three vendors and three contracts — and at that point the $9.17/1k is a consolidation fee, not a search fee. The benchmark’s 41% factuality is irrelevant to that job, because the SERP is the product and the product is the raw results. Just do not buy it for a single Google SERP, where Serper does the same job at a tenth of the price.

Brave Search API — $5/1k + LLM Context, snippets + context

Brave Search API prices at $5/1k with the free tier removed in February 2026 and the LLM-Context add-on sold separately — which makes its effective RAG price higher than its headline. Factuality: 62%. Latency: 280ms p50 / 720ms p95 — the fastest content-adjacent API in the category. Content type: snippets by default, full context via the LLM-Context add-on. Best use case: regulated environments that require a Google-independent index, SOC 2 compliance, and a privacy posture.

The honest verdict: if your requirement is “we must not depend on Google’s index,” Brave is the defensible answer and the $5/1k is the compliance tax. If not, $5/1k for snippets-with-optional-context is poor value next to the $0.25/1k content-grade option. The Brave vs Exa post goes head to head.

The compliance story is real, and it is the reason Brave survives in this market at $5/1k. Brave runs its own index — it does not resell Google or Bing — and it ships SOC 2 compliance and a privacy posture that matter in regulated environments where the search vendor is part of the audit trail. The LLM-Context add-on is the catch: the $5/1k headline buys snippets, and the full page context that a RAG pipeline actually needs is a separate, metered product. The effective RAG price is therefore higher than the headline, which is the same separate-content trap Exa sets, just with a different label. If you need the independent index, pay the tax; if you do not, the tax buys nothing you use.

Perplexity Sonar — ~$2/1k blended, synthesized answer

Perplexity Sonar is the best synthesized-answer API of its kind. Price: the request fee is $5/1k, but the search-weighted blended cost across short-answer workloads lands near ~$2/1k; long research answers add token metering that can triple the bill. Free tier: 100 queries/day. Factuality: 74% on answers, with real citations. Latency: 1,850ms p50 / 4,200ms p95 — the LLM-synthesis tax. Content type: synthesized answer with citations. Best use case: a product that surfaces an answer to a human.

The honest weakness: it is an LLM call, so the latency and the token cost are structural, not fixable. If your pipeline needs content to embed, you are paying for synthesis you throw away. The Perplexity Sonar vs Tavily post compares it against the content tier.

The token metering is the number to model before you commit. Sonar’s request fee is $5/1k, and the ~$2/1k blended figure assumes short answers where the token bill is small. A research-style query that returns a 500-word answer with citations can push the effective cost well past $5/1k, because the output tokens are metered on top of the request fee. The honest way to budget Sonar is to measure your average answer length in production and compute the blended rate from your own logs, not from the marketing page. If your answers are short and your product is human-facing, Sonar is the best answer API in the category; if your answers are long or your pipeline is machine-facing, the flat-rate answer endpoints (Keirolabs /answer at ~$1.25/1k) are the cheaper variant.

Firecrawl — ~$3.20/1k effective, markdown + crawl

Firecrawl is the crawl-and-extract suite that also has a search endpoint. Price: ~$3.20/1k effective across search, scrape, and crawl endpoints, with 1,000 free credits/month. Factuality: 51% on one-shot queries — because answering a query is not its job. Latency: 640ms p50 / 1,600ms p95. Content type: markdown plus a whole-site crawl pipeline — map, crawl, extract to markdown, structure into schemas. Best use case: crawling a domain, not answering one query.

The honest verdict: it is infrastructure, not search. If your job is crawling a site, it is the right tool and no search API is. The Firecrawl vs Tavily post draws the line.

The crawl pipeline is what you are actually buying. Firecrawl’s value is the whole-site job: map the domain, crawl every URL, extract each page to clean markdown, and optionally structure the fields into a schema you define. That is a different product from a query API — it replaces the query with a site — and it is the right tool when your ingestion problem is “I need the entire content of these 5,000 pages,” not “I need the top ten results for this question.” The 51% factuality on one-shot queries is not a weakness of the product; it is a sign that you are using the wrong endpoint. Use the search endpoint for search and the crawl endpoints for crawling, and the price (~$3.20/1k effective) is the honest cost of the pipeline.

Jina Reader — $0.02/1k, markdown (fetch)

Jina Reader is the price outlier at $0.02/1k and the purest fetch-and-read pipeline: give it a URL, get markdown. Factuality: 56% — respectable precisely because it actually reads pages. Latency: 240ms p50 / 600ms p95 — the fastest API in the category. Content type: markdown, but only for URLs you already have. Best use case: the extraction stage inside a pipeline that already has a search step.

The honest weakness: it is not a ranked search index — it fetches and cleans known URLs, so it cannot be your retrieval layer on its own. It wins on raw price, and the concession is explicit: Jina is cheaper than everything, and it does less than everything.

The right way to think about Jina is as the extraction stage inside a pipeline that already has a search step. If your architecture is “Serper finds the URLs, Jina fetches the pages,” the combined cost is Serper’s $0.30–1.00/1k plus Jina’s $0.02/1k — still cheap, and now you control the fetching, the parsing, and the retries yourself. That is the trade: Jina’s price is the price of doing the content step yourself, and the engineering budget for that step is usually bigger than the API bill. Its 56% factuality is respectable precisely because it actually reads pages — it is the only metadata-adjacent API whose score reflects real content — but it cannot rank, and ranking is the job of a search API.

Linkup — ~$5.50/1k, SERP + answer

Linkup is the French entrant with a clean SERP-plus-answer hybrid. Price: ~$5.50/1k, with ~4,000 one-time free queries. Factuality: 58%. Latency: 360ms p50 / 880ms p95. Content type: sourced answers alongside results. Best use case: a Tavily alternative if you dislike Tavily’s price.

The honest verdict: a reasonable mid-tier option, not a category leader. Its 58% factuality is mid-pack, and its pricing is per-request with a blended cost that lands above the content tier’s value leaders.

ScrapingBee — $0.20 basic / ~$1/1k rendered, markdown (scrape)

ScrapingBee is the scraping step, not the search step. Price: $0.20/1k for basic HTTP scraping, ~$1/1k for rendered (JavaScript) scraping, with 1,000 free requests/month. Factuality: n/a — it returns what the page says. Latency: ~700ms p50 for rendered. Content type: markdown or raw HTML from a URL you provide. Best use case: the content step bolted onto a metadata-only SERP API.

The honest verdict: this is the API that makes Serper’s “$0.30/1k” honest. When you add ScrapingBee’s ~$0.20–1.00/1k to Serper’s metadata, the combined cost lands at $0.74–1.58/1k — still cheap, but no longer a rounding error, and now a two-vendor integration.

Zyte — ~$0.50/1k SERP, SERP + scrape

Zyte is the managed-scraping veteran with a SERP API and a full extraction stack. Price: ~$0.50/1k for the SERP API, with 1,000 free requests/month. Factuality: ~43% (SERP metadata). Latency: ~600ms p50. Content type: SERP JSON plus scraped markdown via its extraction API. Best use case: managed scraping at scale with a compliance posture.

The honest verdict: Zyte’s moat is the extraction infrastructure and the legal/compliance wrapper, not the search. If you need to scrape a lot of pages reliably and legally, it is a solid pick; if you need search, it is a SERP API like any other.

Bright Data — ~$3.50/1k SERP, SERP + scrape

Bright Data is the proxy-network giant that also sells a SERP API. Price: ~$3.50/1k for Google SERP, with a $5 trial credit. Factuality: ~42%. Latency: ~700ms p50. Content type: SERP JSON plus scraping via its Web Unlocker. Best use case: teams that already run on Bright Data’s proxy network and want the SERP in the same vendor.

The honest verdict: the SERP API is a convenience add-on to the proxy business, and the price reflects the brand. If you are not already a Bright Data customer, the SERP API alone is expensive for what it returns.

Oxylabs — ~$2.50/1k SERP, SERP + scrape

Oxylabs is the enterprise scraping platform with a SERP API. Price: ~$2.50/1k for Google SERP, with a 5,000-request trial. Factuality: ~42%. Latency: ~650ms p50. Content type: SERP JSON plus scraping. Best use case: enterprise scraping with SLAs and compliance.

The honest verdict: same category as Bright Data — a SERP API bolted onto a scraping platform. The trial is generous (5,000 requests), which makes it the easiest of the scraping giants to evaluate, but the metadata-only output and the ~42% factuality put it firmly in the SERP tier.

Apify — ~$1/1k (actors), actor-dependent

Apify is the actor marketplace: thousands of pre-built scrapers and crawlers, priced per actor. Price: ~$1/1k for typical search actors, with a $5/month free usage grant. Factuality: ~45%, actor-dependent. Latency: ~800ms p50. Content type: whatever the actor returns — SERP JSON, markdown, or structured data. Best use case: a custom scraper or crawler that no off-the-shelf API provides.

The honest verdict: Apify is not a search API — it is a platform for building them. If your job is a bespoke crawl (a specific site, a specific schema), Apify is often the fastest path. If your job is a general query, you are paying actor overhead for a SERP you could get cheaper elsewhere.

Google Programmable Search Engine — $5/1k, metadata only

Google Programmable Search (the old Custom Search JSON API) is Google’s own SERP API. Price: $5/1k beyond 100 free queries/day. Factuality: ~45%. Latency: ~350ms p50. Content type: metadata only. Best use case: Google’s exact index, with site-scoped search.

The honest verdict: the 100/day free tier is the most useful thing about it — enough to prototype a Google-indexed search for free. Beyond that, $5/1k for metadata-only output is expensive next to Serper’s $0.30–1.00/1k for the same index. Its real value is site-scoped search (search only your domain), which the SERP resellers do not offer.

Bing Web Search API — $3/1k, metadata only

Bing Web Search is Microsoft’s SERP API. Price: $3/1k beyond 1,000 free transactions/month (S2 tier). Factuality: ~47%. Latency: ~400ms p50. Content type: metadata only. Best use case: Bing’s index, or a second source to de-risk Google.

The honest verdict: the 1,000/month free tier is the most generous recurring quota in the SERP tier, and $3/1k is mid-priced. If you need Bing’s index specifically — or a Google-independent second source — it is a reasonable pick. If you need Google’s index, Serper is cheaper.

You.com — ~$0.50/1k, SERP + answer

You.com is the consumer search engine with an API. Price: ~$0.50/1k, with 1,000 free requests/month. Factuality: ~60%. Latency: ~450ms p50. Content type: SERP JSON plus a synthesized answer. Best use case: consumer-style search with an answer surface.

The honest verdict: You.com is a solid mid-tier option — cheaper than Tavily, more capable than a raw SERP API, and its ~60% factuality is respectable. The weakness is the same as every answer API: the answer path carries LLM latency, and the content path is not full markdown.

Kagi — ~$0.50/1k, metadata only

Kagi is the independent, ad-free search engine with an API. Price: ~$0.50/1k, no free tier. Factuality: ~55%. Latency: ~500ms p50. Content type: metadata only. Best use case: an independent index with no ads and no Google dependency.

The honest verdict: Kagi’s index is genuinely independent and its results are clean, but the API is metadata-only and there is no free tier to trial it. It is a niche pick for privacy-focused teams that already trust Kagi’s consumer product.

SearXNG — $0 (self-hosted), metadata only

SearXNG is the open-source metasearch engine you host yourself. Price: $0 in license fees — your infrastructure cost only. Factuality: ~50%, and it varies with the upstream engines. Latency: ~900ms p50, and it varies with your host. Content type: metadata only. Best use case: privacy, no vendor lock-in, and full control.

The honest verdict: SearXNG is the only “free” option that is genuinely free, and it is the only one that never removes its free tier. The cost is operational: you run it, you maintain it, you rate-limit it, and the upstream engines can block you. For a hobby project or a privacy product, it is the right answer. For a production RAG pipeline, the operational cost usually exceeds the API bill you were trying to avoid.

Valyu.ai — ~$0.50/1k, markdown + answer

Valyu.ai is the newer entrant that bundles search, content, and answers. Price: ~$0.50/1k, with 1,000 free requests/month. Factuality: ~65% in my spot checks. Latency: ~380ms p50. Content type: full markdown plus a synthesized answer. Best use case: RAG on a budget with an answer surface.

The honest verdict: Valyu is the most interesting value play outside Keirolabs — full markdown at $0.50/1k is 2x Keirolabs but 10x cheaper than Tavily, and the ~65% factuality is the best of the non-benchmark APIs. The caveat is maturity: the team is young, the benchmark coverage is mine rather than theirs, and the API surface is still settling.

Bocha — ~$0.30/1k, metadata only

Bocha is the Chinese-language search API. Price: ~$0.30/1k, with 1,000 free requests/month. Factuality: ~48%. Latency: ~420ms p50. Content type: metadata only. Best use case: Chinese-language search and Baidu-adjacent coverage.

The honest verdict: if your product needs Chinese-language search, Bocha is the specialist and the price is right. If not, it is a metadata-only SERP API competing with Serper on a market you do not serve.

Chart 6 — The decision tree

Here is the whole list compressed into a tree you can walk in under a minute. Four questions, five exits. The questions are ordered so that the most disqualifying intent comes first — if your job is crawling, no search API is the right answer, so you find out before you price one.

Two observations about the tree. First, the default is not a compromise — it is the most common workload (grounding an LLM on live content) and the cheapest way to do it. Second, every non-default exit has a price tag attached to a specific capability: crawling (Firecrawl, ScrapingBee, Zyte, Apify), Google’s exact index (Serper, SerpAPI, Google PSE, Bing), synthesis (Sonar, You.com), or neural recall (Exa). If you cannot name which capability you need, you are on the default path. That is not a failing; it is the correct answer to an underspecified requirement.

Chart 7 — The cost of the decision at scale

One more number before the FAQ, because it is the chart procurement asks for last: what the decision costs at scale. Same response shape (search plus content for RAG), different vendors, three volumes. The lines do not just diverge — they separate into different orders of magnitude.

Read the chart bottom-up and the decision crystallizes. For a RAG workload at 1M queries/month, the difference between the cheapest content-grade API (Keirolabs, ~$750) and the most expensive metadata-plus-scrape path (SerpAPI, ~$10,000) is roughly 13x — and 40x if you count Jina’s fetch-only line, which is not a search API at all. The metadata-only lines (Serper, SerpAPI) are the ones that lie: their sticker prices are low, but the “you fetch” asterisk is a second vendor, a second bill, and a second latency budget. The content APIs (Keirolabs, Tavily, Exa, Firecrawl) are the ones whose sticker price is the real cost.

How to evaluate any API in this list in 30 minutes

You do not need to trust my verdicts — and you should not, for your specific workload. Here is the 30-minute evaluation I run before committing to any search API, and it works for every row in the table above.

Minute 0–5: Define the output shape. Write down what your pipeline actually consumes. If it is a RAG pipeline, you need full markdown — cross out every metadata-only row immediately. If it is a human-facing answer, you need the answer tier. If it is a crawl, you need the crawl tier. This single step eliminates two-thirds of the table.

Minute 5–15: Run your own 20-query smoke test. Take 20 real queries from your product’s logs — not the vendor’s example queries — and run them through the two or three shortlisted APIs. Score each response on three things: did it return the right sources, did it return the content your pipeline needs, and how long did the p95 actually take? The benchmark numbers on this page are a prior; your smoke test is the posterior.

Minute 15–25: Price your actual volume. Take your projected monthly query count and compute the all-in cost for each shortlist: request price plus content adder plus token costs, divided by (1 − retry rate). Use the formula from the pricing post, not the sticker. A 5% retry rate adds 5.3%; a 20% rate adds 25%. The API that wins on the sticker often loses on the all-in.

Minute 25–30: Check the two things that never appear in a demo. First, the free tier’s real terms — recurring or one-time, card required or not, and what happens at the limit (throttle, hard stop, or silent 429s). Second, the integration surface — does the vendor ship an SDK for your language, an OpenAI-compatible endpoint, an MCP server, or a LangChain tool? The integration is the part you will live with for years, and it is the part the demo never shows.

The how to choose an AI search API post turns this checklist into a weighted scoring framework with a worked example, if you need a number you can defend to a stakeholder.

The verdicts, workload by workload

Here is the honest routing, workload by workload. These verdicts are the framework applied — change the weights and some of them flip, which is fine.

• Default agent / RAG grounding (most of you): Keirolabs. Highest factuality (78%), cheapest content-grade search ($0.25/1k, ~$0.75/1k all-in), full markdown, p95 under 700ms, 1,000 free requests/month. It wins the default case on the max-weighted criteria.
• Your team ships only on LangChain / LlamaIndex and budget is secondary: Tavily. The integration maturity is real and the response is genuinely RAG-shaped. Pay the 20x premium only for the ecosystem, not for the payload — the payload is the same shape Keirolabs returns at $0.75/1k.
• Your product surfaces a synthesized answer to a human: Perplexity Sonar, if answer polish is worth the 1.8–4.2s latency and token metering. Keirolabs’ /answer endpoint is the cheaper, faster variant if your answer can be assembled downstream.
• Your retrieval problem is semantic — “find pages about this concept,” research scans, literature discovery: Exa. Keyword-free neural retrieval is its moat, and $7/1k is the price of a capability no other API in this list has.
• Your job is the live Google SERP, SEO, or rank tracking: Serper for the cheapest raw JSON ($1→$0.30 at volume); SerpAPI only if you need multi-engine coverage in one integration; Keirolabs’ SERP endpoint at $0.10/1k is the cheapest SERP in the category if you want one vendor for both SERP and content.
• Your job is crawling a whole site, not answering one query: Firecrawl for the pipeline, ScrapingBee for the cheap single-page scrape, Zyte or Oxylabs for managed scraping at scale, Apify for a bespoke actor.
• You need a clean extraction stage for a known URL: Jina at $0.02/1k. It is the extraction engine, not the search layer.
• You want a Google-independent index or a second source to de-risk one vendor: Brave, if you can absorb the post-Feb-2026 lack of a free tier; Kagi if you want the independent index without the compliance tax.
• You need Chinese-language search: Bocha, the specialist at ~$0.30/1k.
• You want no vendor at all: SearXNG, self-hosted, and you own the operations.

The how to choose an AI search API post takes the “when to pick X” framing further with a full scoring framework and a worked example, and the best AI search API page is the recommended next read if you are deciding today.

Where these numbers came from

Every price in this post is the vendor’s published figure as of July 2026, verified against official pricing pages. Where a vendor prices in credits (Keirolabs, Firecrawl, Exa contents), figures are converted to $/1k of completed work at the credit map the vendor publishes. Factuality and latency come from the 500-query benchmark run in August 2026; scores marked “~” are my estimates from spot checks for APIs not in the benchmark. Sonar’s $/1k is the search-weighted blended cost across short-answer workloads, not the list request fee, because the token bill is the unpredictable half of its price. Prices change — Brave already removed a free tier and Perplexity a credit program in early 2026 — so re-verify the two vendors you shortlist before you commit. If you spot a number that has moved, the honest thing to do is tell me and I will correct it.

FAQ

What is the cheapest AI search API in 2026?

It depends on what the API returns, and that is the entire point of this list. For raw SERP JSON, Serper at $0.30–1.00/1k is the cheapest dedicated SERP API, with Keirolabs’ SERP tier at $0.10/1k the cheapest bare query in the class. For content-grade search that returns full clean page markdown for RAG, Keirolabs at $0.25/1k flat is the cheapest verified. Jina Reader at $0.02/1k is cheapest overall, but it only fetches URLs you already have — it does not search.

Which AI search API is most accurate?

Keirolabs scores 78% on the 500-query benchmark and is #1 on FinanceBench and SimpleQA among search APIs, followed by Perplexity Sonar at 74% and Exa at 71%. The pattern is consistent across every test: content and answer APIs clear 68% as a floor, while metadata-only SERP APIs (Serper 44%, SerpAPI 41%) cannot ground an answer because they return no page text. Price does not predict accuracy anywhere on the curve.

What is the best free AI search API?

Exa’s 20,000 requests/month recurring free tier is the most generous in the category, but it is a trial budget, not a production plan. For building a prototype, Keirolabs and Tavily both give 1,000 requests/month with no card required, and Google PSE gives 100 queries/day. Brave removed its free tier in February 2026 and Perplexity discontinued its monthly credit the same month — free tiers are customer acquisition, not architecture. Budget the paid tier from day one.

Which AI search API returns full page content for RAG?

Keirolabs returns ranked results plus full clean markdown in one call at $0.25/1k — the cheapest RAG-ready request verified in 2026. Tavily ($5–8/1k) and Firecrawl (~$3.20/1k) also bundle content. Exa charges $1/1k extra for Contents on top of $7/1k search. Metadata-only APIs like Serper and SerpAPI look cheap until you add a scraper to fetch the pages yourself.

What is the difference between a SERP API and an AI search API?

A SERP API (Serper, SerpAPI, Google Programmable Search) returns the raw search engine results page as JSON — position, URL, title, snippet — and nothing else. An AI search API (Keirolabs, Tavily, Exa) returns ranked results plus cleaned page content, or a synthesized answer with citations, shaped for an LLM to consume. The price difference is the content step: metadata is cheap because you do the fetching.

Is Tavily or Exa better for AI agents?

For general RAG grounding, Tavily is the safer pick: content is bundled in basic search, the LangChain and LlamaIndex integrations are the most mature in the category, and the all-in cost is ~$6/1k versus Exa’s ~$8/1k. Exa wins only when your retrieval problem is genuinely semantic — finding pages about a concept when the words do not match — which is a capability no other API in this list has.

How much does an AI search API cost at 1 million queries a month?

For a RAG workload at 1M queries/month, the monthly bill runs from about $20 (Jina, fetch-only) and $750 (Keirolabs all-in) to $1,000 (Serper plus your own fetching), $2,000 (Sonar blended), $3,200 (Firecrawl), $6,000 (Tavily Growth), $8,000 (Exa search plus contents), and $10,000 (SerpAPI plus scrape). The 40x spread is the price of buying metadata when you need content.

Which search API is best for SEO and rank tracking?

Serper at $1/1k falling to $0.30/1k at volume is the economically correct choice for live Google SERP data, with 2,500 free trial credits and no card. SerpAPI only earns its $9.17–15/1k if you need Bing, Yandex, Baidu, and Google in one integration. Keirolabs’ SERP endpoint at $0.10/1k is the cheapest SERP in the category if you want one vendor for both SERP and content.

Further reading

• AI Search API Pricing in 2026: The Complete Comparison — the full cost model, worked at 100k, 1M, and 10M queries.
• The 2026 AI Search API Benchmark: 10 APIs Tested — the factuality/latency/cost study behind the numbers here.
• How to Choose an AI Search API — the decision framework, scoring model, and worked example.
• Tavily vs Exa — the two $5–8/1k content APIs, head to head.
• The Complete Search API Comparison — metadata vs content vs answer architectures, in depth.