# Shopify Catalog & Change Monitor: Prices, Stock, New Products (`lindenbyte/shopify-catalog-change-monitor`) Actor

Paste Shopify store domains and get their full public product catalog, or only what changed since the last run: new products, price drops, price increases, restocks, sell-outs and removed products. No browser, no login. Pay per result.

- **URL**: https://apify.com/lindenbyte/shopify-catalog-change-monitor.md
- **Developed by:** [Lindenbyte Studio](https://apify.com/lindenbyte) (community)
- **Categories:** E-commerce, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.56 / 1,000 product rows

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## Shopify Catalog & Change Monitor: products, prices, stock and what changed

Paste a list of **Shopify store domains** and get every public product (title, vendor, type, tags, price range, compare-at price, currency, stock flag, dates, image, URL), or schedule it and get **only what changed since the last run**: **new products, price drops, price increases, restocks, sell-outs and removed products**, with the old and new values.

**Step-by-step tutorial:** [Get alerts when a Shopify store drops a price, restocks or adds a product](https://dev.to/lindenbyte/get-alerts-when-a-shopify-store-drops-a-price-restocks-or-adds-a-product-2f3c)

No browser, no login, no proxies needed for most stores. The Actor reads the public `/products.json` catalog feed that Shopify storefronts publish, politely and with an honest user agent.

### What you can do with it

- **Competitor price monitoring**: watch rival stores, get a row the day a price drops or a sale starts.
- **Dropshipping and reselling**: find new arrivals, restocks and sell-outs of products you resell or source.
- **Deal and restock alerts**: schedule hourly/daily, filter by keyword and `price_drop` + `restocked`, push to Slack, Telegram, e-mail, Zapier or Make through Apify integrations.
- **Market research**: catalogs by vendor, product type, price band, sale share, tag usage.
- **Assortment tracking for brands and retailers**: which products does a stockist add or remove, which ones sell out first.

### How it works

1. For each store it reads `/products.json?limit=250&page=N` page by page until the catalog ends (or your product cap is reached), then makes one request to the public `/meta.json` for the shop currency.
2. **Catalog mode** outputs the products. **Changes mode** compares them with the snapshot from the previous run (stored in a named key-value store in your account, keyed by your monitor name) and outputs only the differences.
3. Stores that are not Shopify, are password-protected, block automated access or have no products get a **free status row** with a clear reason. A run only fails if no store at all could be read.

### Input

| Field | What it does |
|---|---|
| `stores` | Domains or URLs. A collection URL (`https://store.com/collections/sale`) limits that store to the collection. |
| `mode` | `catalog` (all products) or `changes` (only differences since last run; first run records a baseline). |
| `stateKey` | Monitor name for Changes mode. Different names keep separate snapshots. |
| `maxProductsPerStore` | Cost cap per store per run (default 500, max 50,000). |
| `collection` | Optional collection handle applied to every store. |
| `keywords`, `vendors`, `productTypes`, `inStockOnly`, `onSaleOnly` | Filters. Filtered-out products are free. |
| `changeTypes` | Which changes to report: `new`, `price_drop`, `price_increase`, `restocked`, `sold_out`, `removed`. |
| `minPriceChangePercent` | Ignore small price moves. |
| `includeCurrency`, `respectRobotsTxt`, `requestDelayMs` | Currency lookup, robots.txt check (default on), politeness delay (default 700 ms). |
| `proxyConfiguration` | Optional; used only for a store that answers 403/429 to direct requests. |

### Output

**Product row** (charged as `product-row`), real example from allbirds.com:

```json
{
  "rowType": "product",
  "store": "allbirds.com",
  "storeUrl": "https://allbirds.com",
  "currency": "USD",
  "id": "7292464824400",
  "handle": "womens-wool-cruiser-port-port-sole",
  "title": "Women's Wool Cruiser - Port (Port Sole)",
  "vendor": "Allbirds",
  "productType": null,
  "tags": ["11/3/26 DROP", "allbirds::hue => red", "DNAM BRANDS"],
  "url": "https://allbirds.com/products/womens-wool-cruiser-port-port-sole",
  "image": "https://cdn.shopify.com/s/files/1/1104/4168/files/A12858W090-PORT_SIDE_TRANSPARENT.png?v=1793836076",
  "minPrice": 120,
  "maxPrice": 120,
  "compareAtPrice": null,
  "onSale": false,
  "variantsCount": 13,
  "availableVariants": 3,
  "available": true,
  "createdAt": "2026-02-04T17:37:18-08:00",
  "updatedAt": "2026-11-16T15:08:13-08:00",
  "publishedAt": "2026-11-04T15:48:27-08:00",
  "scrapedAt": "2026-11-16T23:08:12.904Z"
}
```

**Change row** (charged as `change-detected`):

```json
{
  "rowType": "change",
  "changeType": "price_drop",
  "store": "allbirds.com",
  "title": "Women's Wool Cruiser - Port (Port Sole)",
  "url": "https://allbirds.com/products/womens-wool-cruiser-port-port-sole",
  "currency": "USD",
  "oldPrice": 140,
  "newPrice": 120,
  "priceChangePct": -14.29,
  "oldAvailable": true,
  "newAvailable": true,
  "detectedAt": "2026-11-16T23:10:02.114Z"
}
```

A product whose price and stock both changed produces two change rows. Prices are the lowest variant price (`minPrice`); `compareAtPrice` is the highest compare-at price of any variant.

**Status row** (free): `status` is `baseline-recorded`, `not-shopify`, `blocked`, `password`, `rate-limited`, `robots-disallowed`, `no-products`, `empty-catalog` or `error`, with a `detail`.

### Pricing

Pay per result: a small fee when the run starts, a fee per product row (Catalog mode) and a fee per detected change (Changes mode). Status rows, filtered-out products and unchanged products are free. Set a maximum charge per run in the Apify console and the Actor stops cleanly when it is reached; changes not delivered because of the limit are reported on the next run.

### Limits (please read)

- **Public storefront data only.** Only what the store publishes in `/products.json` and `/meta.json`. No customer, order or inventory-quantity data. `available` is the storefront in-stock flag, not a stock count.
- Some stores disable or block `/products.json` (403/404) or sit behind bot protection; they are reported as free status rows. Stores that answer only on `www` or only on the bare domain are handled automatically.
- Prices are those shown to a default (usually US/home-market) visitor. Stores with market-specific pricing may show other prices to visitors in other countries.
- Stores with more products than `maxProductsPerStore`: Changes mode compares only the first products read and turns `removed` events off for that run. Because the feed order can change, raise the cap to cover the whole catalog for reliable change tracking.
- A product that disappears from the feed is reported as `removed`; stores also unpublish and re-publish products, which then shows as removed then new.
- The snapshot is updated on every Changes run. Use different `stateKey` values for separate monitors.
- Respects `robots.txt` by default, modest concurrency (3 stores at a time) and a delay between requests to the same store.

### Tips

- Cheap start in Changes mode: the first run only records a baseline and costs just the start fee.
- Deal alerts: `changeTypes` = `price_drop`, `restocked`, with `minPriceChangePercent` 10, scheduled hourly.
- Large stores: filter by `collection` (for example `sale`) to track only what you care about.

Not affiliated with Shopify Inc. or with any of the stores you monitor. "Shopify" and all store names are trademarks of their owners. This Actor reads only publicly available, unauthenticated storefront endpoints.

### More from Lindenbyte

- [Bulk Website Tech Stack Detector (7,000+ technologies)](https://apify.com/lindenbyte/bulk-website-tech-stack-detector): Detect the CMS, ecommerce platform, analytics and frameworks behind a list of websites.
- [Sitemap Monitor: All URLs + New Pages Since Last Run](https://apify.com/lindenbyte/sitemap-monitor-new-pages): Extract every URL from a site's XML sitemaps and get only the pages added since the last run.
- [Bulk Website Screenshots + PDF + Visual Change Detection](https://apify.com/lindenbyte/bulk-website-screenshots): Full-page or viewport screenshots (and PDFs) of many URLs, with optional visual change detection.
- [Google Ads Transparency Center Scraper: Competitor Ads](https://apify.com/lindenbyte/google-ads-transparency-scraper): Every ad an advertiser runs on Google Search, YouTube and Display, from the Ads Transparency Center.

See all our Actors at [apify.com/lindenbyte](https://apify.com/lindenbyte).

# Actor input Schema

## `stores` (type: `array`):

Store domains (allbirds.com) or URLs (https://www.gymshark.com). A collection URL such as https://example.com/collections/sale limits the run to that collection. Stores that are not Shopify, are password-protected or block automated access get a free status row instead of an error.

## `mode` (type: `string`):

Catalog outputs the current products. Changes compares with the snapshot of the previous run (kept in a named key-value store in your account) and outputs only the differences. The first Changes run only records a baseline and outputs nothing but a free status row.

## `stateKey` (type: `string`):

Changes mode only. Monitors with different names keep separate snapshots (one per client, schedule or Slack channel). Change it to start a fresh baseline. Leave empty to use the name "default".

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

Cost cap: at most this many products are read per store (250 per request). In Changes mode a store larger than the cap is only partly compared and 'removed' events are switched off for it.

## `collection` (type: `string`):

Only read this collection for every store, e.g. 'sale' or 'mens-shoes' (the last part of /collections/<handle>). Leave empty for the whole catalog. A collection URL in the store list overrides this for that store.

## `keywords` (type: `array`):

Optional. Case-insensitive; matched against title, handle, tags, vendor and product type. Filtered-out products are free.

## `vendors` (type: `array`):

Optional. Exact vendor/brand names (case-insensitive), useful for multi-brand stores.

## `productTypes` (type: `array`):

Optional. Exact product type names (case-insensitive), e.g. 'Sneakers'.

## `inStockOnly` (type: `boolean`):

Keep only products with at least one variant available. In Changes mode this filters the reported changes (the snapshot still covers every product, so sell-outs are never missed).

## `onSaleOnly` (type: `boolean`):

Keep only products whose compare-at price is higher than the current price.

## `changeTypes` (type: `array`):

Changes mode only. Which kinds of change are output (and charged). Default is all six. Example: price_drop + restocked for a deal alert.

## `minPriceChangePercent` (type: `number`):

Changes mode only. Ignore price drops/increases smaller than this percentage of the old price. 0 reports every change.

## `includeCurrency` (type: `boolean`):

One extra free request per store to the public /meta.json to fill the currency field (ISO code). Turn off to save a request.

## `respectRobotsTxt` (type: `boolean`):

Skip a store whose robots.txt disallows the products endpoint for automated clients (reported as a free status row). Shopify's default robots.txt allows it.

## `requestDelayMs` (type: `integer`):

Politeness delay between requests to the same host. At most 3 stores are read in parallel.

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

Optional. Requests go out directly first; only if a store answers 403/429 to us, that store is retried through this proxy. Leave off for most stores.

## Actor input object example

```json
{
  "stores": [
    "allbirds.com",
    "gymshark.com"
  ],
  "mode": "catalog",
  "maxProductsPerStore": 500,
  "keywords": [],
  "vendors": [],
  "productTypes": [],
  "inStockOnly": false,
  "onSaleOnly": false,
  "changeTypes": [
    "new",
    "price_drop",
    "price_increase",
    "restocked",
    "sold_out",
    "removed"
  ],
  "minPriceChangePercent": 0,
  "includeCurrency": true,
  "respectRobotsTxt": true,
  "requestDelayMs": 700,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

## `changes` (type: `string`):

No description

## `runSummary` (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 = {
    "stores": [
        "allbirds.com",
        "gymshark.com"
    ],
    "keywords": [],
    "vendors": [],
    "productTypes": [],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("lindenbyte/shopify-catalog-change-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 = {
    "stores": [
        "allbirds.com",
        "gymshark.com",
    ],
    "keywords": [],
    "vendors": [],
    "productTypes": [],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("lindenbyte/shopify-catalog-change-monitor").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 '{
  "stores": [
    "allbirds.com",
    "gymshark.com"
  ],
  "keywords": [],
  "vendors": [],
  "productTypes": [],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call lindenbyte/shopify-catalog-change-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,lindenbyte/shopify-catalog-change-monitor"
        }
    }
}
```

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/QBXOMlvIcCQQShhAD/builds/WpKHBm6QHUQawiK4e/openapi.json
