# Shopify App Store Monitor — New Apps & Pricing Changes (`xqfech/shopify-app-store-monitor`) Actor

Watches Shopify App Store categories and specific apps between runs. Detects newly listed apps, delisted apps, pricing plan changes, and rating movements. Outputs structured change events instead of raw snapshots.

- **URL**: https://apify.com/xqfech/shopify-app-store-monitor.md
- **Developed by:** [Emmanuel Obiefule](https://apify.com/xqfech) (community)
- **Categories:** E-commerce, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 change events

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 App Store Monitor — Track New Apps, Pricing & Rating Changes

Most Shopify App Store scrapers give you a snapshot. This Actor gives you **what changed**: newly listed apps in any category, delisted apps, pricing plan updates, and rating movements for the apps you care about — as clean, structured change events.

Run it on a schedule (daily or hourly) and get a live feed of Shopify App Store movement instead of re-scraping and comparing thousands of rows yourself.

### What it does

- **Watch categories** — pass any category or subcategory URL from apps.shopify.com. Every run compares the full app list against the previous run and emits `new_app` / `removed_app` events. New app in your niche? You know the same day.
- **Watch specific apps** — pass app listing URLs. Every run extracts rating, review count, developer, and full pricing plans (name, price, billing period, features), then emits `app_changed` events with field-level before/after diffs.
- **First run = baseline** — the initial snapshot is stored (and optionally emitted as `baseline` items), so from run two onward you only see real changes.

### Who uses this

- **Shopify app developers** — know the moment a competitor changes pricing, ships a new plan, gains/loses rating, or a new competitor enters your category.
- **Agencies & consultants** — track the app landscape for client niches without manual checking.
- **Investors & analysts** — monitor category dynamics: launch velocity, churn, pricing trends.
- **Marketplaces & data teams** — feed structured change events into Slack, sheets, or your own pipeline via Apify integrations.

### Output example

```json
{
  "type": "app_changed",
  "source": "watch",
  "handle": "klaviyo-email-marketing",
  "name": "Klaviyo: Email Marketing & SMS",
  "url": "https://apps.shopify.com/klaviyo-email-marketing",
  "changes": [
    { "field": "rating", "before": 4.6, "after": 4.7 },
    { "field": "ratingCount", "before": 2901, "after": 2938 }
  ],
  "detectedAt": "2026-08-04T10:00:00.000Z"
}
```

`new_app` and `removed_app` events carry the app snapshot (handle, name, icon, URL) and the category they appeared in or vanished from.

### Input

| Field | Description |
| --- | --- |
| `categoryUrls` | Category/subcategory URLs to watch for new & removed apps |
| `appUrls` | App listing URLs to watch for detail changes |
| `maxPagesPerCategory` | Pagination depth per category (~24 apps per page) |
| `monitorId` | State namespace — same ID shares history between runs |
| `emitBaseline` | Emit the initial snapshot on the first run |

### How reliable is it?

The Actor validates every extracted item against a strict schema and fails loudly instead of silently returning garbage when Shopify changes markup. Parsing is covered by automated tests against stored page fixtures, and the pricing extraction reads Shopify's stable `data-test-id` attributes rather than fragile CSS classes.

### Scheduling

Pair it with an Apify Schedule (e.g. daily at 09:00) and an integration (Slack, email, webhook, Google Sheets) so change events land where your team works. The Actor only charges for what it finds — quiet days cost almost nothing.

### FAQ

**Does it need login or cookies?** No. Only public pages are read.

**Can I watch multiple niches independently?** Yes — run separate schedules with different `monitorId` values.

**What happens if a page fails to load?** Requests retry with exponential backoff; transient failures don't corrupt your stored snapshot.

**Is this an official Shopify product?** No. This Actor reads publicly available pages of the Shopify App Store and is not affiliated with Shopify.

# Actor input Schema

## `categoryUrls` (type: `array`):

Shopify App Store category or subcategory URLs, e.g. https://apps.shopify.com/categories/marketing-and-conversion-marketing-email-marketing/all. Every run compares the full app set against the previous run and reports additions and removals.

## `appUrls` (type: `array`):

Specific app listing URLs, e.g. https://apps.shopify.com/klaviyo-email-marketing. Every run extracts rating, review count, pricing plans and developer, and reports field-level changes.

## `maxPagesPerCategory` (type: `integer`):

Each page lists ~24 apps. Higher values cover bigger categories but take longer.

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

State namespace. Runs with the same Monitor ID share the previous-run snapshot. Use different IDs for independent watch lists.

## `emitBaseline` (type: `boolean`):

On the very first run there is nothing to compare against. When enabled, the full initial snapshot is pushed as baseline items so you still get data.

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

Proxy settings for fetching apps.shopify.com.

## Actor input object example

```json
{
  "categoryUrls": [
    "https://apps.shopify.com/categories/marketing-and-conversion-marketing-email-marketing/all"
  ],
  "appUrls": [
    "https://apps.shopify.com/klaviyo-email-marketing"
  ],
  "maxPagesPerCategory": 5,
  "monitorId": "default",
  "emitBaseline": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "categoryUrls": [
        "https://apps.shopify.com/categories/marketing-and-conversion-marketing-email-marketing/all"
    ],
    "appUrls": [
        "https://apps.shopify.com/klaviyo-email-marketing"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("xqfech/shopify-app-store-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 = {
    "categoryUrls": ["https://apps.shopify.com/categories/marketing-and-conversion-marketing-email-marketing/all"],
    "appUrls": ["https://apps.shopify.com/klaviyo-email-marketing"],
}

# Run the Actor and wait for it to finish
run = client.actor("xqfech/shopify-app-store-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 '{
  "categoryUrls": [
    "https://apps.shopify.com/categories/marketing-and-conversion-marketing-email-marketing/all"
  ],
  "appUrls": [
    "https://apps.shopify.com/klaviyo-email-marketing"
  ]
}' |
apify call xqfech/shopify-app-store-monitor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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