# Google search results API — $0.0004 per result

> Google search results API: Organic search results for a query — Google, Bing or. $0.0004 per delivered result, nothing delivered means nothing charged.

[Home](https://quanticdata.io/)/[Collectors](https://quanticdata.io/collectors/)/*Google search results API*

# 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](https://app.quanticdata.io/register) [See the request](/collectors/google-search-results-api/#integration)

$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 / result**5,000 results on the free $2 every month

**Semantic input**query, engine, country — no URL lists

**Up to 100**results per run, pagination handled for you

**No browser**read over HTTP/TLS — cheaper and faster than rendering

On this page: [What it is](/collectors/google-search-results-api/#what) [Output fields](/collectors/google-search-results-api/#output) [Inputs](/collectors/google-search-results-api/#input) [Pricing](/collectors/google-search-results-api/#pricing) [Integration](/collectors/google-search-results-api/#integration) [Use cases](/collectors/google-search-results-api/#use-cases) [Versus the alternatives](/collectors/google-search-results-api/#compare) [FAQ](/collectors/google-search-results-api/#faq)

## 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.

Input is meaning, not a URL *query* *engine* *country* *lang* *location*

## 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.0004**per delivered result*$0.4 per 1,000 delivered results*

**5,000 results**on the free allowance*$2 every month, no card*

**Zero rows**zero charge*blocks, captchas and retries are on us*

**−30%**on volume tiers*the 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

Most popular

### 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](https://quanticdata.io/web-data-api-for-ai/). 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 →](mailto:hello@quanticdata.io)

### 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](https://app.quanticdata.io/register)

Related: [All 32 collectors](https://quanticdata.io/collectors/) [Image scraper API](https://quanticdata.io/collectors/image-scraper-api/) [Keyword research API](https://quanticdata.io/collectors/keyword-research-api/) [Google News API](https://quanticdata.io/collectors/google-news-api/) [SERP API](https://quanticdata.io/serp-api/) [Documentation](https://quanticdata.io/docs/)

---

Source: https://quanticdata.io/collectors/google-search-results-api/ · Site index for AI: https://quanticdata.io/llms.txt