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 See the request

$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 / listing2,000 listings on the free $2 every month

A query, not a URLno merchant feed, no Merchant Center account

Up to 100 listingsper run, merged across pages

product_id on rowsthe key to every seller offer for that product

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

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.001per delivered listing$1 per 1,000 delivered listings

2,000 listingson 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/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 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 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 →

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, 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