# Shopify Competitor Store Watcher: Prices, New Products & Stock (`vanborn_labs/shopify-competitor-store-watcher`) Actor

Watch public Shopify prices, sales & in/out-of-stock (not quantities). First run saves a baseline; later runs emit only changes. No password or headless stores.

- **URL**: https://apify.com/vanborn_labs/shopify-competitor-store-watcher.md
- **Developed by:** [Van Born Labs](https://apify.com/vanborn_labs) (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

$0.80 / 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.

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 Competitor Store Watcher: Prices, New Products & Stock

Know the moment a competitor changes something. Point this Actor at any public Shopify store and get **prices, sales, and in/out-of-stock status**, plus a clear list of **what changed since your last run**: new launches, removed products, price drops, price increases, items back in stock and items that sold out. Schedule it daily and you have a competitor price tracker without spreadsheets or browser tabs.

No login, no Shopify app, no API key. **$0.0008 per product row actually emitted** ($0.80 per 1,000). There is no per-store fee. Failed stores are never billed.

This Actor is **not affiliated with, endorsed by, or sponsored by Shopify Inc.** It reads publicly available storefront information only. No customer data, no checkout, no logins. Make sure your use complies with the store's terms and applicable law.

### Limitations (read these first)

- **Stock is binary.** You get in-stock or sold-out per variant, not exact quantities. This Actor never reports inventory counts.
- **Removed-product detection is reliable only when `catalogComplete` is true.** That flag is on the store summary when the whole catalog (or the whole collection) was read in that run. If *Max products per store* cuts the catalog short, `catalogComplete` is false and removed products are not reported for that run.
- **Password-protected and headless stores are not supported.** Stores that hide their public catalog or require a password appear as a free `error` row.

### What you get

- 🛍️ **Catalog snapshot**: title, URL, vendor, product type, tags, image, lowest and highest price, compare-at (was) price, discount %, created / published / updated dates.
- 🎯 **Variants**: every size and color with SKU, price, was-price and in-stock / sold-out flag (not quantities).
- 🔔 **Change detection between runs**: `new`, `removed`, `changed` or `unchanged` on every product, with a list of changes such as `price_drop` (old, new, %), `price_increase`, `back_in_stock`, `out_of_stock`, `variant_added`, `variant_removed`, `compare_at_changed`, `title_changed`. On the first run, every product is tagged `baseline`.
- 📊 **One summary per store** (free): product count, in stock vs sold out, products on sale, average / min / max price, counts of new, removed and repriced products, and the `catalogComplete` flag.
- 🗂️ **Collections**: paste a collection URL (for example `/collections/sale`) to watch only that part of the store.
- 💸 **Default output is only changes**: after the first run, a quiet day costs nothing unless something actually changed. **The first run for each store always emits the full baseline** (the store summary says so with `firstRun: true` and a short note). Choose *Full catalog every run* when you want every product every time.

### Use cases

- **Competitor price monitoring** for DTC brands: see every markdown the day it happens.
- **Launch tracking**: get the new products a rival added this week.
- **Stock-out alerts**: spot when a competitor's best seller sells out, and push your ads while it is gone.
- **Agencies & analysts**: weekly catalog and pricing reports for many stores at once.
- **Market research**: export a whole niche (supplements, apparel, coffee, cosmetics) to compare price points.

### How to use it

1. Paste one or more **public** store addresses into **Shopify store URLs** (home page, collection page, or any product page of the store). Password-protected and headless stores will not work.
2. Run it once. **The first run emits the full catalog as a baseline and saves it**, even when Output is set to *Only changes*.
3. Run it again later, or put it on a **schedule** (Apify Console → Schedules, daily is typical). From the second run on, only new, removed and changed products are returned, unless you pick *Full catalog every run*.
4. Optional: connect an Apify integration (Slack, email, webhook, Google Sheets, Zapier, Make) to get alerts. Keep *Max products per store* above the store's product count so `catalogComplete` stays true and removed products are detected.

Your baseline is remembered in your own Apify account under the **Watchlist name** (default `shopify-store-watcher`). Use different names for separate watchlists, and *Start a fresh baseline* to reset.

### Input example

Default monitoring (only changes). The first run still returns the full baseline:

```json
{
 "storeUrls": ["https://www.deathwishcoffee.com", "https://partakefoods.com"],
 "outputMode": "changes",
 "maxProductsPerStore": 1000,
 "includeVariants": true
}
```

The Console prefill (small first-run check, 50 products on tentree.com):

```json
{
 "storeUrls": ["https://www.tentree.com"],
 "maxProductsPerStore": 50
}
```

Full catalog every run, one collection:

```json
{
 "storeUrls": ["https://www.brooklinen.com/collections/sheets-bedding"],
 "outputMode": "all",
 "watchlistName": "bedding-competitors"
}
```

### Output example

A product whose price dropped:

```json
{
 "kind": "product",
 "storeDomain": "www.deathwishcoffee.com",
 "title": "Valhalla Java Brewed for Battle Bundle",
 "url": "https://www.deathwishcoffee.com/products/...",
 "minPrice": 50.99,
 "maxPrice": 50.99,
 "currency": "USD",
 "onSale": true,
 "maxDiscountPct": 16.7,
 "inStock": true,
 "changeStatus": "changed",
 "changes": [
 {"type": "price_drop", "variantTitle": "Default Title", "old": 61.19, "new": 50.99, "changePct": -16.7},
 {"type": "back_in_stock", "variantTitle": "Default Title"}
 ]
}
```

Store summary:

```json
{
 "kind": "store_summary",
 "storeName": "Death Wish Coffee",
 "productsFound": 161,
 "productsInStock": 159,
 "productsOnSale": 57,
 "avgPrice": 26.45,
 "newProducts": 1,
 "removedProducts": 1,
 "priceDrops": 1,
 "priceIncreases": 1,
 "catalogComplete": true,
 "firstRun": false
}
```

### Pricing

- **$0.0008 per product row** ($0.80 per 1,000) written to your dataset. You are charged only for rows actually emitted.
- **No per-store fee.** Store summaries and error rows are free.
- **Never billed**: invalid URLs, stores that are not Shopify, password-protected stores, headless storefronts without a public catalog, empty collections, and stores that could not be reached. They appear as free `error` rows so you know what to fix.
- Set a maximum charge per run in Apify if you want a hard cap. The Actor charges only rows that fit under the cap and saves the baseline, together with the list of rows it still owes you, before charging anything.
- Rows that did not fit under your cap are kept exactly as they were detected (same change type, old and new values and detection time) and delivered once on the next run, marked `heldBack: true`. This includes baseline rows. If the product changed in the meantime, the change follows as its own row. Every billed row carries a unique `deliveryId`. If a run stops in the middle of delivery, the next run checks which rows already reached that run's dataset and delivers only the missing ones, in their original order, so a row is never charged twice. If that dataset can no longer be read, the rows in doubt are never charged again; later rows of the same product wait behind them, and after 6 days from the first uncertain attempt they are dropped and listed on the store summary (`rowsDroppedUnconfirmed`, `droppedDeliveryIds`).
- Runs on the same watchlist never overlap: each run takes a lock for its watchlist (a small request queue named `<watchlist>-lock` in your account) before it reads any store. A second run waits up to 5 minutes and otherwise stops with free `watchlist_busy` error rows. Error rows say exactly what was billed (`billed`, `rowsBilled`) and how many rows have an unknown billing outcome because the platform did not acknowledge them (`billingOutcomeUnknownRows`; checked on the next run, never billed twice). In All mode, unchanged rows skipped at your charge limit are counted in `unchangedRowsSkipped`.

Example: watching 10 stores daily in the default *Only changes* mode costs $0.0008 per changed product. A quiet day with no changes costs $0. The first run, which emits the baseline, costs $0.0008 per product in the catalog (1,000 products = $0.80).

### FAQ

**Does it work on every Shopify store?** It works on stores that show their catalog publicly. Password-protected stores, headless storefronts that do not expose a public catalog, and stores that turned their public catalog off are reported as free error rows.

**Why do I get the full catalog on the first run even in "only changes" mode?** The first run creates the baseline. Changes are always relative to your previous run with the same watchlist name. From the second run on, only changes are emitted (unless you pick *Full catalog every run*).

**How are removed products detected?** Only when the whole catalog was read in that run (`catalogComplete: true` on the store summary). If you cap *Max products per store* below the store's size, removed-product detection is switched off for that run.

**Do I get stock quantities?** No. Public storefronts publish in-stock / sold-out per variant, not exact quantities, so that is what you get.

**Is it polite to the stores?** Yes. It reads at a gentle pace with pauses between pages, backs off when a store asks it to slow down, and respects robots.txt.

### Notes

- Currency comes from the store's public metadata, as shown on its storefront, and may be absent on some stores. Prices are in that currency when it is available. If the store's currency changes between runs, the product shows `currency_changed` and its prices are not compared (no false price drops or increases). A baseline saved by version 1.0 did not record the currency, so on the first run after upgrading, prices are re-baselined (stock, variants and titles are still compared) and price changes are reported again from the following run.
- Connections go directly to the store and are pinned to the public IP address the Actor has just checked. Apify Proxy is used only if you turn on both *Proxy* and *Allow Apify Proxy (unpinned)*. Through the proxy, the proxy resolves the store's hostname itself, so that pinning cannot apply; the Actor still requests only https URLs, verifies the store's TLS certificate, re-checks every redirect and keeps no cookies.
- If a run stops at your maximum charge, the store summary shows `rowsDelivered` and `rowsNotDelivered`; the rows that were not delivered come in the next run. If the baseline cannot be saved (for example a store too large for one key-value record), that store fails with `snapshot_too_large` or `snapshot_save_failed` and nothing is billed for it.
- Error rows for invalid inputs show only `inputIndex` and the store hostname, never the full URL you typed (it might contain credentials or tokens).
- The default 512 MB of memory is enough for typical catalogs (the default cap is 1,000 products). A very large first-run baseline with *Include product description* turned on may need more memory; raise it in the run options if a big catalog runs out of memory.
- This tool is not affiliated with Shopify Inc. or with the stores you watch.

### Related

See the [Van Born Labs website](https://vanbornlabs.com) and the [Van Born Labs Apify profile](https://apify.com/vanborn_labs) for more e-commerce tools, including Merchant Feed Doctor for fixing Google Merchant Center feeds.

### Feedback

Missing a field or a change type? Open an issue on the Issues tab, or email <vanbornlabs@gmail.com>. Useful requests are usually added within days.

# Actor input Schema

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

Public Shopify store home pages (https://colourpop.com) or a collection page (https://colourpop.com/collections/lips) to watch only that collection. Password-protected and headless stores without a public catalog are not supported.

## `outputMode` (type: `string`):

Default is only changes, which is the right mode for scheduled monitoring. The first run for each store always emits the full catalog as a baseline and says so in the store summary (firstRun=true). Later runs emit only new, removed and changed products. Choose 'Full catalog every run' when you want every product on every run.

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

Cap on products read from each store. Removed-product detection is reliable only when the full catalog is read (catalogComplete=true in the store summary). Keep this above the store's product count for monitoring.

## `includeVariants` (type: `boolean`):

Add each variant (size, color) with SKU, price, compare-at price and in-stock / sold-out status. Shopify does not publish exact quantities, so this Actor never reports inventory counts.

## `includeDescription` (type: `boolean`):

Add the plain-text product description.

## `watchlistName` (type: `string`):

Where your baseline is remembered between runs (a named key-value store in your account). Use different names to keep separate watchlists. Lowercase letters, digits and hyphens.

## `saveSnapshot` (type: `boolean`):

Turn off for a one-off look that does not change your baseline.

## `resetBaseline` (type: `boolean`):

Ignore what was saved before and treat this run as the first one.

## `requestDelaySecs` (type: `number`):

Polite pause between catalog pages of the same store.

## `maxConcurrency` (type: `integer`):

How many stores are read at the same time.

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

Optional and off by default. Apify Proxy is used only when 'Allow Apify Proxy (unpinned)' below is also turned on.

## `allowUnpinnedProxy` (type: `boolean`):

Use Apify Proxy for store requests. Without the proxy, every connection is pinned to the public IP address the Actor has just checked. Through the proxy, the proxy resolves the store's hostname itself, so that pinning cannot apply (https only and TLS verification still apply). Turn on only if a store blocks direct requests and you accept this.

## Actor input object example

```json
{
  "storeUrls": [
    "https://www.tentree.com"
  ],
  "outputMode": "changes",
  "maxProductsPerStore": 50,
  "includeVariants": true,
  "includeDescription": false,
  "watchlistName": "shopify-store-watcher",
  "saveSnapshot": true,
  "resetBaseline": false,
  "requestDelaySecs": 1,
  "maxConcurrency": 2,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "allowUnpinnedProxy": false
}
```

# Actor output Schema

## `results` (type: `string`):

One item per product (with change status), one store_summary per store, and an error row for any store that could not be checked.

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

JSON counters stored as RUN_SUMMARY.

# 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.tentree.com"
    ],
    "maxProductsPerStore": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("vanborn_labs/shopify-competitor-store-watcher").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.tentree.com"],
    "maxProductsPerStore": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("vanborn_labs/shopify-competitor-store-watcher").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 '{
  "storeUrls": [
    "https://www.tentree.com"
  ],
  "maxProductsPerStore": 50
}' |
apify call vanborn_labs/shopify-competitor-store-watcher --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,vanborn_labs/shopify-competitor-store-watcher"
        }
    }
}
```

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/EpGEEVfH3NqjHGVbe/builds/F4YpueeORqSHa9A8a/openapi.json
