SerpAPI vs Tavily: Price per 1,000 Searches, Tokens and Failed Calls

SerpAPI costs $7.25 to $25 per 1,000 searches and Tavily $5 to $8. We compare the tokens each hands to a model, page reads, failed calls and MCP setup.

Hand-drawn illustration: a large balance on a black background. The left pan sinks under a tall pile of sheets with nested, indented lines. The right pan rises with only three neat cards, the top one marked in yellow. A magnifier lies at bottom right and a yellow four-point star sits at top right.

We read both pricing pages on November 22, 2026. SerpAPI charges $25 per 1,000 searches on its Starter plan and $7.25 per 1,000 on Searcher, the plan with 100,000 searches a month. Tavily charges 1 credit for a basic search. That is $5 per 1,000 on the Growth plan and $8 per 1,000 on pay as you go. At noon the same day we made live web search calls on EveryInfra, and each one charged $0.000694, or $0.694 per 1,000.

The bigger gap is in what each service hands to the model. The sample "coffee" response in the SerpAPI docs has 14 blocks and 9 organic results. It is about 16,599 tokens with the cl100k_base tokenizer, and only 523 of those tokens are titles, links and snippets. Tavily's documented defaults (10 results, up to 3 chunks per result, about 500 characters per chunk) give an upper limit of about 3,868 tokens.

Our own web responses averaged about 973 tokens as returned over 5 queries, and about 703 with the same three fields only. SerpAPI also has a rule that is easy to leave out of the math. Google sometimes sends the AI Overview in a second request, and that request counts as a search.

Diagram: a search box feeds two conveyor belts that lead to a glowing chip. The upper belt sags under a heavy crate of pages; the lower belt carries three thin cards, the first one teal. One search returns the whole page structure; the other returns a few cleaned passages.
Same search: SerpAPI returns the whole results page structure, Tavily returns a few cleaned passages. The model reads about ten times more in the first case. Diagram made by EveryInfra

Our sources for prices and rules are the SerpAPI pricing page, Google Search API docs and Extract API docs. On the Tavily side, they are the pricing page, credits page and search reference. We read them between 12:43 and 12:47 Singapore time on November 22, 2026; all times below are Singapore time. We did not open an account with either company and did not call their APIs. Every number on their side comes from their public rules, and we kept a copy of each page we read. The EveryInfra numbers come from billing.charged_usd in three rounds of live calls between 12:43 and 12:59 Singapore time.

SerpAPI vs Tavily at a glance: billing unit, free tier and failure rules

SerpAPI bills by the search. One successful search counts as 1, whether it returns 100 results or none. It sells parsed results pages from Google, Bing, DuckDuckGo, YouTube, Amazon and more than a hundred other sources. Its pricing page lists over 160 APIs. Tavily bills by the credit.

A basic search costs 1 credit, an advanced search costs 2, and Extract, which reads page text, costs 1 credit per 5 successful URLs. Tavily does not sell the raw page of any one search engine. It returns content that it has picked, split into chunks and scored for relevance. Because the units differ, you have to turn both into dollars for the same job before you compare them.

ItemSerpAPITavily
Billing unit1 per successful search (same price on every engine)Credits: basic search 1, advanced 2
Free tier250 searches a month, 50 an hour1,000 credits a month, no card
Entry paid optionStarter $25 a month for 1,000Pay as you go at $0.008 a credit, or Project $30 for 4,000
Middle plansDeveloper $75/5,000; Production $150/15,000; Big Data $275/30,000Bootstrap $100/15,000; Startup $220/38,000
Upper plansSearcher $725/100,000, then cloud plansGrowth $500/100,000, then custom enterprise pricing
Failed callsCached, errored and failed searches do not count; empty results count as 1Failed Extract URLs and failed Map calls are free
CacheSame parameters within 1 hour hit the cache for freeDocs do not say cache hits are free; max_age_hours picks cache or live fetch
Allowance resetResets on your renewal date; optional early renewalResets on the 1st of each month, whatever your billing date
When you run outRenew early, by hand or automaticallyRequests stop unless pay as you go is on
Read page textExtract API, 1 search per pageExtract, 1 credit per 5 URLs
Format for modelsJSON; output=md gives Markdown at the same priceCleaned content per result, plus optional answer and raw_content
Rate limitsBy plan: Starter 200 an hour, Searcher 20,000 an hourBy organization: free 100 a minute, paid 1,000, Growth 1,500
Remote MCPmcp.serpapi.com, key in a header or the pathmcp.tavily.com, OAuth or key, keyless trial
Screenshot: the FAQ on the SerpAPI pricing page, with a teal box around the question "How are searches counted?" and its answer. Only successful searches count toward the monthly total. Cached, errored and failed searches do not. The number of results does not matter, so a search with 100 results and a search with no results each count as 1.
SerpAPI counts only successful searches, and an empty result still counts as 1. Screenshot of the SerpAPI pricing page, November 22, 2026, 12:51 Singapore time

The SerpAPI AI Overview API docs say that a cached search only hits when the query and every parameter match. The cache expires after 1 hour, and "Cached searches are free". If an agent searches the same term several times within an hour, the later searches cost nothing. The trade is that the results can be up to an hour old. To force a fresh fetch, add no_cache=true.

The Tavily pricing FAQ says credits reset on the 1st of each month, whatever your billing date. When the credits run out, requests stop unless you upgrade or turn on pay as you go.

Its search reference lists two special error codes. 432 means the key or plan allowance is used up. 433 means you passed your pay-as-you-go limit. The rate limit docs only cover 429 for going too fast and 434 for high load.

SerpAPI counts by whether each search succeeded. Tavily counts by how many credits are left this month. So the same monthly volume gives two bills with a different shape.

How far a free tier goes also depends on the unit. The SerpAPI free tier gives 250 searches a month and 50 an hour. Say a prototype agent searches twice and reads 3 pages for each question. That is 5 searches, so the free tier covers about 50 questions a month. The Tavily free tier gives 1,000 credits a month. The same question costs 2 searches plus 1 Extract credit, or 3 credits, so it covers about 330 questions.

Neither free tier rolls over. SerpAPI resets on your account's monthly cycle and Tavily resets on the 1st. EveryInfra has no monthly free allowance and charges per call. The trial credit for new accounts and the top-up options are on the pricing page. For a developer who only wants to see the flow work, Tavily's keyless mode is the lowest bar, since you do not even sign up. A free SerpAPI key needs an account first.

Price per 1,000 searches: from entry plan to lowest plan

To get the price per 1,000, divide the plan price by the monthly allowance. The plan data embedded in the SerpAPI pricing page lists 183 plans, including Ludicrous Speed versions at 2 and 4 times the price. There are 7 named plans at standard speed, and above them are cloud plans from Cloud 1M to Cloud 54M. The Tavily credits page lists 4 monthly plans and a pay-as-you-go rate.

The table below only shows the price per 1,000 basic searches. For all 61 standard-speed SerpAPI plans, see our SerpAPI pricing breakdown. For the credit cost of each Tavily endpoint, see how many credits each Tavily call uses.

TierSerpAPI price / searches a monthSerpAPI per 1,000Tavily price / credits a monthTavily per 1,000 basic searches
Free$0 / 250—$0 / 1,000—
EntryStarter $25 / 1,000$25.00Pay as you go, $0.008 a credit$8.00
SmallDeveloper $75 / 5,000$15.00Project $30 / 4,000$7.50
MiddleProduction $150 / 15,000$10.00Bootstrap $100 / 15,000$6.67
Upper middleBig Data $275 / 30,000$9.17Startup $220 / 38,000$5.79
100,000 a monthSearcher $725 / 100,000$7.25Growth $500 / 100,000$5.00
1,000,000 a monthCloud 1M $3,750 / 1,000,000$3.75Custom enterpriseNot public
EveryInfra webPer call, no monthly fee$0.694 (charged)——

The two come closest at 100,000 searches a month: SerpAPI Searcher is $7.25 and Tavily Growth is $5.00, so Tavily is about 31% cheaper. Lower down, the SerpAPI entry plan costs more. At 1,000 searches a month, you pay $0.025 a search on SerpAPI Starter and $0.008 on Tavily pay as you go. That is a gap of more than 3 times. Higher up, SerpAPI publishes cloud plans that bring the price down to $3.75 and even $1.96 per 1,000, while Tavily only says "Custom" above Growth.

So Tavily is much cheaper at low volume, and the two are about 30% apart near 100,000 searches. Above a million searches, only SerpAPI shows a price you can buy from a web page. EveryInfra web charges $0.000694 per call with no monthly fee or tiers. In the chart below it is the short line at the far left, about 65% below the lowest public SerpAPI cloud plan.

Horizontal bar chart on a log axis showing USD per 1,000 searches. SerpAPI: Starter $25.00, Developer $15.00, Production $10.00, Big Data $9.17, Searcher $7.25, Cloud 1M $3.75, lowest cloud plan Cloud 54M about $1.96. Tavily basic search: pay as you go $8.00, Project $7.50, Bootstrap $6.67, Startup $5.79, Growth $5.00. EveryInfra web charged $0.694, the shortest bar, in teal.

What the model has to read: 16,599 tokens for a SerpAPI sample, about 3,868 for Tavily

An AI agent that calls a search API pays two bills. One is the search API bill. The other is the input tokens the model reads when it gets the results. We could not get live responses from either service without an account, so we measured the material each company publishes.

The SerpAPI Google Search API page contains a full sample response for the query "coffee" in Austin, created on 2021-12-07. The Tavily search reference says how the content field is built from chunks. It also gives the chunk length and the default number of chunks. Our method: minify the JSON to one line and count tokens with the cl100k_base tokenizer. We count two versions on every side: the full response as returned, and title, link and snippet only. Each model family uses a different tokenizer, so read these numbers as orders of size.

What the model getsBytesTokens (cl100k_base)Notes
Full SerpAPI sample JSON43,19316,59914 blocks: metadata, recipes, shopping, local map, local results, knowledge graph, related questions, 9 organic results, related searches, pagination and more
Same sample, organic_results only16,2885,159Same as json_restrictor=organic_results
Same sample, title, link and snippet only2,2955239 results, three fields each
Tavily default upper limit (from docs)about 15,000 charactersabout 3,86810 results × up to 3 chunks × about 500 characters; 3.88 characters per token, taken from our English snippets
EveryInfra web full response, mean of 5 queriesabout 3,414about 973Outer id, tool, billing and quota; title, url and snippet per result, some with published; 5 to 10 results
Same 5 queries, title, link and snippet onlyabout 2,640about 703Three fields per result, the same cut as the SerpAPI row
EveryInfra deep with full text72,092 characters16,9205 results, page text cut at 20,000 characters each
Horizontal bar chart of tokens one search hands to the model. Full SerpAPI docs sample "coffee": 16,599; organic_results only: 5,159; title, link and snippet only: 523. Tavily default, estimated: about 3,868. EveryInfra web, mean of five live queries: about 973 as returned and about 703 with three fields, in teal. EveryInfra deep with full text, 5 results: 16,920.

If you pass the full SerpAPI JSON to a model, 9 results take 16,600 tokens. The title, link and snippet tell the model what each result is about, and they are only 3.2% of that. The rest is redirect links, thumbnail URLs, sitelinks, rich snippets, the knowledge graph and local businesses. Those blocks matter for rank tracking and local SEO, but for an agent that only wants an answer they are noise.

The SerpAPI Markdown output page says that output=md saves about half of the tokens on average. Google Search drops from 150K to 39K, a 74% saving, and deeply nested APIs such as shopping and hotels save about 90%. The price is the same as JSON, 1 search per call. At the 74% average it gives for Google Search, the "coffee" sample would be about 4,300 tokens in Markdown. That is an estimate from its published rate; we did not measure a Markdown copy.

With json_restrictor you keep only the blocks you need. Then 16,600 tokens can shrink to a few hundred or a few thousand. Tavily's defaults are set for feeding a model. Each result has 3 chunks of about 500 characters, so 10 results are about 3,900 tokens. If you turn on include_raw_content, you get the full page text. Then the size is the same order as our deep with full text: more than 10,000 tokens.

Our two rows need the same care. The full web response is 238 to 305 tokens larger than the three-field version. The extra part is the outer request ID, tool name, billing and quota data, plus the published date on some results. It is the same kind of data as search_metadata and search_parameters in the SerpAPI sample. So a fair test compares full with full, and three fields with three fields. Here are the 5 queries one by one:

QueryResultsTokens, full responseTokens, three fields
serpapi vs tavily101,132827
best burr coffee grinder 20269961691
python 3.14 release date5668430
nvidia q3 fiscal 2027 earnings91,084825
docker permission denied var run docker.sock101,020743

Per result, our full response is about 100 to 135 tokens and the three-field version about 75 to 92. The SerpAPI sample with three fields is 523 tokens for 9 results, about 58 per result, so its snippets are shorter than ours. As returned, the gap comes from the blocks: 16,599 for one SerpAPI sample and under 1,200 for one of our responses.

Screenshot: the "Token savings by API" table on the SerpAPI Markdown output page, inside a teal box. Google Search: JSON 150K, Markdown 39K, 74% saved. Google Shopping: 361K to 38K, 90%; Google Hotels: 202K to 22K, 89%; Apple Maps: 494K to 43K, 91%. Amazon: 191K to 97K, 49%; DuckDuckGo: 32K to 12K, 64%; Bing Shopping: 214K to 103K, 52%; Walmart: 106K to 68K, 36%.
SerpAPI's own numbers: Markdown output saves about half of the tokens on average (36% to 91% on these eight APIs), at the same price. Screenshot of the SerpAPI Markdown Output page, November 22, 2026, 12:51 Singapore time

Multiply by the price per million input tokens. Per 1,000 searches as returned, the SerpAPI sample is about 16.6 million input tokens and EveryInfra web about 973,000. With three fields only, SerpAPI is about 523,000 and EveryInfra about 703,000. The Tavily default upper limit is about 3.87 million. Add the search bill and you have the full cost of 1,000 searches. The table assumes two round prices, $1 and $3 per million input tokens, so you can swap in your own model's price:

Handed to the model per 1,000 searchesInput tokensAt $1 per millionAt $3 per million
SerpAPI sample, as returnedabout 16.6 million$16.60$49.80
SerpAPI sample, three fieldsabout 523,000$0.52$1.57
Tavily default upper limitabout 3.87 million$3.87$11.60
EveryInfra web, as returnedabout 973,000$0.97$2.92
EveryInfra web, three fieldsabout 703,000$0.70$2.11

At $1 per million, the token cost of the full SerpAPI response is $16.60, more than twice the $7.25 Searcher search fee. Trimmed to three fields it is $0.52. At $3 per million the two are $49.80 and $1.57. So on SerpAPI, trimming the response saves more than switching to Tavily saves on the search fee ($2.25 per 1,000).

Making the SerpAPI response smaller: three ways

Maybe you pick SerpAPI but do not want the model to read 16,000 tokens on every call. There are three ways to cut the size, and none costs extra. The first is json_restrictor. You list the blocks and fields to keep, for example organic_results[].{title,link,snippet}, and the server returns only those. On the sample, that leaves 523 tokens. The second is output=md, which returns Markdown.

By SerpAPI's own table, Google Search shrinks by 74% on average, and nested APIs such as shopping, hotels and maps shrink by about 90%. The third is to trim in your own code. That lets you keep fields such as position and source that you may need later, but you still pay for the transfer and the parsing. The Python below uses the first way. The parameter names follow the SerpAPI json_restrictor docs, and the key comes from an environment variable.

python
import os, requests

params = {
    "engine": "google",
    "q": "serpapi vs tavily",
    "api_key": os.environ["SERPAPI_API_KEY"],
    # keep only the title, link and snippet of organic results
    "json_restrictor": "organic_results[].{title,link,snippet}",
}
data = requests.get("https://serpapi.com/search.json", params=params, timeout=60).json()
for r in data.get("organic_results", []):
    print(r["title"], r["link"])

After trimming, the SerpAPI response is the same order of size as the EveryInfra web response. Both come to a few hundred thousand to about a million tokens per 1,000 searches. Two differences remain. SerpAPI can give you the full page structure again when you need it, for example for the AI Overview or local results. You just remove the restriction. EveryInfra web returns title, link and snippet per result, some with a publish date, and for page text you call read or deep.

Search once and read 5 pages: how many charges for the most common agent step

After a search, an agent usually reads some pages. Both services can do that, but they count it in different ways. The SerpAPI Extract API, launched on October 13, 2026, counts 1 search per page read. Failed pages and cache hits do not count. A site crawl can go up to max_pages of 100, at 1 search per page.

So "search once and read the top 5 pages" is 6 searches on SerpAPI. Tavily has two paths. You can search and then send the 5 URLs to Extract: 1 credit for the search plus 1 for Extract (1 credit per 5 successful URLs), so 2 credits. Or you can add include_raw_content to the search. The Tavily credits page says the search price depends only on search_depth. It lists no extra charge for full text, so that is 1 credit.

One task: 1 search + read the top 5 pagesChargesPer 1,000 tasks (cheapest self-serve plan)Per 1,000 tasks (entry option)
SerpAPI: Google search + Extract 5 pages6 searches$43.50 (Searcher)$150.00 (Starter)
Tavily: search + Extract 5 URLs2 credits$10.00 (Growth)$16.00 (pay as you go)
Tavily: search with include_raw_content1 credit$5.00 (Growth)$8.00 (pay as you go)
EveryInfra: 1 web + 5 read6 × $0.000694$4.16 (charged)Same, no tiers
EveryInfra: 1 deep with full text1 × $0.000694$0.694 (charged, 5 results per call)Same
Horizontal range bar chart on a log axis: USD for 1,000 runs of "search once and read the top 5 pages". SerpAPI search plus Extract of 5 pages: $43.50 to $150.00. Tavily search plus Extract of 5 URLs: $10.00 to $16.00. Tavily search with include_raw_content: $5.00 to $8.00. EveryInfra web plus 5 read calls: $4.16; EveryInfra deep with full text: $0.694, both in teal.

Once the agent reads pages, the gap gets wide. On search alone, Tavily is about 30% cheaper at the 100,000 tier. On search plus reading, Tavily through Extract is about 77% cheaper, and search with full text is about 89% cheaper. The reason is the unit: SerpAPI charges per page, and Tavily Extract charges 1 credit per 5 pages.

When an agent reads 20 pages, SerpAPI counts 21 searches, and Tavily search plus Extract is 1 + 4 = 5 credits. At the 100,000-a-month plans, 1,000 such tasks cost 21 × $7.25 = $152.25 on SerpAPI Searcher and 5 × $5 = $25 on Tavily Growth. On EveryInfra, 1 web plus 20 read calls is 21 × $0.694, about $14.57. The more pages the agent reads, the wider the per-page gap: at 20 pages SerpAPI costs 6 times what Tavily does.

On the EveryInfra side, read costs $0.000694 per page. deep with full turned on returns 5 results with their page text for the same $0.000694. At 12:46:07 Singapore time we ran deep with full text for "serpapi vs tavily". The page text of the 5 results was 238, 20,000, 20,000, 20,000 and 9,992 characters, and the call charged $0.000694.

But that call took 48.1 seconds on our local clock, an order of size slower than web. When speed matters, use web and call read only for pages you need. For batch jobs that want everything at once, use deep.

The second request for the Google AI Overview: it counts as a search

The SerpAPI AI Overview page describes a special case. Google sometimes sends the AI Overview in a separate request. When that happens, the SerpAPI response only contains a page_token and a serpapi_link. To get the Overview text, you must call the Google AI Overview API within 1 minute.

That second call is another search and counts as usual. For an SEO tool that only reads organic results, the bill does not change. For an agent that uses the AI Overview as an answer source, one question can count as 2 searches.

We did not measure how often this happens. We cannot test it without a SerpAPI account, and we found no public raw data we could check. The bill moves in a straight line with the rate. If a share x of your queries needs a second request, 1,000 questions cost $7.25 × (1 + x) on Searcher. The rates in this table are assumptions, not measurements:

Share needing a second request (assumed)Requests per questionPer 1,000 questions (Searcher)Per 1,000 questions (Starter)
01.00$7.25$25.00
25%1.25$9.06$31.25
50%1.50$10.88$37.50
100%2.00$14.50$50.00

The rate can also change which plan to buy. Take the 50,000-a-month example further down. If half of the questions need a second request, real use is 75,000 searches. Staying on Big Data (30,000 for $275) means paying the plan price three times, $825, so Searcher (100,000 for $725) is $100 cheaper. With no second requests the answer flips: Big Data plus 1 early renewal is $550, $175 less than Searcher. If you do not know your rate, plan for Searcher as the upper bound.

To find your own rate, the 250 free searches are enough for a sample. Run the questions your agent really asks. Then count the responses where ai_overview has only a page_token and no text.

Tavily's include_answer is a short answer written by its own model. By its credits page it costs no extra credit. It is not the Google AI Overview. EveryInfra web does not return the AI Overview. It gives title, link and snippet, so the agent reads and combines sources itself. When you need several sources to confirm each other, use crosscheck at $0.002778 per call. It is on the web search capability page.

Failed calls, empty results and cache: which requests cost money

SerpAPI puts its rule in one FAQ answer. Only successful searches count, and cached, errored and failed searches do not. A search with 100 results and a search with 0 results each count as 1. "Successful" means SerpAPI fetched and parsed the results page, even if the page itself is empty. If you search for a misspelled brand and Google shows "no results found", that still counts as 1. The Extract API adds a rule: failed pages and cache hits are free, and search_metadata.credits_consumed in the response shows how many searches the call used.

Screenshot: the API Credits Costs section of the Tavily docs, with a teal box around Tavily Search and Tavily Extract. Basic search costs 1 credit per request and advanced costs 2. Failed extractions are never charged. Basic Extract costs 1 credit per 5 successful URLs, and advanced costs 2 per 5.
Tavily charges search by depth and Extract by successful URLs, and failed extractions are free. Screenshot of the Tavily credits page, November 22, 2026, 12:50 Singapore time

The Tavily credits page says that failed Extract and Map calls are free. It does not say how a failed search is counted. For an empty search result, its "1 credit per request" wording means 1 credit. The search reference mentions one case that can return fewer results.

You set max_age_hours, the cached copy is too old, and a live fetch fails. Then that result is dropped, so you can get fewer results than max_results. Low values cost no extra credit. On the free tier, while Tavily is under heavy load, requests with this parameter can return 434.

An agent decides its next step from the status code, and the three services use different codes. In the SerpAPI status code docs, 429 means either "over the hourly throughput" or "your account has run out of searches". The code alone does not tell the agent whether to wait or to renew, so it has to read the error text. When the engine itself has no results, SerpAPI returns 200 with search_metadata.status set to Success and organic_results_state set to "Fully empty", and that search counts. A 503 means the search got no valid results; it does not count, and you can retry.

Tavily splits these cases into separate codes. 429 means too fast and comes with Retry-After. 432 means the key or plan allowance is used up, so you upgrade. 433 means you hit the pay-as-you-go limit, which you raise in the dashboard. 434 means live fetching is paused under high load; retry shortly, or drop max_age_hours to get cached content.

What the agent hitsSerpAPITavilyEveryInfra
Too many requests429, same code as running out429 with Retry-After429 with seconds to wait
Allowance or balance used up429; read the error text432; pay-as-you-go cap is 433Per-call balance, no monthly allowance
The engine has no results200, "Fully empty", counts as 1Docs do not sayEmpty result with empty_reason when the target is confirmed missing, no charge
No result this time503, not counted, retry434, retry shortly503 with retryable true and retry_after, charged $0

On EveryInfra, the three rounds of live calls showed four cases with no charge, and each one can be reproduced with the same request. At 12:48:41 Singapore time we called read on a SerpAPI page that does not exist. It returned 404 with the error code target_not_found, billing.charged_usd of 0, and the reason request_failed_refunded. At 12:48:49 we called web with Tavily's parameter names, query and max_results.

It returned 422 with the code unknown_param, said "did you mean q", listed the 7 allowed parameters, and charged nothing. At 12:51:01 a call to bing/search returned 503 with retryable set to true and retry_after of 60 seconds, and charged $0. At 12:58:18 we tried again, got 503 again, and again paid $0. The shared test key we used also allows 10 calls a minute; above that it returns 429, which is free too.

CaseSerpAPITavilyEveryInfra (this test)
0 resultsCounts as 1Search charges 1 per requestWhen the target is confirmed missing, empty result with empty_reason and no charge (catalog rule, not seen in this test)
Target page 404 or fetch failsFailed searches do not count; failed Extract pages do not countFailed Extract URLs are freeread returned 404, charged $0
Wrong parameterError, no countReturns 400 or 422Returns 422 with "did you mean", charged $0
Service briefly unavailableErrors do not countDocs do not saybing/search returned 503, charged $0
Rate limitOver the hourly throughput you wait or retryReturns 429 and Retry-AfterReturns 429 and seconds to wait, charged $0
Cache hitSame parameters within 1 hour are freeDocs do not say it is freeSome capabilities return a repeat request for a confirmed-missing target for free for a short time (not tested)

The same queries, live on EveryInfra

Between 12:43 and 12:46 Singapore time we ran web with 5 queries: "serpapi vs tavily", "best burr coffee grinder 2026", "python 3.14 release date", "nvidia q3 fiscal 2027 earnings" and "docker permission denied var run docker.sock". These 5 stand for the searches an agent sends most: tool comparison, shopping, a fact, news and an error message. Each request set num: 10. The calls returned 10, 9, 5, 9 and 10 results, took 1.41 to 2.48 seconds on our local clock, and each charged $0.000694. The third query returned only 5 results, so num is only a cap. With per-call billing, fewer results do not mean a smaller charge, the same idea as SerpAPI counting an empty result as 1.

Horizontal bar chart of each EveryInfra live call, with time and charge. web queries took 1.41 to 2.48 seconds at $0.000694 each; three read calls took 0.57 to 1.05 seconds. deep with full text took 48.1 seconds at $0.000694. duckduckgo search: 6.32 seconds at $0.000556; google_news and google_shopping search: 1.98 and 14.23 seconds at $0.000792. The read 404, the 422 call and both bing search 503 calls show only a $0 charge.
Time (Singapore time)CapabilityQuery or targetHTTPResultsLocal time`charged_usd`
12:43:24webserpapi vs tavily200101.41 s0.000694
12:43:31webbest burr coffee grinder 202620092.48 s0.000694
12:43:40webpython 3.14 release date20051.83 s0.000694
12:46:07deep (full: true)serpapi vs tavily200548.11 s0.000694
12:47:15readTavily credits page20010.63 s0.000694
12:48:41readA SerpAPI page that does not exist4040—0
12:48:49web (with query)serpapi vs tavily4220—0
12:51:01bing/searchserpapi vs tavily5030—0
12:51:50duckduckgo/searchserpapi vs tavily200106.32 s0.000556
12:52:03google_news/searchSerpApi Google lawsuit200201.98 s0.000792
12:52:12google_shopping/searchburr coffee grinder2002014.23 s0.000792
12:55:41youtube/searchserpapi vs tavily200102.86 s0.000778
12:57:52web (repeat)serpapi vs tavily200101.54 s0.000694
12:58:00web (page: 2)serpapi vs tavily20091.99 s0.000694
12:59:01newsSerpApi Google lawsuit200101.36 s0.000694

The shared key allows 10 calls a minute, and above that it returned 429; we waited 60 seconds and sent again. Leaving out those 429 replies, 24 requests got a response over the three rounds. The 20 charged requests added up to $0.013608, and the 4 requests with no result (404, 422 and two 503s) charged $0.

The table shows 15 of the 24. The others are two web calls, two read calls, one repeat search, three transcript calls and the second bing/search call. First, the repeat search. At 12:57:52 we sent the 12:43:24 query "serpapi vs tavily" again.

Of the 10 results, 8 matched the results from 14 minutes before, and only 3 were in the same position. We repeated "nvidia q3 fiscal 2027 earnings" after 14 minutes, and only 4 of 9 results matched. The results changed, so the second call was a live search, and it charged $0.000694 as usual. On SerpAPI, the same parameters within 1 hour hit the cache and do not count, but you get the copy from 14 minutes earlier. For an agent that watches news or earnings, remember to add no_cache=true, which then counts as 1 search.

Next, paging. At 12:58:00 we asked for page: 2. Only 1 of its 9 results was also on page 1, and the call charged $0.000694. SerpAPI also counts each page as 1 search. Tavily has no paging parameter and returns at most 20 results, so to get more you change the query.

Below is the request from the first round. The key comes from an environment variable; put in your own key to reproduce it. Change "tool": "web" to "news" for news search, or to "read" with a "url" parameter to read page text. If you send a wrong parameter name, the gateway returns 422, lists the allowed parameters in the response, and charges nothing.

bash
export EVERYINFRA_API_KEY="your key"
curl -s https://api.everyinfra.com/api/v1/search \
  -H "Authorization: Bearer $EVERYINFRA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"tool": "web", "params": {"q": "serpapi vs tavily", "num": 10}}' \
  | jq '{n: (.results | length), first: .results[0].title, charged: .billing.charged_usd}'

At 12:43:24 the output was {"n": 10, "first": "...", "charged": 0.000694}. The first result was a serpapi vs tavily comparison guide from November 11, 2026. Each result has title, url and snippet, and some also have published. The full response was 3,874 bytes, about 1,132 tokens; with the three fields only, it was 3,007 bytes, about 827 tokens.

We also ran one news query through two different entry points. At 12:52:03 we sent "SerpApi Google lawsuit" to google_news/search. It returned 20 results, each with the source outlet and published_at, and the first was a Search Engine Journal story from July 21, 2026. At 12:59:01 we sent the same words to the news search tool.

It returned 10 results and charged $0.000694, and the first three came from Search Engine Journal, Search Engine Land and Yahoo Finance. The difference: the first is the Google News page itself, with its order, which suits media monitoring. The second is web search filtered to news, with the same fields as web, which suits passing straight to a model. The SerpAPI Google News API matches the first, and Tavily's topic=news is closer to the second.

SerpAPI's hundred-plus engines and the matching EveryInfra capabilities

SerpAPI's strength is the number of engines. Its API list includes Google Search, Google News, Google Shopping, Google Maps, Google Scholar, Bing, DuckDuckGo, Yandex, Baidu, YouTube, Amazon and more (over a hundred in all). In November it added search and news APIs for one more engine and a Naver Knowledge iN API. Tavily has one search entry point and switches between general, news and finance with topic; it does not say which sources sit behind it. So if your agent needs "the page this search engine is showing users right now", Tavily cannot give it, while SerpAPI and the EveryInfra platform search capabilities can.

Results page you wantSerpAPI APIEveryInfra capabilityEveryInfra per call (catalog, Nov 22)This test
General web searchGoogle Search APIweb$0.0006945 queries, 5 to 10 results each
Bing results pageBing Search APIbing/search$0.000556503 both times, charged $0
DuckDuckGo results pageDuckDuckGo Search APIduckduckgo/search$0.00055610 results, 6.32 s
Google NewsGoogle News APIgoogle_news/search$0.00079220 results with source and publish time
Google ShoppingGoogle Shopping APIgoogle_shopping/search$0.00079220 results with price and merchant
Yandex results pageYandex Search APIyandex/search$0.001389Not called
YouTube searchYouTube Search APIyoutube/search$0.00077810 videos
YouTube transcriptsTranscript part of the YouTube Video APIyoutube/transcript$0.000556Full transcripts of 3 videos

The prices in this table come from the EveryInfra capability catalog and the search tool list. We read both at 12:42 Singapore time on November 22. The fields differ. A SerpAPI Google Shopping result has dozens of fields such as extracted_price, source and rating. Our google_shopping/search gives title, price, merchant, rating and link per result.

At 12:52:12 we searched "burr coffee grinder", and the first result was a grinder with 48 settings at $95 from Target. Maybe you need the full SerpAPI block structure, with the knowledge graph, related questions and local businesses as separate fields. The EveryInfra platform searches do not go that deep, so SerpAPI fits better. If you only need the fields an agent uses (title, link, snippet and price), per-call billing is one to two orders of size cheaper.

Adding them to Claude, Cursor and Codex: MCP setup for all three

All three offer a remote MCP server, and the setup is almost the same. The differences are where the key goes and whether you can try it without a key. The SerpAPI MCP page gives mcp.serpapi.com as the address, with the key as a Bearer token in a header or in the path. Its open-source serpapi-mcp repository also supports self-hosting and an .mcpb bundle, under the MIT license, with its latest commit on November 20, 2026. The Tavily MCP docs support OAuth, so in Claude, Cursor and VS Code you can approve access with one click. You can also set default parameters with a DEFAULT_PARAMETERS header.

Its tavily-mcp repository has 2,499 stars, and on November 18, 2026 it fixed a bug that could write the key to logs. The EveryInfra MCP address is api.everyinfra.com/mcp. All tool names start with everyinfra_, and one connection gives you search, page reading and data from each platform. Details are on the MCP server page.

bash
# SerpAPI (as shown on its MCP page)
claude mcp add --transport http serpapi https://mcp.serpapi.com/mcp \
  --header "Authorization: Bearer $SERPAPI_API_KEY"

# Tavily (remote MCP, key in the URL; or leave the key out and use OAuth)
claude mcp add --transport http tavily "https://mcp.tavily.com/mcp/?tavilyApiKey=$TAVILY_API_KEY"

# EveryInfra
claude mcp add --transport http everyinfra https://api.everyinfra.com/mcp \
  --header "Authorization: Bearer $EVERYINFRA_API_KEY"

Once connected, the tool descriptions the model sees decide how it uses each service. The SerpAPI MCP exposes engine as a parameter, so the model can pick Google, Bing or YouTube itself. The cost is that the response is still the full JSON, so it is best to have the model add json_restrictor or output=md. The Tavily MCP has search, extract, map and crawl tools and returns cleaned passages the model can read at once.

Tavily's @tavily/cli 1.0.1, released on November 13, 2026, adds a tvly setup mcp command that writes this config into the editors on your machine.

Three related YouTube videos: what they show and what they leave out

At 12:55:41 Singapore time we searched "serpapi vs tavily" with youtube/search and got 10 videos. We picked three that show how to connect or choose Tavily or SerpAPI; they ranked 1st, 6th and 5th. We skipped rank 2, a conference talk on browser rendering. We also skipped ranks 3 and 4, two roundups of many search APIs; a company that sells its own search API made one of them. Rank 7 was a Tavily getting-started tutorial from February 2025. It had 29,286 views, the most of the 10, but it covers Tavily alone, so we skipped it too.

Between 12:56 and 12:57 Singapore time we pulled the full transcripts of the three with youtube/transcript, at $0.000556 each. All three show how to connect the service, but none of them works out the price per 1,000.

VideoPublishedLengthWhat it coversWhat it leaves out
A three-way search API comparison for AI agents2026-11-092:20Tavily returns cleaned content a model can use; 1,000 free credits, basic 1 and advanced 2. SerpAPI returns real Google results as structured JSON; 250 free searches, entry at $25 per 1,000. Advice: use bothPrice per 1,000, token size, the new Extract API and Markdown output from October, the second AI Overview request
n8n AI Agent Live Search2026-04-185:51In n8n, SerpAPI has a built-in tool node: drop it under the AI Agent node and paste the key. Tavily is wired up with the generic HTTP Request tool nodeThe cost per call of either setup; Tavily now has its own community node
What's the Best Web Search for OpenClaw?2026-03-0913:26Tavily gives 1,000 free searches a month with no card and connects to MCP with one command; with one test prompt, Tavily missed Google's A2A protocolSerpAPI is not in it: it compares Tavily with other search APIs that have free tiers; results with other prompts or with advanced depth

The n8n method in the second video is already out of date. It connects Tavily in n8n through the HTTP Request tool node. It uses method POST, the URL https://api.tavily.com/search, an Authorization: Bearer header with the key, and a body with query. We checked the docs on both sides. SerpAPI is a built-in node in n8n; the n8n docs list it as a sub-node of the AI Agent, and it ships with n8n.

The Tavily n8n integration docs describe a verified community node, @tavily/n8n-nodes-tavily. You search for "Tavily" in the node panel and click Install. On self-hosted n8n, the owner or an admin installs it under Settings, then Community nodes. The npm release history shows the node has existed since April 2025, and the latest version, 0.7.0, came out on October 19, 2026. It supports five operations: Search, Extract, Crawl, Map and Research. When you attach it to an AI Agent, the model fills in the query, topic, time range, search depth and answer option.

The Tavily docs also add one step the video does not show. Put today's date in the AI Agent system message. The model does not know the date, so it searches for "latest" items with the year from its training. That step applies to the SerpAPI node and to EveryInfra too. In n8n, EveryInfra connects through the HTTP Request tool node for now: set the URL to https://api.everyinfra.com/api/v1/search and the body to {"tool": "web", "params": {"q": ...}}.

The third video's test used a single prompt, so do not read too much into its result. But it shows one thing. Tavily's default basic depth gives only 3 excerpts per result. When the answer is in paragraph 10 of a long page, turn on advanced depth or follow up with Extract.

50,000 searches a month: the monthly bill on each service

The easiest place to get plan math wrong is when your volume falls between two tiers. Say an agent product makes a steady 50,000 searches a month and reads no pages. The SerpAPI Big Data plan gives 30,000 a month, which is not enough. The next tier, Searcher, gives 100,000 for $725, and the 50,000 you do not use reset on your renewal date. The other option is to stay on Big Data and turn on automatic early renewal.

When the allowance runs out, a new cycle starts early and you pay the plan price again. That happens once a month, so you pay the plan price twice, about $550 for 60,000 searches, about $175 less than Searcher. The trade is that your billing date moves every month. Tavily Startup gives 38,000 credits for $220.

The other 12,000 run on pay as you go at $0.008 each, for $316 in total. Growth on its own is $500. EveryInfra charges per call: 50,000 × $0.000694 is $34.70.

50,000 basic searches a monthHow you buyMonthly billPer 1,000
SerpAPISearcher, half of the 100,000 used$725$14.50
SerpAPIBig Data plus 1 automatic early renewal (plan price paid twice)About $550About $11.00
TavilyStartup 38,000 plus 12,000 pay as you go$316$6.32
TavilyGrowth, half of the 100,000 used$500$10.00
EveryInfra webPer call, no monthly fee$34.70$0.694

When you do not use your full allowance, the price per 1,000 can double. SerpAPI Searcher lists $7.25 per 1,000, but at half use it is $14.50. Tavily pay as you go fills the gap, so its bill between tiers is smoother.

If the agent also reads 5 pages per search, SerpAPI needs 300,000 searches a month, which means the Volume plan (250,000 for $1,475) plus early renewal. Tavily search plus Extract needs 100,000 credits, exactly one Growth plan at $500. EveryInfra is 300,000 × $0.000694, or $208.20.

Switching from SerpAPI or Tavily: matching parameters and fields

The 422 response at 12:48:49 Singapore time listed every parameter web accepts: q, site, location, after, before, page and num, 7 in all. The response also said "Nothing was charged" and how to fix the call. If you match the common SerpAPI and Tavily parameters against that list, most have a match, and a few need a different form.

TaskSerpAPI parameterTavily parameterEveryInfra `web`
Queryqqueryq
Number of resultsnum (varies by engine)max_results, default 10, max 20num, a cap
Pagingstart or pageNonepage, from 1
One site onlysite: in qinclude_domainssite
Regionlocation, glcountrylocation, by country
Time rangetbstime_range, start_date, end_dateafter, before
Title, link, snippetorganic_results[].title, link, snippetresults[].title, url, contentresults[].title, url, snippet
Page textCall the Extract APIinclude_raw_content or ExtractCall read, or deep with full
What this call costExtract responses have credits_consumed; search counts per callinclude_usage returns creditsbilling.charged_usd

The thing most often missed when switching is excluding sites. Tavily has exclude_domains, and web has no parameter with that name; write -site: in q instead. If a model writes query or max_results out of Tavily habit, the gateway returns 422 with "did you mean" and charges nothing. The model can fix the call once and keep going.

How we tested, and which numbers to read with care

For both companies we only read public pages. We did not open accounts or call their APIs. So their real response size, latency and failure rate can differ from the docs samples. The SerpAPI token count comes from a sample response from 2021. Google results pages now have more blocks, so a live response may be larger.

The Tavily figure of 3,868 is an upper limit from the docs, and real chunks are often shorter than 500 characters.

We compare tokens with the same cut on both sides: full response against full response, and three fields against three fields. We did not measure how often SerpAPI needs a second request for the AI Overview; above we only give the formula.

The EveryInfra times are single calls from a machine in Singapore, with no concurrency and no long-run statistics. Twenty-four answered requests show how billing and failures work, but they do not show long-term uptime.

We also did not compare result quality. Which service puts the answer in its top 5 results depends on your questions. To test it, take 50 questions your agent really asks and run them on all three. Mark whether the top 5 results hold the answer. Then add the search fee and the token cost to get the cost per correct answer. All three have free or trial credit, so a sample like this costs nothing.

When SerpAPI fits better

SerpAPI fits five kinds of work best. The table lists each one and the reason.

Your needWhy SerpAPI fits
The raw page from one search engine: rank tracking, SEO competitor checks, ad positions, local and shopping slotsIt splits every block (knowledge graph, related questions, AI Overview) into fields; Tavily results match no single engine page
A rare engineIt has Google Scholar, Google Patents, Google Flights, the Apple App Store, Home Depot, Naver and more, and adds new ones each month
Very high volume at a public priceCloud plans cost $3.75 down to about $1.96 per 1,000 above a million searches a month; Tavily asks you to talk to sales above 100,000
Answers that use the Google AI OverviewIt parses the Overview and its follow-up questions into fields; a second request can count as another search
n8n workflowsIt is a built-in n8n node, so you install nothing and need no admin on self-hosted n8n

Count the costs of SerpAPI too. Responses are large, so you need json_restrictor or Markdown output. Page reading is billed per page. Plans are monthly, and the allowance resets on your renewal date. And there is an open lawsuit, covered below.

When Tavily fits better

Tavily fits four other kinds of work best.

Your needWhy Tavily fits
RAG or question answering with only the relevant passagescontent is already split by relevance, up to 3 chunks per result, about 3,900 tokens for 10 results, with no parsing code
Reading page text after every searchExtract costs 1 credit per 5 successful URLs, or include_raw_content adds text at no extra cost: 77% to 89% cheaper than one search per page
Low volume and no card1,000 free credits a month with no card; pay as you go at $0.008 is more than 3 times cheaper than $0.025 on SerpAPI Starter
A short answer for the modelinclude_answer costs no extra credits at basic or advanced depth

Tavily has costs too. You cannot see which engine a result came from or what rank it had there. The allowance resets on the 1st of each month, and requests stop when it runs out. And in February 2026, Nebius announced it would acquire Tavily, so watch for changes to price and product direction.

When to use EveryInfra, and when not to

EveryInfra web charges $0.000694 per call with no monthly fee or tiers, and failed calls are free. It fits three cases. The first is a project with volume that swings, which does not want a monthly fee for quiet months. The second is an agent that wants web search, page reading, news, shopping and YouTube transcripts under one key.

The third is a team that already uses our platform data and wants search on the same bill. It does not fit these cases. If you need the full Google results page (knowledge graph, AI Overview, local businesses), use SerpAPI. If you need content split into passages with relevance scores, use Tavily, or our deep plus your own chunking.

In this test, deep with full text took 48 seconds, which is too slow for interactive chat. One more case to check. Say you repeat one query many times within an hour and older results are fine. Then the free SerpAPI cache can cost less than per-call billing. EveryInfra searches live and charges every time, and repeat results change.

When we repeated a query after 14 minutes, 2 of the 10 results were different.

You can work out the break-even point. One SerpAPI Searcher search costs $0.00725, 10.4 times our $0.000694.

If the same query repeats fewer than 10 times within an hour, per-call billing is still cheaper. At the lowest SerpAPI cloud plan, about $0.00196 a search, the break-even drops to about 2.8. At 3 or more repeats of one query within an hour, that plan's cache starts to pay. Prices for each capability are on the pricing page. For other options that can replace SerpAPI, see the SerpAPI alternatives page.

What changed at both companies in October and November 2026

DateCompanyChange
October 13, 2026SerpAPIExtract API: read any public page, crawl up to 100 pages
October 30, 2026SerpAPIPython client serpapi 1.2.0
November 2, 2026SerpAPIParses clickable follow-up questions in the AI Overview
November 11, 2026SerpAPISearch API for one more engine
November 13, 2026Tavily@tavily/cli 1.0.1 with tvly setup mcp
November 18, 2026Tavilytavily-mcp stops the key from reaching logs
November 19, 2026SerpAPIWalmart Search supports walmart.ca
November 20, 2026SerpAPINews API for that engine; Naver Knowledge iN API
November 2026TavilyRate limits per organization

SerpAPI shipped a lot in these two months. Its release notes list 135 entries from October 26 to November 21, 108 of them in November. These matter for agents. On October 13, 2026 it launched the Extract API, which reads any public web page and crawls up to 100 pages per site.

Failed pages and cache hits are free. How-To Geek and PPC Land both covered it. On November 2, 2026 it began parsing the follow-up questions you can click in a Google AI Overview. On November 11, 2026 it added a search API for one more engine. On November 20, 2026 it added that engine's news API and a Naver Knowledge iN API.

On November 19, 2026 Walmart Search began to support walmart.ca, and Google Light Search stopped parsing unrelated page text as an answer box. On November 18, 2026 it fixed AI Mode responses that left out tables.

The Python client serpapi 1.2.0 came out on October 30, 2026. In serpapi-mcp, a change on November 12, 2026 moved requests off the event loop, so the MCP server does not stall under load. On November 20, 2026 it added install notes for add-mcp. On November 5, 2026, SerpAPI said it had joined the i2Coalition (Internet Infrastructure Coalition) and received the EWDCI trust seal. It also listed its SOC 2 Type II and ISO 27001 certifications.

Tavily's changes in the same period were mostly developer tools and rate limits. On November 13, 2026 it released @tavily/cli 1.0.1; one npx @tavily/cli init command signs you in, saves the key and sets up MCP. The day before, @tavily/core reached 1.1.0, and the Python client tavily-python 0.8.5 came out on October 6, 2026. Its rate limit docs moved to limits per organization in November. The free tier gets 100 a minute, and pay as you go and Project through Startup get 1,000. Growth gets 1,500, crawl and map get 100 a minute, and research gets 20.

The changelog records the max_age_hours parameter from October. It limits results to content fetched within a set number of hours. The keyless mode lets people try a few calls without signing up. On February 10, 2026, Nebius announced an agreement to acquire Tavily.

Tavily's own post said the product and API would continue as before.

Google v. SerpAPI: where the lawsuit stands

On December 19, 2025, Google sued SerpAPI in the US District Court for the Northern District of California, case number 4:25-cv-10826. All filings are in the CourtListener docket. The core claim is under the anti-circumvention rule of the DMCA. Google says SerpAPI got around the technical protection on its results pages.

DateStep
December 19, 2025Google files the case
July 20, 2026The court dismisses the case for the first time
November 9, 2026The court dismisses the amended complaint and gives Google 21 days to amend again
About November 30, 2026Deadline for a new complaint; without one, the dismissal becomes final

Search Engine Roundtable and PPC Land reported on the November ruling. For SerpAPI customers this means two things. So far the court has not accepted Google's claims, and the service runs as usual. But the case is not over, and an appeal is still possible.

This section only records the public court steps. It is not legal advice. For what you do with the data and in which country, ask your own lawyer. The SerpAPI legal page describes its Legal Shield for customers, which comes only with Production and higher plans.

FAQ

Can I use SerpAPI and Tavily together?

Yes, and the top YouTube comparison video recommends it. A common split is SerpAPI for the raw ranking and blocks from an engine, and Tavily for page text or short answers. In the r/LangChain thread on search tools, one user says SerpAPI is good but not cheap and suggests putting usage limits on it. Using both means two keys and two monthly fees, which does not pay off at low volume.

Is the Tavily API free?

Partly. The Tavily pricing page shows a free tier of 1,000 credits a month with no card. A basic search costs 1 credit, so you get 1,000 free searches a month. An advanced search costs 2, and Extract costs 1 per 5 URLs. Credits reset on the 1st of each month and do not roll over.

Is SerpAPI legal? Can Google sue it?

Google did sue SerpAPI in December 2025. The court dismissed Google's DMCA claims in July and again in November 2026, and Google has one more chance to amend. These are court steps, not legal advice. SerpAPI offers its Legal Shield to customers on Production and higher plans.

Is SerpAPI owned by Google?

No. SerpAPI is run by SerpApi LLC in Austin, Texas. It has no ownership link to Google, and the two are in court. It sells parsed results from search engines such as Google and Bing.

Is the Tavily time range filter accurate?

In the r/Rag thread comparing Tavily with a SERP API, a user reports old content in results that use the Tavily time range parameter. In the same thread, another user says RAG built on SERP snippets alone works poorly and that you need page text. In October Tavily added max_age_hours, which limits results to content fetched within a set number of hours. Its docs say that on the free tier, requests with this parameter can return 434 under heavy load.

Can I try Tavily without signing up, and where do I get a key?

Yes. Tavily's keyless mode lets you call search and Extract with the header X-Tavily-Access-Mode: keyless. You need no account, but there is a rate limit.

Its docs say keyless responses are the same as keyed ones. For a higher allowance, sign up in the Tavily dashboard for a free key with 1,000 credits a month. SerpAPI has no keyless mode; you sign up for a key, and the free tier gives 250 searches a month.

Which one uses fewer tokens, SerpAPI or Tavily?

With default settings, Tavily: its default upper limit is about 3,900 tokens, while the full SerpAPI docs sample is about 16,599. But with json_restrictor keeping only three fields, SerpAPI drops to about 523, smaller than the Tavily default, and Tavily with include_raw_content goes above 10,000. Compare the two at the same settings: our web averages about 973 tokens as returned and about 703 with three fields.

How to get started

To reproduce the tests above on EveryInfra, get a key from the quickstart. Then run the curl call above against web. It costs $0.000694 per call, and failed calls are free. To connect Claude or Cursor, use the setup on the MCP server page.

The full list of platform searches is in the marketplace. The web search entry points are the Web Search API, the Bing Search API and the YouTube Data API. Further reading: for the billing details of each service, see the SerpAPI pricing breakdown and how many credits each Tavily call uses.

For another SerpAPI comparison, see our other SERP API comparison. For another Tavily comparison, see our other Tavily comparison. For more options, see Tavily alternatives, SerpAPI alternatives and choosing a web search API for AI agents.

References

  1. SerpAPI pricing page, plans and FAQ, read November 22, 2026
  2. SerpAPI Google Search API docs and sample response
  3. SerpAPI Markdown output
  4. SerpAPI json_restrictor
  5. SerpAPI status and error codes
  6. SerpAPI Extract API docs
  7. SerpAPI MCP page
  8. SerpAPI AI Overview notes
  9. SerpAPI Google AI Overview API docs
  10. SerpAPI release notes
  11. SerpAPI legal page and Legal Shield
  12. serpapi-mcp repository
  13. serpapi-mcp commits
  14. serpapi-python repository
  15. PyPI: serpapi
  16. npm: serpapi
  17. Tavily pricing page, read November 22, 2026
  18. Tavily API credits
  19. Tavily search reference
  20. Tavily Extract reference
  21. Tavily Map reference
  22. Tavily Crawl reference
  23. Tavily rate limits
  24. Tavily MCP docs
  25. Tavily keyless mode
  26. Tavily search best practices
  27. Tavily changelog
  28. tavily-mcp repository
  29. tavily-mcp commits
  30. tavily-python repository
  31. PyPI: tavily-python
  32. npm: @tavily/cli
  33. npm: @tavily/core
  34. npm: tavily-mcp
  35. Nebius announces agreement to acquire Tavily (February 10, 2026)
  36. Tavily is joining Nebius
  37. Google LLC v. SerpApi LLC docket, CourtListener
  38. Search Engine Roundtable: Google loses again against SerpApi (November 10, 2026)
  39. PPC Land: Google faces 21-day deadline (November 11, 2026)
  40. How-To Geek: SerpAPI Extract API
  41. PPC Land: SerpAPI now scrapes any public web page
  42. Reddit r/LangChain: Best Search Tool in Langchain
  43. Reddit r/Rag: choosing between Tavily and a SERP API
  44. YouTube: a three-way search API comparison (November 9, 2026)
  45. YouTube: n8n AI Agent Live Search
  46. YouTube: What's the Best Web Search for OpenClaw?
  47. EveryInfra search tool list, read November 22, 2026
  48. EveryInfra capability catalog, read November 22, 2026
  49. n8n docs: SerpApi tool node
  50. Tavily n8n integration docs
  51. npm: @tavily/n8n-nodes-tavily

Reference BL-212

Google Analytics needs consent. Privacy