# Shopify Competitor Price Tracker — Monitor Rival Prices (`qualifyops/shopify-competitor-price-monitor`) Actor

Shopify competitor price monitor: track competitor product prices and changes across Shopify stores automatically. Get alerts when prices move so you can reprice. Ecommerce competitor price tracking. Pay per price change detected.

- **URL**: https://apify.com/qualifyops/shopify-competitor-price-monitor.md
- **Developed by:** [QualifyOps](https://apify.com/qualifyops) (community)
- **Categories:** Lead generation, Business
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 detected changes

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

### Competitor Price & Stock Monitor — Shopify

**You give:** your competitors' Shopify store URLs.
**You get:** one row per detected change — price drop, price increase, out of stock, back in stock, new product, product removed — with old price, new price and % change.
**You pay:** **only when something actually changes — $0.005 per detected change.** Baseline runs and quiet days are **free**.

Stop checking competitor sites by hand. Paste their store URLs, schedule this, and get alerted rows only when something moved. Competitor-monitoring SaaS charges ~$70/month whether anything changed or not. Here, a week where your competitors touch nothing costs you nothing.

***

#### How it works

1. Reads each store's **public** product catalog (`/products.json` — every Shopify storefront exposes it; no browser, no proxies, no login).
2. **First run per store:** saves a baseline snapshot to a named key-value store. Free, always — you're never charged for a baseline.
3. **Every later run:** re-reads the catalog, diffs it against the stored snapshot **at variant level**, and emits one row per change. Each change row is charged; everything else (summaries, diagnostics, baselines) is free.
4. Saves the new snapshot, so the next scheduled run diffs against today.

#### Change types

| `change_type` | Fires when | Key columns |
|---|---|---|
| `price_drop` | A variant's price went down | `old_price`, `new_price`, `pct_change` |
| `price_increase` | A variant's price went up | `old_price`, `new_price`, `pct_change` |
| `out_of_stock` | A variant went from available to sold out | `available` |
| `back_in_stock` | A sold-out variant is buyable again | `available` |
| `new_product` | A product (or new variant) appeared in the catalog | `new_price` |
| `product_removed` | A product (or variant) left the catalog | `old_price` |

Every row also carries `store`, `product_title`, `variant_title`, `sku`, `product_url` (click straight through to the live page) and `detected_at`.

#### Honest by design

- Reads only the **public** `products.json` every Shopify storefront serves. No login, no scraping tricks, no proxies.
- Stores that disable or password-protect it are reported with a single **free** `store_not_readable` diagnostic row — never a silent failure, never a charge.
- The **baseline run is never charged**, even with `includeBaseline` on (that just gives you the full catalog as free rows so you can see what's being tracked).
- Charged changes are **capped at 500 per run** — a competitor's full-catalog redesign can't cause a runaway bill. Changes past the cap are still delivered, free, flagged `overflow: true`.

#### Schedule it — this is the whole point

One run is a snapshot; a **schedule is a monitor**. Add an [Apify Schedule](https://docs.apify.com/platform/schedules) (daily for most catalogs, hourly for fast movers) with the same `monitorName`, and every run diffs against the last one. The dataset becomes your rolling change feed: quiet day → free summary rows only; competitor cuts prices → charged change rows land in the dataset the next run.

#### Webhook / n8n / Make / Zapier

Set `notifyWebhookUrl` and the run POSTs a JSON change summary (per-store status + change counts) when it finishes — point it at an n8n/Make/Zapier webhook to get Slack or email alerts only on change days. Or consume the dataset directly via the Apify API/MCP and filter on `change_type`.

***

*Input: paste one or more Shopify store URLs. Optional: `trackedKeywords` to watch only matching products, `maxProductsPerStore`, `monitorName` (one name = one shared snapshot state across scheduled runs), `includeBaseline` to emit the free first-run catalog.*

# Actor input Schema

## `storeUrls` (type: `array`):

Competitor Shopify storefront URLs to monitor (their public products.json is read — no login).

## `maxProductsPerStore` (type: `integer`):

Upper bound on products tracked per store (catalog is paginated up to this cap).

## `monitorName` (type: `string`):

Names the key-value store that holds snapshots, so scheduled runs share state. Use one name per monitor/schedule.

## `trackedKeywords` (type: `array`):

Only monitor products whose title contains one of these keywords. Empty = monitor everything.

## `notifyWebhookUrl` (type: `string`):

POSTs the end-of-run change summary JSON here (n8n / Make / Zapier / Slack webhook). Failures are logged, never fatal.

## `includeBaseline` (type: `boolean`):

If on, the first-ever run for a store also outputs the full catalog as free baseline rows. Baselines are never charged.

## Actor input object example

```json
{
  "storeUrls": [
    "https://www.allbirds.com",
    "https://shop.gymshark.com"
  ],
  "maxProductsPerStore": 250,
  "monitorName": "competitor-price-monitor",
  "trackedKeywords": [],
  "includeBaseline": false
}
```

# 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 = {
    "storeUrls": [
        "https://www.allbirds.com",
        "https://shop.gymshark.com"
    ],
    "trackedKeywords": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("qualifyops/shopify-competitor-price-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 = {
    "storeUrls": [
        "https://www.allbirds.com",
        "https://shop.gymshark.com",
    ],
    "trackedKeywords": [],
}

# Run the Actor and wait for it to finish
run = client.actor("qualifyops/shopify-competitor-price-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 '{
  "storeUrls": [
    "https://www.allbirds.com",
    "https://shop.gymshark.com"
  ],
  "trackedKeywords": []
}' |
apify call qualifyops/shopify-competitor-price-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=qualifyops/shopify-competitor-price-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/oZgeLVwGLqChJ0PIp/builds/JwoGYif42gWJVvqIQ/openapi.json