# Google Shopping Scraper — Product Prices & Sellers (`junipr/google-shopping`) Actor

Extract Google Shopping product results with prices, sellers, ratings, images, product URLs, and comparison metadata from snapshots or live SERPs.

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

## Pricing

from $6.50 / 1,000 product scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#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 Scraper — Product Prices & Sellers

Extract product pricing, ratings, merchant info, and delivery data from Google Shopping at scale. Monitor competitor prices, build comparison tables, and track market trends with structured data exports. Works across 30+ countries with automatic currency detection and multi-language support.

Google Shopping Scraper is built for e-commerce professionals who need reliable, structured product data without the overhead of building and maintaining their own scraping infrastructure. Whether you're tracking competitor pricing daily, building a price comparison tool, or researching market trends, this actor gives you clean, analysis-ready data in seconds.

### What Data Can You Extract?

| Field | Description |
|-------|-------------|
| `title` | Product title |
| `price.current` | Current price as a **numeric value** (not a string) |
| `price.original` | Pre-discount price when on sale |
| `price.currency` | ISO 4217 currency code (USD, EUR, GBP, etc.) |
| `price.discountPercent` | Calculated discount percentage |
| `price.priceRange` | Min/max price for variant products |
| `merchant.name` | Seller/merchant name |
| `merchant.rating` | Merchant rating (0-5) |
| `merchant.reviewCount` | Number of merchant reviews |
| `merchant.isVerified` | Google-verified merchant status |
| `productRating.value` | Product star rating (0-5) |
| `productRating.count` | Number of product reviews |
| `delivery.free` | Whether shipping is free |
| `delivery.cost` | Shipping cost as numeric value |
| `delivery.estimatedDate` | Expected delivery date |
| `brand` | Brand name |
| `gtin` | Global Trade Item Number (barcode) |
| `mpn` | Manufacturer Part Number |
| `isSponsored` | Whether the listing is a paid ad |
| `thumbnailUrl` | Product image URL |
| `badges` | Special labels like "Best Seller", "Top Quality Store" |

All price fields are returned as **numeric values** ready for calculations, sorting, and database storage — not raw strings that require additional parsing.

### How to Use

**Zero-config start** — just provide a product query:

```json
{
  "queries": ["wireless headphones"]
}
```

That's it. The safe default returns at most one structured product listing with pricing, ratings, merchant info, and delivery details. Increase the result limits explicitly when you need a larger run.

**Using the Apify API:**

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('junipr/google-shopping').call({
    queries: ['iPhone 15 Pro', 'Samsung Galaxy S24'],
    country: 'us',
    resultsPerQuery: 10,
});

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

### Input Configuration

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `queries` | string\[] | — | Product search queries (max 100) |
| `urls` | string\[] | — | Direct Google Shopping URLs (max 100) |
| `country` | string | `"us"` | Country code (us, gb, de, fr, au, ca, etc.) |
| `language` | string | `"en"` | Language code (en, de, fr, es, etc.) |
| `resultsPerQuery` | integer | `1` | Products per query (1-20) |
| `paginate` | boolean | `false` | Enable multi-page scraping |
| `maxResultsPerQuery` | integer | `1` | Max products when paginating (1-50) |
| `sortBy` | string | `"relevance"` | Sort: relevance, price\_low, price\_high, rating |
| `minPrice` | number | — | Minimum price filter |
| `maxPrice` | number | — | Maximum price filter |
| `condition` | string | `"all"` | Product condition: all, new, used, refurbished |
| `includeSponsored` | boolean | `false` | Include sponsored/ad listings |

**Common configurations:**

Price range filter:

```json
{ "queries": ["coffee machine"], "minPrice": 50, "maxPrice": 200 }
```

Multi-country comparison:

```json
{ "queries": ["laptop"], "country": "de", "language": "de" }
```

### Output Format

Each product is a structured JSON object:

```json
{
  "query": "wireless headphones",
  "position": 1,
  "isSponsored": false,
  "title": "Sony WH-1000XM5 Wireless Noise Canceling Headphones",
  "brand": "Sony",
  "price": {
    "current": 279.99,
    "original": 399.99,
    "currency": "USD",
    "currencySymbol": "$",
    "priceString": "$279.99",
    "discountPercent": 30,
    "priceRange": { "min": null, "max": null }
  },
  "merchant": {
    "name": "Best Buy",
    "rating": 4.7,
    "reviewCount": 12453,
    "isVerified": true
  },
  "productRating": {
    "value": 4.5,
    "count": 8234,
    "countLabel": "8,234 reviews"
  },
  "delivery": {
    "free": true,
    "cost": 0,
    "estimatedDate": "Fri, Apr 4"
  },
  "country": "us",
  "scrapedAt": "2025-04-01T12:00:00.000Z"
}
```

### Use Cases

- **E-commerce price monitoring** — Track competitor prices daily with scheduled runs. Get alerts when prices drop below thresholds.
- **Brand protection** — Find unauthorized resellers listing your products on Google Shopping. Cross-reference GTINs to identify gray market sellers.
- **Market research** — Analyze pricing trends across categories, countries, and time periods. Compare merchant distribution and market share.
- **Procurement benchmarking** — Research supplier pricing before negotiations. Compare the same product across dozens of merchants instantly.
- **Price comparison tools** — Feed structured product data into your comparison engine. Numeric prices and currency codes are ready for direct use.
- **Dropshipping research** — Find pricing benchmarks and profit margins by comparing wholesale vs retail prices across merchants.

### Pricing

**Pay-Per-Event: $6.50 per 1,000 products scraped** with the `product-scraped` event.

Apify platform usage is billed separately because Google Shopping can require SERP/proxy resources. The custom event is charged atomically with each successfully delivered product; failed pages, blocked requests, and queries with zero results do not trigger it.

| Scenario | Products | Cost |
|----------|----------|------|
| Single query (10 products) | 10 | $0.07 |
| Daily price check (25 products) | 750 | $4.88 |
| Weekly market research (6,000 products) | 6,000 | $39.00 |
| Comprehensive catalog (30,000 products) | 30,000 | $195.00 |

Compared to SerpAPI Google Shopping ($50+ per 1,000 results), this actor remains substantially cheaper while providing richer data fields including delivery info, merchant ratings, and product identifiers.

### FAQ

#### Why does Google Shopping require residential proxies?

Google Shopping aggressively blocks datacenter IP addresses. Residential proxies mimic real user traffic from home internet connections, which Google does not block. This actor defaults to Apify's residential proxy network, which requires a paid Apify plan ($49+/month). Free-plan users can provide their own residential proxy URL in the input configuration.

#### How accurate are the prices?

All prices are parsed into numeric values with 100% accuracy on the numeric conversion. The actor handles multiple price formats including US ($1,234.56), European (1.234,56), and various currency symbols. If a price cannot be parsed, `price.current` is set to `null` and the raw `priceString` is preserved for manual review.

#### Can I monitor prices over time with scheduled runs?

Yes. Set up a scheduled run on Apify (daily, hourly, weekly) with your product queries. Each run produces a new dataset. Use Apify's webhook integrations to pipe results to Google Sheets, a database, or your own API for trend analysis.

#### Does it work for all countries?

Google Shopping is available in 30+ countries. The actor supports all of them via the `country` parameter. Popular markets include US, UK, Germany, France, Australia, Canada, Japan, India, and Brazil. Currency and language are automatically configured based on the country code.

#### What happens when Google changes its layout?

The actor uses multiple fallback selectors and robust parsing logic to handle layout variations. If Google makes a major structural change, the actor will log a `PARSE_ERROR` and continue attempting extraction with alternative selectors. We monitor for breaking changes and push updates quickly.

#### Can I filter by condition (new/used/refurbished)?

Yes. Set the `condition` parameter to `"new"`, `"used"`, or `"refurbished"` to filter results. The default is `"all"` which shows products in any condition.

#### How do I get all seller offers for a product?

Use the `paginate` option with `maxResultsPerQuery` set to a higher value (e.g., 100-500). This retrieves more results which often include multiple merchants selling the same product. You can then group results by `productId` or `gtin` to see all available offers.

#### Is scraping Google Shopping legal?

Google Shopping results are publicly accessible to any anonymous user. The hiQ v. LinkedIn Supreme Court precedent established that scraping publicly accessible data may be protected. However, this actor should be used responsibly and in compliance with applicable laws and Google's Terms of Service. Users are responsible for ensuring their use case complies with local regulations.

# Actor input Schema

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

Product search queries to look up on Google Shopping. E.g. \["iPhone 15 Pro", "Sony WH-1000XM5"]. Max 100 queries per run.

## `urls` (type: `array`):

Direct Google Shopping search result URLs. Must contain google.com/search with shopping parameters. Max 100 URLs.

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

Country code (ISO 3166-1 alpha-2) for Google Shopping market. Determines currency, merchants, and pricing. Examples: us, gb, de, fr, au, ca.

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

Language code (ISO 639-1) for search results. Examples: en, de, fr, es, ja.

## `currency` (type: `string`):

Force currency display (ISO 4217). Leave empty for country default. Examples: USD, EUR, GBP.

## `resultsPerQuery` (type: `integer`):

Number of products to extract per query (without pagination). Min: 1, Max: 100.

## `paginate` (type: `boolean`):

Paginate through all result pages to get more products. Respects maxResultsPerQuery limit.

## `maxResultsPerQuery` (type: `integer`):

Maximum products to extract per query when pagination is enabled. Min: 1, Max: 500.

## `sortBy` (type: `string`):

Sort order for search results.

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

Minimum price filter in local currency. Leave empty for no minimum.

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

Maximum price filter in local currency. Leave empty for no maximum.

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

Filter products by condition.

## `includeSponsored` (type: `boolean`):

Include sponsored/ad listings in results.

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

Residential proxy is required — Google blocks datacenter IPs for Shopping results. Defaults to Apify residential proxy (requires paid Apify plan). Free-plan users can provide their own residential proxy URL.

## Actor input object example

```json
{
  "queries": [
    "wireless headphones"
  ],
  "country": "us",
  "language": "en",
  "resultsPerQuery": 1,
  "paginate": false,
  "maxResultsPerQuery": 1,
  "sortBy": "relevance",
  "condition": "all",
  "includeSponsored": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Scraped Google Shopping product listings with structured pricing, merchant details, ratings, delivery info, and product identifiers.

# 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 headphones"
    ],
    "country": "us",
    "language": "en"
};

// Run the Actor and wait for it to finish
const run = await client.actor("junipr/google-shopping").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 headphones"],
    "country": "us",
    "language": "en",
}

# Run the Actor and wait for it to finish
run = client.actor("junipr/google-shopping").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 headphones"
  ],
  "country": "us",
  "language": "en"
}' |
apify call junipr/google-shopping --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,junipr/google-shopping"
        }
    }
}

```

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/X6wDJ3BIy313FRRA0/builds/PYEIHOpCCVeMxbcmy/openapi.json