Google SERP + AI Overviews API

SerpAPI-style Google search JSON — AI Overview answer + citations, organic results, People Also Ask, knowledge graph, top stories and local results in one row per query. One call gives you the full results page, not just the AI Overview.

• Batch up to 1000 queries per run (array input, one API call) — processed with 10-way concurrency (configurable 1–30), rows stream to the dataset as they complete (a timed-out run still delivers partial results)
• AI Overview parsed into structured text_blocks (paragraphs, headings, lists, tables — in document order) + references (the citations linked inside the answer: title + link + snippet) + sources (Google's full source list for the answer, each marked cited_in_answer true/false) — including deferred AIOs Google generates asynchronously (resolved via Google's own /async/folsrch endpoint, no browser rendering, no third-party API)
• Citation tokens auto-resolved: AI Overview citations that arrive as /goto?url=<token> are resolved to their real destination via Google's redirect endpoint (read Location header, ~90ms each), and so are raw /goto? tokens in organic results, top stories, discussions and local results. The original token is kept as goto_url on the item for provenance. If a token genuinely cannot be resolved, the citation is marked unresolved: true and search_metadata.unresolved_citations reports the count — never a silent failure.
• Rich SERP surface: organic results, knowledge graph (facts), top stories, local results (rating/reviews), People Also Ask, discussions & forums
• Geo targeting via location (e.g. "New York, NY", "Kuala Lumpur") — Google uule encoding, same as SerpAPI
• Multi-language AI Overviews: tested on live Google pages in 99 language settings (Italian, German, French, Spanish, Portuguese, Japanese, Chinese, Arabic, Hindi, Malay and many more), with country (gl) targeting and any Google hl code, including regional ones like pt-BR, zh-CN and es-419. See Languages.
• Pay per search, platform costs included: $3.00 per 1,000 queries on the Free plan, $2.50 on Starter, $2.00 on Scale, $1.80 on Business and above. Nothing is added on top for compute or proxies. Queries that return no parseable content (status Empty), a partial page with no organic results (status Partial), or an error are not charged.
• What one row contains: AI Overview (structured text blocks + citations), organic results, People Also Ask, knowledge graph, top stories, local results, discussions & forums. AI-Overview-only actors return the answer and its sources, but no organic results and no People Also Ask, so rank tracking or PAA research needs a second tool.

Input

{
  "queries": ["best crm for startups", "what is retrieval augmented generation"],
  "gl": "us",
  "hl": "en",
  "maxResults": 10,
  "location": "New York, NY",
  "retryDeferredAIO": true,
  "retryDeferredMaxFetches": 2,
  "retryPartialResults": true,
  "retryPartialMaxFetches": 1,
  "retryThinOverview": true,
  "captureRawHtml": false,
  "captureFlaggedFolsrch": false,
  "concurrency": 10,
  "retryDeferredPoll": false,
  "resolveGotoTokens": true,
  "udm56": false,
  "mobile": false,
  "retryAiModeForClassic": false,
  "excludeAiMode": true
}

Field	Type	Default	Description
queries	array of strings	required	Search queries (max 1000 per run)
gl	string	us	Two-letter country code (us, my, uk, sg…)
hl	string	en	Google interface language: a two- or three-letter code (en, it, de, ja, fil) or a regional code (pt-BR, zh-CN, zh-TW, es-419, fr-CA, en-GB). See Languages.
maxResults	integer	10	Max organic results per query (1–10)
location	string	(proxy IP geo)	Geo target, e.g. "New York, NY". Google uule-encoded server-side.
retryDeferredAIO	boolean	true	Resolve deferred AI Overviews (Google generates some answers asynchronously). Uses the embedded /async/folsrch template via a datacenter proxy. Extra cost only on affected queries. false = always single fetch.
retryDeferredMaxFetches	integer	2	Max total fetches per query when a deferred AI Overview shell is detected (1–5). 1 = single fetch, same as retryDeferredAIO: false.
retryThinOverview	boolean	true	Thin AI Overviews — answers that end in a dangling heading or have under 600 characters of text, usually a partly rendered serve — get one fresh SERP fetch (folsrch resolution included). The richer answer is kept; a poorer or AI Mode re-fetch is discarded. Needs retryDeferredAIO and retryDeferredMaxFetches > 1. Rows stay Success and charged. Output marks search_metadata.thin_recovered (replaced) or search_metadata.thin_recovery_attempted (original kept).
retryPartialResults	boolean	true	Google intermittently serves a reduced page — other modules parse (People Also Ask, knowledge graph, top stories) but organic results are missing. When true, the actor re-fetches to recover the organics. Queries that stay organic-empty after the re-fetches are marked status Partial and not charged. Re-fetches are included in the price. The re-fetch never runs for a genuinely empty query (organics empty AND nothing else parsed).
retryPartialMaxFetches	integer	1	Upper bound on total fetches per query when organic results are missing and retryPartialResults is on. 1 = no re-fetch, 2 = one re-fetch, 3 = two re-fetches (1–3).
captureRawHtml	boolean	false	Save the raw SERP HTML for every query to the key-value store (key raw-<query>-<ts>.html). For building golden test corpora / debugging selector drift. Adds ~200–400KB per query to KV storage.
captureFlaggedFolsrch	boolean	false	When a row ends with truncation_detected true (truncated answer — see Truncation semantics), save the answer's source HTML — the raw folsrch fragment when resolved_by is folsrch, else the shell — to the default key-value store as folsrch-evidence-<query>-<ts>.html and point search_metadata.folsrch_evidence at the key. Best-effort diagnostic for studying exact cut points; never fails a row. Adds one KV value per truncated row.
concurrency	integer	10	Parallel queries (1–30). A/B measured: c5=34s, c10=35s, c20=65s for 20 queries — the SERP proxy pool is the bottleneck, so beyond ~10 workers latency balloons. 10 = same throughput as 5 with headroom for AIO-heavy sets. Capped at about 1 parallel query per 100 MB of run memory: 10 at the default 1024 MB, 20 at 2048 MB, 30 from 3072 MB.
retryDeferredPoll	boolean	false	Legacy poll re-fetch for deferred AIOs (re-fetch up to retryDeferredMaxFetches times with backing-off delay 1.5s → 3s → 6s and a fresh proxy IP per attempt, keep richest). Off by default — folsrch resolves 90%+ of deferred AIOs; the poll recovered 0/120 in the stress test. Enable only if folsrch regresses.
resolveGotoTokens	boolean	true	Resolve AI Overview citations that still carry a raw /goto?url=<token> after the resolution chain by reading the Location header of google.com/goto?url=<token> (~90ms each; ~11.5% of citations need it). Original token kept as goto_url on the reference. Failures keep unresolved: true + unresolved_citations count. Verified 93/93 (EnterRank) + 6/6 (our probe).
udm56	boolean	false	Append &udm=56 to the search URL. Default OFF after measurement (2026-09-07 A/B, 10 queries × 2 variants): udm=56 cut AIO coverage 8/10 → 4/10 and did not pin the classic surface (AI Mode share unchanged). Kept for control; leave off for Google's default routing.
mobile	boolean	false	Fetch SERP + folsrch fragment with a mobile device header set (got-scraping header generator, devices: ['mobile']). Default OFF. Measurement (2026-09-07 spike, 10 queries × 4 variants, gl=sg): mobile UA cut truncation 6/8 (75%) → 3/8 (37%), mean answer length 687 → 852 chars, fetch success 15/20 → 19/20. n=10, one market, one day — EnterRank's paired A/B (30 queries × 2, MY market) was inconclusive: zero of 29 queries were classic-with-an-overview in both arms (commercial prompt set routes to AI Mode). Do not flip the default until a classic-serving prompt set settles it.
excludeAiMode	boolean	true	Classic AI Overview only. When the answer is still AI Mode after the optional retryAiModeForClassic re-fetch, the row carries no ai_overview (null) and is marked search_metadata.ai_mode_detected: true and search_metadata.ai_mode_excluded: true, with a warning. Organic results and People Also Ask are still delivered; the row is Success and charged, the same as a query Google shows no AI Overview for. Set false to ship the AI Mode answer as before (flagged ai_mode_detected, Success, charged).
retryAiModeForClassic	boolean	false	When true, an AI Mode serve triggers one re-fetch hoping for a classic AI Overview. Default OFF after measurement (EnterRank, 2026-09-07, 101/101 answers across 4 runs): on a commercial query mix the re-fetch recovered ZERO classic serves — Google routes commercial queries to AI Mode today, so the re-fetch is a doubled SERP fetch with no recovery. Kept behind the input because routing moved once (2026-09-02: 2/2 re-fetches served classic) and can move back. When false (default), an AI Mode answer is not re-fetched: with excludeAiMode on (default) it is dropped (ai_overview: null); with excludeAiMode: false it ships as-is (Success, ai_mode_detected: true, warning set, charged).

Output

One dataset item per query:

{
  "ai_overview": {
    "text_blocks": [
      { "type": "paragraph", "snippet": "The best CRM for a startup depends on your core workflow…" },
      { "type": "heading", "snippet": "Key Comparison Overview" },
      { "type": "table", "headers": ["Feature", "GXS Bank", "UOB"], "rows": [["Base Interest Rate", "0.88% p.a.", "0.05% p.a."]] },
      { "type": "list", "list": [{ "title": "…" }] }
    ],
    "references": [
      { "title": "CRM for Startups: Free Software to Scale Your Business", "link": "https://www.hubspot.com/products/crm/startups", "snippet": "…", "index": 0 }
    ],
    "resolved_by": "folsrch"
  },
  "organic_results": [
    { "position": 1, "title": "…", "url": "https://…", "displayed_link": "…", "snippet": "…" }
  ],
  "people_also_ask": ["…", "…"],
  "search_metadata": { "status": "Success", "created_at": "…", "total_time_taken_ms": 3088, "google_url": "…" },
  "search_parameters": { "q": "best crm for startups", "gl": "us", "hl": "en", "location": "New York, NY" },
  "knowledge_graph": {
    "title": "…",
    "description": "…",
    "source": { "name": "Wikipedia", "link": "…" },
    "facts": [{ "label": "Born", "value": "…" }]
  },
  "top_stories": [ { "title": "…", "url": "…", "source": "The Economist" } ],
  "local_results": [ { "title": "…", "rating": "4.9", "reviews": 534 } ],
  "discussions_and_forums": [ { "title": "…", "url": "…", "source": "reddit" } ],
  "selector_strategy": {
    "organic_results": "primary",
    "people_also_ask": "primary",
    "knowledge_graph": "fallback",
    "top_stories": "structural",
    "local_results": "primary",
    "discussions_and_forums": "primary"
  }
}

• ai_overview.resolved_by is folsrch (deferred answer resolved via Google's async endpoint), poll (recovered via re-fetch), or absent (answer was inline in the SERP).
• Modules are null when Google returns none for that query.
• ai_overview.text_blocks types: paragraph and heading (snippet), list (list: [{ title }], consecutive bullets share one block), and table (headers: the first row, rows: the remaining rows, cell text only; citation cards are never tables). Blocks come out in the order Google renders them. Answer text is taken only from the AI Overview block; the AI Mode teaser card is never read.
• search_metadata.ai_mode_detected: true means the answer was served from the AI Mode surface (no AI Overview block around the answer). A classic AI Overview answer never sets it, even when Google's share-panel furniture is present; that furniture is stripped from the text either way.
• search_metadata.ai_mode_excluded: true (with excludeAiMode, default on) means an AI Mode answer was dropped: ai_overview is null, modules_present.ai_overview is false, status is Success and charged. Organics and PAA are delivered. Set excludeAiMode: false to get the AI Mode text instead.
• search_metadata.status is Success (content parsed), Partial (organic results missing even after re-fetch — not charged), Empty (no parseable content — not charged), or Error (fetch failed after retries — not charged).
• search_metadata.modules_present (all rows) records which modules actually parsed as booleans: organic_results, ai_overview, people_also_ask, knowledge_graph, top_stories, local_results, discussions_and_forums. No more guessing from status strings — an organic-less row that still delivered a full AI Overview is visible as { organic_results: false, ai_overview: true, ... }. On Partial rows the warning also names the modules that were present.
• search_metadata.partial_recovered is true when organic results were recovered by the partial re-fetch (charged normally).
• search_metadata.drift_evidence (present on Empty/Partial rows) is the key of the raw HTML sample saved to the actor's key-value store — grab it for instant diagnosis of selector drift.
• Google's "Verifying your request" holding page is never shipped as an Empty row: it is treated as a blocked serve and retried on another route / fresh IP.
• If a run would hit its timeout, the actor stops scheduling and finishes SUCCEEDED with the rows it already delivered (the run status message says how many).
• search_metadata.lane (all rows) is an internal fetch-route id (e.g. box1 or proxy) for support and diagnostics; search_metadata.box_secs is the route's fetch time in seconds (null on the proxy route).
• search_metadata.truncation_detected / truncation_evidence — see Truncation semantics.
• selector_strategy records which parser strategy fired per module: primary (current Google classes), fallback (stable anchors), or structural (class-free heuristics). primary everywhere = healthy; fallback/structural = Google rotated classes but results still parse.
• ads and related_searches are not included — the Google SERP proxy serves a server-rendered variant where those JS-only modules are absent (verified: the tads ad container arrives empty, "Sponsored" labels never appear). This keeps results clean and ad-free.
• No pagination field — each query returns page 1 results; batch more queries for broader coverage.

Truncation semantics (2026-10-13 rework)

search_metadata.truncation_detected is true when words are actually missing from the AI Overview — Google stopped mid-sentence in the fetched response. It no longer fires on a merely missing full stop (the old punctuation-majority rule flagged 55 false positives out of 67 in run YXlzbPpYtf7PvP0ze). The decision is the text rule only, four reasons:

• unclosed_bracket — an opened ( never closed ("…such as Emirates NBD").
• ends_on_comma — ends on , or Arabic ، ("…balance of AED 50,").
• ends_on_open — ends on ( or [.
• ends_on_joining_word — ends on a connective ("and", "such as", "بشرط", "مثل"…).

Inline links at the end of a sentence are NOT truncation evidence on their own. Google wraps entity names in span[jscontroller$="#Mx1qPe"] and routinely omits the full stop exactly there, so a complete sentence and a real cut are markup-identical under it (live AE fragment audit: blob counts, anchors and stream tokens all overlap; every real cut at a link was already caught by the text rule above). Instead, any list item / paragraph whose last meaningful node is such an inline link carries two metadata fields:

• ends_on_inline_link: true — Google stopped rendering at the link; often the sentence is complete, sometimes words are missing (if they are, the item also carries truncated + truncation_reason from the text rule, so a flagged "(such as Emirates NBD" item carries BOTH its reason and its sources).
• inline_link_sources: [{ url, title, source }] — the pages Google attached to that link, decoded from its TgQPHd comment blobs. The sentence tail itself is never in Google's response.

A missing full stop alone, a trailing colon (labels like "Petrol:") and a semicolon (list style) are deliberately NOT cuts. Details are per item/paragraph: truncated: true + truncation_reason on list items and paragraph blocks; a list/paragraph block with any cut carries truncation_detected: true. On the row, search_metadata.truncation_evidence lists the cuts as { tail, reason } (last 80 characters, max 10). The re-fetch triggers use the same evidence, so no re-fetch ever happens because an answer ends without a period.

Languages

The actor reads the AI Overview in any language Google shows it in. Google gives the AI Overview a different name in almost every language ("Overview dell'AI" in Italian, "Übersicht mit KI" in German, "Aperçu IA" in French, "AI による概要" in Japanese, "Ringkasan AI" in Indonesian), and sometimes two names within one language. The parser therefore finds the answer by the structure of the page, not by its title, so a new or changed name does not break extraction.

Tested on live Google pages in 99 language settings (October 2026): 402 result pages across 115 Google interface languages, plus 50 answers that Google generated after the first page load. Every AI Overview on those pages was extracted, with no invented answers on pages without one. On-platform runs confirmed Italian, German, French, Spanish, Portuguese (Brazil), Japanese, Chinese (Simplified), Arabic, Indonesian, Malay, Dutch, Korean, Russian, Hindi and English.

How to set it up:

• hl sets Google's interface language, and with it the language of the AI Overview's own labels. Use the language of your queries (it for Italian queries). Regional codes work: pt-BR and pt-PT, zh-CN, zh-TW and zh-HK, es-419, fr-CA, en-GB.
• gl sets the country (it, de, br); location narrows it to a city or region ("Milan, Italy").
• The answer text comes back exactly as Google wrote it, in the language of the query.

Languages tested with an AI Overview: Afrikaans (af), Albanian (sq), Amharic (am), Arabic (ar), Armenian (hy), Azerbaijani (az), Basque (eu), Belarusian (be), Bengali (bn), Bosnian (bs), Bulgarian (bg), Burmese (my), Catalan (ca), Chinese (Hong Kong) (zh-HK), Chinese (Simplified) (zh-CN), Chinese (Traditional) (zh-TW), Croatian (hr), Czech (cs), Danish (da), Dutch (nl), English (UK) (en-GB), English (US) (en), Estonian (et), Filipino (fil), Finnish (fi), French (fr), French (Canada) (fr-CA), Frisian (fy), Galician (gl), Georgian (ka), German (de), Greek (el), Gujarati (gu), Hausa (ha), Hebrew (iw), Hindi (hi), Hmong (hmn), Hungarian (hu), Icelandic (is), Indonesian (id), Irish (ga), Italian (it), Japanese (ja), Kannada (kn), Kazakh (kk), Khmer (km), Kinyarwanda (rw), Korean (ko), Kurdish (ku), Kyrgyz (ky), Lao (lo), Latvian (lv), Lithuanian (lt), Luxembourgish (lb), Macedonian (mk), Malay (ms), Malayalam (ml), Maltese (mt), Maori (mi), Marathi (mr), Mongolian (mn), Nepali (ne), Norwegian (no), Odia (or), Pashto (ps), Persian (fa), Polish (pl), Portuguese (Brazil) (pt-BR), Portuguese (Portugal) (pt-PT), Punjabi (pa), Romanian (ro), Russian (ru), Samoan (sm), Serbian (sr), Sesotho (st), Sindhi (sd), Sinhala (si), Slovak (sk), Slovenian (sl), Somali (so), Spanish (es), Spanish (Latin America) (es-419), Swahili (sw), Swedish (sv), Tagalog (tl), Tajik (tg), Tamil (ta), Tatar (tt), Telugu (te), Thai (th), Turkish (tr), Turkmen (tk), Ukrainian (uk), Urdu (ur), Uzbek (uz), Vietnamese (vi), Welsh (cy), Yoruba (yo), Zulu (zu).

Google does not show AI Overviews in these interface languages (none appeared even for English queries): Cebuano, Chichewa, Corsican, Esperanto, Haitian Creole, Hawaiian, Igbo, Javanese, Latin, Malagasy, Scots Gaelic, Shona, Sundanese, Uyghur, Xhosa and Yiddish. Queries in those settings still return organic results and People Also Ask, and are charged as normal searches.

Pricing

Pay per event: one Google SERP charge per query that returns content. Platform usage (compute, proxies, re-fetches) is included: the price below is the whole cost.

Apify plan	Price per 1,000 queries	Price per query
Free	$3.00	$0.003
Starter	$2.50	$0.0025
Scale	$2.00	$0.002
Business and above	$1.80	$0.0018

• One charge covers the whole results page: AI Overview (full answer, citations and sources), organic results, People Also Ask, knowledge graph, top stories and local results.
• You pay per query, whether or not Google shows an AI Overview for it; organic results and the other modules are still delivered.
• Empty, Partial and Error rows are never charged.

Full AI Overview answers, including the lists

Google often builds an AI Overview in two parts: an opening paragraph in the page HTML, then the rest (usually the bulleted list of products, brands or steps) loaded afterwards. If a scraper only keeps the first part, the list is lost, and the list is usually where brands are named. This actor fetches the second part through Google's own /async/folsrch endpoint and returns the whole answer as structured text_blocks.

Same-day test, 50 queries (US, English, 21 Oct 2026), this actor vs the AI Overview add-on of a leading Google search actor on the Apify Store:

	This actor	Other actor
Queries with an AI Overview	49 of 50	48 of 50
Answers (of the 48 both had) where the bulleted list came through	48	8 (47 of their 48 were labelled static, the first part only)
Bulleted list items captured	165	10 of the same 165
Median answer length	about 700 characters	about 610 characters

You also get Google's full source list for each answer in ai_overview.sources (the sources panel: articles, YouTube videos, forum threads, social posts), with cited_in_answer marking the ones the answer text itself links to. ai_overview.references keeps just the in-answer citations.

What you get compared with other Google actors on the Apify Store

	This actor	AI-Overview-only actors	Organic-only SERP scrapers
AI Overview text + citations	Yes	Yes	No
Organic results	Yes	No	Yes
People Also Ask	Yes	No	Varies
Knowledge graph, top stories, local results	Yes	No	Varies
Deferred AI Overviews resolved (Google /async/folsrch)	Yes	Varies	No
Everything in one row, one charge per query	Yes	n/a	n/a

Use cases

• AEO/GEO monitoring — track whether your brand appears in AI Overviews and which sources Google cites, per market with location
• Multi-market, multi-language AEO: compare what Google's AI Overview says about your brand in Italy, Germany, Brazil or Japan, in each market's own language
• SEO rank tracking at scale
• Research / data collection for LLM training sets
• Competitive SERP intelligence

Costs & limits

• 1000 queries max per run (bump the array; batch in chunks for more)
• Each query = 1 Google results page fetch (+ up to 2 extra fetches only when Google defers the AI Overview), all included in the price
• 10-way concurrency (default): about 16 queries per minute (measured Oct 2026: 98 queries in about 6 minutes, all successful), so 1,000 queries take roughly an hour and fit the 7200s timeout. Rows stream to the dataset as they complete, so you can start reading results straight away.
• 7200s timeout (2h), 1024 MB memory (raise it only if you want more than 10 parallel queries)
• Build tags: the actor runs the stable build by default (verified, production-hardened). New builds are pushed to latest and promoted to stable only after verification — buyers are never exposed to unverified code.