# Price Drop & Restock Tracker for Shopify & WooCommerce (`mrslm_data/store-change-watcher`) Actor

Track catalog changes across Shopify and WooCommerce stores, including price changes, restocks, sold-out items, and new or removed products.

- **URL**: https://apify.com/mrslm_data/store-change-watcher.md
- **Developed by:** [MRSLM Data](https://apify.com/mrslm_data) (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.80 / 1,000 change founds

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

## Price Drop & Restock Tracker for Shopify & WooCommerce

**Put any Shopify or WooCommerce store on a schedule and get only what changed since the last run: price drops, price increases, back in stock, sold out, new and removed products. $0.20 per 1,000 products checked + $1 per 1,000 changes.**

Monitor Shopify and WooCommerce stores for price changes, restocks and catalog changes. Export change rows to CSV to review old and new values.

No full catalog dumps to diff yourself. The Actor remembers each store's last state and saves one row per change, with old and new values side by side.

### Quick start

1. Press **Start**. The form is already filled with this example input, so the first run returns real rows in under a minute:

```json
{
  "stores": [
    "allbirds.com",
    "porterandyork.com"
  ],
  "maxProductsPerStore": 200
}
```

2. Swap in your own values, or call the Actor through the Apify API, Make, Zapier, n8n or the Python/JS clients with the same JSON.
3. Download the results as JSON, CSV or Excel from the **Output** tab, or schedule the run to repeat.

**Full guide: How to Monitor a Competitor's Shopify or WooCommerce Store for Price Drops and Stock Changes**

### What the Store Change Watcher does

You give the Actor store domains. It detects whether each store runs on Shopify or WooCommerce and reads its public catalog, down to each variant's price, compare-at price and stock. It then compares every variant with the snapshot saved by the previous run of the same **watchlist** and saves one row per change: `price_drop`, `price_increase`, `back_in_stock`, `out_of_stock`, `new_product` or `removed`. Each row has the store, product and variant title, SKU, link, image, currency, old and new price, the percentage change, old and new stock status, the compare-at price and both check times.

By default it watches price drops, back in stock, out of stock and new products. You can add price increases and removed products, ignore small price moves with **minPriceChangePercent**, and get one free status row for stores where nothing changed.

- Only changes are saved, so the output stays short.
- Variant level: a single size selling out is caught.
- Works on Shopify and WooCommerce, detected automatically.

### Who it is for

- **Ecommerce brands**: see when a rival discounts or runs out of stock, and react the same day.
- **Resellers and deal hunters**: get the price drops and restocks from stores you follow.
- **Pricing and category managers**: keep a running log of competitor price moves.
- **Agencies**: run a separate watchlist for each client's competitor set.

### Real example: a Shopify and a WooCommerce store checked after three days

Say you sell shoes and food online and want to know what changed at Allbirds and Porter & York since your last check. You keep the default watch list and read up to 200 products per store to keep the run small. The same watchlist had last checked both stores on 27 October 2026.

#### Step 1: Enter the input

Open the [Store Change Watcher](https://apify.com/mrslm_data/store-change-watcher) in Apify Console, switch the input form to **JSON** and paste this. It is the exact input used for the run in this guide:

```json
{
  "stores": [
    "allbirds.com",
    "porterandyork.com"
  ],
  "maxProductsPerStore": 200
}
```

What each setting does:

- `stores`: two store domains. The platform is detected for you.
- `maxProductsPerStore`: 200, so only part of Allbirds' catalog is read. Porter & York has fewer than 200 products, so its whole catalog was read.

#### Step 2: Run it

Press **Start**. On 30 October 2026 this input finished with status `SUCCEEDED` in about 10 seconds and saved 13 rows to the run's dataset. The run was charged 270 `product-checked` events, 12 `change` events plus one start event, so the bill was $0.066 on the Free/Bronze tier. Allbirds: 200 products checked (2,359 variants watched), 12 changes. Porter & York: all 70 products checked, no changes, so it got one free `no_changes` row. In total the run charged 270 `product-checked` events and 12 `change` events.

#### Step 3: Read the output

Here are the first rows of the real dataset, cut to the most useful columns:

| changeType | store | productTitle | variantTitle | oldPrice | compareAtPrice | isInStock |
|---|---|---|---|---|---|---|
| out_of_stock | allbirds.com | Women's Wool Runner Mizzle - Natural Grey (Cream… | 5 | 62 | 125 | no |
| out_of_stock | allbirds.com | Women's Dasher NZ Relay - Seagrass (Parchment So… | 9 | 135 |  | no |
| out_of_stock | allbirds.com | Women's Tree Dasher 2 - Utility - Blizzard/Deep… | 10.5 | 100 | 145 | no |
| out_of_stock | allbirds.com | Women's Tree Runner Go - Blizzard (Blizzard Sole… | 5.5 | 89 | 120 | no |
| out_of_stock | allbirds.com | Smallbirds Wool Loungers - Big Kids - Natural Wh… | 2Y | 65 |  | no |
| out_of_stock | allbirds.com | Men's Varsity Airy - Blizzard (Blizzard Sole) | 8 | 120 |  | no |
| out_of_stock | allbirds.com | Men's Wool Runner NZ Waterproof - Dark Navy (Nat… | 10 | 150 |  | no |
| out_of_stock | allbirds.com | Women's Dasher NZ - Anthracite (Dark Anthracite… | 6 | 140 |  | no |
| out_of_stock | allbirds.com | Women's Tree Breezer - Spice (Spice Sole) | 9 | 105 |  | no |
| out_of_stock | allbirds.com | Men's Wool Runner NZ Waterproof - Medium Grey (N… | 9.5 | 150 |  | no |
| out_of_stock | allbirds.com | Women's Cruiser Slip On - Mushroom (Mushroom Sol… | 6 | 100 |  | no |
| out_of_stock | allbirds.com | Women's Varsity - Multi (Natural White Sole) | 8 | 120 |  | no |
| no_changes | porterandyork.com |  |  |  |  |  |

And one full row as JSON (long text shortened with …):

```json
{
  "changeType": "out_of_stock",
  "store": "allbirds.com",
  "platform": "shopify",
  "productTitle": "Women's Wool Runner Mizzle - Natural Grey (Cream Sole)",
  "variantTitle": "5",
  "sku": "WW1WNCW050",
  "url": "https://allbirds.com/products/womens-wool-runner-mizzles-natural-grey?variant=29113511215184",
  "currency": "USD",
  "previousCheckedAt": "2026-10-27T23:21:00.574Z",
  "checkedAt": "2026-10-30T16:12:38.601Z",
  "oldPrice": 62,
  "newPrice": 62,
  "priceChangePercent": null,
  "wasInStock": true,
  "isInStock": false,
  "compareAtPrice": 125
}
```

What changed in three days:

- **All 12 Allbirds changes were sell-outs of single sizes.** For example, size 5 of the Women's Wool Runner Mizzle in Natural Grey, size 9 of the Women's Dasher NZ Relay in Seagrass and size 10 of the Men's Wool Runner NZ Waterproof in Dark Navy went from in stock to out of stock. Each product as a whole is still listed; only that variant ran out.
- **No price drops in this slice.** None of the 2,359 variants read had a lower price than three days earlier, and no new products appeared in it.
- **Some sold-out sizes were already on sale.** Three of the 12 have a compare-at price above the selling price: the Wool Runner Mizzle at $62 (was $125), the Tree Dasher 2 Utility at $100 (was $145) and the Tree Runner Go at $89 (was $120). Sizes selling out at a discount are a sign that clearance stock is running down.
- **Porter & York did not change.** All 70 products had the same prices and stock, and the free `no_changes` row confirms the store was checked.

### How the comparison works

After each run the Actor saves a snapshot of every variant it read in a key-value store named `store-change-watcher-state` in your own Apify account, under `<watchlistName>--<store>`. The next run of the same watchlist compares with that snapshot. The very first run of a watchlist has nothing to compare with, so it saves a baseline and adds a free `baseline_saved` row for each store.

Use a separate `watchlistName` for each schedule or client, so a weekly run never compares with another schedule's daily snapshot. When a catalog is only partly read, because of **maxProductsPerStore** or an error, the Actor keeps the old entries it did not see, so they are not reported as new products later, and it skips `removed` alerts for that store. Removed products are only reported after a full, clean read.

### Output fields

Each row in the dataset has these fields. The example column shows a value from the run above.

| Field | What it means | Example from this run |
|---|---|---|
| `changeType` | price_drop, price_increase, back_in_stock, out_of_stock, new_product or removed; or the free status rows baseline_saved and no_changes. | out_of_stock |
| `store / platform` | Store domain and detected platform. | allbirds.com / shopify |
| `productTitle / variantTitle / sku` | The product, the variant (for example a size) and its SKU. | Women's Wool Runner Mizzle - Natural Grey (Cream Sole) / 5 / WW1WNCW050 |
| `url / imageUrl` | Product link and image. | https://allbirds.com/products/womens-wool-runner-mizzles-nat… / https://cdn.shopify.com/s/files/1/1104/4168/files/WW1MNCW_SH… |
| `currency` | Store currency. | USD |
| `oldPrice / newPrice / priceChangePercent` | Price before and after, and the change in percent (negative for drops). | 62 / 62 / (empty in this run) |
| `wasInStock / isInStock` | Stock status before and after. | yes / no |
| `compareAtPrice` | The store's "was" price, if it shows one. | 125 |
| `previousCheckedAt / checkedAt` | Time of the previous check and of this one. | 2026-10-27T23:21:00.574Z / 2026-10-30T16:12:38.601Z |
| `productsChecked / itemsWatched` | On status rows only: products read and variants watched. | 70 / 70 |

### Export store changes to CSV, Excel or Google Sheets

Every run saves its rows to a dataset, and a dataset can be downloaded in any common format. You do not need to write code for this.

**From Apify Console.** Open the run, go to the **Output** tab and click **Export**. Pick CSV, Excel (XLSX), JSON, XML, HTML or RSS. You can tick only the columns you want, for example `checkedAt`, `changeType`, `store`, `productTitle`, `variantTitle`. Nested values such as lists are flattened into columns like `changeType` in CSV and Excel.

**From a URL.** The same export is a plain HTTPS link. Replace `<DATASET_ID>` with the dataset ID shown on the run's Storage tab:

```bash
## CSV with just the columns you need
curl -H "Authorization: Bearer $APIFY_TOKEN" \
  "https://api.apify.com/v2/datasets/<DATASET_ID>/items?format=csv&clean=1&fields=checkedAt,changeType,store,productTitle,variantTitle,oldPrice,newPrice,priceChangePercent,isInStock,url" -o store-changes.csv

## Excel
curl -H "Authorization: Bearer $APIFY_TOKEN" \
  "https://api.apify.com/v2/datasets/<DATASET_ID>/items?format=xlsx&clean=1" -o store-changes.xlsx
```

**Into Google Sheets.** You have three good options:

1. **One-off:** download the CSV and use **File > Import > Upload** in Google Sheets. Choose "Replace current sheet" to refresh an existing tab.
2. **Automatic, no code:** in Make, Zapier or n8n, use the Apify app's "Watch Actor runs" (or "Run Actor") trigger, then "Get dataset items", then the Google Sheets "Add row" action. Every scheduled run then lands in your sheet. Apify's own [Google Sheets Import & Export](https://apify.com/lukaskrivka/google-sheets) Actor can also append a dataset to a sheet, and you can chain it to this Actor's runs with an integration.
3. **Formula:** `=IMPORTDATA("https://api.apify.com/v2/actor-tasks/<USERNAME>~<TASK_NAME>/runs/last/dataset/items?status=SUCCEEDED&format=csv&token=<YOUR_TOKEN>")` always pulls the latest successful run of a saved task. The token sits in the formula, so anyone who can open the sheet can see it. Only use this in a private sheet.

### Schedule it to run every day at 7 AM

The watcher is built to run on a schedule: each run reports what changed since the last one. Daily is right for most stores; for flash sales or limited drops run it every few hours. Add a Slack or email notification on the task so the changes come to you.

1. In the Actor's input form, set up the input from Step 1 and click **Save as new task**. Give it a clear name such as `competitor-watch-daily`.
2. Go to **Schedules > Create new**, set the cron expression to `0 7 * * *` and pick your timezone, so it runs every day at 7 AM.
3. Add the task to the schedule and save. Each run gets its own fresh dataset.
4. Optional: on the task's **Integrations** tab, add a webhook, Slack or email notification for "Run succeeded", or connect Make, Zapier or n8n, so the new rows go where you need them.

To fetch the newest results without looking up a run ID, use the task's last-run link: `https://api.apify.com/v2/actor-tasks/<USERNAME>~competitor-watch-daily/runs/last/dataset/items?status=SUCCEEDED&format=json`.

### Call it from the API (Python, JavaScript or curl)

You can start the Actor from your own code with the official Apify clients. Put your API token (Console > Settings > API & Integrations) in an environment variable called `APIFY_TOKEN` rather than in the code.

**Python** (`pip install "apify-client>=3"`). Tested with apify-client 3.4:

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run_input = {
    "stores": [
        "allbirds.com",
        "porterandyork.com"
    ],
    "maxProductsPerStore": 200
}

run = client.actor("mrslm_data/store-change-watcher").call(run_input=run_input)

## apify-client 3.x returns a Run object, so use run.default_dataset_id
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item["changeType"], item["productTitle"])
```

In apify-client 3.x, `call()` returns a typed object. Older examples that use `run["defaultDatasetId"]` were written for 1.x and 2.x and fail in 3.x with `TypeError: 'Run' object is not subscriptable`.

**JavaScript / Node.js** (`npm install apify-client`):

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const input = {
    "stores": [
        "allbirds.com",
        "porterandyork.com"
    ],
    "maxProductsPerStore": 200
};

const run = await client.actor('mrslm_data/store-change-watcher').call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, items[0]);
```

**curl**, one request that runs the Actor and returns the rows as CSV (it waits up to 5 minutes, so keep the input small):

```bash
curl -X POST "https://api.apify.com/v2/acts/mrslm_data~store-change-watcher/run-sync-get-dataset-items?format=csv" \
  -H "Authorization: Bearer $APIFY_TOKEN" -H "Content-Type: application/json" \
  -d '{"stores": ["allbirds.com", "porterandyork.com"], "maxProductsPerStore": 200}' -o store-changes.csv
```

### What it costs

The Actor uses pay-per-event pricing. **Product checked**: $0.20 per 1,000 on the Free and Bronze tiers, $0.18 on Silver and $0.16 on Gold; **Change found**: $1.00 per 1,000 on the Free and Bronze tiers, $0.90 on Silver and $0.80 on Gold. Each run also has a start fee of $0.00005 per GB of memory (one event at the default memory). You are not billed separately for compute on normal runs: the event prices are the whole bill.

#### Price per event

Current pay-per-event prices for this Actor on Apify, by Apify subscription plan:

| Event (per 1,000) | Free / Bronze | Silver | Gold / Platinum / Diamond |
|---|---|---|---|
| Product checked (`product-checked`) | $0.20 | $0.18 | $0.16 |
| Change found (`change`) | $1.00 | $0.90 | $0.80 |
| Actor start (once per run at the default memory, not per 1,000) | $0.00005 | $0.00005 | $0.00005 |

You are charged only for the events in this table: nothing for compute, and nothing for searches that return no rows beyond the start fee.

| Scenario | Free / Bronze | Silver | Gold |
|---|---|---|---|
| The run in this guide (270 products checked, 12 changes found) | $0.066 | $0.0595 | $0.0529 |
| 2 stores of ~500 products, daily (30 runs), ~150 changes | $6.15 | $5.54 | $4.92 |
| 10 stores of ~1,000 products, daily (30 runs), ~1,000 changes | $61.00 | $54.90 | $48.80 |
| 1 store of 200 products, every 6 hours (120 runs), ~200 changes | $5.01 | $4.51 | $4.01 |

To cap spending, set **Maximum cost per run** in the run options (or `maxTotalChargeUsd` in the API). The Actor stops cleanly at the cap and you are never billed past it. On Shopify you pay one `product-checked` event per product, not per variant: Allbirds' 200 products had 2,359 variants but were 200 events. Status rows are free.

### Limits

- Shopify and WooCommerce stores with their public catalog enabled. Other platforms are not supported.
- The first run of a watchlist saves a baseline and reports no changes.
- A store's "was" price is only what the store shows; it is not a verified price history.
- With **maxProductsPerStore** set, only part of a large catalog is compared, and removed-product alerts are skipped for that store.
- Stock is in stock or out of stock as the store publishes it, not a unit count.

### FAQ

**Why did my first run return no changes?**
It saved the baseline. Changes appear from the second run of the same watchlist.

**How do I see price increases too?**
Add `price_increase` to **watch**. Add `removed` for products that disappear.

**Can I ignore tiny price changes?**
Yes. Set **minPriceChangePercent**, for example 5, to skip changes under 5%.

**Can I watch several clients' competitors separately?**
Yes. Give each schedule its own `watchlistName`.

**Can I get the whole catalog instead of changes?**
Use our [Shopify Products](https://apify.com/mrslm_data/shopify-products) or [WooCommerce Products](https://apify.com/mrslm_data/woocommerce-products) scraper for full exports.

**Can I run it on a schedule?**
Yes. Save your input as a task and attach a schedule, as shown above. Each run is independent and returns the store changes available at that moment.

**Does it work with Make, Zapier or n8n?**
Yes. All three have an Apify app. Use "Run Actor" (or run a saved task), then "Get dataset items" to pass the rows to the next step, such as Google Sheets, Airtable, a CRM or Slack.

**Can AI agents use it through MCP?**
Yes. Apify's hosted MCP server can expose this Actor as a tool to any MCP client (Claude Desktop, Cursor, VS Code and others). Add `https://mcp.apify.com/?tools=mrslm_data/store-change-watcher` as a remote MCP server and sign in with your Apify account or API token. The agent fills in the same input fields shown above and gets the same rows back, billed at the same per-event prices.

**Do I need a Shopify or WooCommerce API key to watch a store?**
No vendor API key is required. The Actor reads public store data.

**How do I choose which Shopify or WooCommerce stores to monitor?**
Add store domains to `stores`. The Actor detects the platform automatically.

**How do I choose which product changes appear in results?**
Use `watch` to select change types. Use `maxResults` to cap saved change rows.

**Why might a removed product not appear in the results?**
Removed products are reported only after a full, clean catalog read. A `maxProductsPerStore` limit or an error can prevent that check.

**How much does a run checking 1,000 products and saving 10 changes cost?**
On the Free/Bronze tier, product checks cost $0.20 and changes cost $0.01. With the $0.00005 run start fee, the total is $0.21005. Status rows are free.

### Related scrapers

- [Shopify Scraper: Sale Prices, Compare-at & Stock](https://apify.com/mrslm_data/shopify-products)
- [WooCommerce Products Scraper: Prices, Sales & Stock](https://apify.com/mrslm_data/woocommerce-products)
- [AI Shopping & Agentic Commerce Readiness Checker](https://apify.com/mrslm_data/ai-shopping-readiness-checker)

### Is it legal?

This Actor only reads pages and feeds that the website itself publishes to every visitor without a login. It obeys each site's robots.txt, keeps a polite request rate, and never tries to get past logins, paywalls, captchas or bot checks. It does not collect personal data such as emails, phone numbers or names of private individuals. You are responsible for how you use the data: follow the source site's terms, copyright and the privacy laws that apply to you (GDPR, CCPA, etc.). This tool is independent and not affiliated with or endorsed by the platforms it reads.

# Actor input Schema

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

Shopify or WooCommerce store domains, e.g. "allbirds.com". The platform is detected automatically.

## `watch` (type: `array`):

Which changes become result rows. Removed products are only reported when the whole catalog was read without errors.

## `minPriceChangePercent` (type: `integer`):

Ignore price changes smaller than this, e.g. 5 to skip tiny adjustments. 0 = report every change.

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

Each run compares with the previous run of the same watchlist. Use different names for separate schedules or clients. The first run of a watchlist saves a baseline and reports no changes.

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

Newest products first for WooCommerce. 0 = whole catalog. If a catalog is cut off, removed-product alerts are skipped for that store.

## `maxResults` (type: `integer`):

Safety cap on saved change rows. 0 = no cap. Your max cost per run is always respected.

## `reportQuietStores` (type: `boolean`):

Adds one free row per store (changeType "baseline_saved" on the first run, "no_changes" later) so every scheduled run shows it checked the store. Status rows are not charged.

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

Usually not needed. Turn on Apify Proxy when watching many stores.

## Actor input object example

```json
{
  "stores": [
    "allbirds.com",
    "porterandyork.com"
  ],
  "watch": [
    "price_drop",
    "back_in_stock",
    "out_of_stock",
    "new_product"
  ],
  "minPriceChangePercent": 0,
  "watchlistName": "default",
  "maxProductsPerStore": 200,
  "maxResults": 0,
  "reportQuietStores": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

All results as a dataset (JSON, CSV, Excel and more via the API or Console).

## `summary` (type: `string`):

Counts of results, targets that succeeded or failed, and the stop reason.

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

// Run the Actor and wait for it to finish
const run = await client.actor("mrslm_data/store-change-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 = {
    "stores": [
        "allbirds.com",
        "porterandyork.com",
    ],
    "maxProductsPerStore": 200,
}

# Run the Actor and wait for it to finish
run = client.actor("mrslm_data/store-change-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 '{
  "stores": [
    "allbirds.com",
    "porterandyork.com"
  ],
  "maxProductsPerStore": 200
}' |
apify call mrslm_data/store-change-watcher --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,mrslm_data/store-change-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/HsiQdcfUhX1rypUSJ/builds/fqFBPqRZZSCDarJap/openapi.json