# Google Shopping Products Scraper (`googleapi/google-shopping-products-scraper`) Actor

Extract public product details, merchant offers, and variants from Google Shopping product pages.

- **URL**: https://apify.com/googleapi/google-shopping-products-scraper.md
- **Developed by:** [Google API](https://apify.com/googleapi) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.99 / 1,000 results

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?

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

Collect detailed product information from public Google Shopping pages. Start with product URLs, product IDs, or search terms. For search terms, the Actor opens the first visible product card on each requested result page and reads its product details.

Use it to compare displayed prices, seller offers, product variants, specifications, and aggregate review information. Merchant links are recorded when visible; the Actor does not open merchant websites.

### How to use

1. Add product URLs, product IDs, search terms, or a combination of these inputs.
2. Select the Shopping country and language.
3. Set the overall product limit and, for searches, the pages to inspect.
4. Run the Actor and review or export the product records.

Example:

```json
{
  "queries": ["wireless headphones", "Bluetooth speakers"],
  "maxItems": 10,
  "countryCode": "us",
  "languageCode": "en"
}
```

### Input

| Input | Description | Default |
|---|---|---:|
| `productUrls` / `productUrl` | Public Google Shopping product URLs. The singular input is for one URL. | — |
| `productIds` / `productId` | Google Shopping product identifiers. The singular input is for one ID. | — |
| `queries` / `query` | Product search terms. | — |
| `maxItems` | Maximum product records across the run. | 10 |
| `page` / `maxPages` | Starting search page and maximum pages per query. These do not affect direct product URLs or IDs. | 1 / 1 |
| `countryCode` / `languageCode` | Shopping country and language. | `us` / `en` |
| `renderJavaScript` | Use a standard browser if the initial page does not contain enough product details. | `true` |
| `proxyConfiguration` | Optional Apify or custom proxy configuration. | — |

For searches, the first visible product card on each requested page is opened. `maxItems` is a global limit across direct products and searches. See the Input tab for accepted limits and aliases.

### Output

Each dataset item represents one product and includes the required `productTitle` and `productUrl`. Depending on the selected product page, it can also include:

- **Product identity:** brand, manufacturer, model, SKU, MPN, GTIN, and product category.
- **Description and attributes:** full description, highlights, technical specifications, product condition, and variants.
- **Pricing:** current and list price, discount, currency, and Google’s typical price range when shown.
- **Seller offers:** merchant, offer price, availability, delivery, returns, promotions, and coupon wording.
- **Ratings and media:** aggregate rating, review count and distribution, public product images, and Google’s review-image count label.
- **Product insights:** Google’s visible “What you need to know” summary and source label when available.

A product is included only when its public page provides enough distinct product information for a useful record. A sparse result may therefore be skipped. Fields not shown by Google are not guessed. Review counts preserve the displayed label when it is approximate; individual reviewer names, profiles, photos, and text are not collected.

Example dataset item:

```json
{
  "productTitle": "Example Wireless Headphones",
  "productUrl": "https://www.google.com/shopping/product/example",
  "brand": "Example Audio",
  "model": "X100",
  "price": 129.99,
  "priceText": "$129.99",
  "currency": "USD",
  "listPrice": 159.99,
  "discountPercent": 18.75,
  "rating": 4.6,
  "reviewCount": 7953,
  "productDescription": "Product description shown in the product viewer.",
  "specifications": {
    "Battery life": "Up to 30 hours"
  },
  "offers": [
    {
      "merchantName": "Example Store",
      "priceText": "$129.99",
      "availabilityText": "In stock online",
      "deliveryText": "Free delivery"
    }
  ]
}
```

Optional fields depend on the product, locale, and information shown by Google. The Output tab shows the available result fields. Run summary information is available with the run output in Apify.

### Limits and responsible use

Prices, stock, delivery estimates, reviews, and seller terms change by time and region. Additional pages and browser-rendered product viewers increase run time. Google may restrict access; the Actor does not sign in or bypass access checks.

Use public product information responsibly and follow Google terms and applicable laws. This Actor is not affiliated with Google.

# Actor input Schema

## `productUrls` (type: `array`):

Public Google Shopping detail URLs or Google-generated search links containing a #sv= product viewer fragment. Each valid URL requests one product record. Legacy ID-only pages may be unavailable.

## `productUrl` (type: `string`):

Convenience input for one public Google Shopping product detail URL.

## `productIds` (type: `array`):

Google Shopping product identifiers. The Actor opens the corresponding public product page.

## `productId` (type: `string`):

Convenience input for one Google Shopping product identifier.

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

Search terms. The Actor opens the first product card in each rendered Google Shopping search and extracts its selected product viewer.

## `query` (type: `string`):

Convenience input for one Shopping search term.

## `maxItems` (type: `integer`):

Global maximum number of product records to emit across direct inputs and search-result pages.

## `page` (type: `integer`):

Starting Google Shopping results page for every search query. Direct product URLs and IDs are unaffected.

## `maxPages` (type: `integer`):

Maximum result pages per query. The first visible product card on each requested page is opened; maxItems remains the global record cap.

## `countryCode` (type: `string`):

Two-letter Google Shopping country parameter used for search locale and currency interpretation.

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

Language or language-region code sent with public Google Shopping page requests.

## `renderJavaScript` (type: `boolean`):

Use a normal headless Chromium page when static HTML does not expose a complete product record. Pages that require special access are treated as unavailable.

## `timeoutMs` (type: `integer`):

Maximum time for an individual public page request or browser navigation.

## `browserWaitMs` (type: `integer`):

Bounded wait for visible Shopping content after normal browser navigation or product-card selection.

## `maxRetries` (type: `integer`):

Additional attempts for transient HTTP or network failures. Access boundaries are not retried.

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

Optional Apify or custom-proxy configuration. Residential proxies are recommended for Google Shopping; proxy routing is applied to both HTTP and browser requests.

## Actor input object example

```json
{
  "productUrls": [],
  "productIds": [],
  "queries": [],
  "maxItems": 10,
  "page": 1,
  "maxPages": 1,
  "countryCode": "us",
  "languageCode": "en",
  "renderJavaScript": true,
  "timeoutMs": 30000,
  "browserWaitMs": 1800,
  "maxRetries": 1
}
```

# Actor output Schema

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

No description

## `outputSummary` (type: `string`):

No description

## `runHealth` (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 = {
    "productUrls": [],
    "productIds": [],
    "queries": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("googleapi/google-shopping-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 = {
    "productUrls": [],
    "productIds": [],
    "queries": [],
}

# Run the Actor and wait for it to finish
run = client.actor("googleapi/google-shopping-products-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 '{
  "productUrls": [],
  "productIds": [],
  "queries": []
}' |
apify call googleapi/google-shopping-products-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,googleapi/google-shopping-products-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/RawToO6ddJadwqXGA/builds/4kZHYevUyMKn7zEA6/openapi.json