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.

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.

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.
| Item | SerpAPI | Tavily |
|---|---|---|
| Billing unit | 1 per successful search (same price on every engine) | Credits: basic search 1, advanced 2 |
| Free tier | 250 searches a month, 50 an hour | 1,000 credits a month, no card |
| Entry paid option | Starter $25 a month for 1,000 | Pay as you go at $0.008 a credit, or Project $30 for 4,000 |
| Middle plans | Developer $75/5,000; Production $150/15,000; Big Data $275/30,000 | Bootstrap $100/15,000; Startup $220/38,000 |
| Upper plans | Searcher $725/100,000, then cloud plans | Growth $500/100,000, then custom enterprise pricing |
| Failed calls | Cached, errored and failed searches do not count; empty results count as 1 | Failed Extract URLs and failed Map calls are free |
| Cache | Same parameters within 1 hour hit the cache for free | Docs do not say cache hits are free; max_age_hours picks cache or live fetch |
| Allowance reset | Resets on your renewal date; optional early renewal | Resets on the 1st of each month, whatever your billing date |
| When you run out | Renew early, by hand or automatically | Requests stop unless pay as you go is on |
| Read page text | Extract API, 1 search per page | Extract, 1 credit per 5 URLs |
| Format for models | JSON; output=md gives Markdown at the same price | Cleaned content per result, plus optional answer and raw_content |
| Rate limits | By plan: Starter 200 an hour, Searcher 20,000 an hour | By organization: free 100 a minute, paid 1,000, Growth 1,500 |
| Remote MCP | mcp.serpapi.com, key in a header or the path | mcp.tavily.com, OAuth or key, keyless trial |

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.
| Tier | SerpAPI price / searches a month | SerpAPI per 1,000 | Tavily price / credits a month | Tavily per 1,000 basic searches |
|---|---|---|---|---|
| Free | $0 / 250 | — | $0 / 1,000 | — |
| Entry | Starter $25 / 1,000 | $25.00 | Pay as you go, $0.008 a credit | $8.00 |
| Small | Developer $75 / 5,000 | $15.00 | Project $30 / 4,000 | $7.50 |
| Middle | Production $150 / 15,000 | $10.00 | Bootstrap $100 / 15,000 | $6.67 |
| Upper middle | Big Data $275 / 30,000 | $9.17 | Startup $220 / 38,000 | $5.79 |
| 100,000 a month | Searcher $725 / 100,000 | $7.25 | Growth $500 / 100,000 | $5.00 |
| 1,000,000 a month | Cloud 1M $3,750 / 1,000,000 | $3.75 | Custom enterprise | Not public |
EveryInfra web | Per 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.
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 gets | Bytes | Tokens (cl100k_base) | Notes |
|---|---|---|---|
| Full SerpAPI sample JSON | 43,193 | 16,599 | 14 blocks: metadata, recipes, shopping, local map, local results, knowledge graph, related questions, 9 organic results, related searches, pagination and more |
Same sample, organic_results only | 16,288 | 5,159 | Same as json_restrictor=organic_results |
| Same sample, title, link and snippet only | 2,295 | 523 | 9 results, three fields each |
| Tavily default upper limit (from docs) | about 15,000 characters | about 3,868 | 10 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 queries | about 3,414 | about 973 | Outer 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 only | about 2,640 | about 703 | Three fields per result, the same cut as the SerpAPI row |
EveryInfra deep with full text | 72,092 characters | 16,920 | 5 results, page text cut at 20,000 characters each |
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:
| Query | Results | Tokens, full response | Tokens, three fields |
|---|---|---|---|
| serpapi vs tavily | 10 | 1,132 | 827 |
| best burr coffee grinder 2026 | 9 | 961 | 691 |
| python 3.14 release date | 5 | 668 | 430 |
| nvidia q3 fiscal 2027 earnings | 9 | 1,084 | 825 |
| docker permission denied var run docker.sock | 10 | 1,020 | 743 |
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.

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 searches | Input tokens | At $1 per million | At $3 per million |
|---|---|---|---|
| SerpAPI sample, as returned | about 16.6 million | $16.60 | $49.80 |
| SerpAPI sample, three fields | about 523,000 | $0.52 | $1.57 |
| Tavily default upper limit | about 3.87 million | $3.87 | $11.60 |
EveryInfra web, as returned | about 973,000 | $0.97 | $2.92 |
EveryInfra web, three fields | about 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.
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 pages | Charges | Per 1,000 tasks (cheapest self-serve plan) | Per 1,000 tasks (entry option) |
|---|---|---|---|
| SerpAPI: Google search + Extract 5 pages | 6 searches | $43.50 (Searcher) | $150.00 (Starter) |
| Tavily: search + Extract 5 URLs | 2 credits | $10.00 (Growth) | $16.00 (pay as you go) |
Tavily: search with include_raw_content | 1 credit | $5.00 (Growth) | $8.00 (pay as you go) |
EveryInfra: 1 web + 5 read | 6 × $0.000694 | $4.16 (charged) | Same, no tiers |
EveryInfra: 1 deep with full text | 1 × $0.000694 | $0.694 (charged, 5 results per call) | Same |
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 question | Per 1,000 questions (Searcher) | Per 1,000 questions (Starter) |
|---|---|---|---|
| 0 | 1.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.

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 hits | SerpAPI | Tavily | EveryInfra |
|---|---|---|---|
| Too many requests | 429, same code as running out | 429 with Retry-After | 429 with seconds to wait |
| Allowance or balance used up | 429; read the error text | 432; pay-as-you-go cap is 433 | Per-call balance, no monthly allowance |
| The engine has no results | 200, "Fully empty", counts as 1 | Docs do not say | Empty result with empty_reason when the target is confirmed missing, no charge |
| No result this time | 503, not counted, retry | 434, retry shortly | 503 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.
| Case | SerpAPI | Tavily | EveryInfra (this test) |
|---|---|---|---|
| 0 results | Counts as 1 | Search charges 1 per request | When 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 fails | Failed searches do not count; failed Extract pages do not count | Failed Extract URLs are free | read returned 404, charged $0 |
| Wrong parameter | Error, no count | Returns 400 or 422 | Returns 422 with "did you mean", charged $0 |
| Service briefly unavailable | Errors do not count | Docs do not say | bing/search returned 503, charged $0 |
| Rate limit | Over the hourly throughput you wait or retry | Returns 429 and Retry-After | Returns 429 and seconds to wait, charged $0 |
| Cache hit | Same parameters within 1 hour are free | Docs do not say it is free | Some 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.
| Time (Singapore time) | Capability | Query or target | HTTP | Results | Local time | `charged_usd` |
|---|---|---|---|---|---|---|
| 12:43:24 | web | serpapi vs tavily | 200 | 10 | 1.41 s | 0.000694 |
| 12:43:31 | web | best burr coffee grinder 2026 | 200 | 9 | 2.48 s | 0.000694 |
| 12:43:40 | web | python 3.14 release date | 200 | 5 | 1.83 s | 0.000694 |
| 12:46:07 | deep (full: true) | serpapi vs tavily | 200 | 5 | 48.11 s | 0.000694 |
| 12:47:15 | read | Tavily credits page | 200 | 1 | 0.63 s | 0.000694 |
| 12:48:41 | read | A SerpAPI page that does not exist | 404 | 0 | — | 0 |
| 12:48:49 | web (with query) | serpapi vs tavily | 422 | 0 | — | 0 |
| 12:51:01 | bing/search | serpapi vs tavily | 503 | 0 | — | 0 |
| 12:51:50 | duckduckgo/search | serpapi vs tavily | 200 | 10 | 6.32 s | 0.000556 |
| 12:52:03 | google_news/search | SerpApi Google lawsuit | 200 | 20 | 1.98 s | 0.000792 |
| 12:52:12 | google_shopping/search | burr coffee grinder | 200 | 20 | 14.23 s | 0.000792 |
| 12:55:41 | youtube/search | serpapi vs tavily | 200 | 10 | 2.86 s | 0.000778 |
| 12:57:52 | web (repeat) | serpapi vs tavily | 200 | 10 | 1.54 s | 0.000694 |
| 12:58:00 | web (page: 2) | serpapi vs tavily | 200 | 9 | 1.99 s | 0.000694 |
| 12:59:01 | news | SerpApi Google lawsuit | 200 | 10 | 1.36 s | 0.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.
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 want | SerpAPI API | EveryInfra capability | EveryInfra per call (catalog, Nov 22) | This test |
|---|---|---|---|---|
| General web search | Google Search API | web | $0.000694 | 5 queries, 5 to 10 results each |
| Bing results page | Bing Search API | bing/search | $0.000556 | 503 both times, charged $0 |
| DuckDuckGo results page | DuckDuckGo Search API | duckduckgo/search | $0.000556 | 10 results, 6.32 s |
| Google News | Google News API | google_news/search | $0.000792 | 20 results with source and publish time |
| Google Shopping | Google Shopping API | google_shopping/search | $0.000792 | 20 results with price and merchant |
| Yandex results page | Yandex Search API | yandex/search | $0.001389 | Not called |
| YouTube search | YouTube Search API | youtube/search | $0.000778 | 10 videos |
| YouTube transcripts | Transcript part of the YouTube Video API | youtube/transcript | $0.000556 | Full 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.
# 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.
| Video | Published | Length | What it covers | What it leaves out |
|---|---|---|---|---|
| A three-way search API comparison for AI agents | 2026-11-09 | 2:20 | Tavily 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 both | Price per 1,000, token size, the new Extract API and Markdown output from October, the second AI Overview request |
| n8n AI Agent Live Search | 2026-04-18 | 5:51 | In 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 node | The cost per call of either setup; Tavily now has its own community node |
| What's the Best Web Search for OpenClaw? | 2026-03-09 | 13:26 | Tavily 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 protocol | SerpAPI 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 month | How you buy | Monthly bill | Per 1,000 |
|---|---|---|---|
| SerpAPI | Searcher, half of the 100,000 used | $725 | $14.50 |
| SerpAPI | Big Data plus 1 automatic early renewal (plan price paid twice) | About $550 | About $11.00 |
| Tavily | Startup 38,000 plus 12,000 pay as you go | $316 | $6.32 |
| Tavily | Growth, half of the 100,000 used | $500 | $10.00 |
EveryInfra web | Per 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.
| Task | SerpAPI parameter | Tavily parameter | EveryInfra `web` |
|---|---|---|---|
| Query | q | query | q |
| Number of results | num (varies by engine) | max_results, default 10, max 20 | num, a cap |
| Paging | start or page | None | page, from 1 |
| One site only | site: in q | include_domains | site |
| Region | location, gl | country | location, by country |
| Time range | tbs | time_range, start_date, end_date | after, before |
| Title, link, snippet | organic_results[].title, link, snippet | results[].title, url, content | results[].title, url, snippet |
| Page text | Call the Extract API | include_raw_content or Extract | Call read, or deep with full |
| What this call cost | Extract responses have credits_consumed; search counts per call | include_usage returns credits | billing.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 need | Why SerpAPI fits |
|---|---|
| The raw page from one search engine: rank tracking, SEO competitor checks, ad positions, local and shopping slots | It splits every block (knowledge graph, related questions, AI Overview) into fields; Tavily results match no single engine page |
| A rare engine | It 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 price | Cloud 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 Overview | It parses the Overview and its follow-up questions into fields; a second request can count as another search |
| n8n workflows | It 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 need | Why Tavily fits |
|---|---|
| RAG or question answering with only the relevant passages | content 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 search | Extract 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 card | 1,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 model | include_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
| Date | Company | Change |
|---|---|---|
| October 13, 2026 | SerpAPI | Extract API: read any public page, crawl up to 100 pages |
| October 30, 2026 | SerpAPI | Python client serpapi 1.2.0 |
| November 2, 2026 | SerpAPI | Parses clickable follow-up questions in the AI Overview |
| November 11, 2026 | SerpAPI | Search API for one more engine |
| November 13, 2026 | Tavily | @tavily/cli 1.0.1 with tvly setup mcp |
| November 18, 2026 | Tavily | tavily-mcp stops the key from reaching logs |
| November 19, 2026 | SerpAPI | Walmart Search supports walmart.ca |
| November 20, 2026 | SerpAPI | News API for that engine; Naver Knowledge iN API |
| November 2026 | Tavily | Rate 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.
| Date | Step |
|---|---|
| December 19, 2025 | Google files the case |
| July 20, 2026 | The court dismisses the case for the first time |
| November 9, 2026 | The court dismisses the amended complaint and gives Google 21 days to amend again |
| About November 30, 2026 | Deadline 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
- SerpAPI pricing page, plans and FAQ, read November 22, 2026
- SerpAPI Google Search API docs and sample response
- SerpAPI Markdown output
- SerpAPI json_restrictor
- SerpAPI status and error codes
- SerpAPI Extract API docs
- SerpAPI MCP page
- SerpAPI AI Overview notes
- SerpAPI Google AI Overview API docs
- SerpAPI release notes
- SerpAPI legal page and Legal Shield
- serpapi-mcp repository
- serpapi-mcp commits
- serpapi-python repository
- PyPI: serpapi
- npm: serpapi
- Tavily pricing page, read November 22, 2026
- Tavily API credits
- Tavily search reference
- Tavily Extract reference
- Tavily Map reference
- Tavily Crawl reference
- Tavily rate limits
- Tavily MCP docs
- Tavily keyless mode
- Tavily search best practices
- Tavily changelog
- tavily-mcp repository
- tavily-mcp commits
- tavily-python repository
- PyPI: tavily-python
- npm: @tavily/cli
- npm: @tavily/core
- npm: tavily-mcp
- Nebius announces agreement to acquire Tavily (February 10, 2026)
- Tavily is joining Nebius
- Google LLC v. SerpApi LLC docket, CourtListener
- Search Engine Roundtable: Google loses again against SerpApi (November 10, 2026)
- PPC Land: Google faces 21-day deadline (November 11, 2026)
- How-To Geek: SerpAPI Extract API
- PPC Land: SerpAPI now scrapes any public web page
- Reddit r/LangChain: Best Search Tool in Langchain
- Reddit r/Rag: choosing between Tavily and a SERP API
- YouTube: a three-way search API comparison (November 9, 2026)
- YouTube: n8n AI Agent Live Search
- YouTube: What's the Best Web Search for OpenClaw?
- EveryInfra search tool list, read November 22, 2026
- EveryInfra capability catalog, read November 22, 2026
- n8n docs: SerpApi tool node
- Tavily n8n integration docs
- npm: @tavily/n8n-nodes-tavily
Reference BL-212