Google search results API

A Google search results API returns the organic block of a search as rows instead of a page you have to parse. Send a query, a country and a language: back come position, title, URL, breadcrumb, snippet, date and sitelinks, from Google, Bing or DuckDuckGo, and you pay only for the results actually delivered.

Get my free API key See the request

$0.0004 per delivered result · $2 free every month · Failed runs never billed

POST /v1/scraper/collectors/web_search/run

$ curl $QD/web_search/run \
    -H "Authorization: Bearer $QD_API_KEY" \
    -d '{"query": "best running shoes", "engine": "google", "country": "us", "lang": "en", "max_results": 20}'
{ "status": "done", "count": 20,
  "results": [
    {
      "title": "…",
      "link": "…",
      "display_link": "…",
      "source": "…" } ],
  "cost": 0.008 }
# 20 results × $0.0004 · nothing delivered, nothing charged

$0.0004 / result5,000 results on the free $2 every month

Semantic inputquery, engine, country — no URL lists

Up to 100results per run, pagination handled for you

No browserread over HTTP/TLS — cheaper and faster than rendering

What a Google search results API does

Search results are the cheapest ranking signal there is, and the most annoying to collect: the markup changes, the consent screen fires, and one datacenter IP is throttled after a handful of queries. This endpoint hands you the parsed organic block and keeps the exit rotation, the consent cookie and the pagination on our side.

Google is answered from a stateless HTTP tier — the no-JS results page — so a query costs a fraction of a rendered one and never queues behind a browser. Bing and DuckDuckGo are plain requests. Ask for 30 results and the collector walks the pages, merges them, drops duplicate URLs and stops when the engine runs out.

What one result looks like

Every delivered result carries these fields. Nullable means the source did not publish it — the field stays empty instead of being guessed.

Field	Type	What it holds
`rank`	integer	1-based position across the merged pages.
`page`	integer	Which result page this row came from.
`title`	string	Result title.
`link`	string	Result URL.
`display_link`	string · nullable	Breadcrumb path as shown by the engine.
`source`	string · nullable	Result host.
`description`	string · nullable	Snippet.
`date`	string · nullable	Publish date when the engine shows one.
`sitelinks`	string[]	Sitelink titles under the result (empty when none).

Inputs

The whole request. Anything you leave out falls back to the default shown in the catalog.

Input	Type	Required	What it does
`query`	string	yes	What to search, e.g. "best running shoes".
`engine`	string	no	Search engine to query (default google). One of: `google`, `bing`, `duckduckgo`.
`country`	string	no	ISO 3166-1 alpha-2 code — proxy exit geo and Google locale (gl). Omit for the default pool.
`lang`	string	no	Interface language (hl), e.g. en, it, de.
`location`	string	no	Google only — search as if from this place, e.g. "Milan, Italy".
`max_results`	integer	no	How many results to deliver at most (1–100). You pay only for delivered results.

Pricing

Google search results API pricing

$0.0004 per delivered result. A run that delivers nothing costs nothing: blocked pages, challenges and retries are on us, and the $2 monthly allowance covers about 5,000 results before you spend anything.

$0.0004per delivered result$0.4 per 1,000 delivered results

5,000 resultson the free allowance$2 every month, no card

Zero rowszero chargeblocks, captchas and retries are on us

−30%on volume tiersthe catalog returns your key's price

Pay as you go

$0/mo

$2 free credit / month
60 requests / min
List unit prices

Starter

$19/mo

$15 free credit / month
300 requests / min
10% off unit prices

Growth

$79/mo

$50 free credit / month
600 requests / min
20% off unit prices

Scale

$299/mo

$250 free credit / month
1,200 requests / min
30% off unit prices

Same wallet, same key and same $2 monthly allowance as every other Data API. Prices are launch pricing read live from the billing config — GET /v1/scraper/collectors returns the price your key actually pays.

Integration

One POST, typed rows

Base URL https://api.quanticdata.io/v1, Bearer auth, the same key as every other Data API. Endpoint: POST /v1/scraper/collectors/web_search/run.

curl -X POST https://api.quanticdata.io/v1/scraper/collectors/web_search/run \
  -H "Authorization: Bearer $QD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query":"best running shoes","engine":"google","country":"us","lang":"en","max_results":20}'

import requests

r = requests.post(
    "https://api.quanticdata.io/v1/scraper/collectors/web_search/run",
    headers={"Authorization": f"Bearer {QD_API_KEY}"},
    json={
        "query": "best running shoes",
        "engine": "google",
        "country": "us",
        "lang": "en",
        "max_results": 20
    },
    timeout=120,
)
for row in r.json()["payload"]["results"]:
    print(row)

const res = await fetch(
  "https://api.quanticdata.io/v1/scraper/collectors/web_search/run",
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.QD_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"query":"best running shoes","engine":"google","country":"us","lang":"en","max_results":20}),
  },
);
const { payload } = await res.json();
console.table(payload.results);

claude mcp add quantumproxies \
  -e QUANTUMPROXIES_API_KEY=qd_live_your_key_here \
  -- npx -y quantumproxies-mcp

# then, in the chat:
> run the web_search collector with query="best running shoes" and engine="google"

What people build with the Google search results API

Three shapes of work this endpoint was designed around.

Rank tracking

Run the same keyword daily per country and store the position of your domain and of every competitor above it.

SERP research at scale

Feed a keyword list in and get the top-10 landscape for each: who ranks, with what title, with what snippet.

AI grounding

Give an agent live search results with the URL and snippet already separated, instead of an HTML blob to clean up.

Google search results API versus rolling your own

The differences that actually cost time when you build this in-house.

	DIY scraper	This collector
What you send	A URL to fetch and parse yourself	A query, a country, a language
Engines	One scraper per engine	Google, Bing and DuckDuckGo behind one input
Blocked pages	Billed like any other request	Never billed — retries are on us

Why an agent cannot just call Google

Google publishes a Custom Search JSON API, and it answers a different question than the one an agent asks. It queries a Programmable Search Engine — an index you configure — not the public results page, so what comes back is neither the ranking a user sees nor a complete view of the web. Its free tier is a hundred queries a day, which is a demo budget, not a retrieval budget.

That gap matters most when a model is the consumer. A retrieval step that silently returns a partial index produces answers that are confidently wrong, and nothing downstream can tell. Delivering the organic block as typed rows — position, title, URL, snippet, date — gives a model something it can cite, and gives you something you can audit when it cites it badly.

This is also the collector most often wired in as an MCP tool. An agent that can search before it answers stops relying on a training cutoff, and the per-result price means a chatty agent is a rounding error rather than a budget conversation.

Limits, freshness and the legal bit

Up to 100 results per run, merged across pages and de-duplicated by URL. Ask for more than the engine has and you get fewer rows and pay for fewer rows. Throughput is your plan's rate limit rather than anything about the collector: 60 requests/minute on pay-as-you-go, up to 1,200 on the top tier.

Results are live rather than cached, which is the point for grounding but means two runs minutes apart can legitimately differ — rankings move. If you are building a time series, store the collection timestamp with every row and treat the pair as the observation.

Collecting publicly visible data is generally lawful in most jurisdictions, and courts have repeatedly declined to treat reading a public page as unauthorised access. Search snippets are third-party text: quoting them with attribution is ordinary practice, republishing them wholesale is not. Google's terms restrict automated access independently of any of that. None of this is legal advice — get some for your actual use case.

FAQ

Questions we get about the Google search results API.

Something else? Ask us →

How is this different from the <a href="../../serp-api/">SERP API</a>?

Same engine underneath, different shape. The SERP API endpoint returns the whole page model — ads, knowledge panel, people-also-ask, the lot — while this collector returns just the organic rows, paginated and de-duplicated, billed per delivered result. Pick this one when you want a table of results, the other when you want the full anatomy of the page.

Does this search API use a browser?

No. Google is served from the stateless HTTP tier (the no-JS results page) and Bing and DuckDuckGo from plain requests. That is why a search costs a fraction of a rendered page and why throughput does not depend on a browser pool.

Can I get more than 10 results?

Yes — set max_results up to 100 and the collector paginates for you, merging pages and de-duplicating URLs. If the engine has fewer results than you asked for you simply get fewer rows, and you pay for those.

Can I search as if I were in a specific city?

On Google, yes: pass location (for example "Milan, Italy") alongside country and lang. The location is encoded server-side into Google's own geo token.

Is there a free Google search results API?

Every account gets $2 of credit every month with no card, which is about 5,000 delivered results on this endpoint at $0.0004 each. It renews monthly, and a run that delivers nothing is never billed — so a failed or blocked attempt does not eat the allowance.

How much does one run cost?

Multiply the rows you actually receive by $0.0004. A run capped at 100 results — the maximum for this collector — costs $0.04 if every row comes back, and less when the source has fewer. Volume tiers take up to 30% off, and GET /v1/scraper/collectors returns the price your key actually pays.

Can I use this to ground an LLM?

That is the most common use for it. The rows arrive with URL and snippet already separated, so a retrieval step can hand a model source-attributed context instead of an HTML blob. Wire it in over MCP and the agent decides when to search rather than you pre-fetching.

How fresh are the results?

Live — each run queries the engine at request time rather than reading a cache. That is what makes it usable for grounding, and it means rankings can legitimately differ between two runs minutes apart. Store the collection timestamp alongside each row.

Run the Google search results API now

$2 of free credit every month, no card. Your key returns its own prices from GET /v1/scraper/collectors.

Get my free API key