# Shopify App Store Scraper & Rank Tracker (`kempt_horizon_yzk/shopify-app-store`) Actor

Get Shopify App Store data: app details, pricing plans, ratings, reviews and category/keyword rankings with position changes. Input app URLs/handles, categories or search keywords. Returns JSON per app/review/ranking. From $0.0005/review, $0.002/app.

- **URL**: https://apify.com/kempt_horizon_yzk/shopify-app-store.md
- **Developed by:** [Kempt Horizon Data](https://apify.com/kempt_horizon_yzk) (community)
- **Categories:** AI, E-commerce, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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?

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 Scraper & Rank Tracker

Scrape the **Shopify App Store** (apps.shopify.com): app listings, **every pricing plan**, ratings, **reviews**, and **category ranking positions tracked over time**. Each run compares rankings with the previous run, so you see who moved up, who dropped, and which apps are new in your category. Most Shopify app scrapers don't do this.

Built for Shopify app developers, agencies, SaaS founders, investors and market researchers who want Shopify app market data without paying for an analytics subscription.

### For AI agents (MCP / API) – quick reference

- **Use when:** you need Shopify App Store (apps.shopify.com) data: an app's details, pricing plans, rating, reviews, or which apps rank in a category and how positions changed.
- **Don't use for:** Shopify storefront/product data (this is the app marketplace, not merchant stores).
- **Minimal input:** `{"appHandles": ["klaviyo-email-marketing"], "includeReviews": true, "maxReviewsPerApp": 10}` or `{"categories": ["marketing-and-conversion-marketing-email-marketing"], "rankingDepth": 24}`.
- **Output:** dataset items with `type` = app (name, developer, rating, reviewCount, pricing plans, categories, Built for Shopify badge), review (rating, date, text, reply) or `ranking` (positions, movers, new entrants, drop-outs).
- **Price:** $0.001 per run start + **$0.002 per app**, **$0.0005 per review**, **$0.003 per ranking snapshot**. Pay-per-event only, limited permissions, so agentic payments (x402 / Skyfire / Apify AGI) work.
- **MCP:** add `https://mcp.apify.com?tools=kempt_horizon_yzk/shopify-app-store` to your MCP client.

### What does the Shopify App Store Scraper do?

- 📦 **App details**: name, tagline, description, highlights, developer (name, partner page, website, country), launch date, languages, "Works with" integrations, categories with feature tags, screenshots/video, and the **Built for Shopify** badge.
- 💲 **Pricing plans**: each plan's name, price label, parsed amount, currency and billing interval, additional charges and plan features. Also the free plan and free trial length.
- ⭐ **Ratings & reviews**: overall rating, review count, 1-5 star distribution. Reviews come newest first, with rating, date, text, store name and country as displayed, time using the app, and the developer's reply. You can filter by star rating, for example to monitor 1-2 star reviews only.
- 📈 **Category rank tracking with history**: ordered positions (up to 240 deep) for any category, and on every run:
  - `previousPosition` and `change` per app
  - `newEntrants` and `droppedOut`
  - `biggestGainers` and `biggestLosers`
  - `trackedApps` (your apps) with a full `trackedHistory` of positions across up to 1,000 past runs
- 🔁 **Incremental monitoring**: get only **new reviews** since the last run, and optionally only **apps that changed** (rating, review count, pricing, badge, categories, name). Every app includes a `changesSinceLastRun` diff.
- 🐢 **Polite and compliant**: one request at a time with a 2.5 s default delay plus jitter, robots.txt checked every run, retries with exponential backoff, and harder backoff on 429.

### Use cases

- **Competitor price monitoring**: get alerts when a competitor changes plans or prices.
- **App Store rank tracking (ASO)**: see where your app ranks in each category and how that changes week over week.
- **Review monitoring**: send new 1-star reviews to Slack or your helpdesk with an Apify integration.
- **Market research**: build a dataset of every app in a category with ratings, review counts and pricing.
- **Lead generation for agencies and investors**: find fast-rising apps with `biggestGainers` and `newEntrants`.

### How much does it cost to scrape the Shopify App Store?

Pay per event. You only pay for results:

| Event | Price |
|---|---|
| App listing (details + all pricing plans) | $0.002 |
| Review | $0.0005 |
| Ranking snapshot (one category, up to 240 positions, with diff vs. last run) | $0.003 |

Examples: tracking 10 categories daily costs about **$0.90/month**. 100 apps with 50 reviews each costs **$2.70**. Unchanged apps (with *Only save apps that changed*) and already-seen reviews (with *Incremental mode*) are **not charged**.

### How to use it

1. Add **apps** (handles like `klaviyo-email-marketing` or full URLs), **categories** (like `marketing-and-conversion-marketing-email-marketing` or the category URL), or both.
2. Turn on **Scrape reviews** if you need them.
3. For monitoring, set a **State key** (e.g. `my-competitors`), turn on **Incremental mode** and optionally **Only save apps that changed**, then [schedule](https://docs.apify.com/platform/schedules) the Actor daily or weekly.
4. Download results as JSON, CSV or Excel, or connect them to Google Sheets, Slack, Zapier, Make or a webhook.

#### Input example

```json
{
  "appHandles": ["klaviyo-email-marketing", "omnisend"],
  "categories": ["marketing-and-conversion-marketing-email-marketing"],
  "includeReviews": true,
  "maxReviewsPerApp": 50,
  "rankingDepth": 48,
  "incremental": true,
  "onlyChangedApps": true,
  "stateKey": "email-competitors"
}
```

### Output

Every dataset item has a `type`: `app`, `review` or `ranking`. The Output tab has separate **Apps**, **Reviews** and **Ranking snapshots** views. A `RUN_SUMMARY` record shows counts, skipped items and HTTP stats.

#### App (shortened)

```json
{
  "type": "app",
  "handle": "pop-convert",
  "name": "Pop Convert ‑ Pop Ups, Banners",
  "rating": 4.9,
  "reviewCount": 8712,
  "ratingDistribution": { "1": 33, "2": 6, "3": 34, "4": 384, "5": 8255 },
  "pricingSummary": "Free plan available. Free trial available.",
  "freeTrialDays": 90,
  "builtForShopify": true,
  "pricingPlans": [
    { "name": "Shopify Basic", "priceLabel": "$15/month", "amount": 15, "currency": "USD", "interval": "month", "features": ["Unlimited visitors & subscribers", "..."] }
  ],
  "developer": { "name": "Pop Convert", "handle": "pop-convert", "basedIn": "United States" },
  "categories": [{ "name": "Pop-ups", "handle": "marketing-and-conversion-...", "features": ["..."] }],
  "changesSinceLastRun": { "rating": { "from": 4.8, "to": 4.9 } }
}
```

#### Review

```json
{
  "type": "review",
  "reviewId": "2276380",
  "appHandle": "klaviyo-email-marketing",
  "rating": 5,
  "date": "2026-07-08",
  "storeName": "Super Dogs",
  "storeCountry": "Bulgaria",
  "usageDuration": "11 months",
  "text": "Everything just works - from popup to purchase ...",
  "developerReply": { "date": "2026-07-08", "text": "Thank you for such a thoughtful review! ..." },
  "reviewUrl": "https://apps.shopify.com/reviews/2276380"
}
```

#### Ranking snapshot (shortened)

```json
{
  "type": "ranking",
  "rankingType": "category",
  "target": "marketing-and-conversion-marketing-email-marketing",
  "title": "Email marketing apps",
  "totalAppsListed": 419,
  "capturedAt": "2026-10-14T14:39:56.600Z",
  "previousCapturedAt": "2026-10-07T14:00:00.000Z",
  "trackedApps": [{ "handle": "klaviyo-email-marketing", "position": 1, "previousPosition": 5 }],
  "newEntrants": [{ "handle": "qorix-popup", "position": 30 }],
  "droppedOut": [{ "handle": "some-app", "previousPosition": 30 }],
  "biggestGainers": [{ "handle": "klaviyo-email-marketing", "position": 1, "change": 4 }],
  "positions": [{ "position": 1, "page": 1, "handle": "klaviyo-email-marketing", "rating": 4.7, "reviewCount": 3375, "builtForShopify": false, "previousPosition": 5, "change": 4, "isNew": false }]
}
```

### Keyword rankings

Keyword (search) rank tracking is built in. However, apps.shopify.com's robots.txt currently disallows search URLs (`Disallow: *q=*`) for generic crawlers, and this Actor always respects robots.txt. While that rule stays in place, keyword inputs are skipped and **never charged**, and the run summary lists them under `rankings.skippedRobots`. The Actor re-reads robots.txt on every run, so keyword tracking starts working by itself if Shopify relaxes the rule.

### Data, privacy and compliance

- Only public pages are read, with no login. Paths that robots.txt disallows are never requested.
- From reviews, the Actor keeps only the **store name and country as displayed** by Shopify. Those are businesses. It does not collect reviewer personal names, emails or profiles. It also does not collect developer support emails or street addresses.
- Requests are throttled and sent one at a time. Please keep the delay at the default or higher. You are responsible for using the data in line with Shopify's terms and applicable law.

### FAQ

**Where do I find a category handle?** Open a category on apps.shopify.com and copy the URL. Paste the URL or the part after `/categories/`.

**Why do ranking positions differ from what I see?** The Actor captures the default, non-personalized "All apps" order of the category. It skips sponsored placements, so positions are organic rank.

**Where is history stored?** In the named key-value store `shopify-app-store-intel-state` in your account, under your `stateKey`. It persists across runs. Use different state keys for independent monitors.

**Is there an API?** Yes. Like every Apify Actor, you can run it through the [Apify API](https://docs.apify.com/api/v2) or the JS/Python clients, and read the dataset as JSON or CSV.

# Actor input Schema

## `appHandles` (type: `array`):

Optional. Shopify apps to get details/reviews for: handle ("klaviyo-email-marketing") or full URL (https://apps.shopify.com/klaviyo-email-marketing). Returns one app record each ($0.002).

## `categories` (type: `array`):

Optional. Category handles or URLs to get ranked app lists for, e.g. "marketing-and-conversion-marketing-email-marketing". Each returns one ranking snapshot ($0.003) with positions and changes since the previous run.

## `keywords` (type: `array`):

Search keywords to rank-track. Note: apps.shopify.com robots.txt currently disallows search URLs (*q=*) for generic crawlers, so keywords are skipped (and never charged) while that rule is in place. The Actor re-checks robots.txt every run.

## `includeAppDetails` (type: `boolean`):

Name, developer, rating, rating distribution, every pricing plan, Built for Shopify badge, categories and features, languages, integrations, launch date.

## `includeReviews` (type: `boolean`):

Turn on to also return reviews (newest first): rating, date, text, store name/country, usage duration, developer reply. $0.0005 per review; cap with 'Max reviews per app'.

## `maxReviewsPerApp` (type: `integer`):

Cap on reviews per app per run (10 per page).

## `reviewRatings` (type: `array`):

Optional, e.g. \["1","2"] to monitor negative reviews only. Empty = all ratings.

## `rankingDepth` (type: `integer`):

How many positions to capture per category/keyword (24 apps per page).

## `scrapeRankedApps` (type: `boolean`):

Fetch details (and reviews, if enabled) for apps discovered in ranking snapshots.

## `maxRankedAppsToScrape` (type: `integer`):

Cap on extra apps (beyond your list) scraped from ranking snapshots, in rank order.

## `incremental` (type: `boolean`):

Remember review IDs between runs and only save (and charge for) reviews you haven't received before.

## `onlyChangedApps` (type: `boolean`):

Skip (and don't charge for) apps whose rating, review count, pricing, badge, categories, name or tagline are unchanged since the last run. Saved apps include a changesSinceLastRun diff either way.

## `stateKey` (type: `string`):

Name of this monitor. Ranking history, app fingerprints and seen reviews are stored under this key in the named key-value store 'shopify-app-store-intel-state', so separate monitors don't interfere.

## `historyLength` (type: `integer`):

How many past snapshots per category/keyword to keep for position history.

## `requestDelaySecs` (type: `number`):

Requests are made one at a time with at least this delay (plus jitter). Minimum 1 s. A robots.txt Crawl-delay, if set, wins when larger.

## `maxRequests` (type: `integer`):

Safety cap on page fetches.

## Actor input object example

```json
{
  "appHandles": [
    "klaviyo-email-marketing",
    "omnisend"
  ],
  "categories": [
    "marketing-and-conversion-marketing-email-marketing"
  ],
  "includeAppDetails": true,
  "includeReviews": false,
  "maxReviewsPerApp": 50,
  "rankingDepth": 48,
  "scrapeRankedApps": false,
  "maxRankedAppsToScrape": 20,
  "incremental": false,
  "onlyChangedApps": false,
  "stateKey": "default",
  "historyLength": 90,
  "requestDelaySecs": 2.5,
  "maxRequests": 1500
}
```

# Actor output Schema

## `apps` (type: `string`):

No description

## `reviews` (type: `string`):

No description

## `rankings` (type: `string`):

No description

## `all` (type: `string`):

No description

## `summary` (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 = {
    "appHandles": [
        "klaviyo-email-marketing",
        "omnisend"
    ],
    "categories": [
        "marketing-and-conversion-marketing-email-marketing"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("kempt_horizon_yzk/shopify-app-store").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 = {
    "appHandles": [
        "klaviyo-email-marketing",
        "omnisend",
    ],
    "categories": ["marketing-and-conversion-marketing-email-marketing"],
}

# Run the Actor and wait for it to finish
run = client.actor("kempt_horizon_yzk/shopify-app-store").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 '{
  "appHandles": [
    "klaviyo-email-marketing",
    "omnisend"
  ],
  "categories": [
    "marketing-and-conversion-marketing-email-marketing"
  ]
}' |
apify call kempt_horizon_yzk/shopify-app-store --silent --output-dataset

```

## MCP server setup

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

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/xf2y7vxE56QlrroZN/builds/CBc5weVtQI9mnGr9d/openapi.json