# Google Shopping Scraper: Prices, Sellers, Ratings (`datagleaner/google-shopping-scraper`) Actor

Scrape Google Shopping results for any search in 43 countries: product title, brand, price and old price, discount, seller, delivery and returns, rating, review count, thumbnail and Google product IDs. Up to ~200 products per query, price-range filter, no browser. $1 per 1,000 products.

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

## Pricing

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

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

## Google Shopping Scraper: Prices, Sellers, Ratings

**Google Shopping Scraper** turns any Google Shopping search into a clean table of products. Type a query, such as `air fryer`, `Sony WH-1000XM5` or a barcode. For each product you get the title, brand, current price as a number with its currency, the old price and discount badge when there is one, the seller, whether other sellers offer it too, delivery and returns notes, star rating, exact review count, thumbnail and Google's product IDs. It covers **43 countries**, returns **up to about 200 products per query** and can filter by price range. There is no browser and no login to set up. It costs **$1 per 1,000 products**, with no start fee.

### What you can do with it

- **Price monitoring.** Track what a product model costs on Google Shopping in each country, who sells it cheapest and which offers are discounted. Run it on a schedule and compare `price` per `catalogId` over time.
- **Competitor and seller research.** See which merchants show up for your category's searches, how often they appear, and at what prices.
- **Category and assortment research.** Pull the first 200 products for a category (`robot vacuum`, `running shoes`) to learn the brands, price bands, ratings and review volumes that define it.
- **Deal and discount tracking.** Every struck-through price comes back as `oldPrice` with its `discountText` ("30% OFF"), so you can filter for real markdowns.
- **Market entry checks.** Run the same query in the US, UK, Germany, Australia or India and compare prices, sellers and currencies side by side.
- **Feeds for AI agents and dashboards.** The numbers stay numbers (`price`, `rating`, `reviewCount`) and the fields have the same names in every country, ready for a spreadsheet, BI tool or LLM.

### Input

| Field | Type | What it does |
|---|---|---|
| `queries` | list of text | Searches as you would type them into Google Shopping: a product type (`air fryer`), a brand and model (`Sony WH-1000XM5`), or a GTIN/EAN/UPC. Each query returns its own rows. |
| `country` | code | Where the search runs: `us` (default), `uk`, `de`, `fr`, `au`, `ca`, `in`, `jp` and 35 more. It sets the sellers, the prices and the currency you get. |
| `language` | code | Google's interface language, default `en`. It changes labels such as the delivery and returns text, not which products appear. Use `de` for German labels on a German search. |
| `maxProductsPerQuery` | number | Default 60, max 200. The run pages through Google Shopping until it has this many. |
| `minPrice`, `maxPrice` | number | Optional price range, in the country's currency. This uses Google Shopping's own price filter, and rows outside the range are dropped and not charged. |
| `maxConcurrency` | number | How many queries run in parallel. Default 5. |

Example:

```json
{
  "queries": ["air fryer", "Sony WH-1000XM5"],
  "country": "us",
  "maxProductsPerQuery": 50,
  "minPrice": 50
}
```

An empty input `{}` runs a small example (5 products for "wireless earbuds"), and the status message says so.

### Output

One row per product, in Google's order (`position`). Example:

```json
{
  "position": 3,
  "title": "Gourmia 14qt All-in-One Digital Air Fryer Oven",
  "brand": "Gourmia",
  "price": 89.99,
  "currency": "USD",
  "priceText": "$89.99",
  "priceFrom": false,
  "oldPrice": 100,
  "oldPriceText": "$100",
  "discountText": "10% OFF",
  "condition": null,
  "merchant": "Target",
  "moreMerchants": true,
  "delivery": "Free delivery",
  "returns": "90-day returns",
  "rating": 4.2,
  "reviewCount": 1001,
  "thumbnail": "https://encrypted-tbn2.gstatic.com/shopping?q=tbn:ANd9GcSrRRurbMpgpokR...",
  "productUrl": "https://www.google.com/search?ibp=oshop&q=Gourmia%2014qt%20All-in-One%20Digital%20Air%20Fryer%20Oven&prds=catalogid:245647034554133019,headlineOfferDocid:1717260105217047190,gpcid:17366218037613661375,productDocid:1167815073112739801,pvt:hg&hl=en&gl=us&udm=28",
  "offerId": "1717260105217047190",
  "productId": "1167815073112739801",
  "catalogId": "245647034554133019",
  "groupId": "17366218037613661375",
  "query": "air fryer",
  "country": "us",
  "language": "en",
  "page": 1,
  "scrapedAt": "2026-10-21T18:03:53+00:00"
}
```

| Field | What it holds |
|---|---|
| `title`, `brand` | Product title as shown; brand when Google knows it. |
| `price`, `currency`, `priceText` | Current price as a number, its ISO currency code, and the text as shown (`$26.74`, `60,95 €`, `￥65,670`). |
| `priceFrom` | `true` for a "from" price across variants or sellers (`$180+`). |
| `oldPrice`, `oldPriceText`, `discountText` | The struck-through earlier price and the badge ("30% OFF", "$10 OFF"). In India, the maximum retail price. Foreign-currency prices and monthly instalments are not counted as old prices. |
| `condition` | Set only when the item is not new ("Refurbished", "Pre-owned"). |
| `merchant`, `moreMerchants` | The seller of the offer Google shows first. `moreMerchants` is `true` when other sellers offer the same product too ("& more"). |
| `delivery`, `returns` | Notes such as "Free delivery by Mon" or "30-day returns", in the page language. |
| `rating`, `reviewCount` | Average stars out of 5 and the exact review count (33309, where the page shows "33K"). |
| `thumbnail` | Google-hosted product image. |
| `productUrl` | Google Shopping's product page, which lists the product's sellers. Set for catalogued products, which is most multi-seller items. |
| `offerId`, `productId`, `catalogId`, `groupId` | Google's IDs. `catalogId` is shared by every seller's offer of the same product, so use it to match a product across runs. |
| `query`, `country`, `language`, `page`, `scrapedAt` | Where the row came from and when. |

Fill rates measured on 2,800 products across 8 countries (2026-10-22): title, price, currency and thumbnail 100%, merchant 98%, brand 90%, rating and review count 80%, delivery 61%, `moreMerchants` true 61%, catalog ID and product page 72%, returns 39%, old price 30%, discount badge 28%. A field is `null` when Google does not show it for that product.

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

You pay per product saved to the dataset. This price is final:

| Event | Price | Per 1,000 |
|---|---|---|
| `product`: one product row | $0.001 | $1 |

There is no start fee. Nothing is charged for failed pages, retries or pages that return no new products. Platform usage is included in the price. The run stops by itself when it reaches your **maximum total charge**.

Examples:

- **Price check for one product model** (`Sony WH-1000XM5`, 40 listings): **$0.04**.
- **Category research:** 10 queries × 200 products = 2,000 products = **$2.00**.
- **Daily monitoring** of 50 queries × 20 products for a month: 30,000 products = **$30**.

### Limits

- **About 200 products per query.** Google Shopping stops paging after about 6 pages (each adds 30 to 40 new products). To cover more, add more specific queries (brands, sizes, price bands with `minPrice` and `maxPrice`) or more countries.
- **The seller shown is Google's first offer.** When `moreMerchants` is `true`, other sellers have the same product, and `productUrl` opens Google's page that lists them. This Actor does not open that page for every product, which keeps the price at $1 per 1,000.
- **Sorting.** Rows come in Google's relevance order. Sort the dataset by `price` yourself after the run.
- **Speed.** Each Google page takes 3 to 70 seconds. On Apify, 3 US queries of 100 products each (245 products, 9 pages) took 24 seconds, and 3 German queries with a price filter took 84 seconds. Queries run in parallel (`maxConcurrency`).
- **Location.** The search runs from the country's largest city (New York for the US, London for the UK, and so on). Google's local offers ("in store nearby") reflect that city.
- A barcode (GTIN/EAN/UPC) query returns whatever Google Shopping shows for it, which can include related products. Match on `title` or `catalogId` if you need one exact item.
- Google can change its pages at any time. The Actor retries failed pages on a fresh connection, drops any page that Google answers for the wrong country, and says in the status message when a query got no answer.

### Use with Python

```python
## pip install apify-client
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("datagleaner/google-shopping-scraper").call(
    run_input={"queries": ["air fryer"], "country": "us", "maxProductsPerQuery": 50}
)
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item["position"], item["price"], item["currency"], item["merchant"], item["title"][:60])
```

That run returns 50 products for $0.05.

### Use with JavaScript / Node.js

```js
// npm install apify-client
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('datagleaner/google-shopping-scraper').call({
    queries: ['running shoes'],
    country: 'uk',
    maxProductsPerQuery: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const p of items) console.log(p.position, p.price, p.merchant, p.title);
```

### Use it from n8n, Make, Zapier or an AI agent

Actor ID: `datagleaner/google-shopping-scraper`

Minimal input:

```
{"queries": ["wireless earbuds"], "maxProductsPerQuery": 20}
```

Each tool below runs this Actor with your own Apify API token.

- **n8n:** add the **Apify** node (`@apify/n8n-nodes-apify`) and choose **Run an Actor and get dataset**. Set the Actor to `datagleaner/google-shopping-scraper` and paste the input above.
- **Make:** use the Apify app's **Run an Actor** module, then **Get Dataset Items**.
- **Zapier:** use the Apify action **Run Actor**, then the search **Fetch dataset items**.
- **AI agents (MCP):** connect to `https://mcp.apify.com?tools=datagleaner/google-shopping-scraper`. In Claude Code:

  ```
    claude mcp add --transport http apify "https://mcp.apify.com?tools=datagleaner/google-shopping-scraper"
  ```

  Then run `/mcp` to sign in to Apify, and ask in plain language. For example: "Use the Google Shopping scraper to find the 30 cheapest robot vacuums in Germany and tell me which sellers come up most."

### FAQ

**How do I scrape Google Shopping prices for one product?** Put the product's brand and model in `queries`, for example `Sony WH-1000XM5`. Each row is one listing with its `price`, `merchant` and `oldPrice`. Group by `catalogId` to see every listing of the same product.

**Can I scrape Google Shopping in other countries?** Yes, 43 of them. Set `country` (`uk`, `de`, `fr`, `au`, `in`, `jp`...). Prices come in that country's currency, and the `currency` field tells you which.

**Can I filter by price?** Yes. Set `minPrice` and/or `maxPrice` in the country's currency. The Actor uses Google Shopping's own price filter and also drops any row outside your range, so you never pay for one.

**How many products can I get per search?** Up to about 200, which is as far as Google Shopping pages. For more, split the search into narrower queries or price bands.

**Do I need a Google account, API key or proxy?** No. Everything runs on Apify. You only need an Apify account.

**Does it include sponsored products?** Rows are the product listings on Google's Shopping tab, in Google's order. Text ads above the listings are not included.

**Why is `rating` empty for some products?** Google shows no rating for products without enough reviews. About 80% of products have one.

### Responsible use

This Actor collects only publicly visible Google Shopping listings: product names, prices and store names. It does not collect personal data. Respect Google's terms and the terms of the stores whose offers appear. **You** are responsible for using the data lawfully, including any competition, consumer protection or data protection rules that apply where you work. This is not legal advice.

### Feedback

If this Actor saved you time, a rating on its Store page helps others find it. Problems or requests: open an issue on the Issues tab.

# Actor input Schema

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

What you would type into Google Shopping: a product type (air fryer), a brand and model (Sony WH-1000XM5), or a GTIN/EAN/UPC barcode. One row per product listing found.

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

The country Google Shopping searches in: it sets which sellers, prices and currency you get. The search is placed in the country's largest city.

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

Google interface language as a code (en, de, fr, es, ja...). It changes labels such as delivery and returns text, not which products are found.

## `maxProductsPerQuery` (type: `integer`):

Stop each query after this many products. Google Shopping shows about 200 products for a busy query (6 pages of 30-40 new products each).

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

Only products priced at or above this, in the country's currency (e.g. 100 = $100 in the US, £100 in the UK). Uses Google Shopping's own price filter.

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

Only products priced at or below this, in the country's currency.

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

How many queries run at once. Each Google page takes 5-70 seconds, so more parallel queries finish a long list sooner.

## Actor input object example

```json
{
  "queries": [
    "wireless earbuds"
  ],
  "country": "us",
  "language": "en",
  "maxProductsPerQuery": 20,
  "maxConcurrency": 5
}
```

# Actor output Schema

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

No description

# 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"
    ],
    "maxProductsPerQuery": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("datagleaner/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"],
    "maxProductsPerQuery": 20,
}

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

```

## MCP server setup

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