# Google Shopping Price Comparison Tool (`second_coming/google-shopping-scraper`) Actor

Scrape product listings, prices, merchants, shipping info, and ratings from Google Shopping. E-commerce competitive pricing intelligence tool.

- **URL**: https://apify.com/second\_coming/google-shopping-scraper.md
- **Developed by:** [Richard P](https://apify.com/second_coming) (community)
- **Categories:** E-commerce, Marketing
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Google Shopping Price Comparison Scraper

An [Apify Actor](https://apify.com/actors) that scrapes product listings, prices, merchants, shipping information, and ratings from Google Shopping. Designed for competitive pricing intelligence, market research, and e-commerce analysis.

### Features

- **Multiple search queries** — run many product searches in a single execution
- **Structured product data** — title, price, currency, merchant, rating, reviews, shipping, condition, image
- **JSON-LD + HTML parsing** — extracts structured data when available, falls back to HTML card parsing with multiple selector strategies
- **Price filtering** — optional min/max price filters per query
- **Country targeting** — set geolocation via country code (US, GB, DE, FR, JP, etc.)
- **Rate limiting** — configurable delays between requests to avoid blocking
- **Graceful abort** — cleanly shuts down when the Actor is stopped mid-execution
- **Chrome user-agent rotation** — rotates user-agent strings across queries
- **Deduplication** — merges results from JSON-LD and HTML sources by URL

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `searchQueries` | `string[]` | `["iPhone 15 case"]` | One or more product search terms |
| `maxResults` | `integer` | `50` | Max product results per query (1–200) |
| `country` | `string` | `"US"` | Two-letter country code (US, GB, DE, FR, etc.) |
| `minPrice` | `number` | `null` | Optional minimum price filter |
| `maxPrice` | `number` | `null` | Optional maximum price filter |

#### Example input

```json
{
  "searchQueries": ["iPhone 15 case", "wireless headphones", "USB-C hub"],
  "maxResults": 30,
  "country": "US",
  "minPrice": 5,
  "maxPrice": 100
}
````

### Output

Each dataset item contains:

| Field | Type | Description |
|-------|------|-------------|
| `title` | `string` | Product name |
| `url` | `string` | Google Shopping product URL |
| `merchant` | `string` | Store/seller name |
| `price` | `number` | Current price |
| `currency` | `string` | ISO 4217 currency (USD, EUR, GBP...) |
| `originalPrice` | `number?` | Strikethrough original price (if on sale) |
| `shippingCost` | `number?` | Shipping cost (0 = free) |
| `shippingInfo` | `string?` | Raw shipping description |
| `rating` | `number?` | Average rating (0–5) |
| `reviewCount` | `integer?` | Number of reviews |
| `condition` | `string?` | `new`, `used`, `refurbished`, or null |
| `imageUrl` | `string?` | Product thumbnail URL |
| `taxInfo` | `string?` | Tax-related details |
| `searchQuery` | `string` | The search term that produced this result |
| `scrapedAt` | `string` | ISO 8601 scrape timestamp |
| `source` | `string` | `"jsonld"` or `"html"` (data origin) |

### Usage

#### Local development

```bash
## Install dependencies
pip install -r requirements.txt

## Run locally with Apify CLI
cd /root/workspace/google-shopping-scraper
apify run --purge
```

#### Deploy to Apify

```bash
apify push
```

Or import the Git repository into the [Apify Console](https://console.apify.com).

### How it works

1. **URL construction** — builds search URLs with `tbm=shop` (Shopping tab), `hl=en`, and `gl` (geolocation) parameters
2. **HTTP request** — uses `httpx.AsyncClient` with Chrome user-agent and retry logic
3. **JSON-LD parsing** — extracts structured product data from `<script type="application/ld+json">` blocks
4. **HTML card parsing** — falls back to parsing product card divs with multiple CSS selector strategies
5. **Deduplication** — merges results from both sources, preferring JSON-LD data
6. **Batched push** — pushes results to the Apify dataset in batches of 25

### Limitations

- Google adapts HTML class names over time — the fallback selector system handles this but may occasionally miss results
- Pagination support is limited (Google loads most results dynamically via JavaScript)
- Some merchant sites block or redirect Google Shopping referral links
- Rate limits may apply for high-volume scraping

### License

MIT

# Actor input Schema

## `searchQueries` (type: `array`):

One or more product search terms to look up on Google Shopping. Each query is searched independently.

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

Maximum number of product results to collect per search query. Higher values may trigger additional page requests.

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

Two-letter country code for Google Search geolocation (e.g., US, GB, DE, FR, JP). Affects pricing, availability, and currency.

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

Optional minimum price filter (in the local currency). Only products at or above this price are included.

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

Optional maximum price filter (in the local currency). Only products at or below this price are included.

## Actor input object example

```json
{
  "searchQueries": [
    "iPhone 15 case",
    "wireless headphones"
  ],
  "maxResults": 50,
  "country": "US"
}
```

# Actor output Schema

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

Link to the dataset containing scraped product data

# 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 = {
    "searchQueries": [
        "iPhone 15 case",
        "wireless headphones"
    ],
    "country": "US"
};

// Run the Actor and wait for it to finish
const run = await client.actor("second_coming/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 = {
    "searchQueries": [
        "iPhone 15 case",
        "wireless headphones",
    ],
    "country": "US",
}

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

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

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

```

## CLI example

```bash
echo '{
  "searchQueries": [
    "iPhone 15 case",
    "wireless headphones"
  ],
  "country": "US"
}' |
apify call second_coming/google-shopping-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=second_coming/google-shopping-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Shopping Price Comparison Tool",
        "description": "Scrape product listings, prices, merchants, shipping info, and ratings from Google Shopping. E-commerce competitive pricing intelligence tool.",
        "version": "0.0",
        "x-build-id": "zP85wtjLXo775ikgZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/second_coming~google-shopping-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-second_coming-google-shopping-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/second_coming~google-shopping-scraper/runs": {
            "post": {
                "operationId": "runs-sync-second_coming-google-shopping-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/second_coming~google-shopping-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-second_coming-google-shopping-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "searchQueries"
                ],
                "properties": {
                    "searchQueries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "One or more product search terms to look up on Google Shopping. Each query is searched independently.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "iPhone 15 case"
                        ]
                    },
                    "maxResults": {
                        "title": "Max Results Per Query",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of product results to collect per search query. Higher values may trigger additional page requests.",
                        "default": 50
                    },
                    "country": {
                        "title": "Country (GL parameter)",
                        "enum": [
                            "US",
                            "GB",
                            "DE",
                            "FR",
                            "JP",
                            "CA",
                            "AU",
                            "IN",
                            "BR",
                            "MX",
                            "IT",
                            "ES",
                            "NL",
                            "SE",
                            "NO",
                            "DK",
                            "FI",
                            "PL",
                            "CH",
                            "AT",
                            "BE",
                            "IE",
                            "NZ",
                            "SG",
                            "HK",
                            "ZA",
                            "AE",
                            "SA",
                            "KR",
                            "TW"
                        ],
                        "type": "string",
                        "description": "Two-letter country code for Google Search geolocation (e.g., US, GB, DE, FR, JP). Affects pricing, availability, and currency.",
                        "default": "US"
                    },
                    "minPrice": {
                        "title": "Minimum Price",
                        "minimum": 0,
                        "type": "number",
                        "description": "Optional minimum price filter (in the local currency). Only products at or above this price are included."
                    },
                    "maxPrice": {
                        "title": "Maximum Price",
                        "minimum": 0,
                        "type": "number",
                        "description": "Optional maximum price filter (in the local currency). Only products at or below this price are included."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```