# Google Shopping Scraper & Google Shopping API - Prices, Sellers (`santhej/google-shopping-scraper`) Actor

Scrape Google Shopping results: product title, price, old price, currency, seller, rating, review count & product URL. Compare prices across sellers for any product in 8 countries (US, UK, CA, AU, DE, FR, IT, ES). Clean JSON/CSV for price intelligence & e-commerce. No API keys.

- **URL**: https://apify.com/santhej/google-shopping-scraper.md
- **Developed by:** [Santhej Kallada](https://apify.com/santhej) (community)
- **Categories:** E-commerce, MCP servers
- **Features:** Limited permissions
- **Stats:** 16 total users, 2 monthly users, 88.2% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.60 / 1,000 product 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 — Products, Prices, Sellers & Ratings

**Scrape Google Shopping for any product keyword and compare prices across every seller. Get product title, price, old price and on-sale flag, seller, rating, review count, delivery message and product ID as clean, API-ready rows. $2.00 per 1,000 results, no proxies or captchas to manage.**

### What does Google Shopping Scraper do?

It has two jobs, which you can run separately or together:

- **Product search**: for each keyword, it returns the product offers Google Shopping shows (typically 50 to 60 per keyword), with price, previous price, seller, rating, reviews and delivery information.
- **Seller price comparison**: for each Google Shopping product ID, it returns every seller offering that product, with base price, shipping, total price, availability, seller rating and a link to the offer. Product IDs come from the `product_id` column of a search run.

Filters: price range (`priceMin` / `priceMax`) and on-sale-only offers.

### Use cases

- **Price monitoring and repricing**: track what competitors charge for the same products across retailers.
- **Finding the cheapest seller**: compare base price, shipping and total price for one product across every merchant.
- **Price-comparison and deal sites**: build a structured product feed, and surface discounts with `old_price` and `on_sale`.
- **Market and product research**: see which sellers and brands dominate a product category, and at what price points.
- **AI agents and automations**: feed structured shopping data into n8n, Make, MCP servers and LLM pipelines.

### How to use Google Shopping Scraper

1. Enter your product keywords in **Search keywords** (up to 100 per run).
2. Pick the **Country** and **Language**, and optionally a **Min price** / **Max price** or **On sale only**.
3. To compare sellers for specific products, paste their IDs into **Compare sellers for product IDs** (up to 50). You can leave the keywords empty and run a comparison on its own.
4. Click **Start**.
5. Use the **Shopping products** view for search results and the **Seller comparison** view for seller offers, then export as JSON, CSV or Excel, or read the dataset through the Apify API.

#### Example input

Product search:

```json
{
  "queries": ["air fryer", "ninja air fryer"],
  "locationCode": "2840",
  "languageCode": "en",
  "priceMin": 50,
  "priceMax": 150,
  "onSale": false
}
```

Seller price comparison:

```json
{
  "compareProductIds": ["329494674847835874"],
  "locationCode": "2840",
  "languageCode": "en"
}
```

#### Input configuration

| Field | Type | Default | Description |
|---|---|---|---|
| `queries` | array of strings | empty | Product keywords to search, up to 100 per run. |
| `compareProductIds` | array of strings | empty | Google Shopping product IDs to compare across sellers, up to 50 per run. Take them from the `product_id` column of a search run. |
| `locationCode` | string | `2840` (United States) | Country: United States, United Kingdom, Canada, Australia, Germany, France, Italy or Spain. |
| `languageCode` | string | `en` | Language code, e.g. `en`, `de`, `fr`. |
| `priceMin` | integer | empty | Only return products at or above this price. |
| `priceMax` | integer | empty | Only return products at or below this price. |
| `onSale` | boolean | `false` | Only return offers that are on sale (shown with a higher old price). Other offers are dropped and not charged. |

Provide at least one keyword or one product ID.

#### Example output

Product offer (`record_type: "product"`):

```json
{
  "record_type": "product",
  "query": "ninja air fryer",
  "title": "Ninja French Door 8-in-1 Countertop Oven, with Smart Surroundair Technology and Air Fry Function fo100",
  "price": 169,
  "old_price": 189,
  "on_sale": true,
  "currency": "USD",
  "seller": "Walmart",
  "rating": 4.5,
  "reviews_count": 103,
  "delivery_message": "Free delivery",
  "delivery_price": null,
  "condition": null,
  "tags": ["10% OFF"],
  "is_best_match": false,
  "product_id": "13880216131572586291",
  "url": "https://google.com/search?ibp=oshop&q=ninja+air+fryer+sale&prds=...",
  "rank": 6
}
```

Seller offer (`record_type: "seller_offer"`):

```json
{
  "record_type": "seller_offer",
  "product_id": "329494674847835874",
  "seller": "Target",
  "domain": "www.target.com",
  "base_price": 129.99,
  "shipping_price": null,
  "tax": null,
  "total_price": 129.99,
  "currency": "USD",
  "condition": null,
  "availability": "in_stock",
  "rating": 4.467,
  "url": "https://www.target.com/p/ninja-air-fryer-pro-4-in-1-af141/-/A-90569368?...",
  "rank": 1
}
```

Notes on the fields:

- `on_sale` is `true` when Google shows a higher `old_price`, `false` when it does not.
- `rating` and `reviews_count` are the product's rating and number of reviews; on seller offers, `rating` is the seller's rating.
- `delivery_price` is an object (amount, currency, displayed text) when Google shows a delivery price, otherwise `null`.
- `rank` is the offer's position on the page; offers inside a carousel have no rank.
- `shipping_price`, `tax` and `condition` are filled only when Google shows them for an offer; in the US, most offers show none of them.

A run summary (keywords, product offers, seller offers) is saved to the run's key-value store as `OUTPUT`.

### How much does Google Shopping Scraper cost?

Pay per event. You pay per row returned.

| Event | Free / Bronze plan | Silver plan | Gold plan and above |
|---|---|---|---|
| Product offer returned | $0.002 | $0.0018 | $0.0016 |
| Seller offer returned (price comparison) | $0.002 | $0.0018 | $0.0016 |
| Actor start (once per run) | $0.001 | $0.0009 | $0.0008 |

Worked examples at Free/Bronze prices, from real runs:

- 2 keywords ("air fryer", "ninja air fryer"), 117 product offers: 117 × $0.002 + $0.001 = **$0.235**
- 1 product ID compared across 10 sellers: 10 × $0.002 + $0.001 = **$0.021**
- 1,000 offers: **$2.00** + $0.001

There is no monthly fee and no minimum.

### FAQ

**Can I compare one product's price across sellers?**
Yes. Run a search, copy the `product_id` of the product you want, and pass it in `compareProductIds`. You get one row per seller with base price, shipping, total and availability.

**Which countries are supported?**
United States, United Kingdom, Canada, Australia, Germany, France, Italy and Spain.

**How many products do I get per keyword?**
Whatever Google Shopping shows on its results page, typically 50 to 60 offers per keyword.

**Can I filter by condition (new, used, refurbished)?**
No. Google Shopping's results do not expose a condition filter to this actor, so it is not offered.

**Do I need proxies?**
No. Everything is handled for you.

**Is it good for AI agents and automations?**
Yes. The output is flat JSON with stable field names, which suits MCP servers, n8n, Make and LLM agents.

***

*Tags: google shopping scraper, price comparison, product prices, shopping api, ecommerce scraper, price monitoring, competitor pricing, product feed, retail data.*

# Actor input Schema

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

Products to search on Google Shopping, e.g. ‘running shoes’, ‘air fryer’. One per line. Up to 100 per run.

## `compareProductIds` (type: `array`):

Google Shopping product IDs to compare prices across all sellers (base price, shipping, tax, total, condition, availability). Product IDs appear in the search output. One per line, up to 50.

## `locationCode` (type: `string`):

Target country. Default United States (2840). UK 2826, Canada 2124, Australia 2036, Germany 2276.

## `languageCode` (type: `string`):

Language code (e.g. en, de, fr).

## `priceMin` (type: `integer`):

Only return products at or above this price.

## `priceMax` (type: `integer`):

Only return products at or below this price.

## `onSale` (type: `boolean`):

Only return offers currently on sale (shown with a crossed-out old price). Off-sale offers are dropped and not charged.

## Actor input object example

```json
{
  "queries": [
    "running shoes",
    "air fryer"
  ],
  "locationCode": "2840",
  "languageCode": "en",
  "onSale": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

All scraped Google Shopping product offers.

## `summary` (type: `string`):

Queries and product counts.

# 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": [
        "running shoes",
        "air fryer"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("santhej/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": [
        "running shoes",
        "air fryer",
    ] }

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

```

## MCP server setup

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