# Shopify App Store Scraper: Apps, Rankings and Reviews (`agents001/shopify-app-store-feed`) Actor

Returns Shopify App Store data: app details (developer, rating, reviews, pricing plans, categories, launch date, languages, Built for Shopify badge), category rankings with position changes, and merchant reviews with store name, country and developer replies.

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

## Pricing

from $1.50 / 1,000 app records

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 Scraper: Apps, Rankings and Reviews

Get structured data from the public Shopify App Store at apps.shopify.com in three record types:

- **App details**: name, developer, rating, review count, reviews per star level, pricing plans with prices and features, categories, launch date, languages, integrations ("Works with") and the Built for Shopify badge.
- **Category rankings**: every app in a category in the order the App Store lists it, with position, rating, review count, pricing summary and badge, plus the position change since your previous run.
- **Reviews**: date, star rating, review text, the reviewing store's name and country as published, time using the app, and the developer's reply.

Schedule it daily with **Only new items** switched on to get just the new reviews and the apps that newly entered a category ranking.

This Actor is not affiliated with, endorsed by or sponsored by Shopify. "Shopify" is a trademark of Shopify Inc. and is used here only to describe the public website the Actor reads.

### Who it is for

- **App developers and product teams** tracking competitors' ratings, pricing changes, new features and complaints.
- **Agencies and consultants** comparing apps in a category for clients.
- **Market researchers and investors** sizing categories, spotting fast-growing apps and tracking Built for Shopify adoption.
- **Support and success teams** monitoring their own reviews and replies every day.

### Quick start

1. Click **Start** with the example input. You get two app records, the 20 newest reviews of each, and the top 24 apps in the Product reviews category, in about 10 seconds.
2. Replace the lists with your own:
   - **Apps**: a handle such as `judgeme` or a link such as `https://apps.shopify.com/klaviyo-email-marketing`. The handle is the part of the link after `apps.shopify.com/`.
   - **Categories**: a category handle such as `store-design-site-optimization-seo` or a category link. Use subcategories; top-level categories such as `marketing-and-conversion` only show curated sections and have no ranked list (the Actor tells you which subcategories to use instead).
3. Optional: add **Keywords** to keep only ranked apps whose name or tagline matches, or pick **Only these star ratings** (for example 1 and 2) to collect complaints.
4. Schedule the Actor and switch on **Only new items since the previous run**. Connect the dataset to email, Slack, Google Sheets or your own system with an Apify integration or webhook.

### Input

| Field | What it does | Default |
|---|---|---|
| `apps` | App handles or links. Returns app details and reviews for each | example list |
| `categories` | Category handles or links. Returns the ranking of each | example list |
| `keywords` | Keep only ranked apps whose name, tagline or handle contains any of these words | all |
| `includeAppDetails` | Return one app record per app | true |
| `includeReviews` | Return reviews for each app | true |
| `maxReviewsPerApp` | Reviews per app (10 per page). `0` means all | 20 |
| `reviewsSortBy` | `newest` or `relevance` | `newest` |
| `reviewRatings` | Only reviews with these star ratings | all |
| `maxAppsPerCategory` | Read each ranking down to this position (24 per page). `0` means the whole category | 24 |
| `includeDetailsForRankedApps` | Also return an app record for every ranked app returned | false |
| `onlyNew` | Only reviews and ranked apps not returned by a previous run with the same input | false |
| `maxItems` | Stop after this many records in total. `0` means no limit | 1000 |

If both `apps` and `categories` are empty the example lists are used. Keywords filter category rankings only: the Actor does not use the App Store's search page, because the site's robots.txt asks automated clients not to.

Example input for a daily competitor watch:

```json
{
  "apps": ["judgeme", "loox", "okendo-reviews"],
  "categories": ["marketing-and-conversion-social-trust-product-reviews"],
  "maxReviewsPerApp": 50,
  "maxAppsPerCategory": 48,
  "onlyNew": true
}
```

Example input for collecting complaints about one app:

```json
{
  "apps": ["https://apps.shopify.com/klaviyo-email-marketing"],
  "categories": [],
  "includeAppDetails": false,
  "reviewRatings": ["1", "2"],
  "maxReviewsPerApp": 200
}
```

### What you get

All records share one dataset. The Output tab has three views: **Apps**, **Rankings** and **Reviews**.

**App records** (`recordType: "app"`)

| Field | Example |
|---|---|
| `appHandle`, `name`, `tagline`, `appUrl` | `judgeme`, `Judge.me Product Reviews App`, `Collect unlimited product reviews, star ratings, testimonials` |
| `developerName`, `developerUrl`, `developerWebsite`, `developerAddress` | `Judge.me`, the developer's App Store page, website and business address as published |
| `rating`, `reviewCount`, `ratingDistribution` | `5.0`, `48932`, `{"5": 47857, "4": 810, "3": 74, "2": 36, "1": 155}` |
| `pricingSummary`, `hasFreePlan`, `hasFreeTrial`, `pricingNote` | `Free plan available. Free trial available.`, `true`, `true` |
| `pricingPlans` | `[{"name": "Awesome", "priceText": "$15/month", "priceAmount": 15, "currency": "USD", "billingPeriod": "month", "features": [...], "trial": "15-day free trial"}]` |
| `categories`, `categoryFeatures` | `[{"name": "Product reviews", "handle": "...", "url": "..."}]`, `["Photo reviews", ...]` |
| `launchedDate`, `languages`, `worksWith` | `2015-06-25`, `["English", "Spanish", ...]`, `["Shopify Flow", "Klaviyo: Email Marketing", ...]` |
| `builtForShopify` | `true` when the app page shows the Built for Shopify badge |
| `headline`, `description`, `iconUrl` | Listing headline and introduction text, icon link |

**Review records** (`recordType: "review"`)

| Field | Example |
|---|---|
| `reviewId`, `reviewUrl` | `2405181`, `https://apps.shopify.com/reviews/2405181` |
| `rating`, `reviewDate`, `reviewText` | `5`, `2026-10-22`, `explained well thanks` (empty for star-only reviews) |
| `storeName`, `storeCountry`, `usageDuration` | `Foveaux Cod Catcher`, `New Zealand`, `8 months using the app` |
| `developerReply`, `developerReplyDate`, `developerReplyAuthor` | The developer's public reply, its date and the developer name |
| `isNew` | Whether the review is new since the previous run with the same input |

Store names are the business names the App Store shows next to each review. The Actor returns nothing else about reviewers: no personal names, emails or profile links.

**Ranking records** (`recordType: "ranking"`)

| Field | Example |
|---|---|
| `categoryHandle`, `categoryName`, `totalAppsInCategory` | `marketing-and-conversion-social-trust-product-reviews`, `Product review apps`, `486` |
| `position`, `page`, `positionOnPage` | `2`, `1`, `2` |
| `appHandle`, `appName`, `tagline`, `appUrl` | `google-review-plus-by-entangle-1`, `Entangle Google Reviews`, ... |
| `rating`, `reviewCount`, `pricingSummary`, `builtForShopify` | `5.0`, `601`, `Free plan available`, `true` |
| `previousPosition`, `positionChange`, `isNew`, `firstSeenAt` | Movement since the previous run with the same input (positive means the app moved up) |
| `matchedKeywords` | Which of your keywords matched |

Every record also has `scrapedAt` (UTC) and `schemaVersion`. A `RUN_SUMMARY` record in the run's key-value store lists counts, pages read and any inputs that could not be read.

### Output example

```json
{
  "recordType": "review",
  "appHandle": "judgeme",
  "appName": "Judge.me Product Reviews App",
  "appUrl": "https://apps.shopify.com/judgeme",
  "reviewId": "2405181",
  "rating": 5,
  "reviewDate": "2026-10-22",
  "reviewDateText": "October 22, 2026",
  "reviewText": "explained well thanks",
  "storeName": "Foveaux Cod Catcher",
  "storeCountry": "New Zealand",
  "usageDuration": "8 months using the app",
  "developerReply": null,
  "developerReplyDate": null,
  "developerReplyAuthor": null,
  "reviewUrl": "https://apps.shopify.com/reviews/2405181",
  "reviewsSortBy": "newest",
  "ratingFilter": null,
  "isNew": true,
  "scrapedAt": "2026-10-23T11:25:19Z",
  "schemaVersion": 1
}
```

### Pricing

Pay per event: you pay only for the records you get.

| Event | Price per 1,000 records |
|---|---|
| `app-record` (one app's details) | $2.50 |
| `review-record` (one review) | $2.00 |
| `ranking-record` (one app's position in one category) | $1.50 |

The example input returns 2 app, 40 review and 24 ranking records, about $0.12. If you set a maximum charge per run, the Actor stops cleanly when it is reached and keeps everything returned so far. `maxItems` gives you a second cap.

### How it works and limits

- Reads only public App Store pages, without logging in. It checks every link against apps.shopify.com/robots.txt before requesting it, waits at least 1 second between requests and backs off when the site asks it to slow down.
- Speed: about one page per second. 24 ranked apps or 10 reviews per page. Reading all reviews of an app with tens of thousands of reviews takes hours; keep `maxReviewsPerApp` modest and use `onlyNew` for ongoing tracking.
- Content is read in English. Prices are as published (the App Store states them in USD).
- Category rankings are the App Store's own default order at the time of the run. It can differ slightly between visitors.
- With `onlyNew`, app detail records are always returned (so you can track rating and pricing changes); reviews and ranking rows are filtered. History is kept per input in a key-value store named `shopify-app-store-feed-state` in your account.
- The App Store changes its page layout from time to time. If you notice empty fields that should have values, please report it in the Actor's Issues tab.

### Responsible use

The data comes from publicly visible pages. Reviews are written by merchants and identify their stores by business name. Use the data in line with the laws that apply to you, including data protection law, and with the website's terms.

# Actor input Schema

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

App handles or App Store links, for example 'judgeme' or 'https://apps.shopify.com/klaviyo-email-marketing'. The handle is the part of the link after apps.shopify.com/. Returns one app record per app and, if reviews are switched on, its reviews.

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

Category handles or links, for example 'marketing-and-conversion-social-trust-product-reviews' or 'https://apps.shopify.com/categories/store-design-site-optimization-seo'. Returns the ranked app list in the order the App Store shows it. Use subcategories: top-level categories such as 'marketing-and-conversion' have no ranked list.

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

Only return ranked apps whose name, tagline or handle contains any of these words, for example 'google' or 'loyalty'. Positions stay the real positions in the category. This filters category rankings; the Actor does not use the App Store search page because its robots.txt disallows it.

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

One record per app: name, developer, rating, review count, rating breakdown, pricing plans, categories, launch date, languages, integrations and the Built for Shopify badge.

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

One record per merchant review: date, star rating, text, the store name and country as published, time using the app, and the developer's reply.

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

Stop after this many reviews per app (10 reviews per page). 0 means all reviews; popular apps have tens of thousands, which takes hours at a polite request rate.

## `reviewsSortBy` (type: `string`):

Newest first (best for monitoring) or the App Store's 'Most relevant' order.

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

Only reviews with these star ratings, for example 1 and 2 to collect complaints. Empty means all ratings.

## `maxAppsPerCategory` (type: `integer`):

Read the ranking down to this position (24 apps per page). 0 means the whole category.

## `includeDetailsForRankedApps` (type: `boolean`):

Fetch the app page of every ranked app returned and add its app record (one extra request and one app record per app).

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

Remember what was already returned for this exact input and only return reviews not seen before and apps that newly entered the tracked part of each category ranking. App detail records are always returned. The first run returns everything. Ideal for scheduled daily runs. Changing apps, categories, keywords or review filters starts a fresh history.

## `maxItems` (type: `integer`):

Stop after this many records in total (apps, reviews and rankings together). 0 means no limit. You pay per record returned.

## `stateStoreName` (type: `string`):

Name of the key-value store in your account that remembers what was already returned. Each different input gets its own record inside it. Change it only to keep separate histories.

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

Minimum seconds between requests to apps.shopify.com. Keep this polite; values below 0.5 are raised to 0.5.

## Actor input object example

```json
{
  "apps": [
    "judgeme",
    "klaviyo-email-marketing"
  ],
  "categories": [
    "marketing-and-conversion-social-trust-product-reviews"
  ],
  "includeAppDetails": true,
  "includeReviews": true,
  "maxReviewsPerApp": 20,
  "reviewsSortBy": "newest",
  "maxAppsPerCategory": 24,
  "includeDetailsForRankedApps": false,
  "onlyNew": false,
  "maxItems": 1000,
  "stateStoreName": "shopify-app-store-feed-state",
  "requestDelaySecs": 1
}
```

# Actor output Schema

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

No description

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

No description

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

No description

## `runSummary` (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 = {
    "apps": [
        "judgeme",
        "klaviyo-email-marketing"
    ],
    "categories": [
        "marketing-and-conversion-social-trust-product-reviews"
    ]
};

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

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

```

## MCP server setup

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

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/kdwxG1j7OyGIGrOvr/builds/9AAcrg08YFfdGBFty/openapi.json