Shopify Price Monitor — Competitor Price Tracker & Change Alerts

Track competitor prices on any public Shopify store using the free, official /products.json endpoint — no scraping, no Cloudflare, no proxies, no browser. Point it at one or more stores, turn on alert mode, and schedule it daily to get automatic competitor price intelligence delivered to your webhook, Slack, email, Make/Zapier, or database.

Primary keywords: Shopify price monitor · Shopify price tracker · competitor price monitoring · Shopify products.json scraper · price change alerts

What it does

Fetches the full product catalogue of any public Shopify store via its first-party /products.json API and outputs clean, structured product + variant data. In alert mode, it remembers prices from previous runs and outputs only the products whose price changed — so you get signal, not noise, and pay only for real changes.

How it works

1. You provide one or more Shopify store URLs (custom domains or .myshopify.com).
2. The Actor calls each store's public /products.json endpoint and paginates through the whole catalogue automatically (250 products per page, via the Link header).
3. Each raw product is normalized into a consistent schema with all variants, prices, and compareAtPrice.
4. In alert mode, it compares each variant price against the last run's snapshot (stored per store in an Apify key-value store) and emits only changed / new products.
5. Results are written to the dataset — export to JSON/CSV/Excel or pipe to a webhook.

Input

Field	Type	Required	Description
storeUrls	array	yes	Shopify store URLs — e.g. allbirds.com, gymshark.com, mystore.myshopify.com. Any format accepted; the path is stripped automatically.
maxProducts	integer	no	Max products to output per run, across all stores (default: 500, max: 50,000).
alertMode	boolean	no	Only output products where a variant price changed since the last run (default: false).
deltaOnly	boolean	no	In alert mode, output only changed products with a change summary (default: true).
minPriceChangePct	number	no	Minimum % change to report — filters out sub-threshold fluctuations (default: 0 = report every change).

Example — snapshot all products from a store:

{
    "storeUrls": ["allbirds.com", "gymshark.com"],
    "maxProducts": 2000,
    "alertMode": false
}

Example — daily price-change alerts only:

{
    "storeUrls": ["competitor-store.com"],
    "alertMode": true,
    "deltaOnly": true,
    "minPriceChangePct": 1.0
}

Output fields

Each product is one dataset item:

Field	Type	Description
productId	string	Shopify product ID
handle	string	URL slug of the product
title	string	Product title
productType	string	Shopify product type/category
vendor	string	Brand / vendor name
tags	array	Product tags
publishedAt	string	ISO date the product was published
updatedAt	string	ISO date the product was last updated
url	string	Full product page URL
storeDomain	string	Store hostname (e.g. allbirds.com)
storeUrl	string	Store base URL
featuredImage	string | null	First product image URL
variantCount	integer	Number of variants
lowestPrice	string | null	Lowest price across in-stock variants
currency	null	Not exposed by /products.json — always null (see limitations)
variants	array	Per-variant detail (see below)
priceChanges	array | null	Changed variants in alert mode; null in snapshot mode
changedVariantCount	integer | null	Count of changed variants in alert mode
scrapedAt	string	ISO timestamp of this run

Each item in variants:

Field	Type	Description
variantId	string	Shopify variant ID
title	string	Variant title (e.g. US 9 / Natural White)
sku	string	SKU (empty string if none)
price	string	Current price
compareAtPrice	string | null	Original / crossed-out "compare at" price
available	boolean	In-stock flag
inventoryQuantity	integer | null	Inventory count when the store exposes it

Example item:

{
    "productId": "7845123456789",
    "handle": "mens-natural-wool-runner",
    "title": "Men's Natural Wool Runner",
    "productType": "Shoes",
    "vendor": "Allbirds",
    "tags": ["mens", "running", "wool"],
    "publishedAt": "2024-01-15T10:30:00-05:00",
    "updatedAt": "2026-06-12T08:22:00-05:00",
    "url": "https://allbirds.com/products/mens-natural-wool-runner",
    "storeDomain": "allbirds.com",
    "storeUrl": "https://allbirds.com",
    "featuredImage": "https://cdn.shopify.com/s/files/...",
    "variantCount": 8,
    "lowestPrice": "110.0",
    "currency": null,
    "variants": [
        {
            "variantId": "43891234567890",
            "title": "US 9 / Natural White",
            "sku": "FW22M-WR-NWH-090",
            "price": "110.00",
            "compareAtPrice": "130.00",
            "available": true,
            "inventoryQuantity": 42
        }
    ],
    "priceChanges": [
        {
            "variantId": "43891234567890",
            "title": "US 9 / Natural White",
            "price": "110.00",
            "oldPrice": "130.00",
            "changePercent": -15.38,
            "changeType": "decreased"
        }
    ],
    "changedVariantCount": 1,
    "scrapedAt": "2026-06-14T04:30:00.000Z"
}

In alert mode, priceChanges lists only variants that changed, each with oldPrice, changePercent, and changeType — one of increased, decreased, added (new variant), or new_product (first time the product was seen).

Use cases

• E-commerce store owner — watch your top 5 competitors daily and react when they discount, so you never get undercut without knowing.
• Dropshipper — track supplier Shopify stores for price changes and restocks before you commit a customer order.
• Pricing / category manager — pull a full catalogue snapshot for spreadsheet analysis of a competitor's price architecture and discount depth.
• Deal / arbitrage hunter — detect price drops across multiple stores and flag arbitrage gaps automatically.
• AI agent / data pipeline — feed structured Shopify price data to Claude, Cursor, or your own app via Apify's API or MCP server.

Setting up daily price alerts

1. Set your storeUrls, enable alertMode: true, optionally set minPriceChangePct: 1.
2. Create an Apify Schedule to run the Actor daily.
3. Add a webhook: Slack, email, Make/Zapier, or your database.
4. Each run outputs only products with price changes since the previous run.

Price history is remembered per store. The first run always outputs every product to establish the baseline; subsequent runs output only changes.

Pricing — $1 per 1,000 products

This Actor uses Apify's pay-per-event model. You are charged per product written to the dataset — nothing else.

Event	Price	When charged
shopify-product	$0.001	Each product written to the dataset

• That's $1 per 1,000 products.
• In alert mode, unchanged products are never written and never charged.
• A scheduled run that detects no price changes writes nothing and charges $0.
• No monthly fee, no platform rental on top of these events.

Use from Claude, Cursor & AI agents (MCP)

{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com/sse?actors=bikram07/shopify-price-monitor",
            "headers": {
                "Authorization": "Bearer YOUR_APIFY_TOKEN"
            }
        }
    }
}

Ask your agent: "Check if any prices changed at gymshark.com since yesterday."

Or call the API directly:

curl -X POST "https://api.apify.com/v2/acts/bikram07~shopify-price-monitor/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"storeUrls": ["allbirds.com"], "maxProducts": 100, "alertMode": false}'

FAQ

Is this a subscription? No. It's pay-per-event — you're charged $0.001 per product written ($1 per 1,000 products), and nothing when no products are written. There's no monthly fee and no minimum.

How does the pricing / refund work? You pay only for products actually written to your dataset. In alert mode a run with no price changes writes nothing and costs $0. Billing is handled by the Apify platform; refunds and platform usage are governed by Apify's billing terms.

Does it use official APIs, or is it scraping? It uses Shopify's first-party, public /products.json endpoint — the same JSON Shopify storefronts themselves consume. No HTML parsing, no headless browser, no proxy farm, no Cloudflare bypass.

Does it work on custom domains (not .myshopify.com)? Yes. Any public Shopify store — custom domain like allbirds.com or the default .myshopify.com subdomain — exposes /products.json. The Actor auto-detects and handles both.

How many products can it handle? Up to 50,000 per run (maxProducts: 50000). Large catalogues work fine — pagination is automatic.

Can I monitor multiple stores in one run? Yes. List as many URLs as you want in storeUrls. Price history is tracked separately per store.

What's compareAtPrice? Shopify's "compare at price" is the original, crossed-out reference price shown during sales. The Actor captures it per variant alongside the current price, so you can see both the sale price and the regular price.

What it does NOT do (limitations)

• Public stores only. Password-protected stores return 401/403 on /products.json; the Actor logs a warning and skips them.
• No currency field. Shopify's /products.json does not expose the store currency, so currency is always null. Prices are returned as the store's native numeric strings.
• Catalogue data only. It reads what /products.json exposes (products, variants, prices, availability, images, tags). It does not access checkout, customer, order, or admin data.
• Snapshot cadence, not real-time. Price history is built run-over-run; "changes" are detected between scheduled runs, not as a live stream.
• inventoryQuantity is best-effort. It's included only when the store chooses to expose it on /products.json; otherwise it's null.

Related searches

Shopify price scraper · Shopify competitor price monitor · Shopify price tracker · Shopify product tracker · e-commerce price intelligence · Shopify /products.json API · Shopify price change alert · competitor price monitoring tool · Shopify store scraper API · dropship price tracker

---

Uses the Shopify public storefront /products.json endpoint. Not affiliated with Shopify Inc.