# Shopify Commercial Change Intelligence (`northpeak_data/shopify-commercial-change-intelligence`) Actor

Turn public Shopify catalog changes into prioritized commercial events with impact scores, urgency, evidence, and recommended actions.

- **URL**: https://apify.com/northpeak\_data/shopify-commercial-change-intelligence.md
- **Developed by:** [Northpeak Data](https://apify.com/northpeak_data) (community)
- **Categories:** Automation, E-commerce, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 commercial intelligence results

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?

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 Commercial Change Intelligence

Monitor public Shopify stores and turn catalog changes into prioritized commercial intelligence — not thousands of raw product rows.

Designed for competitor monitoring, ecommerce pricing analysis, assortment tracking, sourcing, retail intelligence, and market research.

### What you get

The Actor groups related product changes into decision-ready events:

- Broad price drops or increases across multiple products
- Promotions starting or ending
- Multi-product restocks and stockouts
- Catalog expansion or contraction
- New product categories

Every event includes:

- `impactScore` from 1 to 100
- Urgency and confidence
- Number and percentage of affected products
- Evidence with product links
- A concise summary
- A recommended commercial response

### Why use this Actor

Most Shopify scrapers return product rows. This Actor keeps a persistent baseline for each store and monitor, compares later scans, and consolidates related changes into a small number of meaningful signals.

Instead of reviewing hundreds of records, you can receive an event such as:

> Prices dropped across 34 products, averaging 18%. Impact score: 82. Urgency: critical.

### Quick start

1. Add one or more public Shopify storefront URLs.
2. Keep a stable `monitorId` for each monitoring project.
3. Run the Actor once to create the baseline.
4. Run it again later with the same `monitorId` to detect changes.
5. Schedule recurring runs or connect the dataset to your workflow.

The first run normally returns `baseline_created`. Later runs return a scan summary and any qualified commercial events.

### Input

- `storeUrls`: public Shopify storefront domains
- `monitorId`: stable baseline namespace
- `minPriceChangePercent`: ignores smaller price movements
- `minAffectedProducts`: prevents isolated changes from becoming broad signals
- `maxProductsPerStore`: hard product and cost limit
- `maxStoresPerRun`: hard store and cost limit
- `outputMode`: events with summary, events only, or summary only

### Example output

```json
{
  "eventType": "broad_price_drop",
  "title": "Prices dropped across 34 products",
  "affectedProducts": 34,
  "totalProducts": 180,
  "magnitudePercent": -18,
  "impactScore": 82,
  "urgency": "critical",
  "confidence": 0.98,
  "recommendedAction": "Compare affected SKUs and decide whether to match, hold, or reinforce value positioning.",
  "evidence": [
    {
      "title": "Example product",
      "url": "https://example-store.com/products/example-product",
      "averagePriceChangePercent": -18
    }
  ]
}
```

### Automation and integrations

The structured dataset can be consumed through the Apify API or connected to scheduling and automation workflows. A common setup is to run the same monitor daily or weekly and continue the workflow only when `status` is `changed`.

No store login, private Shopify Admin API token, paid external API, browser, or proxy is required by default.

### Cost controls

The Actor uses direct HTTP and enforces limits for stores and products per run. Its default configuration is intentionally conservative. Users can also set Apify's maximum cost per run.

### Limitations

- The storefront must expose a public Shopify product catalog.
- A store may block or customize its public catalog endpoint.
- The Actor reports catalog-level signals; it does not access orders, customers, private inventory systems, or Shopify Admin data.
- A stable `monitorId` is required for meaningful comparisons.
- Changing product limits between runs can intentionally create expansion or contraction signals.

### Responsible use

Use only with public storefronts and in accordance with applicable law, site terms, and robots policies. The Actor does not log in, bypass access controls, or collect customer data.

# Actor input Schema

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

Public Shopify storefront domains to monitor. No login or private API token is used.

## `monitorId` (type: `string`):

Stable identifier used to keep this monitor's baseline separate from other monitors.

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

Ignore smaller variant price movements when creating commercial events.

## `minAffectedProducts` (type: `integer`):

Minimum products required to turn related changes into one commercial event.

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

Hard safety and cost limit for public products collected from each store.

## `maxStoresPerRun` (type: `integer`):

Hard safety and cost limit for storefronts checked in one run. The conservative default is three stores.

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

Return commercial events with a scan summary, events only, or summary only.

## Actor input object example

```json
{
  "storeUrls": [
    "https://www.zoologistperfumes.com"
  ],
  "monitorId": "default",
  "minPriceChangePercent": 5,
  "minAffectedProducts": 2,
  "maxProductsPerStore": 250,
  "maxStoresPerRun": 3,
  "outputMode": "events_and_summary"
}
```

# Actor output Schema

## `results` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("northpeak_data/shopify-commercial-change-intelligence").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("northpeak_data/shopify-commercial-change-intelligence").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 '{}' |
apify call northpeak_data/shopify-commercial-change-intelligence --silent --output-dataset

```

## MCP server setup

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

```

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/eQqjWFH1W0jgb07L0/builds/CybCWr9UgrPtZhzuU/openapi.json