# Free Google Shopping Reviews Scraper — by SKU/gpcid (`s-r/free-google-shopping-reviews`) Actor - **URL**: https://apify.com/s-r/free-google-shopping-reviews.md - **Developed by:** [SR](https://apify.com/s-r) (community) - **Categories:** E-commerce, Business - **Stats:** 2 total users, 1 monthly users, 25.0% runs succeeded, NaN 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 ## Free Google Shopping Reviews Scraper — Product Reviews + Rating Breakdown by SKU A Google Shopping reviews scraper that returns the full product-review payload Google aggregates across retailers — average rating, total review count, the 5/4/3/2/1-star breakdown, and individual user reviews with author, source retailer, date, and full text — as clean structured JSON. Pass a Google Shopping `sku` (catalogid) or `gpcid` (product cluster id) plus a country code, and the actor paginates the reviews for you. $0.01 per product processed. No Google Merchant Center API account, no DataForSEO subscription, no Selenium. ### What you get - Product `title` as Google renders it on the cluster page (e.g. `"Sony WH-1000XM5 Wireless Noise-Canceling Headphones"`) - `review_summary` — `average_rating` (rounded to 1 decimal, the headline number Google shows), `exact_average` (the un-rounded float for tie-breakers), and `total_reviews` (integer count across all retailers) - `review_breakdown` — the percentage distribution across 5, 4, 3, 2, and 1 stars (e.g. `{"5": "78%", "4": "12%", "3": "5%", "2": "3%", "1": "2%"}`) - `user_reviews[]` — individual reviews each with `title`, `source` (the retailer that hosted the review — Amazon, Best Buy, BHPhoto, Newegg, etc.), `author` name, `rating` as a string, posting `date`, and full review `text` - Up to 10 reviews per page × 10 pages = 100 reviews per product per run - The original `sku` and `gpcid` echoed back so you can join review records to your product catalog - `country` echoed back — the same product cluster has different review pools per Google Shopping country edition ### Why scrape Google Shopping reviews Google Shopping is the only place on the web where reviews from Amazon, Best Buy, Walmart, Target, B&H Photo, Newegg, Adorama, John Lewis, MediaMarkt, Bol.com, and dozens of other retailers are aggregated under a single product cluster. For a brand manager, e-commerce analyst, market researcher, or product-launch team, this aggregated review pool is more valuable than any single retailer's reviews — it's a cross-retailer demand signal that tells you what customers actually say about a product no matter where they bought it. But Google does not expose this data through any public API. The official **Merchant Center API** only returns reviews for products you sell as a verified merchant; the **Custom Search Engine** doesn't index review text; and the only third-party APIs that return Google Shopping reviews (DataForSEO, SerpApi) charge $4-15 per 1000 product reviews with rate limits. This actor solves that by hitting Google Shopping's internal `/async/skp_rj` endpoint directly with `curl_cffi` (Chrome TLS impersonation) — the same JSON endpoint Google's product page calls when you click "See more reviews". Pass a `sku` (the `catalogid` you'll see in any Google Shopping URL like `shopping.google.com/product/123456`) or a `gpcid` (the cluster id) plus a country code, and the actor builds the protobuf `reviewSettings` parameter, paginates through all pages, and returns the full payload for **$0.01 per product**. Concrete buyer math: a brand manager monitoring 200 SKUs across 5 countries weekly pays 200 × 5 × $0.01 = **$10 per weekly run** — versus DataForSEO at $0.045 per product (the same 1000 calls would cost $45) or SerpApi at $0.005 per query × 5-10 paginated calls per product = $25-50. A market-research firm doing one-off competitive sweeps on 5,000 SKUs pays $50. ### Input | Field | Default | Description | |---|---|---| | `products` | required | Array of `{sku: string, country: string}` or `{gpcid: string, country: string}` objects. `sku` = the Google Shopping `catalogid`; `gpcid` = the product cluster id. Mix both in one run | | `max_pages_per_product` | `3` | Pages of reviews per product (10 reviews per page; 1-10 pages = 10-100 reviews) | | `concurrency` | `5` | Parallel product fetches (1-20) | | `default_country` | `us` | Used when a product entry doesn't specify `country` | When you only have a `sku`, the actor first hits the Google Shopping product page to resolve the corresponding `gpcid`, then builds the `reviewSettings` protobuf and starts paginating. When you already have the `gpcid`, the actor skips the resolution step and goes straight to reviews — faster and one fewer network call. ### Output ```json { "sku": "8062340666125262933", "gpcid": "158194847738236757", "country": "nl", "title": "Sony WH-1000XM5 Wireless Noise-Canceling Headphones", "review_summary": { "average_rating": 4.6, "exact_average": 4.62, "total_reviews": 12847 }, "review_breakdown": { "5": "78%", "4": "12%", "3": "5%", "2": "3%", "1": "2%" }, "user_reviews": [ { "title": "Best noise cancelling I've ever owned", "source": "Amazon", "author": "Marcus W.", "rating": "5", "date": "2026-03-12", "text": "Replaced my XM4s and the difference is immediate — the new processor crushes airplane noise even better, and the call quality on the new mics is finally good enough for daily standups." }, { "title": "Great sound, mediocre build", "source": "Best Buy", "author": "Linda K.", "rating": "4", "date": "2026-02-28", "text": "Audio is incredible, but the headband flex feels cheaper than the XM4. For the price I expected metal, not plastic." } ] } ```` `review_summary.exact_average` is the un-rounded float Google uses internally for ranking — handy when you need to break ties between two products both displayed as "4.6 stars". `source` tells you which retailer hosted the original review, so you can weight reviews differently (e.g. trust Best Buy reviews higher than aggregator-site reviews). ### Use cases **Brand manager monitoring product reception across markets.** You're a product manager at a consumer-electronics brand. You ship 50 SKUs across the US, UK, DE, NL, and JP Google Shopping editions. Schedule the actor weekly with all 50 SKUs × 5 countries × `max_pages=10` (100 reviews per product per market). 250 product-runs × $0.01 = **$2.50 per weekly run** — and you have country-segmented sentiment for every SKU you ship. **E-commerce category manager benchmarking competitors.** You sell wireless headphones on a marketplace and want to know what customers actually complain about across the top 30 competitor models. Pull 30 `gpcid`s × 100 reviews each = 3,000 reviews for $0.30. Run topic modeling on `text` and segment by `rating`. Within an hour you know that "comfort over long calls" is the #1 complaint cluster — your next product brief writes itself. **Market-research firm building a product-launch report.** Your client wants a trend report on the air-fryer category for Q2 2026. Pull 200 air-fryer SKUs across the US and EU (1,000 product-runs = $10) and you have a 100,000-review corpus segmented by rating, retailer source, and date. Ship the report; pocket the difference between the $10 of scraping and the $5,000 retainer. **Consumer-insights team training NLP / sentiment models.** You need 1M labeled (rating, text, source) tuples for fine-tuning a multi-retailer aspect-based sentiment model. Pull 10,000 SKUs × 100 reviews each = 1M reviews for $100. Each review carries the source retailer label, which becomes a "domain" feature in your model — invaluable when retailer-specific reviewers have different vocabulary norms. ### How it compares | Service | Price per 1000 product calls | Cross-retailer aggregation | Star breakdown | Per-review source | |---|---|---|---|---| | **This actor (s-r/free-google-shopping-reviews)** | **$10** | yes (Amazon, Best Buy, Walmart, etc.) | yes (5/4/3/2/1 %) | yes | | DataForSEO Google Shopping Reviews API (#2 on `google shopping reviews api` SERP) | ~$45 | yes | yes | yes | | SerpApi Google Product API (#4 SERP, similar feature) | ~$25-50 (paginated) | yes | partial | yes | | Google Merchant API Reviews (#1 SERP) | free (verified merchants only) | own products only | yes | no | | Bright Data Google Reviews API (#6 SERP) | per-request, similar tier | yes | yes | partial | The honest competitive position is: the *only* free or low-cost path to Google Shopping's cross-retailer aggregated reviews is scraping. The Google Merchant API is gated to product owners; everything else (DataForSEO, SerpApi, Bright Data, Outscraper) is a paid scraping wrapper. This actor is a direct, cheap version of the same wrapper. ### Pricing This actor uses Apify's pay-per-event monetization at $0.01 per product processed — that's $10 per 1000 products, with each product yielding the summary + breakdown + up to 100 paginated reviews depending on `max_pages_per_product`. All pricing is pay-per-event — you only pay for products that successfully resolve. No actor-start fee, no per-compute-unit charges, no per-review surcharge — pagination is included in the per-product price. ### Limits and gotchas - Maximum 100 reviews per product per run (10 pages × 10 reviews) — Google paginates beyond this but quality drops sharply (older, less-relevant reviews); for the rare product with >100 useful reviews, run multiple times with different country codes since each country edition has a different review pool - The `country` field controls which Google Shopping edition's reviews pool you query — `us` returns mostly English Amazon / Best Buy reviews, `nl` returns mostly Dutch Bol.com / Coolblue reviews, `de` mostly MediaMarkt / Otto / Amazon DE. The aggregated `total_reviews` count is country-specific - Some products are gated behind region locks (a US `sku` queried with `country=jp` may return zero reviews if the cluster doesn't exist in JP); the actor returns an empty `user_reviews[]` rather than erroring - Apify residential proxy is **not** required — the cookie pool plus `curl_cffi`'s Chrome TLS fingerprint is enough for sustained throughput - Cold-start time is ~2-3 seconds for the first product (one extra fetch to resolve `sku` → `gpcid`); subsequent products in the same run reuse the session pool - Reviewer `date` strings come back in Google's local format for the country (`"March 12, 2026"` for `us`, `"12 maart 2026"` for `nl`); normalize downstream if you need a single date format - The `sku` you pass must be the Google Shopping `catalogid` (the long numeric ID in `shopping.google.com/product/`), not a retailer SKU like Amazon's ASIN ### FAQ **How do I get a Google Shopping product SKU?** Open any product page on Google Shopping (`shopping.google.com/product/...`) — the long numeric ID at the end of the URL is the `catalogid`. That's the `sku` you pass to this actor. Alternatively, if you already have the `gpcid` (cluster id) from a previous run, pass that and skip the resolution step. **What's the cost to scrape 1000 Google Shopping product reviews?** 1000 × $0.01 = **$10** for 1000 product reviews-runs (each yielding the summary + breakdown + up to 100 paginated reviews). For comparison: DataForSEO charges ~$45 for 1000 product calls; SerpApi charges ~$25-50 depending on pagination depth. **Can I scrape Google Shopping reviews without a Merchant Center account?** Yes. The official Google Merchant Center API only returns reviews for products you sell as a verified merchant. This actor scrapes the public Google Shopping product cluster pages, which expose every review across all retailers. No Merchant Center, no Google Cloud account, no API key. **Why are the reviews different in different countries?** Google Shopping runs separate product clusters per country edition — a `gpcid` for the same physical product (e.g. a Sony WH-1000XM5) has a different review pool in `us` (Amazon US, Best Buy, B\&H), `nl` (Bol.com, Coolblue, MediaMarkt NL), and `de` (Amazon DE, MediaMarkt DE, Otto). Run the actor per country to get the full multi-market picture. **Will Google rate-limit my scraping?** At default settings (concurrency 5, fresh session cookies) the actor sustains ~10 products/second. Push `concurrency` to 20 for batch jobs; for sustained >100/sec throughput, supply a residential proxy URL via the `PROXY_URL` env var. ### Related Actors - [Free Google Maps Reviews Scraper](https://apify.com/s-r/free-google-maps-reviews-scraper) — every review for any Google Maps place URL (local-business reviews, not product reviews) - [Free Google Maps Scraper](https://apify.com/s-r/free-google-maps-scraper) — find local businesses by keyword + city with full contact data - [Free Google Hotels Scraper](https://apify.com/s-r/free-google-hotels-scraper) — Google Hotels search with per-room pricing, 18-31 OTA comparison, and review breakdown # Actor input Schema ## `products` (type: `array`): List of {sku, country} OR {gpcid, country} objects. sku = Google Shopping catalogid; gpcid = Google product cluster id. ## `max_pages_per_product` (type: `integer`): 10 reviews per page; cap pages 1-10. ## `concurrency` (type: `integer`): Concurrent product fetches. ## `default_country` (type: `string`): Used when a product entry doesn't specify country. ## Actor input object example ```json { "products": [ { "sku": "8062340666125262933", "country": "nl" }, { "gpcid": "158194847738236757", "country": "us" } ], "max_pages_per_product": 3, "concurrency": 5, "default_country": "us" } ``` # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "products": [ { "sku": "8062340666125262933", "country": "nl" } ] }; // Run the Actor and wait for it to finish const run = await client.actor("s-r/free-google-shopping-reviews").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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "products": [{ "sku": "8062340666125262933", "country": "nl", }] } # Run the Actor and wait for it to finish run = client.actor("s-r/free-google-shopping-reviews").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 '{ "products": [ { "sku": "8062340666125262933", "country": "nl" } ] }' | apify call s-r/free-google-shopping-reviews --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=s-r/free-google-shopping-reviews", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "Free Google Shopping Reviews Scraper — by SKU/gpcid", "version": "0.1", "x-build-id": "BcF8E2RgoJb7K4bOF" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/s-r~free-google-shopping-reviews/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-s-r-free-google-shopping-reviews", "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/s-r~free-google-shopping-reviews/runs": { "post": { "operationId": "runs-sync-s-r-free-google-shopping-reviews", "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/s-r~free-google-shopping-reviews/run-sync": { "post": { "operationId": "run-sync-s-r-free-google-shopping-reviews", "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": [ "products" ], "properties": { "products": { "title": "Products to fetch reviews for", "type": "array", "description": "List of {sku, country} OR {gpcid, country} objects. sku = Google Shopping catalogid; gpcid = Google product cluster id.", "items": { "type": "object" } }, "max_pages_per_product": { "title": "Max review pages per product", "minimum": 1, "maximum": 10, "type": "integer", "description": "10 reviews per page; cap pages 1-10.", "default": 3 }, "concurrency": { "title": "Concurrency", "minimum": 1, "maximum": 20, "type": "integer", "description": "Concurrent product fetches.", "default": 5 }, "default_country": { "title": "Default country", "type": "string", "description": "Used when a product entry doesn't specify country.", "default": "us" } } }, "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 } } } } } } } } } } ```