# Google Products Scraper — Detail, Offers, Variants (`scrape.badger/google-products-scraper`) Actor

Fetch deep Google Shopping product details via Google's immersive product page (/async/oapv): title, brand, price, rating, review count, images, specs, categories, plus optional merchant offers and size/colour variants. Pair with google-shopping-scraper to enrich every search result.

- **URL**: https://apify.com/scrape.badger/google-products-scraper.md
- **Developed by:** [ScrapeBadger](https://apify.com/scrape.badger) (community)
- **Categories:** E-commerce, Developer tools, Automation
- **Stats:** 9 total users, 4 monthly users, 81.3% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 product details

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

### What does Google Products Scraper do?

Fetch deep Google Shopping product details via Google's immersive product page (`/async/oapv`) — title, brand, price, rating, review count, images, specs, categories — plus optional merchant offers and size / colour variants.

### Why use Google Products Scraper?

- **Deep product detail.** Full spec table, all images, categories — what Google surfaces when a tile is clicked.
- **Merchant offers.** Optional `include_offers` fetches the full competing-merchants price list.
- **Size + colour variants.** Optional `include_variants` fetches the variant matrix.
- **Batch input.** One or many `gpcid`s per run — no separate task per product.
- **Pair with Shopping.** Pipe `gpcid`s from `google-shopping-scraper` for end-to-end product enrichment.

### What data can Google Products Scraper extract?

| Field | Type | Description |
|---|---|---|
| product\_id | string | Source `gpcid` |
| title | string | Product title |
| brand | string | Brand / manufacturer |
| rating | number | Star rating |
| reviews\_count | number | Review count |
| price | object | `{value, currency, extracted}` |
| images | array | All product images |
| specs | object | Attribute → value map |
| categories | array | Google category path |
| offers | array | Merchant offer list (optional) |
| variants | array | Size / colour variants (optional) |

### How to scrape Google Shopping (product detail)

1. Click **Try for free**.
2. Paste one or many `gpcid`s into **Product IDs** (comma-separated).
3. Optional: `q` (original query), `gl` / `hl`.
4. Toggle `include_offers` and/or `include_variants` for deeper data.
5. Click **Start** — products stream into the dataset.

### How much will it cost?

**$0.01 per product detail (≈ $10 per 1,000 products).** `include_offers` / `include_variants` each add one sub-request, roughly doubling the per-product cost. Base = $0.01; with all toggles = ≈ $0.03.

#### Competitor benchmark

| Actor | Author | Price | Notes |
|---|---|---|---|
| emastra/google-shopping-product-details | emastra | $30 /mo subscription + CUs | Subscription required |
| apify/google-shopping-scraper | Apify | ~$4 / 1k tiles (no detail) | Shallow tiles |
| compass/crawler-google-shopping | Compass | ~$5 / 1k | Search-only |
| **scrape-badger/google-products-scraper** | **ScrapeBadger** | **$10 / 1k products** | **Only pay-per-use deep detail** |

### Input

Configure the run in the **Input** tab above, or pass a JSON object matching the fields below when calling the Actor via the Apify API.

| Field | Required | Description |
|---|---|---|
| product\_ids | ✅ | One `gpcid` per line, or comma-separated. |
| q | — | Original search query (improves routing). |
| gl / hl | — | Country + language. |
| include\_offers | — | Fetch merchant offers list. |
| include\_variants | — | Fetch size / colour variants. |

### Output

Every successful run streams records into the run's dataset. Download as JSON, CSV, XML, Excel, or HTML from the **Dataset** tab; consume programmatically via the Apify API or webhooks.

Example record:

```json
{
  "product_id": "1234567890123456789",
  "title": "Nike Air Max 90 \u2014 Men's",
  "brand": "Nike",
  "rating": 4.6,
  "reviews_count": 2341,
  "price": {
    "value": "$120.00",
    "currency": "USD",
    "extracted": 120.0
  },
  "images": [
    "https://encrypted-tbn0.gstatic.com/\u2026"
  ],
  "specs": {
    "Color": "White/Black",
    "Sole material": "Rubber"
  },
  "categories": [
    "Apparel & Accessories",
    "Shoes",
    "Athletic Shoes"
  ],
  "offers": [
    {
      "merchant": "Nike.com",
      "price": 120.0
    },
    {
      "merchant": "Foot Locker",
      "price": 115.0
    }
  ],
  "variants": [
    {
      "size": "10",
      "color": "White/Black"
    }
  ]
}
```

### Tips / Advanced options

- **Batch by 100-500 `gpcid`s per run.** Memory + Apify compute budget sweet spot.
- **`include_offers` is great for price comparison.** See every merchant selling the same SKU, ranked by price.
- **Not-found products are stamped, not hidden.** A `{status: empty, reason: not_found, product_id: …}` record per miss.
- **Dedupe by `product_id`.** `gpcid`s are stable across runs — perfect primary key.

### FAQ, Disclaimers, Support

#### What's a `gpcid`?

Google Shopping's product ID. Surfaced as `gpcid` on each tile returned by `google-shopping-scraper`.

#### Can I pass an ASIN or SKU instead?

No — `gpcid` is Google's own ID. Run Shopping search first, collect the `gpcid`, then feed it here.

#### Why is the price an object?

`extracted` is the numeric (cents-safe) value, `value` is the formatted string, `currency` is the ISO code. Use `extracted` for filtering/analysis.

#### What's the difference between `offers` and `variants`?

`offers` = different merchants selling the same product. `variants` = size / colour / configuration options of the same product.

#### Disclaimer

This Actor scrapes public Google data only. You're responsible for compliance with Google's Terms of Service and any applicable data-protection laws (GDPR, CCPA, etc.) in your jurisdiction. ScrapeBadger does not store the scraped results — they are delivered directly to your Apify dataset.

#### Support

Something not working? Open a ticket in the **Issues** tab above — we triage within one business day. Full API reference: [docs.scrapebadger.com](https://docs.scrapebadger.com).

#### Related Actors

- [`google-shopping-scraper`](https://apify.com/scrape-badger/google-shopping-scraper) — Source `gpcid`s via Shopping search

#### Powered by

[ScrapeBadger](https://scrapebadger.com) — Google-optimised residential proxy pool + browser-farm fallback, 99.7% uptime, unmetered bandwidth. No CAPTCHAs reach you.

# Actor input Schema

## `product_ids` (type: `string`):

One or more Google Shopping product IDs (<b>gpcid</b>) separated by commas. Example: <b>1234567890123456789</b> or <b>1234567890123456789,9876543210987654321</b>. Find gpcids in the output of <b>google-shopping-scraper</b>.

## `q` (type: `string`):

The query that surfaced this product. Optional but improves context blob routing accuracy.

## `gl` (type: `string`):

ISO 3166-1 alpha-2 country code (lowercase).

## `hl` (type: `string`):

Language code for the response (BCP-47, e.g. 'en', 'en-GB', 'de'). Affects result language and locale-specific labels.

## `include_offers` (type: `boolean`):

When true, also fetch <b>/async/piu\_ps</b> for the full merchant offers list.

## `include_variants` (type: `boolean`):

When true, also fetch <b>/async/toy\_v</b> for size / colour variants.

## Actor input object example

```json
{
  "gl": "us",
  "hl": "en",
  "include_offers": false,
  "include_variants": false
}
```

# Actor output Schema

## `dataset` (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 = {
    "product_ids": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrape.badger/google-products-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 = { "product_ids": "" }

# Run the Actor and wait for it to finish
run = client.actor("scrape.badger/google-products-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 '{
  "product_ids": ""
}' |
apify call scrape.badger/google-products-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrape.badger/google-products-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/w8Z6jnKjOoDmFmRnr/builds/5ebHDTLbiVNplm5oq/openapi.json