# Shopify App Store History Scraper - Daily Ranks, Reviews (`martin10291/shopify-app-store-tracker`) Actor

Shopify App Store tracker with daily history. Our own archive snapshots about 26,000 apps every day (rating, review count, pricing label, Built for Shopify, rank in each of 90 leaf categories, new and delisted apps). Ask which apps gain reviews fastest, who moves up in a category, which apps launche

- **URL**: https://apify.com/martin10291/shopify-app-store-tracker.md
- **Developed by:** [Martin Petrov](https://apify.com/martin10291) (community)
- **Categories:** E-commerce, Developer tools, Automation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.10 / 1,000 results

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

## Shopify App Store Tracker - Review Velocity, Rank History

**Which Shopify apps are gaining reviews fastest, who is moving up in my category, which apps launched or were delisted this week?** The App Store only shows today. This actor answers from our own **daily archive** of the Shopify App Store and returns clean JSON rows.

No login, no proxies, no scraping on your run: the actor reads our archive, so results come back in seconds. Developer fields are company names only, no personal data.

### What makes this one different

- **Daily history, not a live snapshot.** Scrapers show the App Store as it is right now. Our archive snapshots about **26,000 apps every day**: rating, review count, pricing label, Built for Shopify badge and the rank in each of the **90 leaf categories**. The archive started on **2026-11-03** and grows every day. A clone cannot backfill the days it did not record.
- **Review velocity**: reviews gained over a lookback window, per day, plus rating change.
- **Rank changes** inside every category (`rank`, `rankThen`, `rankChange`).
- **New and delisted apps** feed, based on the Shopify sitemap.
- **Alerts**: only-new mode reports a row only when a competitor gains reviews or moves rank.

**Honest limits:** history starts on 2026-11-03, so with few snapshots most deltas are small or zero. They become richer each day. For live full app details and review text use the [Shopify App Store Scraper](https://apify.com/martin10291/shopify-app-store-scraper).

### Modes

| Mode | What you get |
|---|---|
| `velocity` (default) | Apps sorted by reviews gained over `lookbackDays`, optionally within one category |
| `category` | Ranked list of one category with rank changes |
| `apps` | Current numbers plus the daily history (rating, reviews, pricing) of the apps you list |
| `new` | Newly listed and delisted apps (`event` new or delisted). Can be empty on a quiet day, which is not an error |
| `categories` | The 90 category slugs with app counts |

### How to use it (step by step)

1. Click **Try for free**.
2. Keep the default (review-gain ranking in the Product Reviews category) or choose a mode.
3. Click **Start** and download JSON, CSV or Excel, or call it by API.

### API example (copy and paste)

Replace `MY_APIFY_TOKEN` with your token from Apify Console, Settings, Integrations.

```bash
curl -s -X POST "https://api.apify.com/v2/acts/martin10291~shopify-app-store-tracker/run-sync-get-dataset-items?token=MY_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"velocity","category":"marketing-and-conversion-social-trust-product-reviews","limit":20}'
```

Daily history of competitor apps:

```bash
curl -s -X POST "https://api.apify.com/v2/acts/martin10291~shopify-app-store-tracker/run-sync-get-dataset-items?token=MY_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"apps","apps":["judgeme","loox"]}'
```

### Use it from AI agents (MCP)

Add the actor to Claude, Cursor or any MCP-capable agent with the Apify MCP server:

```
https://mcp.apify.com?tools=martin10291/shopify-app-store-tracker
```

Then ask: "Which apps in the email marketing category gained the most reviews in the last 14 days?" The output is flat, documented JSON.

### Alerts on competitors

Set `onlyNew` to true and a `monitorId`. In `new` mode you get each newly listed or delisted app once. In the other modes you get only rows whose reviews, rating or rank changed since the last run with the same Monitor ID (`change` is `new` or `changed`). The first run reports everything. Schedule it daily and connect a webhook, Slack or email. Each result is paid for once.

### Input

| Field | Default | Description |
|---|---|---|
| `mode` | velocity | velocity, category, apps, new or categories |
| `category` | marketing-and-conversion-social-trust-product-reviews | Leaf category slug or categories URL (required for category mode) |
| `apps` | judgeme, flow | App handles or URLs (apps mode) |
| `lookbackDays` | 30 | Compare with this many days ago (velocity) |
| `minReviews` | 0 | Skip apps with fewer reviews (velocity) |
| `since` | empty | YYYY-MM-DD, for new mode |
| `limit` | 50 | Max rows (1-1000) |
| `onlyNew` | false | Only new or changed rows since last run |
| `monitorId` | default | Separate memory per watch list |

### Output example (velocity mode, real data from 2026-11-04)

```json
{
  "handle": "judgeme",
  "name": "Judge.me Product Reviews App",
  "url": "https://apps.shopify.com/judgeme",
  "developer": "Judge.me",
  "launched": "June 25, 2015",
  "rating": 5.0,
  "reviews": 49583,
  "pricing": "Free plan available",
  "builtForShopify": true,
  "reviewsThen": 49580,
  "reviewsDelta": 3,
  "reviewsPerDay": 3.0,
  "ratingThen": 5.0,
  "ratingDelta": 0.0,
  "categories": [{"category": "marketing-and-conversion-social-trust-product-reviews", "rank": 1}],
  "comparedWith": "2026-11-03",
  "day": "2026-11-04",
  "archiveFrom": "2026-11-03",
  "archiveSnapshots": 2
}
```

Fields that are not known for an app (for example `developer` or `launched`, which exist only for apps with detail pages in the archive) are `null`.

### Pricing

Pay per result, **$3 per 1,000 results**. The Run summary record (`RUN_SUMMARY`) reports counts, the archive range and `lastError`.

### FAQ

**Where does the data come from?** From our own daily snapshots of the public Shopify App Store, not from your run.

**How far back does history go?** To 2026-11-03. Each day adds one snapshot, so lookbacks get more meaningful over time.

**Can I get review texts or full app descriptions?** Not here. Use the [Shopify App Store Scraper](https://apify.com/martin10291/shopify-app-store-scraper) for live details and reviews.

**Why is `new` empty?** No app was newly listed or delisted in that period. The run still succeeds.

**Is personal data included?** No. Developer means the company name shown in the App Store.

# Actor input Schema

## `mode` (type: `string`):

velocity = apps ranked by reviews gained; category = ranked list of one category with rank changes; apps = current numbers plus daily history for chosen apps; new = newly listed and delisted apps; categories = the 90 category slugs with app counts.

## `category` (type: `string`):

Leaf category slug or full apps.shopify.com/categories URL. Required in category mode, optional filter in velocity mode (empty = all apps). Get all slugs with mode categories.

## `apps` (type: `array`):

App handles (the last part of apps.shopify.com/<handle>) or full app URLs. Used in apps mode.

## `lookbackDays` (type: `integer`):

Compare today with this many days ago (velocity mode). The archive starts on 2026-11-03, so the maximum useful value is the number of days since then.

## `minReviews` (type: `integer`):

Skip apps with fewer total reviews than this (velocity mode). Use it to hide brand-new apps with a handful of reviews.

## `since` (type: `string`):

Only in new mode: show apps listed or delisted since this date, format YYYY-MM-DD. Empty = since the start of the archive.

## `limit` (type: `integer`):

Maximum number of rows to return (1 to 1000). You pay per result.

## `onlyNew` (type: `boolean`):

For alerts: in new mode output only apps not reported before; in the other modes output only rows whose reviews, rating or rank changed since the last run with the same Monitor ID. The first run reports everything. Each result is paid for once.

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

Separate memory for each watch list (used with only-new mode). Use a different ID per category or list of apps.

## Actor input object example

```json
{
  "mode": "velocity",
  "category": "marketing-and-conversion-social-trust-product-reviews",
  "apps": [
    "judgeme",
    "flow"
  ],
  "lookbackDays": 30,
  "minReviews": 0,
  "since": "",
  "limit": 50,
  "onlyNew": false,
  "monitorId": "default"
}
```

# Actor output Schema

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

One row per Shopify app (or category or event): rating, reviews, review gain over the lookback window, category ranks and rank changes, new and delisted apps.

# 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 = {
    "category": "marketing-and-conversion-social-trust-product-reviews",
    "apps": [
        "judgeme",
        "flow"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("martin10291/shopify-app-store-tracker").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 = {
    "category": "marketing-and-conversion-social-trust-product-reviews",
    "apps": [
        "judgeme",
        "flow",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("martin10291/shopify-app-store-tracker").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 '{
  "category": "marketing-and-conversion-social-trust-product-reviews",
  "apps": [
    "judgeme",
    "flow"
  ]
}' |
apify call martin10291/shopify-app-store-tracker --silent --output-dataset

```

## MCP server setup

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

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/a2psHTx8BjvTOwJZU/builds/B8TlthJ2mS8K4sYQq/openapi.json