---
title: "Google AI Overviews API vs SerpApi: Which Fits Your Project?"
description: "Google AI Overviews API vs SerpApi: one direct request or a full SERP platform. Request flow, response fields and cost for the same workload, checked Nov 2026."
author: "Let's Scrape"
date: "2026-11-16T07:32:00.0000000"
modified: "2026-11-16T07:32:00.0000000"
category: "Web Scraping"
image: "https://letsscrape.com/site/images/639299297533869749_.jpg"
url: "https://letsscrape.com/blog/web-scraping/google-ai-overviews-api-vs-serpapi-which-fits-your-project"
---

# Google AI Overviews API vs SerpApi: Which Fits Your Project?

![Google AI Overviews API vs SerpApi: Which Fits Your Project?](https://letsscrape.com/site/images/639299297533869749_.jpg)

**Choose the Let's Scrape Google AI Overviews API when your project only needs the AI answer and its sources, and choose SerpApi when it also needs the rest of the results page or other search engines.** The first returns the overview from one request and starts at $19 for 7,500 requests. SerpApi returns it inside Google Search results, sometimes through a second request with a one-minute token, and starts at $25 for 1,000 searches.

## Key takeaways

- Let's Scrape has one endpoint, `GET /ai-overview`, that returns the answer text and a list of sources. SerpApi returns an `ai_overview` block inside its Google Search API response.
- When Google loads the overview separately, SerpApi needs a second request with a `page_token` that expires within 1 minute. Each successful request counts as a search.
- For 5,000 checks per month, the prices read on November 10, 2026 were $19 on Let's Scrape Pro and $75 to $150 on SerpApi, depending on how many checks need the second request.
- SerpApi gives you more around the overview: organic results, many engines, city-level location, a 99.95% SLA and per-block source references.

The Let's Scrape Google AI Overviews API and SerpApi both return Google's AI Overview as JSON, but they are built for different jobs. The Google AI Overviews API does one thing: you send a query, a country and a language, and one request returns the answer with its cited sources. SerpApi is a search results platform. The overview arrives as one block of its Google Search API response, next to organic results, ads and everything else on the page.

If the answer and its sources are all you store, the single-purpose API is the smaller integration and the lower bill. If your product also reads the rest of the results page, SerpApi already has it. Documentation and pricing for both were read on November 10, 2026. Let's Scrape publishes this blog, so check the linked sources before you decide.

[Try the one-request endpoint on RapidAPI](https://letsscrape.com/go/api/google-ai-overviews-api?article=google-ai-overviews-api-vs-serpapi-which-fits-your-project&position=answer)

## Google AI Overviews API vs SerpApi: the short answer

| Question | Let's Scrape Google AI Overviews API | SerpApi |
| --- | --- | --- |
| What do you call? | `GET /ai-overview` on RapidAPI | Google Search API, plus the Google AI Overview API when a token is returned |
| Requests per check | One | One or two |
| What comes back? | Answer text, sources, optional screenshot and results HTML | The whole results page as JSON, with an `ai_overview` block |
| Billing unit | Requests | Successful searches |
| Free plan | 200 requests per month | 250 searches per month |
| First paid plan | $19 for 7,500 requests | $25 for 1,000 searches |
| Other search data | None | Organic results, ads and many other engines |

The table uses each provider's own units. A SerpApi search and a Let's Scrape request are comparable only when one search is enough to get the overview, which the next section explains.

## How each API returns an AI Overview

The [Google AI Overviews API](https://letsscrape.com/api/google-ai-overviews-api) has one product endpoint. It requires `query`, `gl` for the country and `hl` for the language:

```
curl --request GET \
  --url "https://google-ai-overviews.p.rapidapi.com/ai-overview?query=how%20does%20a%20heat%20pump%20work&gl=us&hl=en" \
  --header "x-rapidapi-host: google-ai-overviews.p.rapidapi.com" \
  --header "x-rapidapi-key: $RAPIDAPI_KEY"
```

SerpApi starts with a normal Google search. Its documentation describes two outcomes. In the first, the `ai_overview` block is already in the search response. In the second, Google delivers the overview through a separate request, and SerpApi returns a `page_token` with a ready `serpapi_link` instead. You then call the Google AI Overview API (`engine=google_ai_overview`) with that token. Both values expire within 1 minute of the search.

A client that handles both outcomes looks like this. It follows SerpApi's documentation and was not run for this article:

```
import os
import requests

API = "https://serpapi.com/search.json"
key = os.environ["SERPAPI_KEY"]

search = requests.get(API, params={
    "engine": "google", "q": "how does a heat pump work",
    "gl": "us", "hl": "en", "api_key": key,
}, timeout=60).json()

overview = search.get("ai_overview")
if overview and "page_token" in overview:
    # Google loaded the overview separately. The token expires within 1 minute.
    overview = requests.get(API, params={
        "engine": "google_ai_overview",
        "page_token": overview["page_token"], "api_key": key,
    }, timeout=60).json().get("ai_overview")

if overview is None:
    print("no AI Overview for this query")
else:
    print(len(overview.get("text_blocks", [])), "blocks,",
          len(overview.get("references", [])), "references")
```

The second branch is the part to plan for. The follow-up has to run right away, and an expired token means repeating the search. SerpApi does not publish how often the token path occurs, so the number of requests per check is something you measure on your own keywords.

## What the responses look like

The Google AI Overviews API returns a flat record. This shortened response keeps the field names observed in our product test on August 5, 2026:

```
{
  "description": "OK",
  "status": 200,
  "data": {
    "exists": true,
    "ai_overview": "[answer text omitted]",
    "sources": [
      {
        "url": "https://example.com/article",
        "title": "Example source",
        "site": "example.com",
        "position": 1
      }
    ],
    "screen_url": "[screenshot URL omitted]",
    "html": "[raw HTML omitted]"
  }
}
```

SerpApi splits the overview into typed blocks. This is shortened from the example in its documentation:

```
{
  "ai_overview": {
    "text_blocks": [
      {
        "type": "paragraph",
        "snippet": "Drop shipping is a retail model where an online store...",
        "reference_indexes": [0, 1, 3]
      },
      { "type": "heading", "snippet": "Here's a more detailed breakdown:" },
      { "type": "list", "list": [ { "title": "No Inventory:", "snippet": "...", "reference_indexes": [1, 3] } ] }
    ],
    "references": [
      {
        "title": "Drop shipping - Wikipedia",
        "link": "https://en.wikipedia.org/wiki/Drop_shipping",
        "source": "Wikipedia",
        "index": 0
      }
    ]
  }
}
```

![Pixel art comparison of two AI Overview responses: one answer card with a plain list of sources on the left, and an answer split into blocks with dotted links to individual sources on the right](https://letsscrape.com/site/images/639299297549454478_.jpg)

| You need | Let's Scrape field | SerpApi field |
| --- | --- | --- |
| The answer as text | `data.ai_overview`, one string | `text_blocks`, joined by your code |
| The cited pages | `data.sources` with `url`, `title`, `site`, `position` | `references` with `link`, `title`, `source`, `index` |
| Which source supports which sentence | Not in the fields we observed | `reference_indexes` on each block |
| Proof of what Google showed | `data.screen_url` and `data.html` | Raw HTML output, stored for 31 days |
| A version for an LLM | Not offered | Markdown output with `output=md` |

The practical difference is granularity. If your report only asks whether a domain was cited, a flat source list is enough and needs less code. If you want to show which claim each source supports, SerpApi's `reference_indexes` give you that link directly. The [response field guide](https://letsscrape.com/blog/web-scraping/google-ai-overviews-api-response-fields) covers the Let's Scrape fields and error states in detail.

## What does each one cost for the same workload?

Three workloads, all in one country and language. The SerpApi column is a range because its FAQ says only successful searches are counted, and a follow-up AI Overview request is a search like any other. The low figure assumes no check needs it. The high figure assumes every check does. Prices were read on November 10, 2026.

| Checks per month | Let's Scrape | SerpApi, one search per check | SerpApi, two searches per check |
| --- | --- | --- | --- |
| 1,000 | $19 (Pro, 7,500 requests) | $25 (Starter, 1,000 searches) | $75 (Developer, 5,000 searches) |
| 5,000 | $19 (Pro, 7,500 requests) | $75 (Developer, 5,000 searches) | $150 (Production, 15,000 searches) |
| 30,000 | $78.25 (Ultra with overage) or $99 (Mega) | $275 (Big Data, 30,000 searches) | $725 (Searcher, 100,000 searches) |

The Ultra figure is $49 plus 9,750 extra requests at $0.003. At every size the direct endpoint costs less, and the gap grows with volume: per included unit, Let's Scrape Pro works out to about $0.0025 per request and SerpApi Developer to $0.015 per search. SerpApi's free plan is slightly larger, 250 searches against 200 requests, and it does not count cached searches. Its cache lasts one hour, which rarely helps a daily tracker.

That comparison only holds when the overview is the product. A SerpApi search also returns the organic results, ads and other blocks for the same query. If you would otherwise buy those from a second provider, add that cost to the Let's Scrape column before you compare.

## Markets, languages and location

Both APIs take a country code in `gl` and a language code in `hl`. SerpApi's Google Search API adds a `location` parameter and recommends setting it at city level to simulate a real user. The Let's Scrape listing documents the country and language inputs and an optional `cr` country restriction, and nothing more precise than that.

The two providers describe language coverage differently. SerpApi's AI Overview page says the block is currently only seen for English searches (`hl=en`) in a limited range of countries. The Let's Scrape listing gives Polish and German as example values for `hl`. We did not test either statement for this article. If you track markets outside English, run those queries on both free plans first.

## Limits, reliability and support

| Topic | Let's Scrape Google AI Overviews API | SerpApi |
| --- | --- | --- |
| Rate limit | Basic allows 1,000 requests per hour; no limit is listed for paid plans | Hourly throughput of 20 percent of the plan volume |
| Quota overrun | Basic and Pro stop at the limit; Ultra and Mega continue at $0.003 per request | Move to a larger plan |
| Failed requests | Not charged, according to the listing | Not counted, according to the FAQ |
| Uptime commitment | None published | 99.95% SLA on all plans |
| Legal cover | None published | U.S. Legal Shield on the Production plan and above |
| Response time | 5.7 to 28.9 seconds in our August 5, 2026 test | Not measured for this article |

SerpApi publishes more operational commitments. Its FAQ states the SLA, the throughput rule and SOC 2 certification, and it keeps the JSON and HTML of every search for 31 days. The Let's Scrape listing says the provider opens real browsers, which explains the response times in our test, where some attempts also returned a temporary HTTP 500. With either API, set a timeout, retry temporary errors a limited number of times and store the failures.

## When SerpApi is the better choice

- Your product shows or analyzes organic results, ads or other blocks from the same search.
- You need engines other than Google under one account and one response format.
- You need city-level location, or sentence-level links between the answer and its sources.
- A published SLA, SOC 2 report or legal cover is a purchasing requirement.

## When the Google AI Overviews API is the better choice

- You track whether an AI Overview appears and which domains it cites, and store nothing else from the page.
- You want one request and one result state per check, without token handling.
- The budget is fixed and the job runs thousands of checks per month.
- You want a screenshot with each record to settle disputes about what Google showed.

The other guides in this series fit the second list. The [citation checker](https://letsscrape.com/blog/web-scraping/is-your-website-cited-in-google-ai-overviews-check-it-with-an-api) and the [competitor monitor](https://letsscrape.com/blog/web-scraping/who-is-google-citing-build-an-ai-overview-competitor-monitor) are built on that single request. For a wider field of providers, see the [comparison of seven AI Overview APIs](https://letsscrape.com/blog/web-scraping/best-google-ai-overview-apis-for-developers-in-2026).

## Run the same 30 queries through both

Both free plans cover a 30-query test. Use real keywords from your list, keep `gl` and `hl` identical, and include a few queries where you expect no overview. Google's documentation says AI Overviews "often don't trigger" ([Google Search Central](https://developers.google.com/search/docs/appearance/ai-features)), so a valid empty result is part of the test.

Record for each API:

- how many queries returned an overview with at least one source;
- how many SerpApi queries needed the `page_token` request;
- the time per check, including the second request;
- whether the two APIs returned the same sources for the same query, and how often they differed.

The second number turns the price range above into one figure for your keywords. The fourth tells you whether the simpler record loses anything your report depends on. Some difference is normal, because the two requests reach Google at different moments.

[Start the 200-request free plan](https://letsscrape.com/go/api/google-ai-overviews-api?article=google-ai-overviews-api-vs-serpapi-which-fits-your-project&position=implementation)

## Frequently asked questions

### Is the Google AI Overviews API a SerpApi alternative?

For AI Overview data, yes. It returns the answer and its sources at a lower price per check. It is not a replacement for SerpApi's other search data, because it has no organic results, ads or other engines.

### Does SerpApi charge for the second AI Overview request?

SerpApi's FAQ says only successful searches count toward the monthly total, and cached, errored and failed ones do not. The follow-up request is made through the same search endpoint, so budget one more search for every check that returns a token.

### Which API is faster?

We did not measure SerpApi. In our own test on August 5, 2026, the Google AI Overviews API took between 5.7 and 28.9 seconds per successful request. Time both with your queries, and include the second SerpApi request when it occurs.

### Can I use both in one project?

Yes. One workable split is the direct endpoint for scheduled overview tracking and SerpApi for the pages where you also need the full results. Store the provider name with each record, because the two response formats differ.

## Sources and verification dates

All pages below were read on November 10, 2026. Prices and limits change, so open them before you subscribe.

- [Let's Scrape Google AI Overviews API product page](https://letsscrape.com/api/google-ai-overviews-api) and the [DataOcean listing on RapidAPI](https://rapidapi.com/dataocean/api/google-ai-overviews): endpoint, parameters, plans, overage and rate limit.
- [SerpApi Google AI Overview Results](https://serpapi.com/ai-overview): response structure, token flow and language note.
- [SerpApi Google AI Overview API](https://serpapi.com/google-ai-overview-api): `page_token`, cache and output formats.
- [SerpApi Google Search API](https://serpapi.com/search-api): `location`, `gl` and `hl`.
- [SerpApi pricing](https://serpapi.com/pricing) and [SerpApi FAQ](https://serpapi.com/faq): plans, search counting, throughput, SLA and legal cover.
- [Google Search Central: AI features and your website](https://developers.google.com/search/docs/appearance/ai-features).

The Let's Scrape response times and temporary HTTP 500 errors come from a product test performed on August 5, 2026. They describe that test and are not a service guarantee. SerpApi was not tested for this article.

[Compare the direct endpoint on your own queries](https://letsscrape.com/go/api/google-ai-overviews-api?article=google-ai-overviews-api-vs-serpapi-which-fits-your-project&position=final)
