# SerpAPI Alternatives Priced Per 1,000 Searches

> SerpAPI is $15–$25 per 1,000 searches on lower tiers. EveryInfra's bing and duckduckgo search are $0.556 per 1,000, web $1.389, billed per request.

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

Send 1,000 web search requests. SerpAPI's cheapest tier, Starter, costs $25. Developer costs $15 ([SerpAPI pricing](https://serpapi.com/pricing), read 2026-11-17). On the same day I called EveryInfra for real. `bing/search` and `duckduckgo/search` charged $0.000556 each. That is $0.556 per 1,000.

`web/search` charged $0.001389, or $1.389 per 1,000. Against the Developer tier that is 27 times and 11 times cheaper. The widest gaps come from one thing. SerpAPI sells monthly subscriptions with prepaid search quotas. EveryInfra bills per request, tops up what you use, and keeps the balance from expiring.

When you replace SerpAPI, you compare more than the unit price. It is also the billing unit, whether failed or empty results cost money, the smallest first payment, free tiers, setup steps, and MCP support. And it is where each of the four named here beats us: SerpAPI, Serper, Tavily, and Firecrawl.

> **Key points**
>
> - Per 1,000 web searches: SerpAPI Starter $25, Developer $15, Big Data $9.17; EveryInfra `bing/search` and `duckduckgo/search` $0.556, `web/search` $1.389. Against Developer that is 11 to 27 times cheaper.
> - Serper is the cheapest of the four at $1.00 per 1,000 and $0.30 at volume. But $0.30 needs a $3,750 prepayment and credits that expire after six months. Our $0.556 has no prepay floor and no expiry.
> - One key covers `web`, `bing`, `duckduckgo`, `google_news`, and `google_shopping`, at $0.556 to $1.389; across three moments the web search price held at $0.001389.
> - Failures are free: a bad parameter returns 422, a missing key returns 401, and a full search source returns 503. All three were charged $0 in testing.
> - Live calls here cost about $0.0107 in total; every competitor price comes from a public pricing page, with no account signed up or plan purchased.

The "price per 1,000" is the amount one search request charges, times 1,000. SerpAPI, Serper, Tavily, Firecrawl, and EveryInfra all return one page of results per request. So billing per request is the most direct unit. SerpAPI and Serper call it one search or one credit. For the competitors I use public material only. That means pricing pages, docs, and store pages.

I did not sign up or buy any plan. So their numbers here are public unit prices, not measured bills. Every number on our side comes from the `billing.charged_usd` field in a real response. Each is timed to the second and converted to Singapore time. As you read, watch two cues. A clock time with "Singapore time" marks a request that really went out and really charged.

A URL with a read date marks a current price on a public page. Re-read those pages in a month or two.

![Concept diagram. On the left, a card holds a key, standing for one API key; the card is outlined in teal. Five teal lines run from the card to five result cards on the right. Each result card is a magnifier over two lines of results. The five stand for web, bing, duckduckgo, google_news, and google_shopping, all on the same key.](https://everyinfra.com/articles/serpapi-alternatives/fig-01-one-key-engines.light.svg?utm_medium=ai_doc&utm_campaign=page_md)

## The whole table: what 1,000 searches cost on each

The table below puts five providers side by side, per 1,000 web searches. SerpAPI, Serper, and Firecrawl use the tiers on their public pricing pages. Tavily is converted from its per-credit price, where one basic search is one credit. EveryInfra is this article's live calls. One request returns one page at a fixed price. That price does not depend on how many rows come back.

| Provider | Billing unit | Entry per 1k | Cheapest self-serve per 1k | Free tier | Does balance expire |
| --- | --- | --- | --- | --- | --- |
| SerpAPI | one successful search | $25 (Starter) | $9.17 (Big Data $275/30,000) | 250/month | monthly quota does not roll over |
| Tavily | 1 credit per basic search | $8.00 (pay-as-you-go $0.008/credit) | $5.00 (monthly $0.005/credit) | 1,000 credits/month | monthly credits reset each month |
| Firecrawl | 2 credits per 10 results | $7.60 (Hobby $19/5,000 credits) | $1.50 (Scale $749/1M credits) | 1,000 credits/month | self-serve credits do not roll over |
| Serper | 1 credit per call (2 for 11–100) | $1.00 ($50/50,000) | $0.30 ($3,750/12.5M) | 2,500 (one-time) | credits expire after 6 months |
| EveryInfra `web/search` | one request | $1.389 (measured) | $1.389 (flat) | claimable trial | balance never expires |
| EveryInfra `bing`, `duckduckgo` | one request | $0.556 (measured) | $0.556 (flat) | claimable trial | balance never expires |

Read this table for two things. First, SerpAPI's cheapest self-serve price is $9.17. But you prepay $275 a month and lock 30,000 searches. Our $0.556 has no monthly fee. It starts at a $10 top-up, billed per request. Second, Serper pushes the volume price to $0.30 per 1,000, below us.

But that tier wants a one-time $3,750 prepayment. And the credits you buy expire after six months if unused ([Serper pricing](https://serper.dev/pricing), verified against serper.dev on 2026-11-14). So the lowest unit price is not the cheapest total. It depends on your monthly volume, whether you prepay, and whether credits sit until they expire.

The size of these gaps comes down to the billing unit, not data quality. A per-request API charges one fixed amount for one request. That request returns one page. The amount does not change with row count or paging. A monthly-fee API makes you buy a month of volume up front. There is no refund and no rollover for what you do not use.

A credit API adds a layer. So many rows equal so many credits, and credits expire. Convert all three to the same "per 1,000 searches" denominator. The gap then appears. So does the part you overpay. It is the slack in a monthly fee, the credits that lapse, or the per-row doubling.

What switching saves is often these hidden layers, not just the headline number. For a team whose volume swings, those layers can exceed the unit price itself.

![Dot chart, horizontal axis is price per 1,000 searches in dollars on a log scale from $0.1 to $100, each step ten times. Six rows, up to three dots each. A grey square marks the entry tier, a dark diamond the cheapest self-serve price, and a teal circle the EveryInfra measurement. SerpAPI entry $25, cheapest $9.17; Tavily $8, $5; Firecrawl $7.6, $1.5; Serper $1.0, $0.3; EveryInfra web $1.389; EveryInfra bing $0.556. The two EveryInfra teal dots sit farthest left.](https://everyinfra.com/articles/serpapi-alternatives/fig-03-per1k-ladder.en.light.svg?utm_medium=ai_doc&utm_campaign=page_md)

## SerpAPI pricing: billed per successful search, five monthly tiers

SerpAPI parses Google and over a hundred other search surfaces into JSON. It bills per successful search. A response with 10 rows or 100 rows counts as one. Empty or errored searches do not count ([SerpAPI pricing FAQ](https://serpapi.com/pricing)). Its plans are monthly subscriptions.

The prices read on 2026-11-17 are these. Free is $0 for 250, and Starter $25 for 1,000. Developer is $75 for 5,000, and Production $150 for 15,000. Big Data is $275 for 30,000.

Each tier has an hourly throughput cap.

| SerpAPI plan | Monthly | Searches/month | Per 1,000 | Throughput/hour |
| --- | --- | --- | --- | --- |
| Free | $0 | 250 | — | 50 |
| Starter | $25 | 1,000 | $25.00 | 200 |
| Developer | $75 | 5,000 | $15.00 | 1,000 |
| Production | $150 | 15,000 | $10.00 | 3,000 |
| Big Data | $275 | 30,000 | $9.17 | 6,000 |

![Screenshot of the SerpAPI pricing page with four plan cards: Starter $25/month, 1,000 searches per month; Developer $75/month, 5,000 searches per month; Production $150/month, 15,000 searches per month, marked Most popular; Big Data $275/month, 30,000 searches per month. Each card lists an hourly throughput and U.S. Legal Shield.](https://everyinfra.com/articles/serpapi-alternatives/img-serpapi-pricing.webp?utm_medium=ai_doc&utm_campaign=page_md)

The four self-serve SerpAPI tiers, captured 2026-11-17 Singapore time; per 1,000 runs from $25 on Starter to $9.17 on Big Data. [SerpAPI pricing page screenshot](https://serpapi.com/pricing)

The monthly fee is prepaid. Searches you do not use that month do not roll over. If you go over, you can early-renew or add usage ([SerpAPI pricing](https://serpapi.com/pricing)). Production and above include a U.S. Legal Shield. It takes on some liability for lawful collection of public search data, up to $2 million.

That is one layer the others do not offer. Enterprise starts at $3,750/month for 100,000. Reserved searches are $2.75 per 1,000 and on-demand are $7.50 per 1,000 ([SerpAPI subscriptions breakdown](https://serpapi.com/blog/breakdown-of-serpapis-subscriptions/)). To replace it, first find which tier your real monthly volume lands in. On Reddit, one person found 100 free searches a month hard to work with. Another noted the first paid tier is $75 ([r/n8n](https://www.reddit.com/r/n8n/comments/1k5yny8/serp_alternative_web_search/), [r/n8n](https://www.reddit.com/r/n8n/comments/1gy42z9/we_should_look_for_another_option_besides_serpapi/)).

Those two sentences are where a switch starts.

## Test one: web search, same price across three moments

`web/search` returns up to 10 rows. The fields are `title`, `url`, `text`, `rank`, and `published_at`. News adds an `image_url`. Sites with sitelinks add a `sub_links` array ([capability catalog](https://api.everyinfra.com/api/v1/social/catalog)). I sent one call at each of three moments, with different queries. At 00:19 Singapore time on 2026-11-17, "best web search api for ai agents" returned 10 and charged $0.001389.

At 00:35 Singapore time, "cheaper serpapi alternative" returned 10 and charged $0.001389. Also at 00:35, I searched the first query again: 10 rows, $0.001389. All three were $0.001389, or $1.389 per 1,000. The price held whether or not the request set `country` or `language`.

![Screenshot of a real response. The top half is the request, POST /api/v1/social, platform web, action search, params with keyword best web search api for ai agents, language en, country us. The bottom half is a 200 response at 2026-11-17 00:19:20 Singapore time. It shows count 10 in a teal box and the first four results with rank, title, and domain. It shows billing with charged true and charged_usd 0.001389 in a teal box, plus the fields title, url, text, rank, published_at.](https://everyinfra.com/articles/serpapi-alternatives/img-api-return.webp?utm_medium=ai_doc&utm_campaign=page_md)

One real web/search response: 10 results, one charge of $0.001389 (balance and internal fields left out). [EveryInfra real response, web search API](https://everyinfra.com/web-api/search?utm_medium=ai_doc&utm_campaign=page_md)

The engine surfaces cost less. `bing/search` is $0.000556. At 00:19 it returned 5 rows for the same query. `duckduckgo/search` is $0.000556. At 00:20 it returned 10. It adds a `favicon_url`.

It also supports `page` for paging and `time_window` for a time filter. Both go straight into `params`. Both engines are $0.556 per 1,000. That is 27 times cheaper than SerpAPI's Developer tier. That 27x is not about how many or how good the results are. It is only the billing unit.

It shifts from "prepay thousands a month" to "charge a fraction of a cent per request." One caution: cheaper is not always enough. `bing/search` and `duckduckgo/search` return those engines' results.

They may not match Google's ranking. For monitoring tied to Google rank, `web/search` is closer. Pick the engine by the source you need. Price is only one axis.

Look at the surfaces. `google_news/search` is $0.000792. At 00:20 it returned 20 news items with `source` and `published_at`. `google_shopping/search` is $0.000556. At 00:22 Singapore time it returned 20 products with `price`, `merchant`, `rating`, and `review_count`. One key, each surface billed per request at its own fixed price.

![Bar chart, five teal bars for EveryInfra's five search surfaces at price per 1,000 from this article's live calls: web/search $1.389 in a darker shade, google_news $0.792, bing/search $0.556, duckduckgo/search $0.556, google_shopping $0.556. The vertical axis runs from $0 to $1.6.](https://everyinfra.com/articles/serpapi-alternatives/fig-06-engines.en.light.svg?utm_medium=ai_doc&utm_campaign=page_md)

## Search surfaces and field coverage: what one key returns

The five surfaces return different fields. That decides whether you can skip a parsing step. `web/search` returns `title`, `url`, `text`, `rank`, and `published_at`. It is the closest to organic web results. It adds `sub_links` on sites that have them, and `image_url` on news. `bing/search` adds a `displayed_url` and drops `published_at`.

`duckduckgo/search` carries a `favicon_url`. It supports `page` and `time_window`. So paging or a last-week filter is one parameter, not a second call. `google_news/search` returns news items with `source`, `published_at`, and `image_url`, up to 20. `google_shopping/search` returns products with `price`, `price_text`, `merchant`, `rating`, and `review_count`, up to 100.

These are structured values you can put straight into a table. Among the 20 products from "mechanical keyboard" at 00:22, a Keychron Q1 showed $89.99, rating 4.5, 300 reviews. A Razer BlackWidow V3 showed $73.97, rating 4.8, 1,100 reviews. For price checks or product research, those fields save a round of page parsing. A German case was tested too. At 00:22, with `language` de and `country` de, I searched "beste suchmaschine api".

`web/search` returned 10 German results and still charged $0.001389. Region and language do not add cost. They do not depend on whether you set those two parameters.

SerpAPI is finer on structure. It splits one Google results page into many structured objects. These include organic results, a knowledge panel, an answer box, related searches, and a shopping box. All come in one request ([SerpAPI API list](https://serpapi.com/search-api)). Serper also returns a knowledge graph, an answer box, and related searches ([Serper Playground](https://serper.dev/playground)). Want a full SERP structure?

SerpAPI and Serper save work. Want organic results from a few engines? This unified snake_case set is easier to wire, with billing per request. Comparing engines is simple. Search the same query on `web`, `bing`, and `duckduckgo`. Compare fields and counts.

Then pick the one you ship.

| Surface | Max per call | Main fields | Paging / time window |
| --- | --- | --- | --- |
| `web/search` | 10 | title, url, text, rank, published_at, sub_links | country, language |
| `bing/search` | — | rank, title, url, displayed_url, text, date_text | country, language |
| `duckduckgo/search` | 50 | rank, title, url, displayed_url, text, favicon_url | page, time_window |
| `google_news/search` | 20 | rank, title, url, source, text, published_at, image_url | time_window |
| `google_shopping/search` | 100 | title, price, merchant, rating, review_count, url | sort, price range |

## Test two: billing unit and failure charges differ

The billing unit decides how a bill grows. SerpAPI and Serper bill per call. One price per search, 10 rows or 100 rows the same. Tavily bills per credit. One for a basic search, two for an advanced one ([Tavily credits](https://docs.tavily.com/documentation/api-credits)). Firecrawl bills "2 credits per 10 results".

Search and scrape draw on one shared credit balance ([Firecrawl search docs](https://docs.firecrawl.dev/features/search)). EveryInfra bills per request. `web/search` is $0.001389, `bing` and `duckduckgo` are $0.000556. `limit` only sets how many rows you want. There is no price change below the cap.

Whether failures and empty results cost money is the item most often missed. I tested three "no data" requests. At 00:22 I added a nonexistent `cursor` to `web/search`. It returned 422. It listed the allowed `keyword`, `country`, `language`, and `limit`. It gave a runnable example.

It said "Nothing was charged." It did not charge. At 00:22 a request without a key returned 401. It prompted for the key in the Authorization header. It did not charge. At 00:35 `duckduckgo/search` with `page` 2 hit a search source that was briefly full. It returned 503.

`billing.charged_usd` was 0. All three were $0.

![Concept loop with four stations and a teal marker moving around: the top is sending a request, a circle with an arrow; the right is checking the key and parameters, a circle with a check; the bottom is charging once per request after data is fetched, a teal coin; the left is a refund on an empty or errored result, a return arrow. The center is a ledger whose top line is teal, meaning one entry per request.](https://everyinfra.com/articles/serpapi-alternatives/fig-02-billing.light.svg?utm_medium=ai_doc&utm_campaign=page_md)

| Case | Singapore time | HTTP | Response | Charged |
| --- | --- | --- | --- | --- |
| `web/search` extra `cursor` | 2026-11-17 00:22 | 422 | `unknown_param`, lists allowed params and an example, Nothing was charged | $0 |
| no key | 2026-11-17 00:22 | 401 | `missing_key`, prompts for the Authorization header | $0 |
| `duckduckgo/search` paging | 2026-11-17 00:35 | 503 | search source briefly full, `charged_usd` 0 | $0 |

On SerpAPI's side, only successful searches bill. Cached, errored, blocked, and captcha requests are free ([SerpAPI pricing FAQ](https://serpapi.com/pricing)). That matches us. Firecrawl states a scrape that returns no result is not charged. But a page that responds with an error status, such as 403 or 404, is still returned and costs 1 credit ([Firecrawl pricing](https://firecrawl.dev/pricing)). So all four say failures are free.

Which failures count differs. Match it to your own error types before switching.

This matters more than it looks. Search engines change their layouts and throttle. In a batch run, a small share of requests always come back empty. If that share still charges, it is a hidden cost over time. Our errors are an HTTP status plus an `error.code`. Request problems like 401 and 422 do not charge.

A 503 from a full search source does not charge. An empty result states its refund reason in the response. All of this is visible, reproducible, and reconcilable. When switching, do not only test the normal path. Send each failure case once. See which charges and which does not.

Then write that into your cost model. Normal unit prices are easy to find. What pulls long-term cost apart is how failures are billed.

## Each of the four grows its bill differently

Per call, per credit, per month: the three models grow a bill differently. Run each one before switching. SerpAPI is a monthly subscription billed per successful search. You pick a tier and get that month's quota. You early-renew or add usage when you go over. Cached, errored, blocked, and captcha requests are free ([SerpAPI pricing FAQ](https://serpapi.com/pricing)).

Its enterprise plan has two more methods. Reserved searches are $2.75 per 1,000. On-demand are $7.50 per 1,000 ([SerpAPI subscriptions breakdown](https://serpapi.com/blog/breakdown-of-serpapis-subscriptions/)). So SerpAPI's real unit price depends on two things. Which tier you land in, and whether you fill it. A full Big Data is $9.17 per 1,000.

Using half is $18.3.

Serper prepays credits. One call uses one credit. But a request for 11 to 100 results uses two ([Serper pricing](https://serper.dev/pricing)). That rule can double the real unit price. If your script defaults to 100 rows, a $1.00 headline is really $2.00. Add the six-month credit expiry.

An irregular workload has to fold the lapsed credits into its real price. Tavily bills per credit, one for basic and two for advanced. It is $0.008/credit pay-as-you-go, dropping to $0.005 monthly ([Tavily credits](https://docs.tavily.com/documentation/api-credits)). So basic search is $8 per 1,000 pay-as-you-go and $5 monthly. Advanced doubles to $16 and $10. Firecrawl needs more care, because of the shared balance.

Search, scrape, crawl, and extract all draw on one credit pool. Search is 2 credits per 10 results. Advanced features like JSON and extract add credits per page ([Firecrawl pricing](https://firecrawl.dev/pricing), [Firecrawl search docs](https://docs.firecrawl.dev/features/search)).

EveryInfra bills per request. One fixed price per request: $0.001389 for `web/search`, $0.000556 for `bing` and `duckduckgo`. `limit` only sets the row count, with no price change below the cap. There is no monthly fee, no credit conversion, and no "100 rows doubles it" add-on. The bill equals request count times unit price, one step. That is the core difference between per-request and the others.

The per-request real price is the headline. The per-credit or per-month real price has to fold in the tier, the expiry, the add-ons, and whether you fill the plan.

| Provider | Unit | What quietly raises the real price |
| --- | --- | --- |
| SerpAPI | per successful search | paying for an unfilled monthly quota; enterprise reserved vs on-demand |
| Serper | per credit | 11–100 rows cost 2 credits; credits expire after 6 months |
| Tavily | per credit | advanced search is 2 credits; monthly vs pay-as-you-go rate |
| Firecrawl | 2 credits per 10 results | one balance shared with scrape and crawl; JSON/extract add credits |
| EveryInfra | per request | none: the bill is request count times a fixed unit price |

## Throughput and rate limits: how many per hour

Unit price is one axis. How fast you can send requests is another. SerpAPI ties throughput to the plan. Free is 50 per hour, Starter 200, Developer 1,000, Production 3,000, Big Data 6,000. Higher concurrency means a higher tier and more monthly searches. Serper's four tiers map to 50 to 300 QPS ([Serper pricing](https://serper.dev/pricing)).

Firecrawl gives per-minute requests by plan, from a few a minute to several thousand ([Firecrawl rate limits](https://docs.firecrawl.dev/rate-limits)). Tavily's per-tier limits are not publicly documented. Ask or load-test ([Tavily docs](https://docs.tavily.com/welcome)). EveryInfra rates by account, shared across keys. The per-minute default rises with cumulative top-ups. Rate packs are optional ([pricing](/pricing)).

Put throughput and billing together, and the trade is clear. SerpAPI ties throughput and monthly fee into one tier. More concurrency means more monthly searches. We split rate from balance. The rate rises by account, and the balance is charged per request. So a small workload with occasional bursts does not pay for the peak year-round.

Before a big batch, do two things. Match your peak QPS against each provider's throughput cap. Then match your monthly total against unit price. Watch two axes, not only price per 1,000.

One volume is often overlooked: scheduled-job concurrency. Many monitoring setups search a batch of keywords or accounts once a day. They fire hundreds or thousands of requests in one burst. That is a short peak, not an all-day average. Buying concurrency through a monthly fee pays for that peak year-round. An account-rate, per-request model puts the peak cost only in those minutes.

To cost one of these jobs, lay out three numbers. How many times a day, how many requests each time, and over how long. Then match them to throughput and billing. Do not apply a lump monthly total.

## Test three: smallest first payment, free tier, and steps

![Screenshot of the Firecrawl pricing page, a slider at the top marked 100,000 credits/month, Standard, and four plan cards below: Free 1,000 credits/month, Hobby 5,000 credits/month, Standard 100,000 credits/month marked Recommended, Growth 500,000 credits/month. Each card lists the matching searches or pages scraped, for example Standard is 50,000 searches or 100,000 pages scraped. A currency selector at the top right showed the local currency at capture.](https://everyinfra.com/articles/serpapi-alternatives/img-firecrawl-pricing.webp?utm_medium=ai_doc&utm_campaign=page_md)

The Firecrawl pricing page, captured 2026-11-17 Singapore time; the credit-to-search mapping is on the cards, the page localizes currency by region, and USD figures are in the references. [Firecrawl pricing page screenshot](https://firecrawl.dev/pricing)

What decides whether you can "try a little" is the smallest first payment. Firecrawl's Hobby is $19/month ($16 annual) for 5,000 credits, or 2,500 searches. Standard $99 gives 100,000 credits, or 50,000 searches. Scale $749 gives 1M credits ([Firecrawl pricing](https://firecrawl.dev/pricing), read 2026-11-17, prices effective September 4). Serper gives a new account 2,500 one-time. After that, the smallest pack is $50 for 50,000 credits.

Tavily gives 1,000 credits a month at $0.008/credit pay-as-you-go ([Tavily pricing](https://tavily.com/pricing)). Its Project tier is $30/month for 4,000 credits. EveryInfra has no monthly grant. Starring two repositories on GitHub claims a one-time trial. Real use starts at a $10 top-up that never expires ([pricing](/pricing), [quickstart](/docs#quickstart)).

![Bar chart of the smallest paid step to start, in dollars: Serper $50, Tavily $30, SerpAPI $25, Firecrawl $19, EveryInfra $10; the EveryInfra bar is teal and shortest. The subtitle notes all have free tiers and EveryInfra balance never expires.](https://everyinfra.com/articles/serpapi-alternatives/fig-05-entry-cost.en.light.svg?utm_medium=ai_doc&utm_campaign=page_md)

Look at free tiers and expiry together. SerpAPI's 250 a month, and Firecrawl's and Tavily's 1,000 credits a month, do not roll over. They reset at month end. Serper's 2,500 is one-time, not monthly, and its bought credits expire after six months.

Our balance has no date and does not reset ([pricing](/pricing)). For a team that just wants to wire it up at low volume, these points shape the experience more than the headline.

| Provider | Free tier | Rolls over / expires |
| --- | --- | --- |
| SerpAPI | 250 searches/month | monthly, does not roll over |
| Tavily | 1,000 credits/month | monthly, resets each month |
| Firecrawl | 1,000 credits/month | monthly, does not roll over |
| Serper | 2,500 (one-time) | bought credits expire after 6 months |
| EveryInfra | claimable trial, then $10 min | balance never expires |

Count the steps too. On a per-request API, setup is three steps. Get a key, write one POST, read `results`. There is no tier to pick first and no credit math. A monthly or credit API usually asks you to decide which tier and how much to load first. For a team testing several providers quickly, this matters.

Dropping the "decide how much to buy" step pushes trial cost down to cents. We claim a trial by starring two repos and start at $10. A round of testing costs cents by the live calls.

## Test four: monthly cost for two common workloads

We costed a month for two common workloads. On each competitor we pick the cheapest plan that fits. The cost is the lower of the monthly fee and the metered price. Free is available only when usage fits its allowance. Our side is request count times unit price (`bing/search` $0.000556).

| Monthly workload | Count | SerpAPI | Serper | Tavily | Firecrawl | EveryInfra bing |
| --- | --- | --- | --- | --- | --- | --- |
| 10,000 web searches/month | 10,000 | $150 (Production) | $50 (one pack) | $72 (metered) | $99 (Standard) | $5.56 |
| 100,000 web searches/month | 100,000 | $3,750 (enterprise) | $100 (two packs) | $500 (monthly) | $399 (Growth) | $55.6 |

![Grouped bar chart on a log scale, horizontal axis the five providers SerpAPI, Serper, Tavily, Firecrawl, EveryInfra bing; two bars each, light for 10k a month and dark for 100k a month. 10k: SerpAPI $150, Serper $50, Tavily $72, Firecrawl $99, EveryInfra $5.56; 100k: SerpAPI $3750, Serper $100, Tavily $500, Firecrawl $399, EveryInfra $55.6. The two EveryInfra bars are teal and shortest.](https://everyinfra.com/articles/serpapi-alternatives/fig-04-monthly-jobs.en.light.svg?utm_medium=ai_doc&utm_campaign=page_md)

SerpAPI is $150 on the first row. 10,000 is above Developer's 5,000 and needs Production $150. Our 10,000 is $5.56, 27 times cheaper. The second row is starkest. 100,000 is above SerpAPI's self-serve cap of 30,000. It goes to enterprise, from $3,750/month.

Ours is $55.6. Serper is cheap here. Two $50 packs cover 100,000 for $100. But you prepay, and the credits expire in six months. The table costs only the searches. It does not cost concurrency, proxies, or storage.

SerpAPI's monthly fee is prepaid and does not roll over. Our balance does not reset.

Look one tier higher, at 1,000,000 a month. SerpAPI goes to a custom enterprise contract. Firecrawl's Scale $749 gives 1M credits, or 500,000 searches. So 1,000,000 needs two, about $1,498. Serper uses a $1,250 Scale pack (2.5M credits), at $0.50 per 1,000. Ours is 1,000,000 times $0.000556, about $556.

This is where the four narrow. Serper's $500 range and our $556 are close. Firecrawl reaches $1,498. SerpAPI is custom. So the higher the volume, the more you weigh prepayment, expiry, and throughput beside unit price. Unit price alone gives an optimistic read.

Cost all three tiers, 10k, 100k, and 1M, to see how much a switch really saves.

Plot the price per 1,000 by tier, from small to large. The shape is clear. SerpAPI falls from Starter's $25 to Big Data's $9.17, always in double-digit dollars. Firecrawl falls from Hobby's $7.6 to Scale's $1.5, close to us at volume. Serper falls from $1.0 to $0.3, the only one below us at its top tier. Our `bing/search` is a flat line at $0.556.

There is no single cheapest. At entry and mid volume, the flat line sits below most tiers. Only at Serper's top tier, with $3,750 prepaid, does it drop below. Pick your volume first. Then see who is lower at that level.

![Line chart on a log scale, horizontal axis tiers from entry to bulk in four steps, vertical axis dollars per 1,000. Four lines are drawn. SerpAPI runs from $25 to $9.17, always highest. Firecrawl runs from $7.6 to $1.5. Serper runs from $1.0 to $0.3. EveryInfra bing is a flat line at $0.556. Only Serper's bulk tier drops below the flat line.](https://everyinfra.com/articles/serpapi-alternatives/fig-07-tier-curve.en.light.svg?utm_medium=ai_doc&utm_campaign=page_md)

## When these four fit better

A comparison is easy to write for one side only. The earlier sections made the "we are cheaper" case. This one makes the "where we fall short" case. The decision should not hinge on price per 1,000 alone. It also turns on the data type, field structure, and compliance you need. Cheap but missing the fields you want is no saving.

In these cases, SerpAPI, Serper, Tavily, or Firecrawl fits better, or does what we cannot.

First, you want Google's vertical pages parsed into structured JSON. SerpAPI covers a hundred-plus surfaces. It has dedicated endpoints for flights, hotels, scholar, patents, Lens, and AI Overviews ([SerpAPI API list](https://serpapi.com/search-api)). Our `web/search` gives title, link, text, and rank. It does not split the knowledge panel or answer box. Second, you want a model-ready answer.

Tavily's `/search` returns content shaped for a model, with PII filtering, prompt-injection detection, and SOC 2 ([Tavily search endpoint](https://docs.tavily.com/documentation/api-reference/endpoint/search)). It is now part of Nebius, under its own brand ([composio, 2026-11-04](https://composio.dev/content/best-browser-agent-apis)). We return the search results themselves, with no answer synthesis. Third, you want to search and pull the full page content at once. Firecrawl's search returns page content, with `/crawl`, `/map`, and structured extraction ([Firecrawl scrape docs](https://docs.firecrawl.dev/features/scrape)). On 2026-11-11 it raised a $75M Series B and launched the Alexandria dataset ([Firecrawl blog, 2026-11-11](https://www.firecrawl.dev/blog/what-is-alexandria)).

We return search results only, not full page content. Fourth, you send millions a month and unit price is the hard constraint. Serper's bulk tier is $0.30 per 1,000 with 300 QPS ([Serper pricing](https://serper.dev/pricing)), below us. But it prepays $3,750, expires in six months, and bills 11-to-100-row requests as 2 credits.

Of these four, the first three are differences in structure and content. The fourth is unit price at volume. For structure, SerpAPI's vertical endpoints are the most complete. They parse flights, hotels, scholar, and patents into fields. For a model-ready answer plus compliance, Tavily builds PII filtering and prompt-injection detection into the API and holds SOC 2. It is still under its own brand after joining Nebius.

For search-plus-content toward a knowledge base, Firecrawl raised $75M in November. It pushed Alexandria company data to 75 million firms ([Firecrawl changelog, 2026-11-13](https://www.firecrawl.dev/changelog/company-data-relaunch)). It also has `/crawl`, `/map`, and batch scrape ([Firecrawl batch scrape](https://docs.firecrawl.dev/features/batch-scrape)). These are directions we do not take. We return search results only. We do no full-page SERP parsing, no answer synthesis, and no full-page content.

Map your need to these items. Then you know whether to switch and what you would give up.

Where we fit is clear too. You switch between `web`, `bing`, `duckduckgo`, `google_news`, and `google_shopping` on one key. You bill per request, with a balance that never expires. Your volume is small, and you do not want to prepay or carry a monthly fee. You value a "failures and empties are free" rule you can see in the response. And you want to drop search into an AI tool and let the model call it.

With those lined up, a per-request API is cheaper to run and to wire. Miss a key one, and match the better provider against the four items above.

## Does the result hold: search the same query again

A search API returns the batch of results at that moment, not a fixed table. So test stability before switching. I searched "best web search api for ai agents" at 00:19 and again at 00:35. Both returned 10. Both charged $0.001389. The price was perfectly stable.

Result content shifts over time, which is normal for trend and sentiment monitoring. You deduplicate by `url`. Per-request billing makes repeat searches cheap. The same query ten times a day is only $0.01389. That suits "pull a few times on a schedule and dedupe" better than a credit or monthly model. For just the recent window, `duckduckgo/search` has `time_window`, and `google_news/search` has it too.

So you do not filter by date yourself.

Stability also means consistency in what the API returns. Across 11 live calls, `web/search` returned a full 10 three times. `bing/search` returned 5 once. The result page has as many rows as it has. Per-request billing charges the same for 5 or 10. So a single call's value-per-dollar swings with row count, while per-request totals stay steady over time.

This matches SerpAPI, which also bills "one search" for 10 or 100 rows. Anchor billing on requests, not rows, and the bill stays easy to forecast.

## Compliance and limits: public search results only

These APIs read public search result pages. They do not log in or touch private content. SerpAPI, from Production up, carries a U.S. Legal Shield. It takes on some liability for lawful collection of public search data, up to $2 million. That is one legal cushion the others lack, though all read public results.

Note that results can contain personal information: business names, review authors, and contacts. This is subject to different privacy laws by region. So storage and use follow your local law. When unsure, ask a lawyer. This is not legal advice.

The limits on what the data can reach differ too. We return search results only. We cannot reach content behind a login, and we do not pull full page content. For full page content, Firecrawl's search with content fits. For vertical structured fields, like flight prices or hotel availability, SerpAPI's dedicated endpoints cover more. Match "what you can get" against "what is compliant".

Then decide which provider does which step.

## Switching from SerpAPI: three changes

Videos on these alternatives sum the migration up as a three-line change. Swap the endpoint, swap the parameter names, swap where the results live, and the rest stays ([transcript pulled via a live YouTube call](https://www.youtube.com/watch?v=RFv6H0Wb5RE)). By that logic, moving from SerpAPI to EveryInfra is three changes. First, the endpoint and body. SerpAPI is a GET with `api_key`, `engine`, and `q`. We are a POST with a key header and a body of `platform`, `action`, and `params`.

```bash
curl -s https://api.everyinfra.com/api/v1/social \
  -H "Authorization: Bearer $EVERYINFRA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"platform":"web","action":"search","params":{"keyword":"best web search api for ai agents","language":"en","country":"us"}}'
# returns 200, results is the array, billing.charged_usd is the charge
```

Second, the parameter names. SerpAPI's `q` is our `keyword`. `gl` and `hl` map to `country` and `language`. You set `limit` for the row count. Third, where results live. SerpAPI puts organic results in `organic_results`.

We put them in `results`. Each row uses a unified snake_case name: `title`, `url`, `text`, `rank`, `published_at`. Match them against the catalog `response_fields`, not from memory. To switch engines, change only `platform`. `bing`, `duckduckgo`, and `web` return the same result shape. Below is the common mapping.

Change by this table, not from memory.

| SerpAPI | EveryInfra | Note |
| --- | --- | --- |
| `engine=google` | `platform` web, bing, duckduckgo | switch engine here only |
| `q` | `keyword` | the query |
| `gl`, `hl` | `country`, `language` | region and language |
| `num` | `limit` | row count, below the cap |
| `organic_results[]` | `results[]` | organic results array |
| `organic_results[].position` | `results[].rank` | rank |
| `organic_results[].link` | `results[].url` | link |

After this, a loop that read `title` and `link` from `organic_results` reads `title` and `url` from `results` and runs. The cleaning script's field map was written for SerpAPI's shape. Remap it by the table above, against the catalog `response_fields` ([capability catalog](https://api.everyinfra.com/api/v1/social/catalog)), not from memory. To be safe, run both on the same batch of queries for a stretch. Compare rank, fields, and counts. Confirm the results are enough.

Then cut traffic over. SDKs exist for each side ([SerpAPI JS client](https://github.com/serpapi/serpapi-javascript), [Tavily JS SDK](https://github.com/tavily-ai/tavily-js), [Firecrawl Python SDK](https://github.com/firecrawl/firecrawl-py)). So most of the change is a thin wrapper swap.

In an AI client, EveryInfra is a remote MCP service. MCP is the Model Context Protocol for AI clients to call external tools ([spec 2025-06-18](https://modelcontextprotocol.io/specification/2025-06-18)). Tool names start `everyinfra_`. Add one config block, and the model can search on its own.

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

Then you can say: "Use EveryInfra to search bing for 'serpapi alternative', drop the ads, and list the top 10 titles and links." The model picks the engine, sends the request, and reads `results`. You only describe what you want. Per-request billing is easy to forecast here too. Each search the model runs is one fixed price. A stray request for 100 rows does not double the bill. The total tracks request count.

Serper, Tavily, and Firecrawl each have an MCP too ([Tavily MCP](https://docs.tavily.com/documentation/mcp), [Firecrawl MCP](https://docs.firecrawl.dev/mcp-server), [Firecrawl LangChain](https://docs.firecrawl.dev/integrations/langchain)). They are used much the same way. The difference is still billing. More pages means more request fees on per-request, and more credits on per-credit. For wiring details, see [remote MCP setup](/build/remote-mcp-setup).

## How we checked these numbers

Every number traces to a raw response or a public pricing page. SerpAPI's and Firecrawl's prices are read from the pricing page and captured. Serper's tiers use serper.dev current prices, with a third-party date cross-check. Tavily is converted from its per-credit documentation. Our charges come from `billing.charged_usd` in each response. From 00:19 to 00:37 Singapore time on 2026-11-17, I sent 11 keyed search requests.

Web search was $0.001389 across three moments. I also sent three bad or paging requests, to verify failure billing. All are timed to the second. The price per 1,000 and monthly costs in the figures are computed by the plotting script from these numbers. They are checked against the text one by one. What we did not do is stated too.

We did not sign up for the four, nor buy their plans. So for them we have public unit prices only, with no measured bill, success rate, or result quality.

This split is for verifiability. Competitor prices change every month or two. The SerpAPI four tiers, the Serper four tiers, and the Firecrawl credit conversion all carry a read date. Re-read those pages later. Our price per 1,000 comes from a live bill. Anyone with the same test key and request body reproduces the same `charged_usd`.

Both trace to a source. So competitor prices stay public tiers and ours stay live calls: what you can use directly and what to re-check are kept apart. When you apply these to your own volume, record the read date.

Recompute in a month or two. Do not price today's decision on a six-month-old table.

## Recent changes (last 30 days)

| Date | Event | What it means for you |
| --- | --- | --- |
| 2026-11-14 | A directory verified Serper's four tiers against serper.dev: $1.00, $0.75, $0.50, $0.30 per 1,000 ([The GTM Directory](https://thegtmdirectory.com/compare/serper-dev-vs-tavily)) | Serper's volume price needs a $3,750 prepay; compare by how much you actually prepay |
| 2026-11-13 | DeepSeek opened its whole app suite, including web search, to developers ([DeepSeek changelog, 2026-11-13](https://api-docs.deepseek.com/updates/)) | Another search provider; compare unit price and coverage together before choosing |
| 2026-11-13 | Firecrawl's Alexandria company data reached 75 million firms ([Firecrawl changelog, 2026-11-13](https://www.firecrawl.dev/changelog/company-data-relaunch)) | Firecrawl is moving to "search plus database"; prices and features shift, so read the page that day |
| 2026-11-11 | Firecrawl announced a $75M Series B and the Alexandria dataset ([Firecrawl blog, 2026-11-11](https://www.firecrawl.dev/blog/what-is-alexandria)) | Features and pricing may change after funding; confirm renewal and price-rise terms before a long contract |
| 2026-11-04 | A review noted Tavily is now part of Nebius, still under its own brand ([composio, 2026-11-04](https://composio.dev/content/best-browser-agent-apis)) | Watch roadmap and SLA continuity for an acquired service |
| 2026-10-27 | A third-party page updated Serper's tiers, listing the six-month credit expiry ([SerpBase](https://serpbase.dev/blog/serpbase-vs-serper-dev-serp-api-pricing-and-feature-comparison)) | Expiry is a hidden cost; an irregular workload should subtract the lapsed part when pricing |
| 2026-10-22 | A DeepSeek API status review priced search at $0.75 per 1,000 ([shattered.io, 2026-10-22](https://shattered.io/where-the-deepseek-api-stands-on-october-22-2026/)) | New low-priced search APIs are pushing prices down; the pricing window is shorter |
| 2026-10-19 | DeepSeek's search API pricing and limits, $0.75 per 1,000 successful requests ([eesel, 2026-10-19](https://www.eesel.ai/blog/deepseek-search-api)) | More low-priced search APIs, but coverage and stability differ, so look past unit price |

## Pressing the choice into three questions

Switching SerpAPI comes down to three questions. First, do you want a full SERP structure or organic results from a few engines? For the former, SerpAPI's structured objects and Serper's knowledge graph fit. For the latter, a per-request API with unified fields is easier to wire and skips a parsing step. Second, how many searches a month, and will you prepay? A few thousand to tens of thousands, without prepay, favors per-request at $0.556 per 1,000.

Millions, with a few thousand dollars prepaid, favors Serper's $0.30. The middle weighs monthly fee, prepay, and expiry together. Third, can you accept the failure billing? Which failure counts differs by provider. So send your real error types once each: bad param, no result, blocked, timeout. See which charges and whether a refund is stated.

Write that into the cost estimate.

Beyond these three, two things get hidden by the headline. One is credit expiry. Serper's credits lapse in six months. So an irregular workload folds the lapsed part into its real price. The other is whether throughput covers your peak. SerpAPI ties throughput to the tier.

A high peak means a high monthly fee year-round. An account-rate, per-request API separates "steady volume" from "occasional peak". List these two beside price per 1,000 before deciding. One more low-priced newcomer is worth a quick look. DeepSeek opened a search API to developers in October 2026 at $0.75 per 1,000 successful requests ([eesel, 2026-10-19](https://www.eesel.ai/blog/deepseek-search-api)). Its coverage and stability are its own.

So weigh price and coverage together.

## FAQ

### Is there a free SerpAPI alternative?

This is from the Google autosuggest "serpapi alternatives free." Few are free every month. SerpAPI's 250 a month, and Firecrawl's and Tavily's 1,000 credits a month, do not roll over. They reset at month end. Serper's 2,500 is one-time, not monthly. EveryInfra has no monthly grant. But starring the everyinfra-agent-plugins and seo-skills repos on GitHub claims a one-time trial.

Real use starts at $10 with no expiry. For "a free batch every month," Firecrawl's and Tavily's 1,000 monthly credits fit. For "pay per use, no prepay, no reset," a per-request API is cheaper. Every free tier is enough to wire the flow and test result quality once. The long-term cost is the unit price and billing unit after the free tier runs out. Do not be drawn by the free amount alone.

### SerpAPI is too expensive; is there a cheaper alternative for n8n?

This is from the autosuggest "n8n serpapi alternative" and two r/n8n threads. One found 100 free searches a month hard. One noted the first paid tier is $75 ([r/n8n](https://www.reddit.com/r/n8n/comments/1gy42z9/we_should_look_for_another_option_besides_serpapi/), [r/n8n](https://www.reddit.com/r/n8n/comments/1k5yny8/serp_alternative_web_search/)). In n8n you need no special node. Use an HTTP Request node with the URL, headers, and body. The `results` array passes straight down the flow.

By the cost table, "10,000 web searches a month" is $150 on SerpAPI and about $5.56 on `bing/search` per request. To let an AI node decide what to search, add the remote MCP and let the model call it. To write results into a sheet or database, the `results` field names are unified. Map once and keep it.

### How much code changes when switching from SerpAPI?

This is from YouTube videos on these alternatives, summed as a three-line change. For EveryInfra it is three spots: swap the endpoint, swap the parameter names, swap where results live. Your loop still reads title and link, and switching engines changes only `platform`. The field-by-field mapping is in the "Switching from SerpAPI" section above.

### Is Serper cheaper than EveryInfra?

This is from the autosuggest "serpapi cheaper alternative" and comparison threads. Serper's entry is $1.00 per 1,000. That is below our `web/search` $1.389 but above our `bing/search` $0.556. Serper's bulk tier is $0.30, below us. But that tier prepays $3,750. Credits expire in six months.

And 11-to-100-row requests bill 2 credits. Our $0.556 has no prepay floor and no expiry. Small to mid volume, without prepay, favors us. Millions a month, with prepay, favors Serper's bulk price.

### Is an open-source SerpAPI alternative reliable?

This is from the autosuggest "serpapi alternatives open source" and an r/LocalLLaMA thread ([r/LocalLLaMA](https://www.reddit.com/r/LocalLLaMA/comments/1c62wmz/serp_alternative_google_result_scrape_hopefully/)). Running open-source scraping saves the API fee. But you handle proxy pools, layout changes, blocks, and captchas yourself. A layout change means a fix. Stability and maintenance are on you. A hosted API folds those into the unit price, for one fewer thing to maintain.

The line is whether you want to run it yourself. Small, occasional, and tolerant of a failed run: open-source works. Steady supply, pay-as-you-go, focus on the business: a hosted API is easier. A middle path works too. Run on a hosted API first. Reassess self-hosting only when volume makes the fee the big line item.

Most teams never reach that scale. The fee stays cheaper than an engineer's maintenance hours.

### How is price per 1,000 searches actually computed?

This is from this article's tests. Price per 1,000 is the amount one search request charges, times 1,000. SerpAPI and Serper bill per call, one price regardless of rows. Tavily and Firecrawl bill per credit. Convert that to "credits per basic search times price per credit". Firecrawl's search is 2 credits per 10 results.

EveryInfra bills per request: $0.001389 for `web/search`, $0.000556 for `bing` and `duckduckgo`. Fold all providers into "dollars per 1,000 searches" to compare on one denominator. For your real spend, look past the headline. Fold in Serper's 11-to-100 doubling and expiry. Fold in whether SerpAPI fills the month. Fold in Tavily's basic versus advanced.

Fold in Firecrawl's shared balance.

## Getting started: from one trial to a daily run

First, get an API key. Star the everyinfra-agent-plugins and seo-skills repos on GitHub to claim a one-time trial. Real use starts at a $10 top-up that never expires ([quickstart](/docs#quickstart), [pricing](/pricing)). Second, open the capability page and run the one-click try: [try web search](/web-api/search), [try Bing search](/bing-api/search), [try DuckDuckGo search](/duckduckgo-api/search). Third, read `charged_usd` and the row count in the response. Multiply the charge by 1,000 for your scenario's price per 1,000.

Compare it to your current SerpAPI bill. To migrate production, change the request by the mapping table above. Run both on the same batch of queries for a stretch. Compare rank, fields, and counts. Then cut over last. The change is in three spots, with the field map remapped once.

To let an AI tool search on its own, add the remote MCP. The model calls the `everyinfra_*` tools, without you writing each request by hand. All surfaces are at [web search API](/web-api), [Bing search API](/bing-api), and [DuckDuckGo search API](/duckduckgo-api). Or browse the [data market](/market) by category. For a pricing breakdown, see [SerpAPI pricing explained](/blog/serpapi-pricing-explained) and [picking a search API for AI agents](/blog/best-web-search-api-for-ai-agents). Comparison pages are at [the SerpAPI alternatives page](/alternatives/serpapi).

## References

1. SerpAPI pricing page (plans, per 1,000, FAQ billing rules), read and captured 2026-11-17 Singapore time. https://serpapi.com/pricing
1. SerpAPI homepage (four plan cards, current prices), read 2026-11-17. https://serpapi.com
1. SerpAPI search API list (100+ search surfaces), read 2026-11-17. https://serpapi.com/search-api
1. SerpAPI subscriptions breakdown (enterprise, reserved and on-demand prices), SerpAPI blog, read 2026-11-17. https://serpapi.com/blog/breakdown-of-serpapis-subscriptions/
1. DataForSEO vs SerpApi (per-1,000 table by tier), SerpAPI blog, read 2026-11-17. https://serpapi.com/blog/dataforseo-vs-serpapi/
1. SerpAPI Python client (google-search-results), GitHub. https://github.com/serpapi/google-search-results-python
1. SerpAPI Python SDK, GitHub. https://github.com/serpapi/serpapi-python
1. SerpAPI JavaScript client, GitHub. https://github.com/serpapi/serpapi-javascript
1. Serper pricing page (four credit tiers, QPS), verified against serper.dev 2026-11-14. https://serper.dev/pricing
1. Serper homepage (Google search JSON example), read 2026-11-17. https://serper.dev
1. Serper Playground (request and response shape), read 2026-11-17. https://serper.dev/playground
1. The GTM Directory: Serper vs Tavily (Serper four tiers, Tavily tiers), 2026-11-14. https://thegtmdirectory.com/compare/serper-dev-vs-tavily
1. SerpBase: Serper.dev pricing and free tier (six-month credit expiry), updated 2026-10-27. https://serpbase.dev/blog/serpbase-vs-serper-dev-serp-api-pricing-and-feature-comparison
1. Tavily credits and pricing (per-credit price, basic and advanced search), Tavily docs. https://docs.tavily.com/documentation/api-credits
1. Tavily search endpoint (search depth, fields), Tavily docs. https://docs.tavily.com/documentation/api-reference/endpoint/search
1. Tavily extract endpoint (billed per successful extraction), Tavily docs. https://docs.tavily.com/documentation/api-reference/endpoint/extract
1. Tavily crawl endpoint, Tavily docs. https://docs.tavily.com/documentation/api-reference/endpoint/crawl
1. Tavily map endpoint, Tavily docs. https://docs.tavily.com/documentation/api-reference/endpoint/map
1. Tavily MCP service (search, extract, crawl tools), Tavily docs. https://docs.tavily.com/documentation/mcp
1. Tavily Python SDK quickstart, Tavily docs. https://docs.tavily.com/sdk/python/quick-start
1. Tavily Python SDK, GitHub. https://github.com/tavily-ai/tavily-python
1. Tavily MCP server, GitHub. https://github.com/tavily-ai/tavily-mcp
1. Tavily JavaScript SDK, GitHub. https://github.com/tavily-ai/tavily-js
1. Tavily pricing page (Researcher, Pay As You Go, Project), read 2026-11-17. https://tavily.com/pricing
1. Tavily documentation home, Tavily docs. https://docs.tavily.com/welcome
1. Tavily quickstart, Tavily docs. https://docs.tavily.com/documentation/quickstart
1. Firecrawl pricing page (credit conversion, search 2 credits per 10 results, failure billing), read and captured 2026-11-17, current prices effective September 4. https://firecrawl.dev/pricing
1. Firecrawl search feature (search returns content), Firecrawl docs. https://docs.firecrawl.dev/features/search
1. Firecrawl search endpoint, Firecrawl docs. https://docs.firecrawl.dev/api-reference/endpoint/search
1. Firecrawl scrape feature, Firecrawl docs. https://docs.firecrawl.dev/features/scrape
1. Firecrawl crawl feature, Firecrawl docs. https://docs.firecrawl.dev/features/crawl
1. Firecrawl batch scrape, Firecrawl docs. https://docs.firecrawl.dev/features/batch-scrape
1. Firecrawl introduction and endpoints, Firecrawl docs. https://docs.firecrawl.dev/introduction
1. Firecrawl API reference introduction, Firecrawl docs. https://docs.firecrawl.dev/api-reference/introduction
1. Firecrawl rate limits, Firecrawl docs. https://docs.firecrawl.dev/rate-limits
1. Firecrawl MCP server, Firecrawl docs. https://docs.firecrawl.dev/mcp-server
1. Firecrawl LangChain integration, Firecrawl docs. https://docs.firecrawl.dev/integrations/langchain
1. Firecrawl SDK overview, Firecrawl docs. https://docs.firecrawl.dev/sdks/overview
1. Firecrawl source repository, GitHub. https://github.com/firecrawl/firecrawl
1. Firecrawl MCP server source, GitHub. https://github.com/firecrawl/firecrawl-mcp-server
1. Firecrawl Python SDK, GitHub. https://github.com/firecrawl/firecrawl-py
1. What is Alexandria ($75M Series B, Alexandria dataset), Firecrawl blog, 2026-11-11. https://www.firecrawl.dev/blog/what-is-alexandria
1. Firecrawl Alexandria covers 75M companies, Firecrawl changelog, 2026-11-13. https://www.firecrawl.dev/changelog/company-data-relaunch
1. DeepSeek changelog (full app APIs including web search to developers), 2026-11-13. https://api-docs.deepseek.com/updates/
1. DeepSeek search API pricing and limits ($0.75 per 1,000), eesel, 2026-10-19. https://www.eesel.ai/blog/deepseek-search-api
1. DeepSeek API status review, shattered.io, 2026-10-22. https://shattered.io/where-the-deepseek-api-stands-on-october-22-2026/
1. 10 Best Web Access Tools for AI Agents (Tavily part of Nebius), composio, 2026-11-04. https://composio.dev/content/best-browser-agent-apis
1. EveryInfra capability catalog (price_usd, max_limit, response_fields), read 2026-11-17. https://api.everyinfra.com/api/v1/social/catalog
1. EveryInfra llms.txt (failures and empty results are not charged). https://api.everyinfra.com/llms.txt
1. EveryInfra remote MCP endpoint. https://api.everyinfra.com/mcp
1. Model Context Protocol spec 2025-06-18. https://modelcontextprotocol.io/specification/2025-06-18
1. SERP alternative discussion, Reddit r/n8n. https://www.reddit.com/r/n8n/comments/1k5yny8/serp_alternative_web_search/
1. Should we replace SerpAPI, Reddit r/n8n. https://www.reddit.com/r/n8n/comments/1gy42z9/we_should_look_for_another_option_besides_serpapi/
1. Open-source SERP alternative discussion, Reddit r/LocalLLaMA. https://www.reddit.com/r/LocalLLaMA/comments/1c62wmz/serp_alternative_google_result_scrape_hopefully/
