# Google Shopping Scraper: Prices, Sellers & Price Tracker (`vncntlabs/google-shopping-scraper`) Actor

Google Shopping scraper for any product search in 45 countries: price, old price, discount, seller, rating and delivery. Get every store's offer with shipping and total price, track competitor prices and MAP violations, plus specs and variants. You pay only for products that have a price.

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

## Pricing

from $2.00 / 1,000 products

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: product prices, seller offers and competitor price tracker

**Google Shopping scraper and price tracker.** Scrape Google Shopping for any product search in 45 countries and get price, old price and discount, seller, rating, reviews and delivery for every listing. Add every store's offer for the products you care about (price, shipping, total price, condition, availability) with built-in competitor price tracking and MAP-violation checks, plus product specs and variants. You pay only for products that have a price.

Built for:

- **E-commerce sellers and brands**: see who sells your products, at what price, and where you rank on price.
- **Price-monitoring and MAP-enforcement teams**: schedule a run on your product URLs and get every seller advertising below your minimum advertised price.
- **Agencies and analysts**: market snapshots per search (min, median, average and max price, share on sale, top sellers) for clients and pitches.

You pay only for products **with a price**. Listings without a price, searches with no results, products not found and failed requests are free.

### What you get

| | Per product listing (search) | Store offers (`product-offers`) | Product details (`product-details`) |
|---|---|---|---|
| Data | rank, title, price, oldPrice, discountPct, currency, seller, more stores, tags, rating, reviews, delivery, productId, dataDocid, gid, Google Shopping link, image | every store: seller, domain, price, shipping, totalPrice, condition, availability, link, priceRank; lowest/median/highest price, spread; MAP and my-store checks | description, specifications table, brand, variants with links, images |
| How | `queries` | `offersForTopProducts` or `products` | `detailsForTopProducts` or `detailsForProducts` |

Each search also adds one free **summary row** (`type: "search"`) with min, median, average and max price, `onSalePct` and the top sellers' share of listings.

### Input examples

Search, 40 products (the default):

```json
{ "queries": ["airpods pro 2", "running shoes"], "country": "United States" }
```

MAP monitoring of your own products (scheduled daily):

```json
{
  "products": ["https://www.google.com/search?ibp=oshop&q=...&prds=catalogid:11912907156228950968,..."],
  "mapPrice": 199.99,
  "myStore": "mystore.com"
}
```

Competitor price check for the top 10 products of a search, with details for the top 3:

```json
{ "queries": ["stand mixer"], "maxProductsPerQuery": 40, "offersForTopProducts": 10, "detailsForTopProducts": 3,
  "myStore": "walmart.com", "country": "United Kingdom" }
```

**Tips**

- Product URL: open a product on Google Shopping and copy the browser URL. IDs from a previous run (`productId`) work too.
- A model number or GTIN/EAN as the query usually finds the exact product.
- `minPrice` and `maxPrice` filter the search like on Google. `sortBy` (price low/high, review score) orders the listings Google returns; `rank` is the position after sorting and `googleRank` is Google's own position.

### Output example (search product with store offers, shortened)

```json
{
  "type": "product", "source": "search", "status": "ok", "query": "airpods pro 2", "country": "United States",
  "rank": 1, "productId": "6883422599141817139", "title": "AirPods Pro Apple", "price": 42, "currency": "USD",
  "seller": "eBay", "moreStores": true, "rating": 4.4, "reviewsCount": 11000,
  "offersCount": 10, "lowestPrice": 69.99, "lowestPriceSeller": "eBay", "highestPrice": 250.99,
  "medianPrice": 149.67, "priceSpreadPct": 258.6,
  "mapPrice": 200, "belowMapCount": 8, "belowMapSellers": ["eBay (69.99)", "Quick Ship Electronics (99.99)", "..."],
  "myStorePrice": null, "myStoreNote": "'walmart.com' does not sell this product on Google Shopping in this country.",
  "offers": [
    { "seller": "eBay", "price": 69.99, "shipping": null, "totalPrice": 69.99, "availability": "in_stock",
      "url": "https://www.ebay.com/...", "priceRank": 1, "belowMap": true, "isMyStore": false }
  ],
  "googleShoppingUrl": "https://google.com/search?ibp=oshop&...", "chargedEvents": ["product", "product-offers"],
  "scrapedAt": "2026-10-16T23:38:05Z"
}
```

When `myStore` sells the product you also get `myStorePrice`, `myStorePriceRank`, `cheaperCompetitors`, `lowestCompetitorPrice`, `gapToLowestCompetitor` and `gapToLowestCompetitorPct`.

The dataset has three ready views: **Products**, **Price monitor** (offers, MAP, my store) and **Searches** (market snapshot). Export to CSV, Excel or JSON, or use the API.

### Pricing (pay per event)

| Event | When it is charged |
|---|---|
| Actor start | once per run |
| `product` | one product listing with a price delivered from a search |
| `product-offers` | every store's offer for one product, with the MAP and my-store checks |
| `product-details` | description, specifications, brand, variants and images for one product |

You are not charged for:

- product listings without a price (they are still delivered, with `status: "no_price"`);
- searches with no products;
- products not found, and products where Google shows no store offers;
- failed requests;
- skipped inputs (duplicates, invalid URLs);
- search summary rows;
- anything beyond your run's maximum charge. The run stops cleanly and lists what it didn't process.

**Apify free plan:** 1 search of up to 40 products, 3 store-offer lookups and 1 product details per run. Any paid Apify plan unlocks up to 200 searches, 120 products per search and 1,000 offer/detail lookups per run.

### FAQ

**Which countries?** 45 Google Shopping countries, including the US, UK, Canada, Australia, Germany, France, Spain, Italy, the Netherlands, Brazil, Mexico, India and Japan. Prices are in the country's currency.

**How fresh is the data?** Every run fetches live Google Shopping results. Prices change often; each row carries `scrapedAt`.

**How do I monitor prices every day?** Save your input as a task and add an Apify schedule. Use product URLs or IDs so you track the same products every day.

**Is the total price exact?** `totalPrice` is price + shipping as Google Shopping shows it; taxes may not be included.

**Why does a product have fewer offers than on Google?** Google shows a limited number of stores per product and country; the Actor returns what Google shows.

**Is this the official Google Shopping API?** No. Google has no public Shopping search API. This Actor uses DataForSEO's licensed API and is not affiliated with or endorsed by Google.

# Actor input Schema

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

Products to search on Google Shopping, one per line (up to 200): <code>airpods pro 2</code>, <code>running shoes</code>, a model number <code>KSM150PSER</code> or a GTIN/EAN. Each query returns Google Shopping's product listings in Google's order.

## `products` (type: `array`):

Optional. Google Shopping product URLs (copy from the browser) or numeric product IDs (<code>productId</code> from a previous run), up to 500. Returns every store's offer for each product (price, shipping, total, condition), with the MAP and my-store checks. Ideal for scheduled price monitoring of your own catalog.

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

Google Shopping country (prices, currency and stores of that country).

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

Optional language code (en, de, fr, es, pt-BR...). Defaults to the country's main language.

## `maxProductsPerQuery` (type: `integer`):

Product listings per search (Google's order), up to 120.

## `offersForTopProducts` (type: `integer`):

For the first N priced products of each search, also fetch every store's offer: seller, price, shipping, total price, condition, availability and link, sorted cheapest first, with price spread. Charged per product (product-offers), only when Google shows offers.

## `detailsForTopProducts` (type: `integer`):

For the first N priced products of each search: description, specifications, brand, variants (colors/sizes) and image count. Charged per product (product-details).

## `detailsForProducts` (type: `boolean`):

Also fetch details for every product in 'Specific products'.

## `mapPrice` (type: `number`):

Optional. Flags every store offer advertised below this price (belowMap, belowMapCount, belowMapSellers). Works on store offers: set 'All store offers for the top N' or add specific products.

## `myStore` (type: `string`):

Optional, e.g. <code>walmart.com</code> or <code>Best Buy</code>. For each product with offers: your price, your price rank, how many competitors are cheaper and the gap to the lowest competitor.

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

In the country's currency.

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

In the country's currency.

## `sortBy` (type: `string`):

Google Shopping sort order.

## `includeImages` (type: `boolean`):

Include all image URLs from product details (otherwise only the main image).

## Actor input object example

```json
{
  "queries": [
    "airpods pro 2"
  ],
  "country": "United States",
  "maxProductsPerQuery": 40,
  "offersForTopProducts": 0,
  "detailsForTopProducts": 0,
  "detailsForProducts": false,
  "sortBy": "relevance",
  "includeImages": false
}
```

# Actor output Schema

## `products` (type: `string`):

No description

## `monitor` (type: `string`):

No description

## `searches` (type: `string`):

No description

## `all` (type: `string`):

No description

## `summary` (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": [
        "airpods pro 2"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("vncntlabs/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": ["airpods pro 2"] }

# Run the Actor and wait for it to finish
run = client.actor("vncntlabs/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": [
    "airpods pro 2"
  ]
}' |
apify call vncntlabs/google-shopping-scraper --silent --output-dataset

```

## MCP server setup

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