# Google Shopping Price Tracker & Seller Monitor (`monkey.d.scraping/google-shopping-price-change-seller-monitor`) Actor

Track Google Shopping prices and sellers automatically. Schedule product queries and receive verified new-offer and price-change events—no API key required.

- **URL**: https://apify.com/monkey.d.scraping/google-shopping-price-change-seller-monitor.md
- **Developed by:** [Monkey D. Scraping](https://apify.com/monkey.d.scraping) (community)
- **Categories:** E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $9.00 / 1,000 product query checkeds

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

## Google Shopping Price Tracker & Seller Monitor

Stop checking Google Shopping prices manually. Add the products you want to monitor, choose a country and language, and schedule automatic checks. The Actor keeps a private baseline and returns clean events only when it verifies a new seller offer or a comparable price change.

No Google account, cookies, seller login, or external API key is required. The Actor observes public Google Shopping results and produces structured data for alerts, spreadsheets, dashboards, and price-intelligence workflows.

### What does this Google Shopping price tracker do?

- Monitors one or more exact product or product-family queries.
- Tracks public prices and displayed seller names by country and language preference.
- Establishes a private baseline for each Saved Task.
- Emits `new_offer` when a previously unknown seller offer is observed.
- Emits `price_changed` only when the same canonical offer has two comparable prices.
- Suppresses duplicate events caused by normal ranking churn or an unchanged offer reappearing.
- Preserves the last healthy baseline when source quality drops instead of replacing it with incomplete data.
- Supports seller allowlists and blocklists.
- Reports per-query health, coverage, billing, and reconciliation metrics in `SUMMARY`.

### Why use it?

- **Change-focused output** — later runs stay empty when nothing verifiable changed.
- **Reliable comparisons** — product model filtering helps prevent a result for one model from changing the price of another.
- **Seller visibility** — identify newly observed public resellers without treating every ranking movement as a new seller.
- **Monitoring-ready state** — Saved Tasks retain known offers between scheduled runs.
- **Predictable pricing** — pay per successfully checked product query, not per offer or change event.
- **Automation-friendly data** — connect the dataset and run status to webhooks, Make, n8n, Zapier, Google Sheets, or your own API client.

### Quick start

#### 1. Create a Saved Task

Open the Actor's **Input** tab, add the products you want to monitor, choose market preferences, and save the configuration as a Saved Task. A Saved Task is required for comparisons across runs because it gives the monitor a persistent private baseline.

#### 2. Run the first check

Choose one of these first-run behaviours:

- **Return current offers now** (`emitCurrent`) — returns the offers observed now and establishes the baseline. Recommended for the first test.
- **Create a quiet baseline** (`baseline`) — establishes the baseline without writing current offers to the dataset.

#### 3. Schedule the Saved Task

Attach an hourly, daily, or weekly Apify Schedule to the Saved Task. Later healthy runs emit only verified `new_offer` and `price_changed` events.

For most catalogues, start with a daily schedule. Increase frequency only when faster detection justifies the additional query checks.

### Example input

```json
{
  "queries": [
    "Sony WH-1000XM5",
    "Apple AirPods Pro 2"
  ],
  "countryCode": "it",
  "languageCode": "it",
  "maxOffersPerQuery": 30,
  "initialRun": "emitCurrent",
  "includeSellers": [],
  "excludeSellers": []
}
```

### What data does it return?

| Field | Description |
| --- | --- |
| `eventType` | `current_offer`, `new_offer`, or `price_changed`. |
| `query` | Product query that produced the observed offer. |
| `countryCode` / `languageCode` | Market preferences used for the public Shopping check. |
| `productTitle` | Public product title displayed in the result. |
| `sellerName` | Public seller name displayed in the result. |
| `priceText` | Current price exactly as observed. |
| `priceAmount` / `currency` | Parsed comparable price and currency when reliably available. |
| `previousPriceText` | Prior observed price for a verified `price_changed` event. |
| `previousPriceAmount` / `previousCurrency` | Prior comparable numeric price and currency. |
| `productUrl` | Public offer or comparison URL when exposed; otherwise `null`. |
| `observedAt` | ISO timestamp of the current observation. |

#### Example price-change event

```json
{
  "eventType": "price_changed",
  "query": "Sony WH-1000XM5",
  "countryCode": "IT",
  "languageCode": "it",
  "productTitle": "Sony WH-1000XM5 Cuffie Wireless",
  "sellerName": "Example Shop",
  "productUrl": null,
  "priceText": "299,00 €",
  "priceAmount": 299,
  "currency": "€",
  "previousPriceText": "329,00 €",
  "previousPriceAmount": 329,
  "previousCurrency": "€",
  "previousObservedAt": "2026-08-02T07:30:00.000Z",
  "observedAt": "2026-08-03T07:30:00.000Z"
}
```

### How monitoring state works

| Run | Expected dataset | Reason |
| --- | --- | --- |
| First Saved Task run with `emitCurrent` | Current public offers | Returns a starting snapshot and establishes state. |
| First Saved Task run with `baseline` | Empty | Quietly establishes state. |
| Later run with no verified difference | Empty | No duplicate or speculative event is created. |
| Comparable price differs | `price_changed` | Includes the previous and current price. |
| Previously unknown seller offer appears | `new_offer` | Captures the newly observed public offer. |
| Known offer reappears unchanged | Empty | Ranking churn is suppressed. |
| Source quality drops severely | Run is degraded or fails | The last healthy checkpoint is preserved. |

An empty dataset can therefore be a correct, successful outcome. Open the `SUMMARY` record in the run's key-value store to inspect health status, observed counts, price and seller coverage, baseline status, and billing reconciliation.

### Pricing

This Actor uses transparent pay-per-event pricing:

- **$0.009 per successfully checked product query** (`product-query-checked`).
- **$0.00005 Actor start fee** per run.
- Platform usage is included.
- Failed or degraded queries are not charged.
- Offers, new-seller events, and detected price changes have no additional charge.
- A query that successfully retrieves and evaluates Shopping results is charged even when optional seller filters leave no accepted offers.

Approximate examples, assuming 30 days:

| Monitoring frequency | Approximate customer cost |
| --- | ---: |
| 1 product checked daily | $0.27/month |
| 10 products checked daily | $2.70/month |
| 100 products checked daily | $27.00/month |
| 10 products checked hourly | $64.80/month |

Customers can set a maximum total charge for every run. Before starting another paid query, the Actor checks the remaining run budget and stops cleanly when the next query cannot be covered. The `SUMMARY` record exposes `billableQueries`, `chargedQueries`, `unbilledQueries`, `queriesSkippedForBudget`, and `budgetLimitReached` for direct reconciliation.

### Automate alerts and downstream workflows

- **Apify Schedules** — run the same Saved Task hourly, daily, or weekly.
- **Webhooks** — react when a run succeeds or fails and fetch only its change events.
- **Make, n8n, and Zapier** — route changes to email, Slack, Google Sheets, Airtable, or a database.
- **Apify API** — start runs and retrieve datasets from any application.
- **MCP and AI agents** — expose the Actor as a structured monitoring tool through the Apify MCP server.

For change-only notifications, trigger downstream processing on successful runs and continue only when the default dataset contains at least one item.

### Use cases

- Competitor and reseller price monitoring.
- Marketplace seller discovery.
- MAP and channel review queues based on publicly observed prices.
- E-commerce catalogue monitoring across countries and languages.
- Price-change alerts for commercial teams.
- Compact change streams for BI tools, spreadsheets, and data warehouses.

### Data quality and responsible use

Google Shopping result composition can change because of ranking, localization, availability, consent, rate limits, or source-layout changes. Country and language are result preferences, not guarantees of seller location, shipping coverage, or listing language.

The Actor reports only fields it can observe and verify. Missing values remain `null`. It does not infer stock, seller removal, delivery promises, product identity, or price changes from incomplete data. A result that stops appearing is not reported as removed because public rankings can change independently of seller availability.

The Actor accesses public results only. It does not use private Google accounts, checkout flows, merchant back offices, or user data. You remain responsible for complying with applicable law and platform terms and for independently validating commercial decisions.

### FAQ

#### Why is a successful run's dataset empty?

After the baseline, an empty dataset normally means no verified new offer or comparable price change was observed. Check `SUMMARY` to confirm that the queries were healthy.

#### Do I need a Saved Task?

Yes for monitoring across runs. One-off Actor runs are useful for current snapshots, but Saved Tasks provide the persistent identity used to retain and compare the private baseline.

#### Are failed searches charged?

No. Queries classified as degraded because results were unavailable or unsafe to compare are not charged. Successfully fetched queries intentionally reduced to zero results by seller filters are charged.

#### Does it report that a seller removed an offer?

No. Absence from a later public result set is not reliable evidence of removal. This avoids false alerts caused by ranking changes.

#### Does it always return a direct merchant URL?

No. `productUrl` is returned only when a public result exposes a usable URL. Otherwise it is `null`; the Actor never invents a destination.

#### Can I monitor several countries in one Saved Task?

Each task has one country and language configuration. Create separate Saved Tasks for separate markets so baselines and schedules remain clear.

#### Do I need a Google account or API key?

No. Proxy access and public Shopping retrieval are handled inside the Apify run.

### Support

If a query starts returning degraded runs, attach the shared run URL to a new item in the Actor's **Issues** tab. Include the query, country, language, and expected product family, but do not post credentials or private data.

Feature requests for additional countries, seller matching, notification workflows, and richer public destination links are welcome. If the Actor saves you time, a review helps guide future improvements.

# Actor input Schema

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

Public Google Shopping queries to monitor. At least one is required.

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

Country preference for public Shopping results. It is not a seller-location guarantee.

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

Language preference for public Shopping results. It does not classify or translate offers.

## `maxOffersPerQuery` (type: `integer`):

Upper bound for unique public offers processed for each query in a run. A smaller cap keeps scheduled monitoring focused and predictable.

## `includeSellers` (type: `array`):

Keep offers only when the publicly displayed seller name contains one of these phrases. Leave empty to include every observed seller.

## `excludeSellers` (type: `array`):

Discard offers when the publicly displayed seller name contains any of these phrases.

## `initialRun` (type: `string`):

Create a private baseline to receive only later changes, or return the offers observed now as a one-time starting snapshot.

## `resetState` (type: `boolean`):

Starts a new comparison history for this task. Use only when you intentionally want to discard the prior baseline.

## Actor input object example

```json
{
  "queries": [
    "Sony WH-1000XM5"
  ],
  "countryCode": "us",
  "languageCode": "en",
  "maxOffersPerQuery": 30,
  "includeSellers": [],
  "excludeSellers": [],
  "initialRun": "emitCurrent",
  "resetState": false
}
```

# Actor output Schema

## `events` (type: `string`):

Observed current offers, new offers, and confirmed price changes. No event is emitted for an offer that merely stops appearing in a result set.

## `runSummary` (type: `string`):

Health status, per-query quality metrics, coverage, observed counts, baseline status, deduplication, and isolated non-sensitive query errors.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("monkey.d.scraping/google-shopping-price-change-seller-monitor").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("monkey.d.scraping/google-shopping-price-change-seller-monitor").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 '{}' |
apify call monkey.d.scraping/google-shopping-price-change-seller-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=monkey.d.scraping/google-shopping-price-change-seller-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/10uPqp2lPQg7Hpgvd/builds/AUK3fMfK4FVZKockP/openapi.json