# Google Shopping Scraper - Prices, Deals & Product Data (`confidential_gnat/google-shopping-scraper`) Actor

Scrapes Google Shopping (google.com/shopping) product listings for any search query and country: title, current and previous price, discount, merchant, star rating, review count, shipping and product link as JSON, CSV or Excel.

- **URL**: https://apify.com/confidential_gnat/google-shopping-scraper.md
- **Developed by:** [ActorFlow](https://apify.com/confidential_gnat) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 results

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

## Google Shopping Scraper - Prices, Deals & Product Data

**Scrape product listings, prices and deals from Google Shopping (google.com/shopping)** for any search query and any country. This **Google Shopping scraper** returns the product title, **current price and previous price**, discount badge, merchant, star rating, review count, shipping terms and a shareable product link for every result — exported as JSON, CSV or Excel, or called directly as an **API**. Type a search term, press Start, and the results arrive in under a minute.

![Google Shopping scraper cover: every price drop on Google Shopping with price, previous price and discount](https://i.postimg.cc/sxFKmGCv/Gemini-Generated-Image-svsj68svsj68svsj.jpg)

**Target website:** [google.com/shopping](https://www.google.com/shopping)

### ✨ Features of this Google Shopping products scraper

- **Product listing extraction** — title, price, currency, previous price, discount, merchant, rating, review count, shipping and product link for every search result
- **Price-drop detection** — products Google shows as reduced carry both the current and the previous price, plus the discount badge, so you can find deals without comparing runs
- **Multi-query support** — pass any number of search terms in one run; each is scraped independently with its own item limit
- **Country and language targeting** — prices, merchants and availability all change by market, so choose the one you actually sell into
- **Price range filtering** — restrict results to a minimum and/or maximum price
- **Pagination support** — the scraper walks to the next page of results until your item limit is reached
- **Cross-run caching** — name a cache project and repeat runs return only products you have not already collected
- **Proxy support** — uses the Apify Google SERP proxy, which is what makes Google Shopping reachable at all
- **No browser required** — runs on plain HTTP requests, so runs are fast and cost a fraction of a browser-based scraper

### 🚀 How to scrape Google Shopping products in 5 steps

1. [Sign up](https://apify.com/sign-up) for a free Apify account — includes **$5 monthly credit**.
2. Open the actor page and click **Try for free**.
3. Enter one or more **search queries** and pick your **country**.
4. Click **Start** and wait for the run to complete.
5. Download results from the **Output** tab in JSON, CSV, or Excel format.

You can also run this actor via the [Apify API](https://docs.apify.com/api/v2) or integrate it directly into your workflows using [Zapier](https://zapier.com/apps/apify), [Make](https://www.make.com/), or [n8n](https://n8n.io/).

### 💰 Pricing for the Google Shopping scraper

This actor uses **pay-per-result** billing based on the compute units a run consumes.

- New Apify accounts include **$5 of free monthly credit**.
- It sends plain HTTP requests rather than driving a headless browser, so it costs significantly less to run than browser-based scrapers.
- The Google SERP proxy is required and is billed as part of your Apify proxy usage. Setting a realistic **Max products per query** is the single biggest lever on run cost.

### 🔧 Google Shopping scraper input configuration

![Google Shopping scraper input form with the input fields numbered 1 to 6](https://i.postimg.cc/pVZnqnH8/image.png)

1. **Search queries** — one product search per entry
2. **Cache project name** — return only products you have not collected before
3. **Max products per query** — product limit for each search query
4. **Country** — the Google Shopping market, such as `us`, `gb` or `de`
5. **Language** — the result language, such as `en`, `de` or `fr`
6. **Minimum price** and **Maximum price** — keep only products inside this price range

The proxy configuration sits below the part shown in the screenshot.

| Field | Type | Required | Default | Description |
| ----- | ---- | -------- | ------- | ----------- |
| `queries` | array | ✅ | `["laptop"]` | Product searches to run, one per entry. Each query is scraped independently and the item limit applies to each separately. |
| `maxItems` | integer | — | `40` | Maximum products to scrape **per search query**. Set to `0` for as many as Google returns. |
| `country` | string | — | `us` | Two-letter country code for the Google Shopping market, e.g. `us`, `gb`, `de`. Prices, merchants and availability all vary by country. |
| `language` | string | — | `en` | Two-letter language code for the results, e.g. `en`, `de`, `fr`. |
| `minPrice` | integer | — | — | Only return products at or above this price, in the market's currency. |
| `maxPrice` | integer | — | — | Only return products at or below this price, in the market's currency. |
| `cacheProjectName` | string | — | — | Name a project to remember which products were already scraped across runs, so repeat runs return only new listings. |
| `proxyConfiguration` | object | — | Apify Proxy, `GOOGLE_SERP` group | **Required for Google Shopping.** Google does not serve results to ordinary requests. |

**A note on the proxy:** unlike most scrapers, this one will not work with proxies switched off. Google answers an unproxied request with a "JavaScript required" shell or an "unusual traffic" check, both of which contain no products. The actor detects both and tells you in the log rather than finishing green with an empty dataset. Leave `proxyConfiguration` on its default unless you know what you are changing it to.

### 📦 Google Shopping scraper output data (JSON, CSV, Excel)

Each row is one product, with the keys: `title`, `price`, `currency`, `priceText`, `wasPrice`, `discount`, `merchant`, `rating`, `reviewCount`, `shipping`, `productUrl`, `image`, `productId`, `query`, `searchUrl` and `position`.

The dataset has three views. **Overview** is a compact table of title, price, previous price, discount, merchant, rating and link. **Full product details** shows every scraped field including shipping, review count and the originating search. **Discounted products** filters down to the price-reduced items, with the previous price next to the current one.

**Sample output:**

```json
{
    "title": "Lenovo IdeaPad Slim 3 Chromebook 14\" 2K Touchscreen Laptop",
    "price": 199,
    "currency": "$",
    "priceText": "$199.00",
    "wasPrice": 419,
    "discount": "52% OFF",
    "merchant": "Best Buy",
    "rating": 4.5,
    "reviewCount": 64,
    "shipping": "Free delivery",
    "productUrl": "https://www.google.com/shopping/product/14670569720637338315?gl=us&hl=en",
    "image": null,
    "productId": "9599257023838937516",
    "query": "laptop",
    "searchUrl": "https://www.google.com/search?q=laptop&tbm=shop&hl=en&gl=us&num=40",
    "position": 2
}
```

```json
{
    "title": "Nike Men's Run Defy Running Shoes",
    "price": 64.99,
    "currency": "$",
    "priceText": "$64.99",
    "wasPrice": null,
    "discount": null,
    "merchant": "DICK'S Sporting Goods",
    "rating": 4.6,
    "reviewCount": 1700,
    "shipping": null,
    "productUrl": "https://www.google.com/shopping/product/7788596270766492275?gl=us&hl=en",
    "image": null,
    "productId": "16542939390107348922",
    "query": "running shoes",
    "searchUrl": "https://www.google.com/search?q=running+shoes&tbm=shop&hl=en&gl=us&num=40",
    "position": 2
}
```

### 🐍 How to scrape Google Shopping with Python, JavaScript or the API

Run the actor programmatically with the official Apify clients. Replace `<YOUR_API_TOKEN>` with the token from your [Apify Console](https://console.apify.com/account/integrations).

**Python** (`pip install apify-client`):

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")

run = client.actor("confidential_gnat/google-shopping-scraper").call(run_input={
    "queries": ["laptop", "running shoes"],
    "maxItems": 12,
    "country": "us",
    "language": "en",
    "proxyConfiguration": {"useApifyProxy": True, "apifyProxyGroups": ["GOOGLE_SERP"]},
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

**JavaScript** (`npm install apify-client`):

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

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });

const run = await client.actor('confidential_gnat/google-shopping-scraper').call({
    queries: ['laptop', 'running shoes'],
    maxItems: 12,
    country: 'us',
    language: 'en',
    proxyConfiguration: { useApifyProxy: true, apifyProxyGroups: ['GOOGLE_SERP'] },
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**cURL** — start a run and wait for the dataset:

```bash
curl -X POST "https://api.apify.com/v2/acts/confidential_gnat~google-shopping-scraper/run-sync-get-dataset-items?token=<YOUR_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{
    "queries": ["laptop", "running shoes"],
    "maxItems": 12,
    "country": "us",
    "language": "en",
    "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["GOOGLE_SERP"] }
  }'
```

### 💡 What you can use Google Shopping product data for

- **Competitor price monitoring** — track what every merchant charges for the same product across a market, on a schedule
- **Price-drop and deal tracking** — the previous price and discount badge identify genuine reductions rather than permanent "sale" pricing
- **Merchant and assortment research** — see which retailers appear for a category and how deep their catalogue runs
- **Market entry and localisation checks** — run the same query across `us`, `gb` and `de` to compare pricing and availability by country
- **Product catalogue enrichment** — attach live ratings, review counts and market prices to your own product records

E-commerce and retail teams use this data for repricing and margin decisions; brand and market research analysts use it to watch category pricing; affiliate and comparison sites use it to keep listings current.

### ⚠️ Limitations of the Google Shopping scraper

- **Proxy is mandatory** — Google Shopping will not return products without the Apify Google SERP proxy. This is the one input you should not turn off.
- **Product images are often empty** — Google lazy-loads thumbnails and publishes only some of their URLs in the page itself; the rest arrive in a later request that an HTTP scraper never makes. Top-of-page products are consistently among the missing, so `image` is frequently `null`. Every other field is unaffected.
- **Merchant, rating and shipping can be empty** — Google does not show them on every product card, so a few rows can have `merchant`, `rating`, `reviewCount` or `shipping` set to `null`.
- **Results are personalised and volatile** — Google Shopping varies results by location, time and session. Two runs minutes apart can return different products, prices and ordering. Compare by `productId`, not by `position`.
- **Previous price** — `wasPrice` comes from Google's "Was" and "Usually" prices, so only products Google marks as reduced have it, and `discount` appears only when Google shows a percentage badge.
- **Roughly 50–70 products per query page** — one search page carries this many results; a larger item limit triggers pagination automatically.

### ❓ Google Shopping scraper FAQ

#### Can I scrape Google Shopping legally?

This actor only collects data that is already publicly visible on Google Shopping search results — no login, no paywall and no private content is accessed. Scraping publicly available data is generally considered lawful, with *hiQ Labs v. LinkedIn* the usual precedent cited. You remain responsible for complying with Google's Terms of Service and with any applicable laws in your jurisdiction.

#### Why are product images empty in my results?

Google lazy-loads product thumbnails and only publishes some of their URLs in the search page itself; the rest are fetched by a second, browser-driven request. This scraper uses plain HTTP for speed and cost, so it captures only the thumbnails Google includes up front — often none of the top results. Every other field is complete.

#### How many products can I scrape from one search query?

One Google Shopping results page carries roughly 50 to 70 products. Set **Max products per query** higher than that and the scraper paginates automatically until the limit is met or Google runs out of results. The limit applies per query, so three queries at 40 each returns up to 120 products.

#### Do I need a proxy to scrape google.com/shopping?

Yes, and this is the exception to the usual advice. Google refuses shopping results to ordinary requests, answering with a JavaScript shell or an "unusual traffic" check instead. The actor defaults to the Apify **Google SERP** proxy group and will report the problem in the log if it is switched off.

#### How do I scrape Google Shopping with Python?

Install `apify-client`, then call the actor with your search queries and read the dataset back. The **How to scrape Google Shopping with Python, JavaScript or the API** section above has a complete, copy-pasteable example.

#### Can I run this Google Shopping scraper on a schedule?

Yes — use [Apify Schedules](https://docs.apify.com/platform/schedules) to run it hourly, daily or weekly. Set **Cache project name** to have each scheduled run return only products it has not already collected, which is what makes daily price monitoring cheap.

#### What output formats are supported?

JSON, CSV, Excel, XML and RSS, either from the **Output** tab or through the Apify API.

### 🔗 Relevant actors for Google Shopping and product price data

| Scraper | Description |
| ------- | ----------- |
| [🛒 AliExpress Products Scraper](https://apify.com/confidential_gnat/aliexpress-products-scraper) | AliExpress search results and product pages: title, price, discount and ratings. |
| [🏭 Alibaba.com Products Scraper](https://apify.com/confidential_gnat/alibaba-products-scraper) | Wholesale products from Alibaba.com by product, search or category. |
| [🛍️ Carousell Products Scraper](https://apify.com/confidential_gnat/carousell-products-scraper) | Carousell.sg product listings with prices, seller ratings and deal methods. |
| [🗾 Mercari Japan Scraper](https://apify.com/confidential_gnat/mercari-japan-listings-scraper) | Mercari Japan listings with price in JPY, sold status, condition and category. |
| [🥦 Woolworths Products Scraper](https://apify.com/confidential_gnat/woolworths-products-scraper) | Woolworths Australia grocery products: name, brand, price and unit price. |

### 🔗 Other actors you may find useful

| Scraper | Description |
| ------- | ----------- |
| [📈 Kalshi Markets Scraper](https://apify.com/confidential_gnat/kalshi-markets-scraper) | Prediction market prices, implied probability, spread and volume. |
| [🥾 AllTrails Scraper](https://apify.com/confidential_gnat/alltrails-scraper) | Hiking, biking and running trails by park, city, state or coordinates. |
| [🍷 Vivino Wine Scraper](https://apify.com/confidential_gnat/vivino-wine-scraper) | Wine name, winery, vintage, region, country and ratings from Vivino. |
| [🏠 Rightmove Property Scraper](https://apify.com/confidential_gnat/rightmove-property-scraper) | UK sale and rent listings from Rightmove with price, address and coordinates. |
| [📰 Google News AI Scraper](https://apify.com/confidential_gnat/google-news-ai-scraper) | Google News search with optional article text and AI summaries. |

### 💬 Support & contact

If you encounter any issues or have questions, please [open an issue](https://apify.com/confidential_gnat/google-shopping-scraper/issues/open).

You can also find more of our actors on the [Actor Flow](https://apify.com/confidential_gnat) page.

# Actor input Schema

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

Product searches to run, one per entry. Each query is scraped independently and the Max products limit applies to each separately.

## `cacheProjectName` (type: `string`):

Optional. Name a project to remember which products have already been scraped across runs, so repeated runs only return new listings.

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

Maximum number of products to scrape per search query. Set to 0 for as many as Google returns.

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

Two-letter country code for the Google Shopping market, for example us, gb, de. Prices, merchants and availability all vary by country.

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

Two-letter language code for the results, for example en, de, fr.

## `minPrice` (type: `integer`):

Only return products at or above this price, in the market's currency.

## `maxPrice` (type: `integer`):

Only return products at or below this price, in the market's currency.

## `proxyConfiguration` (type: `object`):

REQUIRED for Google Shopping. Google does not serve results to unproxied requests — use the Apify SERP proxy by selecting the GOOGLE_SERP group. Without it a run will return no products.

## Actor input object example

```json
{
  "queries": [
    "laptop"
  ],
  "maxItems": 40,
  "country": "us",
  "language": "en",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "GOOGLE_SERP"
    ]
  }
}
```

# Actor output Schema

## `overview` (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": [
        "laptop"
    ]
};

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

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

```

## MCP server setup

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