# 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:** 3 total users, 0 monthly users, 93.8% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.02 / scan run

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

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