# Serper vs SerpAPI: price, fields and speed compared, with our own test

> Serper vs SerpAPI, read on 2026-11-19: Serper costs $0.30 to $1.00 per 1k with 6-month credits. SerpAPI costs $1.96 to $25 per 1k. We timed 7 searches.

- Canonical page: [https://everyinfra.com/en/blog/serper-vs-serpapi](https://everyinfra.com/en/blog/serper-vs-serpapi?utm_medium=ai_doc&utm_campaign=page_md)
- Published: 2026-11-19T02:03:45+08:00 · Fact-checked: 2026-11-19T01:00:00+08:00

Serper and SerpAPI both sell Google results as JSON, and their list prices differ by 6.5 to 25 times per 1,000 searches (both pricing pages read on 2026-11-19, Singapore time, SGT). We compare their public prices, billing rules, fields and published speed. As a third reference, we ran the same 7 search types in three rounds on EveryInfra unified search.

> **Key points**
>
> - Entry price per 1,000 searches: SerpAPI Starter $25, Serper Starter $1.00, a 25x gap. EveryInfra `/api/v1/search` charged $0.000694 per call for 7 search types, or $0.694 per 1,000.
> - Expiry and monthly fees change the real cost. At 1,000 searches per month: Serper $8.33, SerpAPI $25, EveryInfra $0.694 per 1,000. At 100,000 per month: $0.79, $7.25 and $0.694.
> - From about 500,000 searches per month, Serper is the cheapest ($0.54 per 1,000, and $0.33 at 5 million). SerpAPI stays above $1.96 per 1,000 in every self-serve plan.
> - Failure rules differ. SerpAPI says an empty result counts as 1 search, errors do not count, and a repeat within 1 hour comes from a free cache. Serper only says it charges on a successful response. Our 422, 429 and empty results all charged $0.
> - We sent 60 live calls for a total of $0.0213. Competitor numbers come only from public pricing pages, docs and their own blogs. We did not sign up or buy a plan.

The names Serper and SerpAPI differ by two letters, but their pricing models are opposite. Serper sells prepaid credit packs with no monthly fee, and the credits expire after 6 months.

SerpAPI sells monthly plans with a fixed number of searches, and unused searches do not carry over. So the same "price per 1,000" means different things at each vendor. You must recompute it for your own monthly volume.

For the two vendors we used only public material. That means the [Serper homepage pricing block](https://serper.dev/) and the [SerpAPI pricing page](https://serpapi.com/pricing). It also means both sets of docs, SerpAPI's public roadmap on GitHub and its blog. We did not create accounts or buy plans.

So on their side you get list prices and the speed numbers they publish, not our own bills or timings. On the EveryInfra side every number comes from live calls on one day. We sent them in three rounds between 00:14 and 00:48 SGT on 2026-11-19. Each response's `billing.charged_usd`, HTTP status and timing is in the raw files, and a script computes every number from those files.

![Flow chart with four boxes from left to right: send the search request, check the key and parameters, get results, record the charge. The third box splits in two. The path with results goes to a teal box, charge one call. The path for a bad parameter, a rate limit or zero results goes to a gray box, no charge. A teal dot moves along the line from left to right.](https://everyinfra.com/articles/serper-vs-serpapi/fig-06-billing-flow.en.light.svg?utm_medium=ai_doc&utm_campaign=page_md)

## Serper vs SerpAPI at a glance: price per 1,000, billing unit, expiry and free tier

The two vendors sell in different ways. Serper sells credit packs, and SerpAPI sells monthly plans. Serper has four packs: $50 for 50,000 searches, $375 for 500,000, $1,250 for 2.5 million and $3,750 for 12.5 million. That is $1.00, $0.75, $0.50 and $0.30 per 1,000.

Every pack says "Credits valid for 6 months", and prices exclude sales tax ([Serper homepage pricing block](https://serper.dev/), read at 00:17 SGT on 2026-11-19). The first screen of the SerpAPI pricing page shows four plans. Starter is $25 for 1,000 searches per month, Developer $75 for 5,000, Production $150 for 15,000 and Big Data $275 for 30,000.

Under "All plans" SerpAPI lists 57 more tiers. The largest, Cloud 54M, costs $106,050 per month ([SerpAPI pricing page](https://serpapi.com/pricing), read at 00:18 SGT the same day). We saved the plan data that the page embeds. The table below puts the main terms side by side, with EveryInfra as a third column from our own test.

| Item | Serper | SerpAPI | EveryInfra (our test) |
| --- | --- | --- | --- |
| How you pay | Prepaid credit packs, no monthly fee | Monthly plan with a search quota | Prepaid balance, charged per request |
| Entry price per 1,000 | $1.00 ($50 pack) | $25 (Starter, $25 per month) | $0.694 (`/api/v1/search`) |
| Lowest self-serve price per 1,000 | $0.30 ($3,750 pack) | $1.96 (Cloud 54M) | $0.694 (flat) |
| Smallest payment | $50 | $25 per month | $10 |
| Free tier | 2,500 searches at sign-up, no card | 250 searches per month | $1 for starring two GitHub repos, valid 24 hours |
| When credit expires | 6 months after purchase | Unused monthly searches do not roll over | Balance does not expire |
| Billing unit | 1 query = 1 credit, 11 to 100 results = 2 credits | 1 successful search = 1, empty results count | 1 request = 1 charge, empty results free |
| Throughput | 50 to 300 queries per second, by pack | 50 to 640,000 per hour, by plan | 60 per minute by default, up to 1,800 per minute with a boost pack |
| Search types | About 10 Google result types | 100+ APIs, including Bing, Baidu, Brave | 17 search tools plus 612 data capabilities |
| Own MCP server | None (community servers) | Yes, `mcp.serpapi.com` | Yes, `https://api.everyinfra.com/mcp` |

![Screenshot of the Serper homepage pricing area, titled Simple, Affordable Pricing, with four cards: Starter $50, 50k credits ($1.00/1k), 50 queries per second; Standard $375, 500k credits ($0.75/1k), 100 per second; Scale $1250, 2.5M credits ($0.50/1k), 200 per second; Ultimate $3750, 12.5M credits ($0.30/1k), 300 per second. Teal boxes mark the per-1k price row and the Credits valid for 6 months row.](https://everyinfra.com/articles/serper-vs-serpapi/img-serper-pricing.webp?utm_medium=ai_doc&utm_campaign=page_md)

Serper's four credit packs cost $1.00 to $0.30 per 1,000, and every card says credits are valid for 6 months. Captured 2026-11-19 SGT. [Serper homepage pricing screenshot](https://serper.dev/)

Free tiers also line up by searches in the first six months. Serper gives 2,500 at sign-up, and its homepage says "No credit card required". SerpAPI gives 250 per month, which is 1,500 over six months. On EveryInfra, you star two GitHub repositories to get a $1 trial. It covers about 1,440 calls at $0.000694, but it expires after 24 hours. The smallest paid top-up is $10, and a paid balance does not expire ([pricing](/en/pricing), read 2026-11-19).

![Bar chart with three bars for free searches in the first six months: Serper 2,500 at sign-up, SerpAPI 250 per month for six months, 1,500 in total, and EveryInfra about 1,440 from the $1 trial. The EveryInfra bar is teal.](https://everyinfra.com/articles/serper-vs-serpapi/fig-14-free-tier-bar.en.light.svg?utm_medium=ai_doc&utm_campaign=page_md)

## The two price lists, tier by tier: Serper's 4 packs and SerpAPI's 61 plans

Across Serper's four packs, the price per 1,000 falls from $1.00 to $0.30, a 70% drop. The pack size grows from 50,000 to 12.5 million searches, which is 250 times larger. The rate limit rises with the pack, from 50 to 300 queries per second.

The Ultimate FAQ answer gives about 15,000 to 18,000 queries per minute. The refund rule is also in the homepage FAQ. You can get a full refund within 7 days of your first purchase if you used no more than 20% of the credits.

Serper's FAQ also says when it charges. It deducts a credit each time it returns a successful response, and it stops accepting requests when the balance reaches zero. There is no overage billing, so a script that runs past its budget simply stops. For some teams that is a safety feature. For a production job that must not stop, it means you watch the balance yourself.

| Serper pack | Price | Credits | Per 1,000 | Queries per second | Valid for |
| --- | --- | --- | --- | --- | --- |
| Free | $0 | 2,500 | — | — | At sign-up |
| Starter | $50 | 50,000 | $1.00 | 50 | 6 months |
| Standard | $375 | 500,000 | $0.75 | 100 | 6 months |
| Scale | $1,250 | 2,500,000 | $0.50 | 200 | 6 months |
| Ultimate | $3,750 | 12,500,000 | $0.30 | 300 | 6 months |

SerpAPI has 61 self-serve tiers at Best Effort, its standard speed. These are 7 named plans and 54 Cloud tiers that step up by one million searches. Each tier also has a Ludicrous Speed version at 2 times the price and a Ludicrous Speed Max version at 4 times.

So the page holds 183 plan records. The [Ludicrous Speed page](https://serpapi.com/ludicrous-speed) says the faster tier uses twice the server resources for concurrent requests. Starter at Ludicrous Speed costs $50 per month, and at Max it costs $100, for the same 1,000 searches.

| SerpAPI plan | Monthly fee | Searches per month | Hourly limit | Per 1,000 | U.S. Legal Shield |
| --- | --- | --- | --- | --- | --- |
| Free | $0 | 250 | 50 | — | No |
| Starter | $25 | 1,000 | 200 | $25.00 | No |
| Developer | $75 | 5,000 | 1,000 | $15.00 | No |
| Production | $150 | 15,000 | 3,000 | $10.00 | Yes |
| Big Data | $275 | 30,000 | 6,000 | $9.17 | Yes |
| Searcher | $725 | 100,000 | 20,000 | $7.25 | Yes |
| Volume | $1,475 | 250,000 | 50,000 | $5.90 | Yes |
| Infrastructure | $2,750 | 500,000 | 100,000 | $5.50 | Yes |
| Cloud 1M | $3,750 | 1,000,000 | 110,000 | $3.75 | Yes |
| Cloud 5M | $11,475 | 5,000,000 | 150,000 | $2.30 | Yes |
| Cloud 54M | $106,050 | 54,000,000 | 640,000 | $1.96 | Yes |

![Screenshot of four plan cards on the SerpAPI pricing page: Starter $25 per month, Developer $75, Production $150 marked Most popular, and Big Data $275. A teal box marks the searches per month row: 1,000, 5,000, 15,000 and 30,000. Below are hourly throughput rows of 200, 1,000, 3,000 and 6,000, and a cross before U.S. Legal Shield on Starter and Developer.](https://everyinfra.com/articles/serper-vs-serpapi/img-serpapi-pricing.webp?utm_medium=ai_doc&utm_campaign=page_md)

SerpAPI's first four plans fall from $25 to $9.17 per 1,000, and the Legal Shield starts at Production. Captured 2026-11-19 SGT. [SerpAPI pricing page screenshot](https://serpapi.com/pricing)

On one scale, the gap between the two vendors falls into three bands. At entry level, SerpAPI Starter costs $25 per 1,000 and Serper Starter costs $1.00, so SerpAPI is 25 times higher. In the middle, SerpAPI Searcher (100,000 per month) costs $7.25 and Serper Standard costs $0.75, a 9.7x gap. At the top, SerpAPI Cloud 54M costs $1.96 and Serper Ultimate costs $0.30, a 6.5x gap.

The gap narrows with volume, but no SerpAPI tier reaches any Serper pack. EveryInfra is a flat line. On `/api/v1/search`, 16 of the 17 tools cost $0.000694 per call, and only `crosscheck` costs $0.002778 ([search tool catalog](https://api.everyinfra.com/api/v1/search/tools)). The 7 tools in this test all cost $0.000694. That is cheaper than Serper Starter and Standard, and more expensive than Scale and Ultimate.

![Line chart. The x axis is searches per plan or pack, and the y axis is price per 1,000 searches. Both axes are log scale, 10x per step. A gray line shows SerpAPI's 61 Best Effort tiers, from Starter at 1,000 searches for $25 down to Cloud 54M at 54 million for $1.96. A dark gray line shows Serper's four packs, from 50,000 at $1.00 down to 12.5 million at $0.30. A teal flat line shows the EveryInfra test price of $0.694. The teal line sits below every SerpAPI point and crosses the Serper line between Standard and Scale.](https://everyinfra.com/articles/serper-vs-serpapi/fig-01-per1k-ladder-line.en.light.svg?utm_medium=ai_doc&utm_campaign=page_md)

SerpAPI explains its price in three ways on its pricing page and blog. The first is coverage. One key reaches Google Search, Maps, Shopping, Bing, Baidu, Yandex, YouTube, Amazon, Walmart and more than 100 APIs in total, while Serper covers Google only.

The second is structure. SerpAPI splits a Google page into dozens of block types, such as ads, knowledge graph, related questions, local results, shopping and top stories. Its [Google Search API docs](https://serpapi.com/search-api) list more than 60 block types, each with fixed fields.

The third is legal cover. From the Production plan up, SerpAPI includes a U.S. Legal Shield. Under it, SerpAPI takes responsibility for claims about the lawful collection and parsing of search data.

The Free, Starter and Developer plans do not include it ([U.S. Legal Shield page](https://serpapi.com/us-legal-shield)). Whether you need these three things decides whether the SerpAPI premium is worth it.

Whether the SerpAPI fast tiers are worth it depends on your bottleneck. They add no searches. They only raise concurrency and cut response time. Starter goes from $25 per month to $50 and $100, and Searcher goes from $725 to $1,450 and $2,900.

Take chat search at a few thousand calls per month, where one user waits for one answer. For that job, the 0.73-second Best Effort average from SerpAPI's own test is enough. Rank monitoring is different, because it must finish hundreds of thousands of calls in a fixed window. Only jobs like that need to pay one to three times more for concurrency.

![Grouped bar chart for four SerpAPI plans, Starter, Production, Big Data and Searcher, with three bars each: Best Effort, Ludicrous Speed and Ludicrous Speed Max. Starter is $25, $50 and $100. Production is $150, $300 and $600. Big Data is $275, $550 and $1,100. Searcher is $725, $1,450 and $2,900. The longest teal bar is Searcher at Max.](https://everyinfra.com/articles/serper-vs-serpapi/fig-11-serpapi-speed-tier-bar.en.light.svg?utm_medium=ai_doc&utm_campaign=page_md)

![Grouped bar chart for three bands, entry, middle and top, with two bars each: the SerpAPI price per 1,000 as a multiple of Serper and of EveryInfra. Entry is 25.0x and 36.0x, middle is 9.7x and 10.4x, and top is 6.5x and 2.8x. The multiples shrink as the band rises.](https://everyinfra.com/articles/serper-vs-serpapi/fig-15-gap-ratio-bar.en.light.svg?utm_medium=ai_doc&utm_campaign=page_md)

## Expiry and monthly fees change the real cost: seven monthly volumes

The list price is "dollars per 1,000". The real cost is "what you paid this month for what you used this month". Each vendor has one rule that pushes the real cost above the list price.

Serper credits expire after 6 months. SerpAPI monthly searches do not carry over. To put both rules in one table, we wrote a script and ran it for 7 monthly volumes.

For SerpAPI, the script picks the cheapest plan with enough monthly searches. For Serper, it takes six months of demand and subtracts the 2,500 free searches. Then it finds the cheapest mix of the four packs and spreads the total over 6 months. For EveryInfra, it multiplies the monthly volume by the $0.000694 we were charged.

| Searches per month | SerpAPI plan and fee | SerpAPI per 1,000 | Serper 6-month purchase | Serper per month | Serper per 1,000 | EveryInfra per month | EveryInfra per 1,000 |
| --- | --- | --- | --- | --- | --- | --- | --- |
| 1,000 | Starter $25 | $25.00 | 1 Starter | $8.33 | $8.33 | $0.69 | $0.694 |
| 5,000 | Developer $75 | $15.00 | 1 Starter | $8.33 | $1.67 | $3.47 | $0.694 |
| 20,000 | Big Data $275 | $13.75 | 3 Starter | $25.00 | $1.25 | $13.88 | $0.694 |
| 100,000 | Searcher $725 | $7.25 | 1 Standard + 2 Starter | $79.17 | $0.79 | $69.40 | $0.694 |
| 500,000 | Infrastructure $2,750 | $5.50 | 1 Scale + 1 Standard | $270.83 | $0.54 | $347.00 | $0.694 |
| 1,000,000 | Cloud 1M $3,750 | $3.75 | 2 Scale + 2 Standard | $541.67 | $0.54 | $694.00 | $0.694 |
| 5,000,000 | Cloud 5M $11,475 | $2.30 | 2 Ultimate + 2 Scale | $1,666.67 | $0.33 | $3,470.00 | $0.694 |

Serper Starter lists at $1.00 per 1,000. In six months you use only 6,000 searches, and after the 2,500 free ones you need just 3,500. You still must buy the 50,000 pack, and the other 46,500 credits expire.

So you pay $50 over 6 months, which is $8.33 per month and $8.33 per 1,000, eight times the list price. SerpAPI has no expiry in this row, but Starter already costs $25 per 1,000. A per-request API adds nothing here. You pay for 1,000 calls when you make 1,000 calls, and a $10 top-up lasts more than 14 months at this volume.

The same script gives the expired share. At 1,000 searches per month, you use only 6,000 of the 52,500 searches you hold in six months, including the free ones, so 88.6% expire. At 5,000 per month, 42.9% expire. At 20,000 per month, 21.3% expire, and at 100,000 per month only 0.4% expire. Until the expired share drops below about one tenth, you cannot compare the Serper list price directly with a per-request API.

At 100,000 searches per month, Serper's expiry problem almost disappears. Six months need 600,000 searches, and 1 Standard plus 2 Starter packs cover that exactly. That is $79.17 per month, or $0.79 per 1,000, only 14% above our $0.694.

At 500,000 per month Serper becomes cheaper than us. Six months need 3 million, and 1 Scale plus 1 Standard cost $0.54 per 1,000. At 5 million per month, 2 Ultimate plus 2 Scale packs cost $0.33 per 1,000, about half our price.

The script also steps up in units of 10,000 to find the crossover. It sits at about 310,000 searches per month. Above that point, a six-month Serper purchase costs less than $0.694 per 1,000. SerpAPI is the most expensive vendor in all 7 rows. At 5 million per month it costs $2.30 per 1,000, still 7 times Serper.

![Line chart. The x axis is searches per month, from 1,000 to 5 million, on a log scale. The y axis is the real price per 1,000 searches, on a log scale. The gray SerpAPI line falls from $25 to $2.30. The dark gray Serper line falls from $8.33 to $0.33, and its first two points sit above list price because of expiring credits. The teal EveryInfra line stays at $0.694. The Serper line crosses the teal line at about 310,000 searches per month and stays below it after that.](https://everyinfra.com/articles/serper-vs-serpapi/fig-02-monthly-cost-line.en.light.svg?utm_medium=ai_doc&utm_campaign=page_md)

1. The Serper rows assume you buy six months of packs in month zero. If you buy small packs each month, less expires, but the unit price is higher. A team at 1,000 searches per month cannot avoid the $50 minimum pack.
1. The SerpAPI rows use one plan only. They ignore two rules from the [SerpAPI pricing FAQ](https://serpapi.com/pricing). Unused searches turn into Extra Credits when you downgrade. You can also renew early when you run out. Those rules help teams with uneven monthly volume.
1. The unit is one search request with up to 10 results. For 11 to 100 results, Serper charges 2 credits and SerpAPI needs one page per request. The section on pagination covers that case.

![Stacked bar chart with four rows for 1,000, 5,000, 20,000 and 100,000 searches per month. In each row the teal part on the left is credit used within six months, and the gray part on the right is credit that expires. The expired shares are 88.6%, 42.9%, 21.3% and 0.4%. The first row is almost all gray and the last row is almost all teal.](https://everyinfra.com/articles/serper-vs-serpapi/fig-10-serper-expiry-share.en.light.svg?utm_medium=ai_doc&utm_campaign=page_md)

## Search types: Serper's ten Google surfaces and SerpAPI's 100+ APIs

The example switcher on the [Serper homepage](https://serper.dev/) lists ten surfaces: Search, Images, News, Maps, Places, Videos, Shopping, Scholar, Patents and Autocomplete (archived at 01:48 SGT on 2026-11-19). All of them are Google surfaces. The switcher has no reverse image search and no reviews, and the web scraping endpoint from the Clay video is not in it either. A third-party review read the prices on 2025-07-05. It says these endpoints share one rule: up to 10 results cost 1 credit, and more cost 2 ([ColdIQ's Serper pricing breakdown](https://coldiq.com/blog/serper-pricing)). Another review says Serper has no Bing, Baidu or Yandex, and no separate endpoint for AI Overviews or AI Mode ([busyless review of Serper](https://busyless.space/seo-apis/serper)).

SerpAPI's list is much longer. Its docs sidebar groups APIs by engine. Google alone has more than 20 APIs ([sidebar of the SerpAPI status and error codes page](https://serpapi.com/api-status-and-error-codes)). They include Search, Light Search, AI Mode, AI Overview, Gemini, Ads Transparency, Autocomplete and Books.

Others are Events, Finance, Flights, Hotels, Images, Jobs, Lens and Maps. The list goes on with Maps Reviews, News, Patents, Play Store and Scholar. Beyond Google, it covers Bing, Baidu, Yandex, Yahoo, DuckDuckGo and YouTube. It also covers Amazon, eBay, Walmart and the Apple App Store.

This list changes fast, and SerpAPI logs each change in its [release notes](https://serpapi.com/release-notes) and weekly changelog. In the week from 2026-11-09 to 2026-11-15 it added three APIs: Brave Search, Brave Images and DuckDuckGo Images. The source is the [SerpAPI weekly changelog for November 9 to 15](https://serpapi.com/blog/serpapi-weekly-changelog-november-09-15-2026/). The roadmap items are [#74](https://github.com/serpapi/public-roadmap/issues/74), [#325](https://github.com/serpapi/public-roadmap/issues/325) and [#2219](https://github.com/serpapi/public-roadmap/issues/2219).

The EveryInfra unified search endpoint, `POST /api/v1/search`, has 17 tools named by what you want to find. They include `web` for pages, `media` for images and video, and `news`, `places` and `shopping`. There is also `scholar` for papers and patents and `suggest` for autocomplete.

Then `lens` runs a reverse image search, and `read` gets page text. Other tools such as `deep`, `semantic`, `forum` and `crosscheck` change how the search runs. `crosscheck` queries several sources and costs $0.002778 per call. The other 16 tools cost $0.000694 per call ([search tool catalog](https://api.everyinfra.com/api/v1/search/tools)).

The data endpoint `POST /api/v1/social` has separately priced search capabilities. `web/search` costs $0.001389 per call, `bing/search` $0.000556, `google_news/search` $0.000792, `google_shopping/search` $0.000556 and `bing_maps/search` $0.000556 ([capability catalog](https://api.everyinfra.com/api/v1/social/catalog)). The table maps each search type across the three.

| What you search | SerpAPI API | Serper homepage switcher | EveryInfra | EveryInfra per call |
| --- | --- | --- | --- | --- |
| Web (Google) | Google Search, Google Light | Search | `web` tool, `web/search` | $0.000694, $0.001389 |
| Web (Bing) | Bing Search | None | `bing/search` | $0.000556 |
| Web (DuckDuckGo) | DuckDuckGo Search | None | `duckduckgo/search` | $0.000556 |
| Web (Baidu, Brave, Yandex) | Yes | None | None | — |
| Images | Google Images, Google Images Light | Images | `media` (kind=image) | $0.000694 |
| Video | Google Videos, YouTube Search | Videos | `media` (kind=video) | $0.000694 |
| News | Google News, Google News Light | News | `news` tool, `google_news/search` | $0.000694, $0.000792 |
| Places | Google Maps, Google Local | Maps, Places | `places` tool, `bing_maps/search` | $0.000694, $0.000556 |
| Shopping | Google Shopping, Immersive Product | Shopping | `shopping` tool, `google_shopping/search` | $0.000694, $0.000556 |
| Scholar, patents | Google Scholar, Google Patents | Scholar, Patents | `scholar` (papers, patents) | $0.000694 |
| Autocomplete | Google Autocomplete | Autocomplete | `suggest` | $0.000694 |
| Reverse image | Google Lens | Not listed | `lens` | $0.000694 |
| AI answer surfaces | Google AI Mode, AI Overview | None | None | — |

## Returned fields: what each result carries for the same query

To compare fields, we sent the same 7 queries to 7 EveryInfra search tools. These were the queries:

- Web: "serper vs serpapi"
- Images: "golden gate bridge"
- News: "serpapi"
- Places: "coffee shop" in Austin, TX
- Shopping: "running shoes"
- Scholar: "retrieval augmented generation"
- Autocomplete: "serper vs"

For the two vendors we used their own public examples. The Serper homepage embeds a sample JSON for each endpoint, and each SerpAPI API page opens with a full sample response.

| Surface | Serper homepage sample JSON fields (per result) | SerpAPI sample fields (selection) | EveryInfra fields in our test |
| --- | --- | --- | --- |
| Web | `title`, `link`, `snippet`, `date`, `position`, `sitelinks`, `attributes`; page-level `knowledgeGraph`, `peopleAlsoAsk`, `relatedSearches` | `position`, `title`, `link`, `displayed_link`, `snippet`, `sitelinks`, `rich_snippet`; 60+ page blocks | `title`, `url`, `snippet`, `published` |
| Images | `title`, `imageUrl`, `imageWidth`, `imageHeight`, `thumbnailUrl`, `thumbnailWidth`, `thumbnailHeight`, `source`, `domain`, `link`, `googleUrl`, `position` | `original`, `thumbnail`, `original_width`, `original_height`, `source`, `link` | `title`, `url` |
| News | `title`, `link`, `snippet`, `date`, `source`, `imageUrl`, `position` | `title`, `link`, `source`, `date`, `thumbnail` | `title`, `url`, `published` |
| Places (Places sample) | `position`, `title`, `address`, `latitude`, `longitude`, `rating`, `ratingCount`, `category`, `phoneNumber`, `website`, `cid` | `title`, `place_id`, `gps_coordinates`, `rating`, `reviews`, `type`, `address`, `hours` | `title`, `address`, `latitude`, `longitude`, `rating`, `rating_count`, `category`, `categories`, `phone`, `website`, `opening_hours`, `place_id`, `thumbnail_url` |
| Shopping | `title`, `source`, `link`, `price`, `delivery`, `imageUrl`, `rating`, `ratingCount`, `offers`, `productId`, `position` | `title`, `price`, `extracted_price`, `source`, `rating`, `reviews`, `thumbnail` | `title`, `url`, `price`, `merchant`, `rating`, `rating_count`, `image_url`, `product_id` |

![Grouped bar chart with two bars for each of five surfaces. One bar is the number of fields per result in the Serper homepage sample, and the other is the number in our EveryInfra test. Web: Serper 7, EveryInfra 4. Images: Serper 12, EveryInfra 2. News: Serper 7, EveryInfra 3. Places: Serper 11, EveryInfra 13. Shopping: Serper 11, EveryInfra 8. EveryInfra bars are teal, and the teal Places bar is the longest.](https://everyinfra.com/articles/serper-vs-serpapi/fig-03-fields-bar.en.light.svg?utm_medium=ai_doc&utm_campaign=page_md)

Places is our richest surface. For "coffee shop" in Austin, each of the 10 results had an address, coordinates, rating, rating count, phone, website, opening hours by weekday and a `place_id`. The Serper Places sample has no opening hours, one category and no place ID. The Serper Maps sample adds `placeId`, `types` and `description`, but it has no opening hours either.

Images is our weakest surface. In this test, each `media` result had only the page title and page URL. It had no image file URL, no size and no thumbnail, and both Serper and SerpAPI samples include the original image URL and size.

So for reverse image work, image rights monitoring or image downloads, Serper or SerpAPI fits better. For web and news, we return four fields: title, link, snippet and date. That set suits a model that reads results. If you need the whole page, with ads, knowledge graph and related questions, use SerpAPI. Serper returns part of that page.

Field names also differ. Serper uses camelCase (`imageUrl`, `ratingCount`). SerpAPI and EveryInfra use snake_case (`rating_count`, `place_id`). The organic result link is `link`, `link` and `url` across the three.

The rank is `position`, `position` and `rank` (`web/search` uses `rank`, and the unified `web` tool uses array order). These names cause most migration bugs. Map them from each vendor's docs, not from memory.

Scholar shows the largest gap. Each result in the Serper Scholar sample has 6 fields: `title`, `link`, `publicationInfo`, `snippet`, `year` and `citedBy`. Each result in the Patents sample has 15 fields. They include priority date, filing date, grant date, inventor, assignee, publication number, PDF URL and figures. Our `scholar` tool returned only 3 fields per result in this test: `title`, `url` and `snippet`. It had no year and no citation count.

To sort papers by citations or to track patents by filing date, the Serper sample fields are enough. The SerpAPI Google Scholar and Google Patents APIs also publish full sample responses. To give a model a list of titles and snippets, 3 fields are enough. We counted each Serper surface as the union of fields across all sample results under the homepage switcher, archived the same day.

## Speed: the vendors' claims, SerpAPI's own test and our three rounds

The Serper homepage says "all queries are returned in 1 to 2 seconds". It adds that some requests need a retry and take 2 to 4 seconds. It also says that it caches nothing and fetches every query live ([Serper homepage FAQ](https://serper.dev/)).

On 2025-07-30 SerpAPI published a speed test. The author states at the top that he works for SerpAPI. He ran the same query, "google search api", at least 100 times per vendor.

In that test SerpAPI averaged 0.73 seconds with a p99 of 1.45 seconds, and Serper averaged 0.83 seconds with a p99 of 2.10 seconds. SerpAPI with Ludicrous Speed Max averaged 0.64 seconds ([SerpAPI speed test blog](https://serpapi.com/blog/who-has-the-fastest-google-search-api/)). One vendor ran and published these numbers, and we could not repeat the test. Treat them as a reference only.

On the EveryInfra side, we sent the same query set in three rounds at three different times. We used curl from a machine in Singapore and recorded the full round trip, including the TLS handshake and the network. For each tool we report the median of all successful samples. In round two we sent web twice (00:22 and 00:27) and news twice (both at 00:27). Both calls count, so web and news have 4 samples each. Scholar has 2, because round one hit a rate limit, and the other tools have 3.

| Tool | Round 1 | Round 2 | Round 3 | Median (all samples) | Results per call |
| --- | --- | --- | --- | --- | --- |
| Web (`web`) | 1.65 s (00:14) | 1.49 s (00:22), 1.99 s (00:27) | 2.67 s (00:45) | 1.82 s | 10 |
| Images (`media`) | 2.06 s (00:14) | 2.48 s (00:27) | 2.28 s (00:45) | 2.28 s | 10 |
| News (`news`) | 3.30 s (00:15) | 2.39 s, 1.92 s (00:27) | 2.55 s (00:45) | 2.47 s | 10 |
| Places (`places`) | 3.45 s (00:15) | 3.15 s (00:28) | 2.59 s (00:45) | 3.15 s | 10 |
| Shopping (`shopping`) | 4.16 s (00:15) | 2.10 s (00:28) | 2.24 s (00:45) | 2.24 s | 10 |
| Scholar (`scholar`) | 429, not charged | 1.98 s (00:27) | 1.74 s (00:45) | 1.86 s | 10 |
| Autocomplete (`suggest`) | 1.43 s (00:15) | 1.46 s (00:29) | 1.52 s (00:46) | 1.46 s | 7 |

![Horizontal bar chart with one bar for each of 7 tools. Bar length is the median round trip of all samples: Web 1.82 s, Images 2.28 s, News 2.47 s, Places 3.15 s, Shopping 2.24 s, Scholar 1.86 s, Autocomplete 1.46 s. The web bar is teal and the others are gray. A light gray band marks 1 to 2 seconds, the range Serper claims, and a dashed line marks 0.73 seconds, the SerpAPI average from its own test.](https://everyinfra.com/articles/serper-vs-serpapi/fig-04-latency-bar.en.light.svg?utm_medium=ai_doc&utm_campaign=page_md)

We sent the three rounds at about 00:14, 00:22 to 00:29, and 00:45 Singapore time. In round two the key hit its limit of 10 requests per minute, so that round ran from 00:22 to 00:33. The 7 medians range from 1.46 to 3.15 seconds. Autocomplete was fastest at 1.46 seconds and returned 7 terms. Places was slowest at 3.15 seconds, and each of its results carries opening hours and more than ten fields.

Web search had a median of 1.82 seconds across 4 samples. That is inside the 1 to 2 seconds that Serper claims. It is about 2.5 times the 0.73-second average from SerpAPI's own test. Part of our time is the network trip from Singapore to the server. The SerpAPI post does not say which region it tested from, so the two numbers are not directly comparable.

The spread across rounds for one tool was larger than the spread between tools. Shopping took 4.16 seconds in round one at 00:15 Singapore time, then 2.10 and 2.24 seconds. Places took 3.45, 3.15 and 2.59 seconds.

So one measurement shows only the order of magnitude. To decide on speed, run your own queries from your own region for a full day. Then look at p50 and p95.

Take an AI assistant that searches 2 to 3 times per turn. The medians add about 4 to 6 seconds per turn, and most chat interfaces can accept that. For under 1 second, the only public number is SerpAPI's own test of its fast tiers. Those tiers cost 2 to 4 times the Best Effort price.

![Dot plot with 7 rows for web, images, news, places, shopping, scholar and autocomplete. Each row has two to four dots: light gray for round one, dark gray for round two and teal for round three. The web and news rows have two dark gray dots each. A thin line joins the dots, and a short black tick marks the median of all samples. The round-one shopping dot sits near 4 seconds, far from the other two. All three autocomplete dots sit near 1.5 seconds.](https://everyinfra.com/articles/serper-vs-serpapi/fig-08-latency-rounds-dot.en.light.svg?utm_medium=ai_doc&utm_campaign=page_md)

## Failures, empty results and rate limits: which requests cost money

All three say failures are free, but the details differ. The SerpAPI pricing page says only successful searches count toward the monthly quota. Cached, errored and failed searches do not count. A search counts as one whether it returns 100 results or zero ([SerpAPI pricing FAQ](https://serpapi.com/pricing)). So a rare keyword that finds nothing still uses one search at SerpAPI.

The SerpAPI changelog for November 9 to 15 has a related fix. The Google Short Videos API sometimes returned Google's "Verifying your request" page as a successful search with zero results. It now retries that case automatically ([roadmap #4554](https://github.com/serpapi/public-roadmap/issues/4554)). Before the fix, those pages counted as successful searches.

SerpAPI has one more rule that saves money. If you repeat an identical query within 1 hour, it returns the cached result by default. Cached searches are free and do not count. To force a fresh result, pass `no_cache=true` ([no_cache parameter in the Google Search API docs](https://serpapi.com/search-api)).

Serper says it deducts a credit for each successful response. It does not say whether an empty result counts. It also says it does not cache, so the same query twice costs two credits.

On the EveryInfra side, we tested three requests that should not cost money. The first was a bad parameter. We set the image tool's `kind` to `gif`, which the catalog does not allow. For that call, the response was 422 `invalid_value`. It listed `image` and `video` as the allowed values and charged $0.

The second was an empty result. We searched the web for a quoted string of random letters. For that call, the response was 200 with zero results. It showed `billing.charged` false and the reason `empty_result_refunded`, so it charged $0.

The third was a rate limit. This test key allows 10 requests per minute. 23 requests got a 429 response that said "Nothing was charged" and gave a `retry_after` value. We waited that long, resent, and the balance did not change.

| Case | Serper | SerpAPI | EveryInfra (our test) |
| --- | --- | --- | --- |
| Success with results | 1 credit | 1 search | 1 charge, $0.000694 |
| Success with zero results | Not stated | 1 search | 200, $0 (`empty_result_refunded`) |
| Bad parameter | Not stated | Errors do not count | 422, $0 |
| Rate limit | Not stated | Errors do not count | 429, $0, with `retry_after` |
| Same query again within 1 hour | Charged each time (no cache) | Cached by default, free | Charged each time |
| 11 to 100 results | 2 credits | 1 search per page | 1 charge per page |

![Screenshot of a real EveryInfra unified search round trip. The top half is the request: POST /api/v1/search with tool places, q coffee shop, location Austin, TX and num 10. The bottom half is the 200 response. The first result is a coffee shop with address, coordinates, a 4.4 rating, rating count, phone and opening hours. A teal box marks the billing line with charged true and charged_usd 0.000694. A second block shows the 422 response for the image tool with kind set to gif, and a teal box marks Nothing was charged.](https://everyinfra.com/articles/serper-vs-serpapi/img-api-return.webp?utm_medium=ai_doc&utm_campaign=page_md)

One places search cost $0.000694, and one request with a bad parameter returned 422 at no charge. We removed the balance and internal fields. [EveryInfra unified search live response](https://api.everyinfra.com/api/v1/search/tools)

Put these rules into one real job. A rank monitor checks 2,000 keywords per day for the top 10, which is 60,000 queries per month. 5% of the keywords are rare long-tail words that return zero results. 3% of requests hit a rate limit at peak and get resent after the wait time. A second version of the job runs the same batch again within 1 hour as a check.

One script priced both versions with each vendor's published rules. Serper does not state how it bills empty results, so the table shows both cases.

| Version | SerpAPI | Serper (empty charged) | Serper (empty free) | EveryInfra |
| --- | --- | --- | --- | --- |
| One run per day: billed calls | 60,000 (empty counts, rate limit does not) | 60,000 | 57,000 | 57,000 (empty and rate limit free) |
| One run per day: monthly cost | Searcher $725 | 1 Standard, $62.50 per month | 7 Starter, $58.33 per month | $39.56 |
| Rerun within 1 hour: billed calls | 60,000 (rerun hits the free cache) | 120,000 | 114,000 | 114,000 |
| Rerun within 1 hour: monthly cost | Searcher $725 (Volume, $1,475, without the cache) | 1 Standard + 5 Starter, $104.17 per month | 1 Standard + 4 Starter, $95.83 per month | $79.12 |

The empty-result rule moves the bill by about 5%. We and an "empty free" Serper bill 3,000 fewer calls, which saves $2 to $4 per month. The 1-hour cache moves the whole plan. On a rerun, the SerpAPI bill stays the same. Without the cache, SerpAPI would move from Searcher to Volume, which adds $750 per month.

Serper and EveryInfra charge per call, so a rerun doubles the bill. Even then, SerpAPI is the most expensive of the three for this job. The cache only cuts its gap to Serper from about 12 times to about 7 times. Rate limits cost nothing at all three: SerpAPI does not count errors, Serper charges only on a successful response, and our 429 responses charged $0.

![Grid chart. Six rows are success with results, success with zero results, bad parameter, rate limit, same query within 1 hour, and 11 to 100 results. Three columns are Serper, SerpAPI and EveryInfra. Teal cells say Free, gray cells say Charged, light gray cells say Not stated and a dark gray cell says 2x charge. The middle three Serper cells say Not stated. SerpAPI is free for bad parameters, rate limits and repeated queries. EveryInfra is free for zero results, bad parameters and rate limits.](https://everyinfra.com/articles/serper-vs-serpapi/fig-13-billing-cases-heat.en.light.svg?utm_medium=ai_doc&utm_campaign=page_md)

## Pagination and num: how many calls each vendor needs for 100 results

In mid-September 2025, Google stopped honoring the `num=100` parameter that returned 100 results in one page. Search Engine Land reported that month that 77% of sites saw fewer visible keywords in Search Console ([Search Engine Land, 2025-09-18](https://searchengineland.com/google-num100-impact-data-462231)). Users in Google's own help forum reported around 2025-09-16 that the 100-results-per-page option was gone ([Google Search Help forum](https://support.google.com/websearch/thread/373102276)). This changed the bill for 100 results at all three vendors. Ten results per page is now normal, and deeper results need more pages.

The SerpAPI Google Search docs no longer list a `num` parameter. You page with `start`, and each page is one search. Its changelog for November 9 to 15 also says it "reduced follow-up pages without organic results when `start` is 10 or more" ([roadmap #4058](https://github.com/serpapi/public-roadmap/issues/4058)). That shows deep paging is not fully stable. For Serper, a third party says 11 to 100 results cost 2 credits ([ColdIQ](https://coldiq.com/blog/serper-pricing)).

Another test says a single `num=100` request returned HTTP 400, and only 10 pages worked ([Scrapeless comparison page](https://www.scrapeless.com/en/alternatives/serper-alternative)). The two reports do not agree, and we have no Serper account to check. Test it with your free credits first. The EveryInfra `web` tool returns up to 10 results per page and pages with `page`. Each page costs $0.000694.

| For the top 100 results | Serper | SerpAPI | EveryInfra `web` tool |
| --- | --- | --- | --- |
| Requests | 1 (num=100, if it works) or 10 | 10 (start=0 to 90) | 10 (page=1 to 10) |
| Billing | 2 or 10 credits | 10 searches | 10 charges |
| At entry price | $0.002 or $0.010 | $0.25 (Starter) | $0.00694 |
| At lowest price | $0.0006 or $0.003 | $0.0196 (Cloud 54M) | $0.00694 |

For jobs that need the top 100, the SerpAPI premium grows 10 times. On Starter, 100 results for one keyword cost $0.25. At 200 keywords per day, the top 100 is 60,000 searches per month. SerpAPI needs the Searcher plan at $725 per month. For the same volume, Serper needs one Standard pack per six months, or $62.50 per month, and we cost $41.64.

Rank tracking and full competitor indexing are where Serper and per-request APIs gain the most. For AI retrieval, Q&A and fact checks that need only the top 10, all three charge one call per request. Only the unit price differs.

![Bar chart on a log scale showing the cost of the top 100 results for one keyword. SerpAPI Starter $0.25 is the longest bar. SerpAPI Cloud 54M is $0.0196, Serper Starter with 10 pages is $0.010, Serper Ultimate with 10 pages is $0.003, Serper Starter with num=100 is $0.002 and EveryInfra with 10 pages is $0.0069. The EveryInfra bar is teal.](https://everyinfra.com/articles/serper-vs-serpapi/fig-09-top100-cost-bar.en.light.svg?utm_medium=ai_doc&utm_campaign=page_md)

## Three common jobs priced per month: an AI assistant, a rank monitor and local leads

Real jobs rarely land on the round numbers in the seven-row table. They fall between tiers, and the tier steps change the bill again. We priced three common jobs with the same method. SerpAPI takes the cheapest plan that fits.

Serper buys six months at once after the free credits. EveryInfra multiplies volume by $0.000694. One script computes all four rows.

| Job | Requests per month | SerpAPI | Serper (6-month buy, per month) | EveryInfra |
| --- | --- | --- | --- | --- |
| AI assistant: 200 questions per day x 3 searches | 18,000 | Big Data $275 | 3 Starter, $25.00 | $12.49 |
| Rank monitor: 2,000 keywords daily, top 10 | 60,000 | Searcher $725 | 1 Standard, $62.50 | $41.64 |
| Rank monitor: 2,000 keywords daily, top 100 | 600,000 | Cloud 1M $3,750 | 1 Scale + 2 Standard + 2 Starter, $350.00 | $416.40 |
| Local leads: 500 cities x 5 pages of places | 2,500 | Developer $75 | 1 Starter, $8.33 | $1.73 |

The AI assistant answers 200 questions per day and searches 3 times per question. That is about 18,000 searches per month, each for the top 10. SerpAPI Production gives 15,000 per month, which is not enough, so the job needs Big Data at $275. Serper needs 108,000 searches in six months.

After the free 2,500, three Starter packs cost $150, or $25 per month. EveryInfra costs $12.49 per month. The SerpAPI tier step drives this row: 3,000 extra searches move the fee from $150 to $275.

At the top 10, the job sends 60,000 searches per month. SerpAPI has no plan between 30,000 and 100,000, so you buy Searcher and lose 40,000 unused searches each month. Serper needs 360,000 in six months, and one Standard pack covers it.

We cost $41.64 per month. At the top 100, the volume grows 10 times to 600,000 per month. SerpAPI moves to Cloud 1M, and Serper's cheapest six-month mix costs $350 per month.

At that depth we cost $416.40 per month, so Serper is now cheaper. This matches the crossover near 310,000 searches per month. If `num=100` works on your Serper account at 2 credits, Serper's cost in this row drops to about one fifth. Test that with free credits before you plan around it.

The local leads job is small and runs once a month. It searches one business type in 500 cities and reads 5 pages of places per city, for 2,500 requests. SerpAPI Starter has only 1,000 searches, so you buy Developer. Serper needs one Starter pack. Six months need 15,000 searches. After the 2,500 free ones, you use 12,500 of the pack's 50,000 credits, and 37,500 expire.

We charge $1.73 per month. A per-request API with a balance that does not expire is the cheapest fit for this job. Our places results also carry opening hours and several categories, which saves a second lookup per business.

![Grouped bar chart on a log scale with three bars for each of four jobs: SerpAPI, Serper and EveryInfra monthly cost. AI assistant at 18,000 per month: $275, $25.00 and $12.49. Rank monitor, top 10, 60,000 per month: $725, $62.50 and $41.64. Rank monitor, top 100, 600,000 per month: $3,750, $350.00 and $416.40. Local leads at 2,500 per month: $75, $8.33 and $1.73. EveryInfra is teal, and only in the top-100 row is it longer than Serper.](https://everyinfra.com/articles/serper-vs-serpapi/fig-07-scenarios-bar.en.light.svg?utm_medium=ai_doc&utm_campaign=page_md)

## Law and data quality: Google v. SerpApi and "poisoned" results

On 2025-12-19, Google sued SerpApi in the U.S. District Court for the Northern District of California. It claimed SerpApi bypassed SearchGuard, an anti-bot system Google launched in January 2025, in breach of the anti-circumvention rule in Section 1201 of the Digital Millennium Copyright Act ([Reuters, 2025-12-19](https://www.reuters.com/legal/litigation/google-lawsuit-says-data-scraping-company-uses-fake-searches-steal-web-content-2025-12-19/)).

The text of the rule is at [17 U.S.C. § 1201](https://www.law.cornell.edu/uscode/text/17/1201), and the U.S. Copyright Office explains it at [copyright.gov/1201](https://www.copyright.gov/1201/).

On 2026-07-20 the court granted SerpApi's motion to dismiss the first complaint. Claims about search results with no copyrighted content were dismissed without leave to amend. Claims about results with copyrighted content could be amended, and discovery was stayed. Google filed its amended complaint on 2026-08-10.

On 2026-11-09, Chief Judge Yvonne Gonzalez Rogers dismissed Google's amended complaint. She gave Google 21 days to amend again, or the case would end with prejudice ([court order PDF, docket entry 62](https://storage.courtlistener.com/recap/gov.uscourts.cand.461513/gov.uscourts.cand.461513.62.0.pdf)). SerpApi described the order in [its blog post of November 10](https://serpapi.com/blog/court-dismisses-googles-amended-complaint-against-serpapi/), and [Search Engine Roundtable covered it on 2026-11-10](https://www.seroundtable.com/google-loses-again-against-serpapi-42508.html).

The judge's court page is on the [Northern District of California site](https://www.cand.uscourts.gov/judges/gonzalez-rogers-yvonne-ygr/). Search Engine Roundtable notes that the judge did not rule that SerpApi's scraping is lawful. The order says only that Google's complaint lacked facts, and the new deadline is November 30.

For SerpAPI users, the U.S. Legal Shield from Production up covers claims about lawful collection and parsing of search data. It covers only claims in U.S. courts under U.S. law, and it does not cover how you use the data ([U.S.

Legal Shield page](https://serpapi.com/us-legal-shield)). For Serper users, we found no similar promise on its homepage or in its [terms](https://serper.dev/terms). SerpAPI's terms and legal pages are at [serpapi.com/legal](https://serpapi.com/legal). The busyless review also says Serper has "no public stance on scraping law".

Google states its own rules more directly. Its spam policies define machine-generated traffic as sending automated queries to Google. They name "scraping results for rank-checking purposes" and other automated access without express permission. They say these violate the spam policies and the Terms of Service ([Google Search spam policies](https://developers.google.com/search/docs/essentials/spam-policies)).

The [Google Terms of Service](https://policies.google.com/terms), effective 2026-07-30, also forbid automated access in violation of machine-readable instructions on its pages. These are Google's own policy and terms. The court in this case is reviewing a DMCA anti-circumvention claim.

If a buyer needs the vendor to carry claims in writing, SerpAPI has the Legal Shield terms, and Serper's public pages have no such terms. We only report what the two vendors publish. This is not legal advice. Ask your own lawyer about your use case.

The second issue is data quality. The rank tracking company Nozzle published research on 2026-10-10 and updated it on 2026-11-03. It found that since September, Google has served bulk collectors pages that look normal but carry swapped results. Across 42.5 million result pages, it found an average of 27.6% with page one or two swapped, with a peak of 68.6% on 2026-11-02 ([Nozzle research](https://nozzle.io/research/poisoned-google-serps/)).

SerpAPI posted on 2026-11-12 that it also saw such results in its Google Search and Google Shopping APIs. It said it had adjusted its collection, and that the issue still appears at times. It also opened an incident on its status page ([SerpAPI blog, 2026-11-12](https://serpapi.com/blog/googles-poisoned-search-results/), [status page incident](https://status.serpapi.com/incidents/bhj19czp9b04), roadmap [#3781](https://github.com/serpapi/public-roadmap/issues/3781) and [#4475](https://github.com/serpapi/public-roadmap/issues/4475)). Serper made no public comment.

Any API that returns Google results can see this problem, including ours. Recheck stable keywords on a schedule. When a rank jumps, query again a day or two later before you draw a conclusion.

Google's own path is also closing. Its Custom Search JSON API docs say the API is closed to new customers and will shut down on January 1, 2027. Current customers get 100 free queries per day and pay $5 per 1,000 above that ([Custom Search JSON API docs](https://developers.google.com/custom-search/v1/overview)). New projects that need Google results by API will have only third-party options. Count the legal and quality issues above when you choose one.

## Connecting AI tools: MCP servers and request formats for all three

In Claude, ChatGPT and Cursor, a search API usually connects as an MCP server. MCP is the Model Context Protocol, the way AI clients call outside tools ([specification, 2025-06-18 version](https://modelcontextprotocol.io/specification/2025-06-18)). SerpAPI hosts its own MCP service at `mcp.serpapi.com`. One `search` tool covers all its engines. You pass the key in a header or in the path, and it can compress results to Markdown to save tokens ([serpapi-mcp repository](https://github.com/serpapi/serpapi-mcp)).

Serper has no MCP server of its own. People use community servers such as [mcp-server-serper](https://github.com/marcopesani/mcp-server-serper) and [serper-mcp-server](https://github.com/garylab/serper-mcp-server), which you run on your own machine over the stdio transport. A remote service uses the Streamable HTTP transport, so the client needs only a URL ([MCP transports specification](https://modelcontextprotocol.io/specification/2025-06-18/basic/transports)). In agent frameworks, Serper has ready tool classes, such as the [CrewAI SerperDevTool](https://docs.crewai.com/en/tools/search-research/serperdevtool) and the [LangChain Google Serper integration](https://python.langchain.com/docs/integrations/tools/google_serper/).

EveryInfra is a remote MCP service at `https://api.everyinfra.com/mcp`. All its tool names start with `everyinfra_`, and it includes unified search and 612 data capabilities. In Claude Code, add it as an HTTP server as the [Claude Code MCP docs](https://code.claude.com/docs/en/mcp) describe.

Through the Claude API, use the [MCP connector](https://docs.claude.com/en/docs/agents-and-tools/mcp-connector). Through the OpenAI Responses API, use the remote MCP tool ([OpenAI docs](https://platform.openai.com/docs/guides/tools-remote-mcp), [connectors and MCP guide](https://developers.openai.com/api/docs/guides/tools-connectors-mcp)). Keep the key in an environment variable:

```text
{
  "mcpServers": {
    "everyinfra": {
      "type": "http",
      "url": "https://api.everyinfra.com/mcp",
      "headers": { "Authorization": "Bearer ${EVERYINFRA_API_KEY}" }
    }
  }
}
```

Without an AI tool, unified search is one POST. Set `tool` to the tool name and put the arguments in `params`. This is the places query from our first round, unchanged. The `billing.charged_usd` field in the response is the charge for that call:

```bash
curl -s https://api.everyinfra.com/api/v1/search \
  -H "Authorization: Bearer $EVERYINFRA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"tool":"places","params":{"q":"coffee shop","location":"Austin, TX","num":10}}'
# 200: results holds 10 shops (title, address, latitude, longitude, rating, rating_count, phone, website, opening_hours, place_id)
# billing.charged_usd = 0.000694
```

To move from Serper, change three things. The URL changes from `google.serper.dev/<endpoint>` to `/api/v1/search`, and the endpoint name becomes `tool`. The auth header changes from `X-API-KEY` to `Authorization: Bearer`.

Result fields change from camelCase to snake_case, and `link` becomes `url`. To move from SerpAPI, change GET to POST and `engine` to `tool`. Keep `q`, and read `results` instead of `organic_results`.

SerpAPI maintains its own Python and JavaScript clients ([serpapi-python](https://github.com/serpapi/serpapi-python), [google-search-results-python](https://github.com/serpapi/google-search-results-python), [serpapi-javascript](https://github.com/serpapi/serpapi-javascript), and on PyPI [serpapi](https://pypi.org/project/serpapi/) and [google-search-results](https://pypi.org/project/google-search-results/)). Does your code use these clients? Then replace the client calls with plain HTTP requests. You can also let the AI tool use MCP. To call a separately priced capability such as Google News on the data endpoint, send `platform` and `action`:

```bash
curl -s https://api.everyinfra.com/api/v1/social \
  -H "Authorization: Bearer $EVERYINFRA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"platform":"google_news","action":"search","params":{"keyword":"serpapi","country":"us","language":"en"}}'
# 200: each result has rank, title, url, source, text, published_at, image_url
```

In workflow tools such as n8n, SerpAPI has a ready node ([n8n SerpApi tool node docs](https://docs.n8n.io/integrations/builtin/cluster-nodes/sub-nodes/n8n-nodes-langchain.toolserpapi/)). For Serper and for us, use the [HTTP Request node](https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.httprequest/) with the URL and body above.

This table lists what changes when you connect each vendor to an AI tool or to code:

| Item | Serper | SerpAPI | EveryInfra |
| --- | --- | --- | --- |
| Own MCP service | None, community servers run locally (stdio) | `mcp.serpapi.com`, remote | `https://api.everyinfra.com/mcp`, remote |
| Where the key goes | Header `X-API-KEY` | Query parameter `api_key`; MCP takes a header or path | Header `Authorization: Bearer` |
| Method | POST with a JSON body | GET with query parameters | POST with a JSON body |
| How you pick a surface | Endpoint path (`/search`, `/images`) | `engine` parameter | `tool` field; `platform` and `action` on the data endpoint |
| Result array | `organic`, `images`, `places` and others | `organic_results`, `images_results` and others | Always `results` |
| Link and rank fields | `link`, `position` | `link`, `position` | `url`, `rank` (or array order) |
| What this call cost | Check the dashboard balance | Check the dashboard or the Account API | `billing.charged_usd` in each response |

We return `billing.charged_usd` in every response, so a script can add it up as it runs and stop at its budget. With Serper and SerpAPI you check usage in a dashboard or an account endpoint.

## What the videos show that the web pages do not

We searched YouTube for "serper vs serpapi" and read the transcripts of the top three videos. The first sets up a Serper HTTP request in n8n (TUTOR BASE, 2026-02-04). The second uses Serper inside a Clay table (Jim Ortiz, 2025-10-15).

The third is a product tour from SerpAPI's own channel (2026-01-30). All publish dates are in Singapore time. None of the three compares the two vendors head to head. They do show details that the pricing pages and doc home pages leave out.

At 0:58 the n8n video sets the node's built-in authentication to "None" and puts the key in a request header. It advises you to store the key in n8n credentials, not in shared fields ([video](https://www.youtube.com/watch?v=U277WSj3X4U)). The [n8n credentials docs](https://docs.n8n.io/credentials/) show how. At 2:01 it lists three common errors. A 401 means the key is missing or wrong. A 400 means the body is malformed or `q` is missing.

A 429 means a rate limit, so wait and retry. These codes mean the same on EveryInfra. The difference is a bad parameter. There we return 422 and list the allowed values in the error. The client or AI tool can then fix the call and resend.

These status codes have standard meanings. 429 Too Many Requests comes from section 4 of [RFC 6585](https://www.rfc-editor.org/rfc/rfc6585). The server can add a Retry-After header to say when to try again. Section 15.5 of [RFC 9110](https://www.rfc-editor.org/rfc/rfc9110) defines 400, 401 and 422.

Retry logic that follows these standards works on all three vendors. Do not retry 401 or 422, and fix the key or the parameters first. Wait for the Retry-After time on 429, and retry 503 after a pause. Our transcript requests returned 503 three times in a row, so we stopped and read the transcripts another way.

The Clay video has three details worth noting ([video](https://www.youtube.com/watch?v=y2N1mr_5aaM)). First, Clay has no direct Serper integration, so you use the generic HTTP API column and set the method to POST. Second, the author sets `num` to 1 when he needs only the first result. The default is 10, and at Serper this saves no money, because up to 10 results cost 1 credit, but it keeps the table clean. Third, a places search returns at most 10 results per call, so he builds 5 columns for pages 1 to 5.

He also says Serper's web scraping endpoint costs more, from 2 to 10 credits per call depending on the site. His own math is $50 for 50,000 credits, which he puts at 57 times cheaper than the same Google searches with Clay credits. That figure is his, from his own Clay plan.

The SerpAPI tour centers on the playground ([video](https://www.youtube.com/watch?v=ViZ5WvDbzKY)). You pick an engine, type a query and read the JSON before you write code. The dashboard shows a search history for every call. You can invite team members and give each one a key, and an Account API reports usage to your code. On EveryInfra, each capability page has a live try-it panel, every response carries `billing.charged_usd`, and the console shows the balance and each charge.

The comments show one pain point. Under the Clay video, a viewer asked where the request body came from, because the video does not explain it. The author replied that he asked ChatGPT to write the JSON body.

EveryInfra `youtube/comments` returned these 3 comments at 00:47 Singapore time. The n8n video returned no comments this time, so the call counted as an empty result and cost nothing. The 2 comments under the SerpAPI tour are thanks only.

On the request body, all three vendors give examples you can copy. Serper has code boxes under its homepage switcher. SerpAPI has a playground on each API page. EveryInfra has a try-it panel on each capability page.

Copy an example from there before you connect. Models often write `q`, `gl` and `num` with another vendor's parameter names.

| Video | Published | Detail the video shows and the web pages do not |
| --- | --- | --- |
| Serper in n8n (TUTOR BASE) | 2026-02-04 | Set node auth to None, put the key in a header and store it in credentials; what 401, 400 and 429 mean |
| Serper in Clay (Jim Ortiz) | 2025-10-15 | No direct Clay integration, so use the HTTP API column; places return 10 per call, so build 5 columns for pages; web scraping costs 2 to 10 credits per call |
| SerpAPI product tour (SerpAPI channel) | 2026-01-30 | Read the JSON in the playground first; a search history for every call; one key per team member; the Account API for usage |

## When Serper is a better fit

Serper fits better than us and SerpAPI in three cases. The first is steady Google search volume above 500,000 per month. By the table above, Serper costs $0.54 per 1,000 at 500,000 per month and $0.33 at 5 million. We stay at $0.694, so the gap grows with volume. The second is image search where you need the image file URL.

The Serper `/images` sample has `imageUrl`, width, height and a thumbnail, and our `media` tool returned only the page title and URL in this test. The third is bursts of hundreds of queries per second. The Ultimate pack allows 300 per second by default, and the homepage says it can go higher on request.

Our limit is per account, shared by all your keys, and it is 60 per minute by default. A 30-day boost pack costs $10 for 180 per minute, $30 for 600 and $78 for 1,800. Total top-ups of $50, $150 and $750 unlock the same tiers for free ([pricing](/en/pricing), read 2026-11-19). The top tier of 1,800 per minute is one tenth of the 300 per second on Serper Ultimate. The test key in this article allows 10 per minute, which is only a limit for writing.

![Bar chart on a log scale for maximum requests per hour: Serper Starter 180,000, Serper Ultimate 1,080,000, SerpAPI Starter 200, SerpAPI Searcher 20,000, SerpAPI Cloud 54M 640,000, EveryInfra default 3,600 and EveryInfra top boost 108,000. The two EveryInfra bars are teal.](https://everyinfra.com/articles/serper-vs-serpapi/fig-16-rate-limit-bar.en.light.svg?utm_medium=ai_doc&utm_campaign=page_md)

## When SerpAPI is a better fit

SerpAPI has the highest unit price of the three, but some things only it offers. One SerpAPI key covers engines beyond Google, such as Bing, Baidu, Yandex, Brave and Naver. The same key covers Google verticals such as Flights, Hotels, Jobs, Finance and the Play Store. Serper has none of these, and we have some. For SEO work on full-page structure, such as ad positions, knowledge graph, related questions, local packs and AI Overviews, SerpAPI splits the page most finely.

For legal cover, the Production plan and up include the U.S. Legal Shield. SerpAPI also offers ZeroTrace mode, which keeps no queries or results in its systems ([ZeroTrace page](https://serpapi.com/zero-trace-mode)). For open operations data, it has a public status page per engine ([API status page](https://serpapi.com/status)) and a [public roadmap](https://github.com/serpapi/public-roadmap). For jobs with many repeated queries, the free 1-hour cache also cuts the bill. In the rank monitor above, a rerun within 1 hour leaves the SerpAPI bill unchanged, while the Serper and EveryInfra bills double.

## Recent changes (last 30 days)

| Date | Event | What it means for you |
| --- | --- | --- |
| Around 2026-11-16 | SerpAPI weekly changelog: new Brave Search, Brave Images and DuckDuckGo Images APIs, plus fixes for missing organic results on deep Google pages, missing ad descriptions ([#4526](https://github.com/serpapi/public-roadmap/issues/4526)) and Jobs API timeouts in some languages ([#4337](https://github.com/serpapi/public-roadmap/issues/4337)) ([changelog](https://serpapi.com/blog/serpapi-weekly-changelog-november-09-15-2026/)) | SerpAPI keeps adding engines, and multi-engine reach is the main reason to pick it |
| 2026-11-05 | SerpApi joins the Internet Infrastructure Coalition and gets the Ethical Web Data Collection Initiative trust seal ([press release](https://www.morningstar.com/news/pr-newswire/20261105da90449/serpapi-joins-the-internet-infrastructure-coalition-earns-ethical-web-data-collection-initiative-trust-seal)) | One more compliance document to request during procurement |
| 2026-10 | EFF criticizes the use of DMCA Section 1201 against scrapers and names Reddit's suit against SerpAPI ([EFF](https://www.eff.org/deeplinks/2026/10/anti-circumvention-laws-raise-cost-knowledge)) | SerpAPI also faces a suit from Reddit, so the legal risk is not one case |

![Vertical timeline from October 10 to November 19, 2026, with one event per row and each dot placed by date. Oct 10, Nozzle poisoning study. Nov 3, Nozzle update with a 68.6% peak. Nov 5, SerpApi joins an industry coalition. Nov 9, the court dismisses the amended complaint. Nov 10, SerpApi blogs about the ruling. Nov 12, SerpAPI confirms poisoned results. Nov 16, SerpAPI adds Brave and other APIs. Nov 19, our price read and test, shown in teal.](https://everyinfra.com/articles/serper-vs-serpapi/fig-12-changes-timeline.en.light.svg?utm_medium=ai_doc&utm_campaign=page_md)

## How we checked these numbers

We read both price lists directly between 00:17 and 00:18 SGT on 2026-11-19. Serper's pricing block is on its homepage, because `serper.dev/pricing` returned 404 that day, and we saved the page text. The SerpAPI pricing page embeds 183 plan records (61 tiers times 3 speeds), and we saved them as JSON.

One script computes the price per 1,000, the seven-volume table, the three jobs and the crossover from those files and our live results. Every number in the charts and tables comes from that script. We took both pricing screenshots at the same time with headless Chrome, and the teal boxes mark only the rows we cite.

On the EveryInfra side we sent 60 requests. 31 returned 200 and 29 returned another status (422, 429 or 503). The total charge was $0.0213, and each call's HTTP status, timing and `charged_usd` is in the raw files. Timings are full round trips from a client in Singapore, so another region or another hour will differ.

Three rounds are a small sample. They show the order of magnitude for these queries on this day, not a stable p50. For the two vendors we cite only their own published speed numbers.

What we did not do: we did not sign up for Serper or SerpAPI. We did not compare whether the three return the same ranks for the same query. We did not test how Serper bills an empty result or `num=100`. Our YouTube transcript capability returned 503 three times during this test at no charge, so we read the transcripts from the video pages instead.

## FAQ

### Is SerpAPI free?

SerpAPI has a free plan with 250 searches per month and up to 50 per hour. The searches do not roll over, and the plan has no U.S. Legal Shield ([SerpAPI pricing page](https://serpapi.com/pricing)).

Its 2024 comparison post still says 100 searches per month ([SerpAPI comparison post](https://serpapi.com/blog/compare-serpapi-with-the-alternatives-serper-and-searchapi/)), so trust the pricing page. Serper gives 2,500 searches at sign-up, with no card. EveryInfra gives $1 of trial credit when you star two GitHub repositories, valid for 24 hours, which covers about 1,440 unified searches at $0.000694 each.

### Is SerpAPI legal?

Google sued SerpApi in December 2025. The court dismissed Google's complaint on 2026-07-20 and again on 2026-11-09, but the judge said she did not rule the scraping lawful. Google can amend until November 30 ([Search Engine Roundtable](https://www.seroundtable.com/google-loses-again-against-serpapi-42508.html)).

SerpAPI gives Production and higher customers a U.S. Legal Shield that covers lawful collection claims in U.S. courts. We only report public material and give no legal advice. Ask a lawyer whether your use is compliant.

### Is SerpAPI owned by Google?

No. SerpApi, LLC is a company based in Austin, Texas. Its own comparison post says it started in 2017.

It is on the other side of a lawsuit with Google. SERP in its name stands for "search engine results page" and does not mean a link to Google. Google's own search API is the Custom Search JSON API, which is closed to new customers and shuts down on January 1, 2027.

## Getting started: run the same queries on all three

First, get a key. On EveryInfra, star ([how stars work](https://docs.github.com/en/get-started/exploring-projects-on-github/saving-repositories-with-stars)) the [everyinfra-agent-plugins](https://github.com/everyinfra/everyinfra-agent-plugins) and [seo-skills](https://github.com/everyinfra/seo-skills) repositories on GitHub to get $1 of trial credit. Paid use starts at a $10 top-up, and the balance does not expire ([quickstart](/en/docs#quickstart), [pricing](/en/pricing)). Serper gives 2,500 free searches at sign-up, and the SerpAPI free plan gives 250 per month.

Second, pick 5 to 10 keywords that you really search, across web, news, places and shopping. Run them on all three vendors. Record the result count, the fields you get and the cost of each call. On our side, you can try each one on its doc page:

- [Web search](/en/web-api/search)
- [Google News search](/en/google-news-api/search)
- [Google Shopping search](/en/google-shopping-api/search)
- [Bing Maps search](/en/bing-maps-api/search)

The platform pages are [Web Search API](/en/web-api), [Bing Search API](/en/bing-api) and [Google News API](/en/google-news-api).

Third, put your monthly volume into the seven-row table above and compare real cost, not list price. To let an AI tool search on its own, add the remote MCP server with the config above. For details, see [remote MCP setup](/en/build/remote-mcp-setup). Browse all capabilities by category in the [data market](/en/market). For one vendor's price details, read our earlier articles:

- [Serper API pricing breakdown](/en/blog/serper-api-pricing)
- [SerpAPI pricing explained](/en/blog/serpapi-pricing-explained)
- [SerpAPI alternatives](/en/blog/serpapi-alternatives)
- [Serper API alternative](/en/blog/serper-api-alternative)
- [Free Serper alternative](/en/blog/serper-api-free-alternative)
- [Best web search API for AI agents](/en/blog/best-web-search-api-for-ai-agents)

The comparison page is [SerpAPI alternatives](/en/alternatives/serpapi).

## References

1. Serper homepage pricing block and FAQ (four packs, 6-month validity, billing and refunds), Serper, read 2026-11-19. https://serper.dev/
1. SerpAPI pricing page (plans, hourly throughput, billing FAQ), SerpAPI, read 2026-11-19. https://serpapi.com/pricing
1. Ludicrous Speed (2x resources, 2x price), SerpAPI. https://serpapi.com/ludicrous-speed
1. EveryInfra search tools catalog (17 tools: crosscheck $0.002778 per call, the rest $0.000694), EveryInfra, read 2026-11-19. https://api.everyinfra.com/api/v1/search/tools
1. SerpAPI Google Search API docs (blocks, start pagination, no_cache rule), SerpAPI. https://serpapi.com/search-api
1. U.S. Legal Shield (included from Production, scope), SerpAPI. https://serpapi.com/us-legal-shield
1. Serper Pricing in 2026 (2-credit rule, flat endpoint price), ColdIQ, prices checked 2026-07-05. https://coldiq.com/blog/serper-pricing
1. Serper Review (Google only, no AI Overviews endpoint, no public legal position), busyless, captured 2026-09. https://busyless.space/seo-apis/serper
1. SerpAPI status and error codes (sidebar lists every API), SerpAPI. https://serpapi.com/api-status-and-error-codes
1. SerpAPI release notes, SerpAPI. https://serpapi.com/release-notes
1. SerpApi Weekly Changelog: November 09 - 15, 2026 (Brave, DuckDuckGo Images and more), SerpAPI. https://serpapi.com/blog/serpapi-weekly-changelog-november-09-15-2026/
1. SerpAPI public roadmap #74: Brave Search API, GitHub. https://github.com/serpapi/public-roadmap/issues/74
1. SerpAPI public roadmap #325: Brave Images API, GitHub. https://github.com/serpapi/public-roadmap/issues/325
1. SerpAPI public roadmap #2219: DuckDuckGo Images API, GitHub. https://github.com/serpapi/public-roadmap/issues/2219
1. EveryInfra capability catalog (612 capabilities, price_usd, response_fields), EveryInfra, read 2026-11-19. https://api.everyinfra.com/api/v1/social/catalog
1. Who Has the Fastest Google Search API? (test by a SerpAPI employee), SerpAPI, 2025-07-30. https://serpapi.com/blog/who-has-the-fastest-google-search-api/
1. SerpAPI public roadmap #4554: verify page returned as a successful empty search, GitHub. https://github.com/serpapi/public-roadmap/issues/4554
1. 77% of sites lost keyword visibility after Google removed num=100, Search Engine Land, 2025-09-18. https://searchengineland.com/google-num100-impact-data-462231
1. User report on the missing 100-results option, Google Search Help forum, 2025-09-15. https://support.google.com/websearch/thread/373102276
1. SerpAPI public roadmap #4058: later pages without organic results, GitHub. https://github.com/serpapi/public-roadmap/issues/4058
1. Serper alternative page (num=100 single request returned 400 in its test), Scrapeless. https://www.scrapeless.com/en/alternatives/serper-alternative
1. Google lawsuit says data scraping company uses fake searches, Reuters, 2025-12-19. https://www.reuters.com/legal/litigation/google-lawsuit-says-data-scraping-company-uses-fake-searches-steal-web-content-2025-12-19/
1. 17 U.S. Code § 1201, Cornell Law School LII. https://www.law.cornell.edu/uscode/text/17/1201
1. Section 1201 rulemaking, U.S. Copyright Office. https://www.copyright.gov/1201/
1. Google LLC v. SerpApi, LLC, No. 4:25-cv-10826-YGR, Dkt. 62 order, N.D. Cal., 2026-11-09. https://storage.courtlistener.com/recap/gov.uscourts.cand.461513/gov.uscourts.cand.461513.62.0.pdf
1. Court Dismisses Google's Amended Complaint Against SerpApi, SerpAPI, 2026-11-10. https://serpapi.com/blog/court-dismisses-googles-amended-complaint-against-serpapi/
1. Google Loses Another Round in Legal Battle Against SerpApi, Search Engine Roundtable, 2026-11-10. https://www.seroundtable.com/google-loses-again-against-serpapi-42508.html
1. Chief Judge Yvonne Gonzalez Rogers, U.S. District Court, N.D. Cal.. https://www.cand.uscourts.gov/judges/gonzalez-rogers-yvonne-ygr/
1. Serper terms of service, Serper. https://serper.dev/terms
1. SerpAPI legal and terms, SerpAPI. https://serpapi.com/legal
1. Spam policies for Google web search (machine-generated traffic), Google Search Central. https://developers.google.com/search/docs/essentials/spam-policies
1. Google Terms of Service, effective 2026-07-30. https://policies.google.com/terms
1. Poisoned Google SERPs, Nozzle, published 2026-10-10, updated 2026-11-03. https://nozzle.io/research/poisoned-google-serps/
1. What We're Seeing in Google's Poisoned Search Results, SerpAPI, 2026-11-12. https://serpapi.com/blog/googles-poisoned-search-results/
1. SerpAPI status incident on unusual Google results, SerpAPI. https://status.serpapi.com/incidents/bhj19czp9b04
1. SerpAPI public roadmap #3781: Google Search result issue, GitHub. https://github.com/serpapi/public-roadmap/issues/3781
1. SerpAPI public roadmap #4475: Google Shopping result issue, GitHub. https://github.com/serpapi/public-roadmap/issues/4475
1. Custom Search JSON API (closed to new customers, ends 2027-01-01), Google for Developers. https://developers.google.com/custom-search/v1/overview
1. Model Context Protocol specification, 2025-06-18. https://modelcontextprotocol.io/specification/2025-06-18
1. serpapi-mcp: SerpAPI MCP server (hosted at mcp.serpapi.com), GitHub. https://github.com/serpapi/serpapi-mcp
1. mcp-server-serper (community project), GitHub. https://github.com/marcopesani/mcp-server-serper
1. serper-mcp-server (community project), GitHub. https://github.com/garylab/serper-mcp-server
1. MCP specification 2025-06-18: Transports (stdio and Streamable HTTP). https://modelcontextprotocol.io/specification/2025-06-18/basic/transports
1. SerperDevTool, CrewAI docs. https://docs.crewai.com/en/tools/search-research/serperdevtool
1. Google Serper integration, LangChain docs. https://python.langchain.com/docs/integrations/tools/google_serper/
1. Connect Claude Code to tools via MCP, Claude Code docs. https://code.claude.com/docs/en/mcp
1. MCP connector, Claude docs. https://docs.claude.com/en/docs/agents-and-tools/mcp-connector
1. Remote MCP, OpenAI docs. https://platform.openai.com/docs/guides/tools-remote-mcp
1. Connectors and MCP servers, OpenAI developer docs. https://developers.openai.com/api/docs/guides/tools-connectors-mcp
1. serpapi-python, SerpAPI, GitHub. https://github.com/serpapi/serpapi-python
1. google-search-results-python, SerpAPI, GitHub. https://github.com/serpapi/google-search-results-python
1. serpapi-javascript, SerpAPI, GitHub. https://github.com/serpapi/serpapi-javascript
1. serpapi package, PyPI. https://pypi.org/project/serpapi/
1. google-search-results package, PyPI. https://pypi.org/project/google-search-results/
1. SerpApi (Google Search) tool node, n8n docs. https://docs.n8n.io/integrations/builtin/cluster-nodes/sub-nodes/n8n-nodes-langchain.toolserpapi/
1. HTTP Request node, n8n docs. https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.httprequest/
1. How to Setup SERPER API HTTP Request in n8n 2026 (video and transcript), TUTOR BASE, YouTube, 2026-02-04 (SGT). https://www.youtube.com/watch?v=U277WSj3X4U
1. Credentials, n8n Docs. https://docs.n8n.io/credentials/
1. RFC 6585: Additional HTTP Status Codes (includes 429), IETF, 2012. https://www.rfc-editor.org/rfc/rfc6585
1. RFC 9110: HTTP Semantics (includes 400, 401, 422), IETF, 2022. https://www.rfc-editor.org/rfc/rfc9110
1. How To Use Serper.dev in Clay (video and transcript), Jim Ortiz, YouTube, 2025-10-15 (SGT). https://www.youtube.com/watch?v=y2N1mr_5aaM
1. Web Search API: A Quick Tour of SerpApi (video and transcript), SerpApi, YouTube, 2026-01-30 (SGT). https://www.youtube.com/watch?v=ViZ5WvDbzKY
1. ZeroTrace Mode, SerpAPI. https://serpapi.com/zero-trace-mode
1. API Metrics for All Engines (public status), SerpAPI. https://serpapi.com/status
1. SerpAPI public roadmap, GitHub. https://github.com/serpapi/public-roadmap
1. SerpAPI public roadmap #4526: ads missing description, GitHub. https://github.com/serpapi/public-roadmap/issues/4526
1. SerpAPI public roadmap #4337: Jobs API falls back to English, GitHub. https://github.com/serpapi/public-roadmap/issues/4337
1. SerpApi Joins The Internet Infrastructure Coalition (press release), PR Newswire via Morningstar, 2026-11-05. https://www.morningstar.com/news/pr-newswire/20261105da90449/serpapi-joins-the-internet-infrastructure-coalition-earns-ethical-web-data-collection-initiative-trust-seal
1. Anti-Circumvention Laws Raise the Cost of Knowledge, EFF, 2026-10. https://www.eff.org/deeplinks/2026/10/anti-circumvention-laws-raise-cost-knowledge
1. SerpApi VS Serper VS ValueSERP VS SearchApi (2026), SerpAPI. https://serpapi.com/blog/compare-serpapi-with-the-alternatives-serper-and-searchapi/
1. Saving repositories with stars, GitHub Docs. https://docs.github.com/en/get-started/exploring-projects-on-github/saving-repositories-with-stars
1. everyinfra-agent-plugins, EveryInfra, GitHub. https://github.com/everyinfra/everyinfra-agent-plugins
1. seo-skills, EveryInfra, GitHub. https://github.com/everyinfra/seo-skills
