# Google Shopping Scraper - Prices, Stores, Offers & Ratings (`scrapersdelight/google-shopping-scraper`) Actor

Scrape Google Shopping by search term or product id: title, price, old price, discount, store, delivery, returns, condition, rating, exact review count, brand and image. Google's own sort and price filters, ~250 products per term, optional store offers with store links, price monitor.

- **URL**: https://apify.com/scrapersdelight/google-shopping-scraper.md
- **Developed by:** [Scrapers Delight](https://apify.com/scrapersdelight) (community)
- **Categories:** E-commerce, SEO tools, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.63 / 1,000 products

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### What does Google Shopping Scraper do?

**Google Shopping Scraper** turns a [Google Shopping](https://www.google.com/search?q=wireless+earbuds\&udm=28) search into a clean product list: one row per product with its title, price, previous price and discount, the store, delivery and returns, condition, rating and review count, brand, image and Google's product ids. Type a search term, a model number or a barcode, paste a Google Shopping URL, or give product ids. Built for price monitoring, MAP enforcement, competitor research, product feeds and e-commerce analytics.

Also known as: Google Shopping API, Google Shopping price scraper, Google product search scraper.

- **🛒 Up to ~250 products per search term** - the actor pages through Google's results (248 unique products for "coffee maker" in one measured run), not only the first ~40.
- **↕️ Google's own sort and filters** - price low to high, high to low, rating; price range, on sale, free shipping, 4 stars and up. Sent to Google the way its own filter chips send them, then checked again on every row before it is charged.
- **🏪 Store offers with the store's own link** - switch on **Product details** to open each product's Google page: every store offer shown there (store, price, old price, availability, delivery, returns, store rating) with the store's real product URL, plus description, specifications, photos, variants and Google's typical price range.
- **🔢 Exact review counts** - `reviewCount` is the exact number from Google's product data (6,632), not the rounded "6.6K" on the card.
- **🌍 Any country** - prices, stores and currency of the country you pick; pages Google localises to the wrong country are detected and fetched again.
- **🔁 Price monitor** - schedule it and get only products that are new or re-priced since the last run, with the previous price and the change.
- **No login, no cookies, no Google API key.** Pay only for delivered products.

### What data can you get from Google Shopping?

| | | |
|---|---|---|
| 🏷️ `title`, `brand` | 💲 `price`, `priceText`, `currency` | 📉 `oldPrice`, `discountPercent`, `badge` |
| 🏪 `store`, `moreStores` | 🚚 `delivery`, `freeDelivery` | ↩️ `returns`, `freeReturns` |
| ⭐ `rating`, `reviewCount` | 🆕 `condition` (new / used / refurbished) | 🖼️ `thumbnail` |
| 🔗 `productUrl` (Google product page) | 🆔 `productId`, `catalogId`, `offerId`, `groupId` | 📍 `nearby` ("Nearby, 17 mi") |
| 💬 `priceNote` ("Usually $23") | 🌐 `foreignPrice` ("£252") | 🗂️ `shelf` (Google's product shelf) |
| 📄 `description`, `specifications` \* | 🛍️ `offers` with store URLs \* | 📊 `typicalPriceLow`, `typicalPriceHigh` \* |
| 🎨 `variants`, `images` \* | 📈 `previousPrice`, `priceChange` \*\* | 🔍 `query`, `position`, `page`, `searchUrl` |

\* with **Product details** on · \*\* with **Only new or re-priced products** on

### How to scrape Google Shopping with Google Shopping Scraper

1. [Create a free Apify account](https://console.apify.com/sign-up) - it comes with monthly free credit.
2. Open **Google Shopping Scraper** and type one or more search terms (`wireless earbuds`, `sony wh-1000xm5`).
3. Pick the **Country**, and optionally a sort order, a price range or other filters.
4. Set **Max products per search** and click **Start**.
5. Download the results as JSON, CSV, Excel or HTML, or send them to Google Sheets, a database or a webhook.

### ⬇️ Input

| Parameter | Type | Description |
|---|---|---|
| `queries` | array | Search terms, one Google Shopping search each: words, model numbers, barcodes (EAN/UPC/GTIN) or pasted Google Shopping search URLs (their own filters are kept). Default `["wireless earbuds"]`. |
| `productIds` | array | Google product ids (`productId` from an earlier run) or Google Shopping product links. Each returns one product with its product page. |
| `country` | string | Google country, e.g. `us`, `gb`, `de`, `fr`, `ca`, `au`. Default `us`. |
| `language` | string | Google interface language, e.g. `en`, `de`. Default `en`. |
| `sortBy` | string | `relevance` (default), `price_low`, `price_high`, `rating` - Google's own sort. |
| `minPrice`, `maxPrice` | number | Price range in the country's currency (Google's own filter, re-checked per row). |
| `onSale`, `freeShipping` | boolean | Google's "On sale" and "Free shipping" filters. |
| `minRating` | number | Minimum stars, 1-5. |
| `exactQuery` | boolean | Stop Google's spelling correction (use it for barcodes and model numbers). |
| `condition` | string | `any` (default), `new`, `used`, `refurbished`. |
| `freeReturns` | boolean | Only products whose card shows free returns. |
| `stores` | array | Only these stores, e.g. `["Walmart", "Best Buy"]` (part of the name is enough). |
| `minReviews` | integer | Only products with at least this many reviews. |
| `includeDetails` | boolean | Open each product's Google page: offers with store URLs, description, specifications, photos, variants, typical price. Default off. |
| `maxDetailsPerQuery` | integer | Products per search that get their product page. Default 10; 0 = all. |
| `monitorMode`, `monitorName` | boolean, string | Deliver only products that are new or re-priced since earlier runs of the same search. |
| `maxResultsPerQuery` | integer | Products per search term. Default 100 (up to 500). |
| `maxResults` | integer | Products for the whole run. Default 1,000; 0 = no cap. |
| `maxConcurrency` | integer | Google pages fetched at once. Default 4. |
| `saveHtml` | boolean | Debugging: keep the raw Google pages in the key-value store. |

#### Input JSON

```json
{
    "queries": ["wireless earbuds", "espresso machine"],
    "country": "us",
    "sortBy": "price_low",
    "minPrice": 30,
    "maxPrice": 80,
    "maxResultsPerQuery": 100,
    "includeDetails": true,
    "maxDetailsPerQuery": 5
}
```

#### Put one product idea per search term

Each line is its own Google Shopping search. `wireless earbuds` and `sony wf-1000xm5` return different product sets; a sentence with several products in it returns a muddled one. Google returns about 40-60 products on the first page and up to ~250 per term in total, so for more products use more (narrower) terms.

#### Barcodes and model numbers: switch on Exact search term

Google corrects the spelling of terms it does not recognise ("These are results for ..."). The row then carries the term Google used in `correctedQuery`. For a barcode, part number or a new brand name, switch on **Exact search term** so Google searches exactly what you typed.

#### Filters are Google's, and they are checked again

Sort, price range, on sale, free shipping and minimum rating are sent to Google, so Google returns matching products. Google's price filter is not exact (in one measured run 12 of 80 products came back outside the range), so every filter is also checked on each product before it is delivered - products outside your filters are dropped and not charged.

### ⬆️ Output

A real row from a measured run ("espresso machine", United States, Product details on, 2026-10-16), trimmed:

```json
{
    "query": "espresso machine",
    "position": 3,
    "title": "Rancilio Silvia Pro X Espresso Machine",
    "brand": "Rancilio",
    "price": 2195,
    "priceText": "$2,195.00",
    "currency": "USD",
    "store": "Majesty Coffee",
    "moreStores": true,
    "rating": 5,
    "reviewCount": 272,
    "productId": "162299799362446413",
    "productUrl": "https://www.google.com/search?ibp=oshop&q=Rancilio+Silvia+Pro+X+Espresso+Machine&prds=catalogid%3A162299799362446413...",
    "offersShown": 5,
    "lowestOfferPrice": 1791,
    "lowestOfferStore": "homecoffeemachines.ie",
    "offers": [
        { "store": "Majesty Coffee", "price": 2195, "label": "Most popular", "availability": "In stock online",
          "delivery": "Free delivery", "returns": "30-day returns",
          "url": "https://majestycoffee.com/products/rancilio-silvia-pro-x?currency=USD&country=US&variant=41606107201687&stkn=5a7eca5ec341" }
    ],
    "specifications": { "Capacity": "Multiple Cups", "Water Tank Size": "2 L", "Milk System": "Steam Wand" }
}
```

#### Fields and how often they are filled

Measured on 388 products from three US searches (wireless earbuds, running shoes, coffee maker), 2026-10-16:

| Field | Filled | Note |
|---|---|---|
| `title`, `price`, `priceText`, `currency`, `productUrl`, `productId` | 100% | |
| `store` | 97% | some cards show only "& more" - the store list is on the product page |
| `offerId`, `imageId` | 97% | |
| `catalogId`, `groupId` | 95-96% | single-store listings have no catalog id |
| `thumbnail` | 94% | |
| `rating`, `reviewCount`, `brand` | 91% | products without reviews have none |
| `moreStores` true | 80% | |
| `returns` | 79% | |
| `delivery` | 60% | |
| `badge` / `oldPrice` + `discountPercent` | 26% / 16-18% | only discounted products |
| `shelf` | 37% | first results page only |
| `priceNote`, `foreignPrice`, `nearby`, `conditionText` | 0-6% | only when Google shows them |

With **Product details** on (4 products, 16 store offers measured): offers, offer store, price, availability, delivery and store URL 100%; images 100%; description and specifications 3 of 4; variants and typical price range 2 of 4 (only when Google shows them); offer store rating 10 of 16; old price on offers only when discounted.

### Use cases

- 💰 **Price monitoring** - schedule a daily run with **Only new or re-priced products** and get every price change with the old price.
- 🏷️ **MAP enforcement** - search your products, filter by store and catch sellers below the advertised price.
- 🔎 **Competitor research** - see which brands, stores and price points own a product category.
- 🧾 **Product feeds and catalogues** - titles, images, specifications and Google product ids for a list of products.
- 🛍️ **Where to buy** - the store offers of a product, with each store's own URL.
- 📈 **Market sizing** - counts, price ranges and ratings across up to ~250 products per term.

### How much does it cost to scrape Google Shopping?

Pay per result, no start fee:

| Event | Price | When |
|---|---|---|
| Product | $0.00063 per product ($0.63 per 1,000) | every product row |
| Product details | $0.012 per product | each product whose Google product page was read (Product details on) |

| Run | Cost |
|---|---|
| 100 products | $0.063 |
| 1,000 products | $0.63 |
| 100 products, 10 with product details | $0.183 |

Not charged: duplicates (a product in several Google shelves is one row), products removed by your filters, unchanged products in monitor mode, pages that could not be read.

### Integrations, API, scheduling & MCP

Run it on a schedule (daily price checks), get a webhook when a run finishes, or connect it to Make, Zapier, n8n, Google Sheets or Slack. Call it from code with the Apify API ([Python](https://docs.apify.com/api/client/python), [JavaScript](https://docs.apify.com/api/client/js)), or let an AI agent run it through the [Apify MCP server](https://mcp.apify.com).

### More Google scrapers

- [Google SERP Scraper](https://apify.com/ScrapersDelight/google-serp-scraper) - organic web results by query.
- [Google News Scraper](https://apify.com/ScrapersDelight/google-news-scraper) - news articles with decoded URLs.
- [Google Trends Scraper](https://apify.com/ScrapersDelight/google-trends-interest-scraper) - interest over time and by region.
- [Google Flights Scraper](https://apify.com/ScrapersDelight/google-flights-scraper) - fares, flight numbers and layovers.
- [Google Ads Transparency Scraper](https://apify.com/ScrapersDelight/google-ads-transparency-scraper) - advertisers' ad creatives.

### Limits & empty runs

- Google shows about 40-60 products on the first page and up to ~250 per term (measured: 248 for "coffee maker" over 8 pages). Paging stops when a page adds no new product.
- Sponsored (paid) Shopping ads are not returned: Google does not show them to automated requests.
- GTIN/MPN are not on the results cards; a barcode works as a search term.
- About 1 in 12 Google pages comes back localised to the wrong country; the actor detects it (page language and currency) and fetches the page again at no charge to you.
- A product page takes about 60 s, so runs with Product details are slower.
- A run that delivers nothing charges nothing. Google answers almost every term with products - for a term it does not know it corrects the spelling (see `correctedQuery`).

### FAQ

#### How much does Google Shopping Scraper cost?

$0.00063 per product, plus $0.012 per product when Product details is on. 1,000 products cost $0.63. No start fee.

#### How many products can Google Shopping Scraper get?

Up to about 250 per search term (Google's own limit), any number of terms per run.

#### Can Google Shopping Scraper get the prices of every store selling a product?

Yes - switch on **Product details**. Each product then carries the store offers on its Google product page, with price, old price, availability, delivery, returns, store rating and the store's own product URL.

#### Can I sort Google Shopping results by price with Google Shopping Scraper?

Yes. `sortBy: "price_low"` sends Google's own "Price: low to high" sort; measured, the first page came back in ascending price order.

#### Can I look up products by barcode or id?

Search a barcode as a term (with **Exact search term** on), or put Google product ids or product links in **Product ids** for one detailed row per product.

#### Can I schedule Google Shopping Scraper as a price tracker?

Yes. Save your input as a task, add a daily schedule and switch on **Only new or re-priced products**: each run delivers only products that are new or whose price changed, with `previousPrice`, `priceChange` and `priceChangePct`.

#### Which countries does Google Shopping Scraper support?

Any country with Google Shopping. Pick it in **Country**; prices come in that country's currency. Measured in the United States and Germany.

#### Can I use Google Shopping Scraper with the Apify API or Python?

Yes - start runs and read the dataset with the Apify API or the Python and JavaScript clients.

#### Can AI agents use Google Shopping Scraper through MCP?

Yes, through the Apify MCP server.

#### Do I need a Google account or API key for Google Shopping Scraper?

No. No login, no cookies, no Google API key.

#### Why did my Google Shopping Scraper run return fewer products than I asked for?

Google ran out of products for the term, or your filters removed them (the run summary lists how many each filter dropped), or monitor mode skipped unchanged products. None of those are charged.

#### Your feedback

Something missing or wrong? Open an issue on the Issues tab - we read every one.

# Actor input Schema

## `queries` (type: `array`):

One Google Shopping search per line, e.g. "wireless earbuds", "sony wh-1000xm5", a barcode like "0194253397694", or a pasted Google Shopping search URL (its own filters are kept).

## `productIds` (type: `array`):

Optional. Google product ids (the `productId` column of a previous run, e.g. "13817196430795275231") or Google Shopping product links. Each returns one product with its full product page (charged as a product + product details).

## `country` (type: `string`):

Google Shopping country (Google's gl parameter): prices, stores and currency are that country's.

## `language` (type: `string`):

Google's interface language (hl), e.g. "en", "de", "fr", "es". Store names and texts such as delivery and returns come back in it.

## `sortBy` (type: `string`):

Google's own result order (the Sort by menu on Google Shopping).

## `minPrice` (type: `number`):

Only products priced at or above this, in the country's currency (e.g. 20). Empty = no minimum.

## `maxPrice` (type: `number`):

Only products priced at or below this, in the country's currency (e.g. 150). Empty = no maximum.

## `onSale` (type: `boolean`):

Google's "On sale" filter: products with a reduced price.

## `freeShipping` (type: `boolean`):

Google's "Free shipping" filter.

## `minRating` (type: `number`):

Only products rated at least this many stars (1-5, e.g. 4). Products without a rating are left out.

## `exactQuery` (type: `boolean`):

Stop Google from correcting the spelling of a term (Google's own "Search instead for" link). Use it for barcodes, model numbers and brand names Google does not know.

## `condition` (type: `string`):

Keep only new, used (pre-owned) or refurbished products, as Google labels them on the card.

## `freeReturns` (type: `boolean`):

Keep only products whose card shows free returns.

## `stores` (type: `array`):

Keep only products sold by these stores (part of the name is enough, e.g. "Walmart", "Best Buy", "Amazon"). Empty = every store.

## `minReviews` (type: `integer`):

Keep only products with at least this many reviews (e.g. 100).

## `includeDetails` (type: `boolean`):

Adds the product page: description, specifications, photos, variants, typical price range and the store offers (store, price, old price, availability, delivery, returns, store rating and the store's own product URL). About 60 s per product page.

## `maxDetailsPerQuery` (type: `integer`):

How many products of each search get their product page (the first ones in Google's order). 0 = every delivered product.

## `monitorMode` (type: `boolean`):

Deliver (and charge) only products that earlier runs of the same search did not return, or whose price changed - with the previous price and the change. The first run returns everything.

## `monitorName` (type: `string`):

Optional. Keeps a separate memory under this name (e.g. one per client or schedule watching the same searches).

## `maxResultsPerQuery` (type: `integer`):

Products per search term. Google shows about 170-250 different products per term over up to 8 pages; 40-60 come on the first page.

## `maxResults` (type: `integer`):

Cap for the whole run across all searches and product ids. 0 = no cap.

## `maxConcurrency` (type: `integer`):

Google pages fetched at the same time (1-10).

## `saveHtml` (type: `boolean`):

Debugging: also save every Google results page as HTML in the run's key-value store (HTML\_<search>\_p<page>).

## Actor input object example

```json
{
  "queries": [
    "wireless earbuds"
  ],
  "country": "us",
  "language": "en",
  "sortBy": "relevance",
  "onSale": false,
  "freeShipping": false,
  "exactQuery": false,
  "condition": "any",
  "freeReturns": false,
  "includeDetails": false,
  "maxDetailsPerQuery": 10,
  "monitorMode": false,
  "maxResultsPerQuery": 40,
  "maxResults": 1000,
  "maxConcurrency": 4,
  "saveHtml": false
}
```

# Actor output Schema

## `results` (type: `string`):

One row per product.

## `summary` (type: `string`):

Per search: pages read, Google requests, products seen, duplicates, filtered and unchanged counts, spelling corrections, errors and why paging stopped.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "queries": [
        "wireless earbuds"
    ],
    "country": "us",
    "maxResultsPerQuery": 40
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapersdelight/google-shopping-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "queries": ["wireless earbuds"],
    "country": "us",
    "maxResultsPerQuery": 40,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapersdelight/google-shopping-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "queries": [
    "wireless earbuds"
  ],
  "country": "us",
  "maxResultsPerQuery": 40
}' |
apify call scrapersdelight/google-shopping-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapersdelight/google-shopping-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/BHpS06iF0HKLR8ykZ/builds/wdDfOWK25ltUxD5pG/openapi.json