# Shopify Competitor Monitor: Products, Prices & Stock Changes (`feeng/shopify-competitor-intelligence-monitor`) Actor

📊 Track Shopify competitors daily. Detect product launches, price cuts, discounts, availability, theme and app changes, and catalog trends in one intelligence report.

- **URL**: https://apify.com/feeng/shopify-competitor-intelligence-monitor.md
- **Developed by:** [Daniel S.](https://apify.com/feeng) (community)
- **Categories:** E-commerce, Marketing, Business
- **Stats:** 2 total users, 0 monthly users, 51.9% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 successful store snapshots

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

## Shopify Competitor Monitor: Products, Prices & Stock Changes

Track Shopify competitors daily. Detect product launches, removals, price and sale changes, availability moves, technology changes, and catalog trends across scheduled runs. 📊

It is fully self-contained: it does not call another Apify Actor, require a Shopify API key, or depend on an external data provider.

### What it does 🔎

For each Shopify store, the Actor reads the public `/products.json` storefront endpoint, normalizes products and variants, then saves a catalog baseline in a named Apify key-value store. On the next run it compares the newest snapshot to that baseline.

Each dataset item includes flat, filterable columns and complete nested evidence. Use the `overview`, `changes`, `catalog`, `technology`, and `allData` dataset views.

- 🏪 Store identity and source metadata
- 🧾 Product, variant, price, discount, and availability summary
- ✨ New and removed products
- 💸 Price, sale-state, and availability changes
- 📦 Discount and stock-pressure signals
- 🧩 Public Shopify theme, marketing app, support, subscription, review, and tracking detection
- 🔁 Theme, app, and tracking changes between snapshots
- 📈 Catalog trend points and daily velocity estimates
- 🎯 A 0-100 change-intensity score and recommended actions

The run also saves `REPORT.html`, `REPORT_SUMMARY.json`, `OUTPUT.json`, `OUTPUT.csv`, and `ERRORS.json` to the key-value store. Failed stores are not written to the paid dataset. Standard Apify dataset exports support JSON, CSV, Excel, and API workflows.

### Input ⚙️

```json
{
  "stores": ["https://www.allbirds.com"],
  "maxProductsPerStore": 250,
  "compareWithPrevious": true,
  "saveSnapshot": true,
  "historyDays": 90,
  "includeTechStack": true,
  "includeHtmlReport": true
}
```

Use full store homepages or domains. A first run creates the baseline; schedule the Actor daily to observe product, pricing, stock, theme, app, and tracking deltas.

### Output example 📊

```json
{
  "storeName": "Example Store",
  "status": "ok",
  "catalog": {
    "productCount": 143,
    "discountedProductCount": 32,
    "availableProductCount": 121,
    "medianPrice": 49
  },
  "delta": {
    "newProductCount": 4,
    "priceChangeCount": 7,
    "availabilityChangeCount": 9
  },
  "analysis": {
    "changeIntensity": 77,
    "confidence": "high"
  },
  "technology": {
    "theme": { "name": "Dawn" },
    "detectedApps": [{ "name": "Klaviyo", "category": "Email and SMS" }]
  }
}
```

### Running locally 💻

```bash
npm install
apify run -p examples/input.json
```

Or set `INPUT.json` in the local Apify storage and run `npm start`.

### Running on Apify ☁️

1. Open the Actor in Apify Console.
2. Add one or more Shopify store URLs.
3. Keep `saveSnapshot` enabled.
4. Run it once for a baseline, then create a daily schedule.
5. Download the dataset or use `REPORT.html` for a client-ready overview.

### Store positioning 🚀

**Title:** Shopify Competitor Monitor: Products, Prices & Stock Changes

**Short description:** 📊 Track Shopify competitors daily. Detect new products, price cuts, discounts, sold-out variants, apps, theme changes, and catalog moves in one actionable report per store.

**SEO tags:** Shopify competitor monitor, Shopify price tracker, Shopify product launch tracker, Shopify stock monitor, Shopify app detector, Shopify theme detector, e-commerce intelligence, DTC research.

### Pricing 💵

The Store price is **$0.002 per run plus $0.02 per successful store snapshot**. Failed stores are written to `ERRORS.json` and are not charged as results. This keeps small daily monitors affordable while covering catalog extraction, history, technology analysis, and reporting.

### Limitations

- It can only monitor stores that expose Shopify's public storefront product endpoint.
- `maxProductsPerStore` is a hard limit; when the catalog exceeds it, the output is explicitly marked as partial.
- Product availability is public storefront availability, not unit inventory or sales volume.
- Respect each website's terms and applicable law when using collected data.

# Actor input Schema

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

Store homepages or domains to monitor. The Actor reads public Shopify storefront endpoints directly.

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

Hard cap for products fetched from each store. Use 250 for a fast daily pulse or a higher number for deeper catalog analysis.

## `compareWithPrevious` (type: `boolean`):

Compare this catalog snapshot with the latest saved snapshot for the same store.

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

Save this run so the next scheduled run can identify changes and trends.

## `historyDays` (type: `integer`):

Number of daily summary points retained for trend reporting. Full catalog data is retained only for the newest comparison baseline.

## `includeProducts` (type: `boolean`):

Include normalized product records in each dataset item. Turn off for lightweight daily monitoring.

## `maxProductsInOutput` (type: `integer`):

Cap product records included in output while retaining the full fetched snapshot for change detection.

## `includeHtmlReport` (type: `boolean`):

Save a visual competitor report as REPORT.html in the run key-value store.

## `includeTechStack` (type: `boolean`):

Detect public Shopify theme, common marketing apps, reviews, support, subscriptions, and tracking signals. Changes are compared between runs.

## `fetchTimeoutSecs` (type: `integer`):

Maximum duration of a single store request.

## `retryCount` (type: `integer`):

Retries transient request failures before returning an error for the store.

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

Optional Apify Proxy configuration. The Actor attempts public endpoints directly first and uses the selected proxy when configured.

## `snapshotStoreName` (type: `string`):

Named key-value store used to preserve snapshots between scheduled runs.

## Actor input object example

```json
{
  "stores": [
    "https://www.allbirds.com"
  ],
  "maxProductsPerStore": 250,
  "compareWithPrevious": true,
  "saveSnapshot": true,
  "historyDays": 90,
  "includeProducts": true,
  "maxProductsInOutput": 250,
  "includeHtmlReport": true,
  "includeTechStack": true,
  "fetchTimeoutSecs": 30,
  "retryCount": 2,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "snapshotStoreName": "shopify-competitor-intelligence-history"
}
```

# Actor output Schema

## `storeIntelligence` (type: `string`):

No description

## `catalogChanges` (type: `string`):

No description

## `productsAndPricing` (type: `string`):

No description

## `technology` (type: `string`):

No description

## `allData` (type: `string`):

No description

## `htmlReport` (type: `string`):

No description

## `csvExport` (type: `string`):

No description

## `jsonExport` (type: `string`):

No description

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

No description

## `errors` (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": [
        "https://www.allbirds.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("feeng/shopify-competitor-intelligence-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": ["https://www.allbirds.com"] }

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

```

## MCP server setup

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

```

## OpenAPI specification

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