# Google Shopping Scraper: products, prices, price watch (`alexmorain/google-shopping-scraper`) Actor

Scrape Google Shopping without a browser or SerpApi, in the country and currency you ask (not the proxy's). Price, condition, store, rating and a stable product ID, up to several hundred products per search. Duplicates and filtered products are never charged. Price watch.

- **URL**: https://apify.com/alexmorain/google-shopping-scraper.md
- **Developed by:** [Alexis Morain](https://apify.com/alexmorain) (community)
- **Categories:** E-commerce, Lead generation
- **Features:** Limited permissions
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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** collects the products that [Google Shopping](https://www.google.com/search?q=espresso+machine\&udm=28) shows for a search. It is a Google Shopping API alternative that needs **no browser and no SerpApi key**. For every product you get the title, price as a number and as text, old price, condition, store, rating, review count, delivery, image and a **stable product ID**, in the **country and currency you ask for**.

It does not open the store pages behind the products, and it does not list the offers of every other store for one product. It returns what the Google Shopping results page itself shows.

### Why use Google Shopping Scraper?

Google Shopping is the one place where the prices of thousands of stores sit side by side. Three things get in the way of collecting it, and this Actor handles all three.

**1. Google prices in the currency of the proxy, not of your country.** Through a proxy, `gl=us` is not enough: Google localizes on the IP address. We ran the same US search, `espresso machine`, several times (measured on 31 October 2026):

| Run | Country sent to Google | What came back | Products in common |
|---|---|---|---|
| A and B, no location parameter | `gl=us` | Euros and Danish crowns in the second run | 1 of 27 |
| C, D and E, with the location parameter (`uule`) | `gl=us` | US dollars | 21 of 23 between two of them |

The Actor sends a `uule` location for your country (or your own location) with every request. That is not the end of it: even with it, about **7 pages in 100 came back in the wrong currency** (reais, rupees, pesos, pounds), because the proxy IP won. In our runs 9 of 120 pages did. The Actor reads the currency of every page. A page in the wrong currency is flagged in the log and in the summary, read again from another IP (up to twice), and dropped if it is still wrong. A price in the wrong currency never reaches your dataset.

**2. One Google page shows 23 to 55 products.** Pagination goes further than most scrapers use it: `start` in steps of 10, up to `start=60`, gives about **170 distinct products** in 7 requests, then Google returns empty pages. For more, the Actor asks Google variations of your search: words like best, cheap, used and refurbished, price bands taken from the prices it has already seen, then the brands and the stores of the products it found. Every distinct product is returned once.

| Search (measured 31 October 2026) | Google requests | Distinct products |
|---|---|---|
| `espresso machine`, US, pages of the search only | 7 | 171 |
| same search, Complete coverage | 60 | 825 |
| `machine expresso`, France, Complete coverage | 60 | 907 |
| `bialetti moka express`, US (a narrow search), Complete coverage | 60 | 281 |

The narrow search ran dry: its requests brought 145, 31, 47, 32, 25 and 1 new products per block of 10. The Actor stops a search when its last 10 requests bring fewer than 20 new products. Of the 281 Bialetti products, 228 have Bialetti in the title; the rest are related products Google lists for the variations. Each product says which query found it (`variant`), so you can keep only the products of your own query.

**3. Prices move, and you only want what changed.** The **Price watch** mode remembers what earlier runs delivered. It can return only the new products, or the new products and the ones whose price changed, with `previousPrice` and `priceChange` (`up` or `down`). Products that did not change are not returned and not charged.

Also worth knowing:

- ⏱️ Schedule it on Apify, run it from the API, send results to Make, Zapier, Google Sheets or a webhook.
- 🌍 13 countries, each checked with a real request: United States, United Kingdom, Canada, Australia, Germany, France, Spain, Italy, Netherlands, India, Brazil, Mexico, Japan.
- 📍 An optional **location** (a city or a region) changes the local offers Google shows.
- 💾 Runs in 512 MB of memory: no browser. The measured peak was 181 MB.

### What data can Google Shopping Scraper extract?

| Field | Type | Description |
|---|---|---|
| `productId` | string | Google's catalog ID of the product (`data-cid`). Stable from one run to the next, use it as the key of a price history |
| `title` | string | Product title as Google shows it |
| `price`, `priceText`, `currency` | number, string | Price as a number, as Google writes it, and its ISO currency. A price shown as `$1,200+` is the lowest price of several stores |
| `originalPrice`, `discountText` | number, string | Old price and discount badge (`24% OFF`) when Google shows them |
| `condition` | string | `new`, `used` or `refurbished`. A product with no label is new |
| `merchant`, `moreMerchants` | string, boolean | The store Google lists, and whether Google shows more stores. When several stores sell the same product Google shows no single store and `merchant` is empty |
| `delivery`, `returns` | string | The delivery and returns lines as Google shows them. Google shows no delivery line in Germany, France, Spain, Italy, the Netherlands, Brazil and Mexico |
| `rating`, `reviewsCount` | number, integer | Average rating out of 5 and number of reviews (`1.6K` becomes 1600) |
| `badges` | array | Other badges, such as `LOW PRICE` |
| `imageUrl` | string | Image URL on Google's servers. About 4 products in 10 have one; for the others Google embeds a small thumbnail in the page and `imageUrl` is empty |
| `gid`, `oid`, `pid` | string | Other Google identifiers. `oid` is the featured offer and changes when the featured store changes |
| `position`, `page`, `query`, `variant`, `country`, `location`, `language`, `searchUrl` | | Where and how the product was found |
| `previousPrice`, `priceChange` | number, string | Price watch only |

Fields Google does not show for a product are `null`.

### How to scrape Google Shopping

1. Open the Actor and go to the **Input** tab.
2. Type one or more **Search terms**, for example `espresso machine`. Each line is one search.
3. Pick the **Country**. It sets the Google domain, the stores and the currency.
4. Set **Max products per search** and press **Start**.
5. Download the dataset as JSON, CSV or Excel, or read it through the API.

To follow prices, set **Price watch** to *New products and price changes*, name the monitor, and schedule a daily run.

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

You pay per event: a small amount when the run starts and an amount for each product returned. Duplicates, products outside your filters and, in Price watch mode, products already delivered at the same price are never charged. The Google proxy is included in the price.

| Event | Free plan | Bronze | Silver | Gold and above |
|---|---|---|---|---|
| Product (per 1,000) | $1.50 | $1.25 | $1.10 | $1.00 |
| Actor start (per GB of memory, 512 MB by default) | $0.002 | $0.002 | $0.002 | $0.002 |

Examples at the Free plan price: 100 products cost about $0.15, 1,000 products about $1.50. A Price watch run that finds 12 new products and 3 price changes costs about $0.025.

Set a maximum charge for the run in the run options: the Actor stops when it is reached and keeps everything it already delivered.

A search for 50 products takes 3 Google requests and about 10 seconds. A Complete coverage search for 800 products takes 60 requests and about 3 minutes.

### Input

See the **Input** tab for every option. The ones that need a word:

- **Search terms** and **Google Shopping URLs** can be mixed. From a URL (`udm=28` or `tbm=shop`) the Actor reads the search text, `hl` and `gl`.
- **Max products per search** (100 by default) and **Max products** (1000, across all searches) are the limits you pay by.
- **Complete coverage** (on by default) spends up to **Max requests per search** (60) Google requests per search. It only goes past the pages of your search when you ask for more products than the pages give. Off, only the pages of your search are read, about 170 products at most.
- **Location** is a place named the way Google names it, from the smallest to the largest: `Austin,Texas,United States`, `Lyon,Auvergne-Rhone-Alpes,France`. Maximum 63 characters. We checked it with `Austin,Texas,United States` and `Boston,Massachusetts,United States`: the results stay priced in dollars and local offers such as same-day delivery show up for Boston. A name Google does not know is ignored by Google, so the country applies.

#### How the filters work

Google's own price, condition and shipping filters do not work through the proxy. We tested them on 31 October 2026: the price parameters kept 11 products of 60 in the range, `$200..$300` in the query kept 21 of 31, and the sort parameter did not sort. So the Actor **checks every filter on the product itself** before it is pushed and charged. A product outside your filters is dropped, not charged.

| Filter | What the Actor does |
|---|---|
| Minimum and maximum price | Checks the price shown. A product with no readable price is kept and counted as unverified in the summary. |
| Condition (new, used, refurbished) | Adds the word to the Google query (it leans: `used espresso machine` returned 19 used products of 20, `refurbished espresso machine` 23 of 29), then checks the condition label of each product. A product with no label counts as new. |
| On sale only | Keeps a product that shows an old price or a discount badge. |
| Free delivery only | Keeps a product whose delivery line says free delivery with no minimum order. A product with a paid or conditional line (`Free delivery on $50+`) is dropped. In countries where Google shows no delivery line nothing can be checked and every product is kept. |

A narrow filter costs more Google requests for the same number of products, because most products found are dropped. The Actor follows the pages and the query variations that bring products matching your filters, and stops when they stop bringing any.

### Output

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel. A shortened item:

```json
{
  "productId": "2817853072745909436",
  "title": "Gaggia Cadorna Prestige Automatic Espresso Machine",
  "price": 679,
  "priceText": "$679.00",
  "currency": "USD",
  "originalPrice": null,
  "discountText": "24% OFF",
  "condition": "refurbished",
  "merchant": "Whole Latte Love",
  "moreMerchants": true,
  "delivery": "Free delivery by Fri",
  "returns": "30-day returns",
  "rating": 4.3,
  "reviewsCount": 661,
  "badges": [],
  "imageUrl": "https://encrypted-tbn0.gstatic.com/shopping?q=tbn:ANd9GcExample",
  "position": 1,
  "page": 1,
  "query": "espresso machine",
  "variant": "espresso machine",
  "country": "us",
  "language": "en",
  "previousPrice": null,
  "priceChange": null
}
```

Each run also writes a `SUMMARY` record to the key-value store. For every search it gives the Google requests made, pages read, empty and failed ones, distinct products found, products returned, products dropped by each filter, products kept without a check (`unverified`), pages read in the wrong currency and how many were recovered, the currency read, the yield of every request (`curve`: kind of query, page, products on the page, new products, matching products) and why the search stopped (`max-items`, `max-items-query`, `max-requests`, `low-yield`, `exhausted`, `no-results`, `blocked`).

#### Use it from Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("alexmorain/google-shopping-scraper").call(run_input={
    "queries": ["espresso machine"],
    "country": "us",
    "maxItemsPerQuery": 300,
    "maxPrice": 500,
    "monitorMode": "newAndPriceChanges",
    "monitorName": "espresso-us",
})
for product in client.dataset(run["defaultDatasetId"]).iterate_items():
    if product["priceChange"] == "down":
        print(product["title"], product["previousPrice"], "->", product["price"], product["currency"])
```

### Tips

- **Ask for the number of products you need.** The Actor stops as soon as it has them. Raise **Max products per search** past 170 to make it use the query variations.
- **Raise Max requests per search** (up to 1000) for a broad search. In our runs a broad search still brought 10 to 20 new products per request at 60 requests. The `low-yield` stop reason in the summary tells you when a search ran dry.
- **Price watch is a feed, not a guarantee.** Two identical runs 30 seconds apart share about 6 products in 10 (99 of 165): Google does not show the same set twice. A product that did not show up in a run is not removed from the memory. A price change can also be a different store featured for the same product (check `oid`).
- **Daily feed.** Price watch, a monitor name and a webhook URL. The webhook receives a short JSON summary when at least one product was returned.
- **One run, several searches.** Several searches share the **Max products** limit.

### FAQ, disclaimers, and support

#### Is it legal to scrape Google Shopping?

Our Actors are ethical and do not extract any private user data, such as email addresses, gender, or location. They only extract what the user has chosen to share publicly. We therefore believe that our Actors, when used for ethical purposes by Apify users, are safe. However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers. Check Google's terms for your use case as well.

#### Why did my run return fewer products than Max products?

Google had no more distinct products for the search, the filters dropped many of them, or the budget of requests ran out. Read the `endReason` of each search in the `SUMMARY` record.

#### Why is a price in another currency than my country?

It should not be. The Actor drops pages read in the wrong currency. In countries that use the dollar (United States, Canada, Australia, Mexico), a page shows a plain `$`, and the Actor cannot tell your dollar from another dollar on it. A few products can also show a price in another currency when a store lists it that way: `currency` says which.

#### Why does a product have no store, no delivery or no image?

When several stores sell a product Google shows no single store. Delivery lines are not shown in every country. About 6 products in 10 only carry an embedded thumbnail, not an image URL.

#### Can I get the offers of every store for one product?

No. Google loads them with a separate request that the proxy does not serve, and searching by GTIN does not return the product. The Actor returns the lowest price Google shows and `moreMerchants`.

#### Why did the run fail?

A run fails when the input is invalid, or when Google refused every request of the run. Nothing is charged in that case. Try again in a few minutes.

#### Can I call it from code?

Yes, see the **API** tab for the endpoints and client libraries. Something wrong or missing? Open a ticket in the **Issues** tab and it will be fixed.

### Guide and use cases

Use cases for outbound and automation, the output fields, pricing and common questions are on the [Google Shopping Scraper page](https://alexis.morain.fr/en/scrapers/google-shopping-scraper/) of my site. The [E-commerce family page](https://alexis.morain.fr/en/scrapers/families/ecommerce/) puts it side by side with the other scrapers of the same family.

# Actor input Schema

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

One product search per line, as you would type it in Google Shopping: <code>espresso machine</code>, <code>wireless earbuds</code>. Each line is one search.

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

Which Google to ask: it sets the domain (google.com, google.de...), the country of the stores and the currency of the prices. Without this, Google would answer for the country of the proxy's IP address.

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

Interface language of Google, a two-letter code such as <code>en</code>, <code>de</code>, <code>fr</code>. Empty uses the main language of the country.

## `location` (type: `string`):

Optional. A place more precise than the country, written as Google names it, from the smallest to the largest: <code>Austin,Texas,United States</code>, <code>Lyon,Auvergne-Rhone-Alpes,France</code>. It changes the local offers Google shows (for example same-day delivery). Maximum 63 characters. Leave empty to use the country.

## `startUrls` (type: `array`):

Optional. Google Shopping search URLs, such as <code>https://www.google.com/search?q=espresso+machine\&udm=28</code> (or <code>tbm=shop</code>). The search text, <code>hl</code> and <code>gl</code> are read from the URL. Other parameters are ignored.

## `maxItemsPerQuery` (type: `integer`):

Products returned for each search. Raise it to get more of the search: pagination alone gives about 170 products and Complete coverage goes further.

## `maxItems` (type: `integer`):

Total products returned by the run, across all searches.

## `completeCoverage` (type: `boolean`):

On: when pagination does not give enough products, ask Google variations of each search (best, cheap, used, price bands, then the brands and stores it finds) until nothing new comes back, up to <b>Max requests per search</b>. Off: only the pages of your own search (about 170 products at most).

## `maxRequestsPerQuery` (type: `integer`):

Budget of Google requests for each search (each returns up to 55 products). The Actor stops earlier when new requests stop finding new products.

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

Google requests in flight at once, 1 to 16.

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

Keep products priced at or above this, in the currency of the country. Google cannot filter by price in this view, so the price shown on each product is checked: a product outside the range is dropped, not charged. A product with no readable price is kept.

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

Keep products priced at or below this, in the currency of the country. Checked on each product, like the minimum price.

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

Keep only new, used (pre-owned) or refurbished products. Google leans towards the condition when asked, but does not filter, so the condition shown on each product is checked: a product showing another condition is dropped, not charged. A product with no label counts as new.

## `onSaleOnly` (type: `boolean`):

Keep only products that show an old price or a discount badge. Others are dropped, not charged.

## `freeShippingOnly` (type: `boolean`):

Keep only products that show free delivery with no minimum order. A product with a paid or conditional delivery line is dropped, not charged. Google shows a delivery line in US, UK, Canada, Australia, India and Japan only: in other countries nothing can be checked and every product is kept.

## `monitorMode` (type: `string`):

Remembers the products returned by earlier runs. <b>New products only</b> returns only products not delivered before. <b>New products and price changes</b> also returns a product whose price changed, with its <code>previousPrice</code> and a <code>priceChange</code> of <code>up</code> or <code>down</code>. The first run returns everything that matches. Schedule it daily for a feed that never repeats. Unchanged products are never charged.

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

Without a name, the memory belongs to each search as typed. With a name, every run using that name shares it, even if you change the other settings. The memory lives in your key-value store <code>google-shopping-monitor</code>.

## `webhookUrl` (type: `string`):

If set, the Actor POSTs a small JSON summary to this URL at the end of the run, <b>only when at least one product was returned</b>: <code>actor</code>, <code>runId</code>, <code>datasetId</code>, <code>products</code>, <code>monitorMode</code> and one line per search. Use the final URL: a redirect is not followed, except a 307 or 308. An unreachable webhook is logged and never fails the run. Stored encrypted.

## Actor input object example

```json
{
  "queries": [
    "espresso machine"
  ],
  "country": "us",
  "maxItemsPerQuery": 50,
  "maxItems": 1000,
  "completeCoverage": true,
  "maxRequestsPerQuery": 60,
  "maxConcurrency": 10,
  "condition": "any",
  "onSaleOnly": false,
  "freeShippingOnly": false,
  "monitorMode": "off"
}
```

# Actor output Schema

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

All products in the default dataset.

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

For each search: Google requests, pages, empty and failed ones, distinct products found, products returned, products dropped by your filters, pages read in the wrong currency, the yield of each request and why the search 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": [
        "espresso machine"
    ],
    "maxItemsPerQuery": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("alexmorain/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": ["espresso machine"],
    "maxItemsPerQuery": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("alexmorain/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": [
    "espresso machine"
  ],
  "maxItemsPerQuery": 50
}' |
apify call alexmorain/google-shopping-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,alexmorain/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/eD8HdnSJh1cNayZ3g/builds/s6MYo6Wp0kKQCWHIu/openapi.json
