# Google Shopping Scraper (`axlymxp/google-shopping-scraper`) Actor

Export Google Shopping results by keyword in 24 countries: price, previous price and discount, shop, delivery, returns, rating, review count and product ids. Use Google's own filters (On sale, brand, store, price) and many keywords per run. Pay only for the products you get.

- **URL**: https://apify.com/axlymxp/google-shopping-scraper.md
- **Developed by:** [axly](https://apify.com/axlymxp) (community)
- **Categories:** E-commerce, SEO tools
- **Stats:** 3 total users, 2 monthly users, 75.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 dataset items

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/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

Export **Google Shopping results by keyword in 24 countries**: product title, price, previous price and discount, the shop
selling it, delivery and returns terms, star rating, review count, image and Google's product ids. Use Google's own filters
(On sale, 4 and up, a brand, a store, a price bucket) by name, run many keywords in one go, and get clean JSON, CSV or Excel.

### Who uses it

- **Brands and online shops**: watch competitor prices, discounts and which shops list your products.
- **Agencies and analysts**: share of shelf per shop, price and discount tracking per market, assortment research.
- **Product researchers and dropshippers**: compare price, rating and review count across hundreds of keywords.
- **AI agents**: one call returns structured shopping results for a keyword (see the AI section below).

### What you get (one row per product)

| Field | Type | Example |
| ----- | ---- | ------- |
| `query`, `country` | string | `wireless earbuds`, `US` |
| `position`, `page` | integer | `3`, `1` |
| `title` | string | `JBL Vibe Buds 2 Noise Cancelling True Wireless Earbuds` |
| `price`, `price_text`, `currency` | number, string, string | `39.95`, `$39.95`, `USD` |
| `old_price`, `old_price_text`, `discount_percent` | number, string, integer | `65`, `$65`, `38` |
| `merchant` | string | `Crutchfield` |
| `more_sellers` | boolean | `true` when Google lists more shops ("& more") |
| `price_varies_by_seller` | boolean | `true` when Google notes "and more prices" |
| `delivery`, `returns` | string | `Free delivery on $50+`, `60-day returns` |
| `rating`, `reviews_count` | number, integer | `4.3`, `5000` |
| `badges` | string\[] | `["3D"]`, `["Pre-owned"]`, `["SALE"]` |
| `thumbnail` | string | product image URL (not available for some top cards) |
| `google_shopping_url` | string | opens the product on Google Shopping with all its offers |
| `product_id`, `offer_id`, `catalog_id`, `gpc_id`, `image_id` | string | Google's ids, stable keys for tracking |
| `block` | string | `grid`, `shelf` or `carousel` (where the card sat on the page) |
| `scraped_at` | string | ISO-8601 time |

Prices are parsed for each country's number format (`152,99 €` → `152.99`, `(2,2 k)` reviews → `2200`).

### Use cases

1. **Competitor price monitoring**: schedule your product keywords daily and compare `price` and `old_price` per `merchant`.
2. **Discount tracking**: run with the `On sale` filter and track `discount_percent` across a category.
3. **Shop share of shelf**: count how often each `merchant` appears in the first 100 products for your category keywords.
4. **Market comparison**: run the same keywords in the US, UK, Germany and France and compare prices by `currency`.
5. **Product research**: pull `rating` and `reviews_count` for many keywords and rank products by demand.

### Input

| Field | Default | Description |
| ----- | ------- | ----------- |
| `queries` | `["wireless earbuds"]` | Keywords; one Google Shopping search each |
| `country` | `US` | US, GB, CA, AU, NZ, IE, IN, SG, DE, AT, CH, FR, BE, NL, IT, ES, PT, PL, SE, DK, NO, MX, BR, JP |
| `maxItemsPerQuery` | `50` | Up to 200; Google shows about 100 unique products per search |
| `filters` | `[]` | Google's filter labels as shown for that keyword, e.g. `On sale`, `4 and up`, `Sony`, `Best Buy`, `Under $35` |
| `minPrice`, `maxPrice` | empty | Keep only products in this price range (products outside it are not pushed or charged) |
| `language` | country default | Interface language code, e.g. `es` for Spanish results in the US |
| `includeSummary` | `false` | Add Google's one-line card summary |

#### Example input

```json
{
    "queries": ["wireless earbuds", "running shoes"],
    "country": "US",
    "maxItemsPerQuery": 50,
    "filters": ["On sale"]
}
```

#### Example output

```json
{
    "query": "wireless earbuds",
    "country": "US",
    "position": 1,
    "page": 1,
    "title": "JLab Go Air Sport True Wireless Earbuds",
    "price": 24.74,
    "price_text": "$24.74",
    "currency": "USD",
    "old_price": 32,
    "old_price_text": "$32",
    "discount_percent": 22,
    "merchant": "Best Buy",
    "more_sellers": true,
    "price_varies_by_seller": false,
    "delivery": "Free delivery",
    "returns": null,
    "rating": 4.1,
    "reviews_count": 18000,
    "badges": [],
    "thumbnail": null,
    "google_shopping_url": "https://www.google.com/search?ibp=oshop&q=wireless+earbuds&prds=catalogid:14611047641738732344,gpcid:14823241773140039338,headlineOfferDocid:15469061001594283225,productDocid:13973934425568129325&udm=28&hl=en&gl=us",
    "product_id": "13973934425568129325",
    "offer_id": "15469061001594283225",
    "catalog_id": "14611047641738732344",
    "gpc_id": "14823241773140039338",
    "image_id": null,
    "block": "shelf",
    "scraped_at": "2026-10-21T03:02:50+00:00"
}
```

### Filters

Google decides which filters exist for each keyword, so the actor uses Google's own labels instead of a fixed list.
Write them as Google shows them in that country's language: `On sale`, `4 and up`, `New`, `Used`, a brand, a store or a
price bucket. Price buckets differ per keyword (`Under $35` for one search, `Under $50` for another).
Every run saves the labels Google offered for each keyword in the key-value store record **FILTERS**, so you can copy
them into the next run. If you ask for a label Google does not offer, that keyword is skipped and no products are charged for it.
Several filters can be combined (for example `On sale` + `4 and up`).

### Scheduling and integrations

Schedule the actor (daily or hourly) in Apify Console to build a price history, and send results to Google Sheets, a
webhook, Make, Zapier, n8n, S3 or your database with Apify integrations. Every row has `product_id` and `offer_id`, so
runs can be joined over time.

### Use it from AI agents (MCP)

AI assistants that support MCP can call this actor through Apify's MCP server (`https://mcp.apify.com`) and get
structured Google Shopping results for a keyword, for example: "find the 20 cheapest wireless earbuds on sale in the UK".

### FAQ

**How many products can I get per keyword?** Google shows about 100 unique products for one search (we have seen 100 to
134\). For more, run several specific keywords (`wireless earbuds sony`, `wireless earbuds under 50`) or use filters.

**Which countries work?** The 24 countries in the `country` field. The actor checks that each page is really for the
country you picked and loads it again when Google serves another market.

**Do I get the shop's product link?** The results page only shows the headline shop. `google_shopping_url` opens the
product on Google Shopping with all its offers.

**Can I sort by price?** Not yet: Google's sort option does not change the server-rendered results. Use `minPrice` /
`maxPrice` or a price-bucket filter instead.

**What if a keyword has no matching products?** Google then shows unrelated popular items. The actor detects this,
skips the keyword and charges no products for it. If a real keyword is skipped as unmatched, add a product word to it
(for example `alphabet pixel phone` instead of `alphabet`).

**Is it legal?** The actor collects publicly visible product listings. Make sure your use complies with the laws that
apply to you and with Google's terms.

**Something broke?** Open an issue on the actor's Issues tab; reports are answered.

# Actor input Schema

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

One Google Shopping search per keyword, e.g. a product type, a model name or a brand.

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

Google Shopping market: decides the Google domain, the currency and which shops appear.

## `maxItemsPerQuery` (type: `integer`):

Stop after this many unique products per keyword. Google shows about 100 unique products for one search; use more specific keywords or filters to reach other products.

## `filters` (type: `array`):

Optional. Apply Google's own filters by their label, exactly as Google Shopping shows them for that keyword in your country's language, for example `On sale`, `4 and up`, `New`, `Used`, a brand (`Sony`), a store (`Best Buy`) or a price bucket. Price buckets differ per keyword (`Under $35` for one search, `Under $50` for another). Each filter costs one extra page load. If a label is not offered for a keyword, that keyword is skipped (no products charged) and the offered labels are logged and saved to the key-value store as FILTERS. Sorting is not supported.

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

Optional. Keep only products at or above this price (in the country's currency). Checked on each product after loading, so it narrows Google's ~100 products per keyword rather than reaching more; combine with a price filter label for that. Filtered-out products are not pushed or charged.

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

Optional. Keep only products at or below this price (in the country's currency). Filtered-out products are not pushed or charged.

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

Optional language code (`hl`) for titles and labels, e.g. `es` for Spanish results in the US. Defaults to the country's main language.

## `includeSummary` (type: `boolean`):

Add Google's one-line accessibility summary of each product card (title, price, shop, delivery, rating) as `summary`.

## `saveHtml` (type: `boolean`):

Store the first Google Shopping page of each keyword in the key-value store (HTML_1, HTML_2, ...).

## Actor input object example

```json
{
  "queries": [
    "wireless earbuds"
  ],
  "country": "US",
  "maxItemsPerQuery": 50,
  "includeSummary": false,
  "saveHtml": false
}
```

# Actor output Schema

## `results` (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": [
        "wireless earbuds"
    ],
    "maxItemsPerQuery": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("axlymxp/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": ["wireless earbuds"],
    "maxItemsPerQuery": 50,
}

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

```

## MCP server setup

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