Google SERP API

Send a query, get back one Google results page as structured data: organic results with titles, display links, dates, snippets, star ratings and in-page links, the AI Overview answer with its cited sources, text ads above and below the results, the local pack of places, top stories, "People also ask" questions, related searches, the knowledge panel and paging. Everything comes from the one page Google renders, so a richer page costs no more. Pick the market with a country code and the interface language with a language code; ScrapeIt renders the page from a residential exit in that country, so you see what a local visitor sees. No proxies, browsers, CAPTCHAs or parser maintenance on your side.

Product	Type	Product code	What it does
Google SERP API	Scraper API (synchronous)	`google_serp`	Run one Google search and get the parsed results page as JSON.

Every field is snake_case, the same convention as the Web Scraping API.

What people build with it

Use case	What you pull
Rank tracking	The position of your pages for a keyword, per country and language.
AI visibility	What the AI Overview answers for a query and which sites it cites.
Local SEO	Which places make the local pack, with rating, price band and category.
News monitoring	Top stories for a brand or topic, with publisher and date.
Competitor monitoring	Who ranks and who advertises for the queries that matter to you.
Keyword research	"People also ask" questions and related searches around a seed keyword.
Brand and entity data	The knowledge panel Google shows for a company, place or person.
Content and SEO audits	Titles, snippets and dates Google displays for a topic, page by page.

Endpoint

GET https://api.scrapeit.io/api/v1/scrape/google/search
x-api-key: YOUR_SCRAPEIT_API_KEY

Parameters

Parameter	Type	Example	Description
`q`	string	`best running shoes 2026`	Required. The search query, exactly as you would type it into Google (up to 2048 characters). Operators such as `site:` work.
`gl`	string	`de`	Market country, two-letter ISO code (`us`, `de`, `gb`, `fr`…); Google's own `uk` works as `gb`. The search runs from an exit in this country; a country ScrapeIt has no exit in answers `422 PROXY_PROVIDER_NOT_FOUND` and is not charged. Defaults to `us`.
`hl`	string	`de`	Interface language (`en`, `de`, `fr`, `pt-BR`…). Defaults to `en`.
`page`	number	`2`	Results page, `1`–`10`. Google serves ten results per page. Defaults to `1`.
`domain`	string	`google.de`	Google host without `www`: `google.com`, `google.de`, `google.co.uk`, `google.com.br`… Defaults to `google.com`.
`time_range`	string	`week`	Only results published within this period: `hour`, `day`, `week`, `month` or `year` - Google's own "Any time" menu. Defaults to any time.
`include_html`	boolean	`false`	Also return the rendered results page HTML in `html`. Defaults to `false`. Paid add-on: +4 credits per request.
`resolve_links`	boolean	`true`	Turn Google's `/goto?url=…` redirects into the real result URLs in `link`. Defaults to `true`; `false` returns only `redirect_link` and answers a little faster.

Google stopped honoring num in 2025 and always pages by ten, so page is the only paging control; an unknown parameter is rejected with VALIDATION_ERROR.

Example request

Search Google Germany in German:

cURLNode.jsPython

bash

curl -G 'https://api.scrapeit.io/api/v1/scrape/google/search' \
  -H 'x-api-key: YOUR_SCRAPEIT_API_KEY' \
  --data-urlencode 'q=beste kaffeemaschine' \
  --data-urlencode 'gl=de' \
  --data-urlencode 'hl=de' \
  --data-urlencode 'domain=google.de'

const response = await fetch(
  'https://api.scrapeit.io/api/v1/scrape/google/search?' +
    new URLSearchParams({ q: 'beste kaffeemaschine', gl: 'de', hl: 'de', domain: 'google.de' }),
  { headers: { 'x-api-key': 'YOUR_SCRAPEIT_API_KEY' } },
);
const { data } = await response.json();
for (const result of data.organic_results) {
  console.log(result.position, result.title, result.displayed_link);
}

python

import requests

response = requests.get(
    "https://api.scrapeit.io/api/v1/scrape/google/search",
    headers={"x-api-key": "YOUR_SCRAPEIT_API_KEY"},
    params={"q": "beste kaffeemaschine", "gl": "de", "hl": "de", "domain": "google.de"},
    timeout=120,
)
data = response.json()["data"]
for result in data["organic_results"]:
    print(result["position"], result["title"], result["displayed_link"])

Response

json

{
  "data": {
    "search_metadata": {
      "request_id": "4f0c2a7e-1b8d-4c55-9a51-0d3e6f7b2c19",
      "url": "https://www.google.com/search?q=best+coffee+maker&hl=en&gl=us",
      "google_domain": "google.com",
      "query": "best coffee maker",
      "country": "us",
      "language": "en",
      "page": 1,
      "time_range": null,
      "proxy_tier": "residential",
      "duration_ms": 6120,
      "processed_at": "2026-10-22T09:28:04.512Z"
    },
    "search_information": { "total_results": 145, "time_taken_seconds": 0.4 },
    "ai_overview": {
      "text": "The best coffee makers depend on your brewing style, budget, and counter space:\nDrip Coffee Makers\nBest Overall Drip: Fellow Aiden Precision Coffee Maker ($365+) features custom temperature profiling, automated blooming, and interchangeable single-serve or batch baskets.",
      "references": [
        {
          "title": "The 9 Best Coffee Makers of 2026 | Reviews by Wirecutter",
          "link": null,
          "redirect_link": "https://www.google.com/goto?url=CAESeAHrOzAV...",
          "source": "The New York Times"
        }
      ]
    },
    "organic_results": [
      {
        "position": 1,
        "title": "Best Drip Coffee Maker - Kev's In-Depth US Review 2026",
        "link": "https://coffeekev.com/best-drip-coffee-maker/",
        "redirect_link": "https://www.google.com/goto?url=CAESaAHrOzAV...",
        "displayed_link": "https://coffeekev.com › best-drip-coffee-maker",
        "source": "Coffee Kev",
        "date": "Sep 11, 2026",
        "snippet": "The Breville Precision Brewer is one of my top picks. The Moccamaster is the classic, old-school, built-to-last option. consider the OXO 8-Cup ...",
        "snippet_highlighted_words": ["The Breville Precision Brewer is one of my top picks"],
        "rating": null,
        "reviews_count": null,
        "sitelinks": []
      }
    ],
    "ads": { "top": [], "bottom": [] },
    "local_results": [],
    "top_stories": [],
    "people_also_ask": [
      { "question": "Can you use tap water in a coffee maker?" },
      { "question": "How do you descale a coffee maker?" }
    ],
    "related_searches": [
      {
        "query": "Best coffee maker for home",
        "link": "https://www.google.com/search?hl=en&gl=us&q=Best+coffee+maker+for+home"
      }
    ],
    "knowledge_graph": null,
    "pagination": {
      "current_page": 1,
      "next_page_url": "https://www.google.com/search?q=best+coffee+maker&hl=en&gl=us&start=10"
    }
  }
}

Response fields

`organic_results[]`

Field	Type	Description
`position`	number	1-based position on this page.
`title`	string	The result title.
`link`	string \| null	The target URL. Google serves most result links as an opaque `/goto?url=…` redirect; ScrapeIt resolves it for you (`resolve_links`). `null` when a link could not be resolved within a few seconds, or with `resolve_links=false`.
`redirect_link`	string \| null	Google's redirect for the result. A plain `GET` of it answers `302` with the target in `Location`, so a `null` `link` can still be followed.
`displayed_link`	string \| null	The breadcrumb Google prints under the title, e.g. `https://example.com › blog › post`; for forum and video results, the line Google shows there (`150+ comments · 1 year ago`).
`source`	string \| null	The site name next to the favicon, e.g. `Wikipedia`, `Reddit · r/JamesHoffmann`.
`date`	string \| null	The date Google prints before the snippet, as shown.
`snippet`	string \| null	The description text.
`snippet_highlighted_words`	string[]	The words Google set in bold in the snippet.
`rating`	number \| null	Star rating of a review, recipe or product rich snippet, e.g. `4.8`; `null` for a plain result.
`reviews_count`	number \| null	The review count printed next to that rating, e.g. `72`; `null` when Google prints none.
`sitelinks[]`	object[]	In-page links Google lists under the result (`Ingredients`, `Instructions`): `title`, `link` and `redirect_link`. Empty for most results.

`ai_overview`

The AI-generated answer Google shows above the results, or null when the page has none (many queries do not get one).

Field	Type	Description
`text`	string	The answer as shown, one line per paragraph, heading or list item (lines joined with `\n`), including the part Google folds behind "Show more"; citation chips are left out.
`references[]`	object[]	The cited sources: `title` of the page, `source` (site name), `redirect_link` (Google's redirect to the page) and `link`, which is `null` when Google names only the redirect.

`local_results[]`

The local pack ("Places") Google shows for a local query such as best pizza in brooklyn; empty otherwise.

Field	Type	Description
`position`	number	1-based position within the pack.
`title`	string	Place name.
`rating`	number \| null	Average star rating, 1-5.
`reviews_count`	number \| null	Review count as Google rounds it: `(6.2K)` is `6200`.
`price`	string \| null	Price band as shown, e.g. `$10–20` or `$$`.
`type`	string \| null	Category, e.g. `Pizza`.
`address`	string \| null	Street address as shown, e.g. `254 S 2nd St`.
`open_state`	string \| null	The status line, e.g. `Closed · Opens 12 PM`.
`snippet`	string \| null	The review quote Google picked for the query.

For every place of an area, with ids, phone, website, coordinates and hours, use the Google Maps API.

`top_stories[]`

News articles of the "Top stories" block, when Google shows one: position, title, source (publisher), date as shown (13 hours ago), redirect_link and link (null when Google names only the redirect).

`ads.top[]` and `ads.bottom[]`

Field	Type	Description
`position`	number	1-based position within the block.
`title`	string	Ad headline.
`link`	string \| null	Ad link.
`displayed_link`	string \| null	The display URL Google shows.
`description`	string \| null	Ad description.

Ads depend on the advertiser's targeting for the market and query; many queries have none.

Other blocks

Field	Type	Description
`people_also_ask[]`	object[]	`question` for each "People also ask" entry. Google loads the answers only when a visitor opens one, so they are not included.
`related_searches[]`	object[]	`query` and the Google search `link` of each related search.
`knowledge_graph`	object \| null	`title`, `subtitle` (e.g. `4.7 (499K) ‧ Tower in Paris, France`), `description`, `description_source`, `facts[]` (`label`, `value`), `rating` and the exact `reviews_count` of a rated place or product (`4.7`, `498627`), the entity's own `website` when the panel links it, and `profiles[]` - the social profiles it links (`name` such as `LinkedIn`, `redirect_link`, `link`).
`search_information`	object	`total_results` (Google's rounded estimate) and `time_taken_seconds`, or `null` when Google shows no counter.
`pagination`	object	`current_page` and the `next_page_url` Google links, or `null` on the last page.
`html`	string	The rendered results page; only with `include_html=true`.

A page with no match for the query answers 200 with empty lists - that is a valid result, not an error.

No-code Google Search Scraper

Prefer a dashboard run and a file? Scrapers without code → Google Search Scraper takes the same q, gl, hl and domain, sweeps up to ten results pages and produces JSON, CSV and XML files with one record per organic result (the organic_results fields above plus the page it came from). The same job is available over HTTP with an API key (x-api-key; scope scrapers:run to start, scrapers:read to poll):

POST https://api.scrapeit.io/api/v1/scrapers/google-search/jobs
GET  https://api.scrapeit.io/api/v1/scrapers/google-search/jobs/{jobId}

Parameter	Type	Example	Description
`q`	string	`best running shoes 2026`	Required. Search query, exactly as typed into Google.
`gl`	string	`us`	Market country, two-letter ISO code; the proxy exit country. Defaults to `us`.
`hl`	string	`en`	Interface language (`en`, `de`, `pt-BR`…). Defaults to `en`.
`domain`	string	`google.com`	Google host without `www`. Defaults to `google.com`.
`time_range`	string	`month`	Only results from the past `hour`, `day`, `week`, `month` or `year`. Defaults to any time.
`max_pages`	number	`10`	Results pages to sweep, `1`–`20`. Defaults to `5`; Google stops at ten.
`output_format`	array	`["json", "csv"]`	One or more of `json`, `csv`, `xml`. Defaults to `["json"]`; an empty list is rejected.

A sweep of five pages or fewer finishes inline and the POST already answers with the result-file ids; a larger one answers queued, so poll the GET endpoint until status is finished (or failed). Each swept page is billed like one search.

Errors

HTTP	Code	When
400	`VALIDATION_ERROR`	A missing `q`, a country or language code in the wrong shape, a `page` outside `1`–`10`, a non-Google `domain`, an unknown `time_range` or an unknown parameter.
502	`TARGET_BLOCKED`	Every attempt was answered with Google's CAPTCHA, consent wall or another page without results. `error.details.block_reason` says which: `captcha`, `consent`, `javascript_required`, `unrecognized_page` or `no_page`. Retry later.

All other errors follow the platform's error codes.

Credits and billing

The product bills per request under google_serp - see billing & credits.

Price per search: 30 credits, flat. Rendering and the proxy are included: a search costs the same whichever exit served it. search_metadata.proxy_tier still says which tier served your result (datacenter or residential).

Resolving the result links (resolve_links) is included: it costs no credits and does not count against your concurrency limit.

search_metadata.request_id is the request the search was charged under: look it up in the dashboard request log. When Google answered the first exits with a CAPTCHA, ScrapeIt renders once more for free, and the id stays the one of the charged request.

Limits and behavior

One request returns one results page. Use page to walk further; results past page 10 are rarely available.
Every search is rendered live - never served from the shared cache - so rankings are current.
Each request is a fresh browser session; nothing from one search (cookies, consent, location) carries into the next.
Result links are resolved in parallel through a datacenter exit of the gl country, with a shared budget of about 2.5 seconds; a link that misses the budget, or a country without a datacenter exit, keeps only redirect_link. A resolved URL that points at a private or local address is never returned. Only organic result links are resolved; links of the AI Overview, top stories, sitelinks and profiles keep redirect_link, which a plain GET follows.
The consent dialog shown to visitors in the EU is accepted automatically, so gl values in the EU return results, not the consent page.
Results are localized by the exit's country (gl), not only by the parameter: the same query from gl=de and gl=us returns different pages.
The desktop results layout is served. Google changes its markup often; fields it stops rendering come back null or empty rather than failing the request.

Web Scraping API - the general single-URL scraper this product runs on.
Billing & credits - credit prices and plans.
Concurrency & limits - how many searches can run at once on your plan.
Managed Google Search scraping - ScrapeIt builds, runs and monitors the scraper for you and delivers ready-to-use data.

Google SERP API ​

What people build with it ​

Endpoint ​

Parameters ​

Example request ​

Response ​

Response fields ​

organic_results[] ​

ai_overview ​

local_results[] ​

top_stories[] ​

ads.top[] and ads.bottom[] ​

Other blocks ​

No-code Google Search Scraper ​

Errors ​

Credits and billing ​

Limits and behavior ​

Related pages ​