# Google Shopping API — $0.001 per Listing

> Google Shopping API: a product query returns listings with price, currency, seller, rating, condition and product id. $0.001 per delivered listing.

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

# Google Shopping API

The Google Shopping API turns a product query into listings: title, price and currency, seller, rating and review count, condition, promo tags and the Google product id. Feed that id to the price comparison collector and you get every seller offer behind the listing. $0.001 per delivered listing.

[Get my free API key](https://app.quanticdata.io/register) [See the request](/collectors/google-shopping-api/#integration)

$0.001 per delivered listing · $2 free every month · Failed runs never billed

POST /v1/scraper/collectors/google_shopping/run

```
$ curl $QD/google_shopping/run \
    -H "Authorization: Bearer $QD_API_KEY" \
    -d '{ "query": "wireless earbuds", "country": "us",
          "max_results": 40 }'
{ "status": "done", "count": 40,
  "results": [
    { "title": "Sony WF-1000XM5",
      "price": "$248.00", "price_value": 248,
      "currency": "USD", "seller": "Best Buy",
      "rating": 4.6, "reviews": 2841,
      "product_id": "1234567890123456789" } ],
  "cost": 0.04 }
# 40 listings × $0.001 · nothing delivered, nothing charged
```

**$0.001 / listing**2,000 listings on the free $2 every month

**A query, not a URL**no merchant feed, no Merchant Center account

**Up to 100 listings**per run, merged across pages

**product_id on rows**the key to every seller offer for that product

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

## What the Google Shopping API returns

**A Google Shopping API reads the public shopping results for a query and returns each listing as a row with its price, seller and identifiers.** It is the fastest way to see what a product sells for right now, across merchants, without a feed integration or a Merchant Center account.

Google’s own Content API for Shopping is for merchants managing their own feed — it tells you nothing about competitors. The public results are what shoppers actually see, and that is what this collector reads, through our residential network, with pagination and de-duplication handled inside the run.

Each row carries the `product_id` parsed from the Google product link. That id is the input to the [price comparison API](https://quanticdata.io/collectors/price-comparison-api/), which opens the product page and returns every seller offer behind it — listings first, offers second, both billed per delivered row. For recurring tracking rather than one-off calls, the managed version is [competitor price monitoring](https://quanticdata.io/competitor-price-monitoring/).

Query in, priced rows out *query* *country* *lang* *max_results*

## What comes back for every listing

Sixteen published fields, versioned. Prices arrive both as shown and parsed to a number, so you can sort without regexes.

| Field | Type | What it holds |
| --- | --- | --- |
| `title` | string | Listing title as displayed. |
| `price` · `price_value` | string · number | Price as shown and the numeric value. |
| `currency` | string | Currency code or symbol. |
| `seller` | string | Merchant name. |
| `rating` · `reviews` | number · integer | Product rating and review count. |
| `condition` | string | refurbished / used / open box, when not new. |
| `multiple_sources` | boolean | True when several merchants offer the same product. |
| `product_id` | string | Google product id — input for the price comparison collector. |
| `product_link` · `link` | string | Google product page and the merchant link. |
| `tag` · `extensions` | string · string[] | Promo tag ("7% OFF") and badges (free shipping, returns…). |
| `image` · `rank` | string · integer | Image URL and position across the merged pages. |

## Inputs: the query and the market

Shopping results are heavily localised — the same query in two countries is two different price landscapes.

| Input | Type | Required | What it does |
| --- | --- | --- | --- |
| `query` | string | yes | Product query — "wireless earbuds", "nike air max 90". |
| `country` | string | no | ISO code: exit geo, currency and merchant mix all follow it. |
| `lang` | string | no | Interface language for titles and badges. |
| `max_results` | integer | no | 1–100, default 20. Billed on delivered listings only. |

Pricing

## What a Google Shopping API costs here

Delivered listings cost $0.001 each — $1 per 1,000. Watching 200 products daily at 20 listings each is 4,000 rows, about $4 a day at list price and less on a volume tier; a query that returns nothing is free.

**$0.001**per delivered listing*$1 per 1,000 delivered listings*

**2,000 listings**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/google_shopping/run`.

```
# 40 shopping listings for a query, US market
curl https://api.quanticdata.io/v1/scraper/collectors/google_shopping/run \
  -H "Authorization: Bearer $QD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "query": "wireless earbuds", "country": "us",
        "max_results": 40 }'
```

```
import requests

BASE = "https://api.quanticdata.io/v1/scraper/collectors"
H = {"Authorization": f"Bearer {KEY}"}

r = requests.post(f"{BASE}/google_shopping/run", headers=H,
    json={"query": "Sony WH-1000XM5", "country": "us",
          "max_results": 20})

rows = r.json()["data"]["results"]
cheapest = min(rows, key=lambda x: x["price_value"] or 1e9)
print(cheapest["seller"], cheapest["price"], cheapest["product_id"])
```

```
const BASE = "https://api.quanticdata.io/v1/scraper/collectors";
const h = { Authorization: `Bearer ${process.env.QD_API_KEY}`,
            "Content-Type": "application/json" };

// listings → product_id → every seller offer
const list = await (await fetch(`${BASE}/google_shopping/run`, {
  method: "POST", headers: h,
  body: JSON.stringify({ query: "nike air max 90", country: "de",
                         lang: "de", max_results: 40 })
})).json();

const id = list.data.results.find(r => r.product_id)?.product_id;
console.log("next: product_offers with", id);
```

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

# then, from the agent:
run_collector  slug="google_shopping"
               input={ "query": "wireless earbuds",
                       "country": "us", "max_results": 40 }
```

## What people run it for

Price is the most-scraped field on the web — these are the four shapes that request takes.

### Competitor price checks

Query your own catalogue terms and see who sells the same product, at what price, with what promo tag — before deciding whether your price is the problem.

### Market entry pricing

The same query per country returns a different merchant mix and currency. Two runs tell you more about a new market than a week of guessing.

### Assortment discovery

Which products even appear for a category term, which are refurbished, which have multiple sellers — the `condition` and `multiple_sources` fields make that filterable.

### Feeding the offer step

Take `product_id` from the interesting rows and run the [price comparison API](https://quanticdata.io/collectors/price-comparison-api/) for the full seller list — listings are the map, offers are the detail.

## Collector vs Content API vs scraping it yourself

Google has a Shopping API — for merchants managing their own feed, not for market data.

|  | Content API for Shopping | Your own scraper | This collector |
| --- | --- | --- | --- |
| What it shows | your own feed and account | whatever you can parse | the public results shoppers see |
| Access | Merchant Center account | proxies and a browser tier | an API key |
| Competitor prices | no | yes, if you survive the blocks | yes, per query and per country |
| Product ids | your own ids | you extract them | `product_id` on every row |
| Billing | free with an account, limited scope | proxy and compute burn | $0.001 per delivered listing |

## Merchant APIs manage your feed, not the market

Google's Content API for Shopping and its successor the Merchant API are merchant-side: they let you upload and manage your own product feed. They cannot tell you what other merchants charge, which is the entire point of a price comparison — and there is no public Google API that returns Shopping search results at all.

For a dataset the hinge is `product_id`. It is Google's identifier for the clustered product, stable enough to use as a join key between runs and the input that turns one listing into the full per-seller offer list through the [product offers](https://quanticdata.io/collectors/price-comparison-api/) collector. Cluster identity is the hard problem in price comparison, and Google has already solved it.

## Limits, markets and the legal bit

Up to 100 listings per run. Google Shopping is a per-market surface: merchants, currencies, availability and even which products exist differ by country, so a US-exit request for a German price list answers the wrong question coherently. Keep `currency` as a column rather than assuming one. 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.

Collecting publicly visible data is generally lawful in most jurisdictions, and courts have repeatedly declined to treat reading a public page as unauthorised access. Google's terms restrict automated access. Prices and merchant names are commercial rather than personal data, which simplifies the privacy side without removing the terms question. Using competitor prices to coordinate rather than to compete is a competition-law problem entirely separate from collection. None of this is legal advice — get some for your actual use case.

## FAQ

What people ask before scraping Google Shopping — access, pricing and how far one call goes.

[Something else? Ask us →](mailto:hello@quanticdata.io)

### Is there a Google Shopping API for price data?

Google’s Content API for Shopping is for merchants managing their own product feed; it does not return competitor prices. To read what shoppers see you need the public results, which is what this collector returns — priced, sourced listings at $0.001 each.

### How much does a Google Shopping scraper API cost?

Here it is $0.001 per delivered listing, $1 per 1,000, with no subscription. The $2 free monthly allowance covers about 2,000 listings, and volume tiers take up to 30% off the unit price.

### Can I get every seller for one product?

Yes, in a second step: take the `product_id` from any listing row and run the [price comparison API](https://quanticdata.io/collectors/price-comparison-api/), which returns the per-seller offer list with prices, totals including shipping and links, at $0.002 per delivered offer.

### Do results differ by country?

Substantially. Currency, merchant mix and even which products appear are localised, so `country` is the field to set deliberately — it drives both the proxy exit geo and Google’s own locale for the request.

### How many listings can one run return?

Up to 100, default 20. Pagination and de-duplication happen inside the run, so consecutive pages are merged and each row appears once, with `rank` reflecting its position across the merged set.

### Is scraping Google Shopping legal?

Prices and listings shown publicly are public data, and collecting public data is generally lawful in most jurisdictions — but Google’s terms restrict automated access, and rules differ by country. This is not legal advice; get it for your specific use case.

### What makes product_id useful in a pipeline?

It is a stable join key. Two runs a week apart can be matched on it exactly, and it is the input to the offers collector, so "which products moved" and "who sells them" become one dataset instead of a fuzzy title-matching exercise.

### Why keep the currency column?

Because cross-market comparisons that assume a single currency are the most common way this dataset goes wrong. The field is explicit precisely so an exchange-rate move is never mistaken for a price move.

## Start with the Google Shopping API

$0.001 per delivered listing, $1 per 1,000 delivered listings. $2 of free credit every month, no card — and a run that delivers nothing is never billed.

[Get my free API key](https://app.quanticdata.io/register)

Related: [All 32 collectors](https://quanticdata.io/collectors/) [Price Comparison API](https://quanticdata.io/collectors/price-comparison-api/) [Competitor Price Monitoring](https://quanticdata.io/competitor-price-monitoring/) [Google Hotels API](https://quanticdata.io/collectors/google-hotels-api/) [SERP API](https://quanticdata.io/serp-api/) [Documentation](https://quanticdata.io/docs/)

---

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