# Shopify App Store Scraper: Apps, Reviews & Categories (`winterlock/shopify-app-store-scraper`) Actor

Scrape Shopify App Store listings, merchant reviews with developer replies, and whole category listings. Monitor mode returns only reviews posted since your last run. No login or API key.

- **URL**: https://apify.com/winterlock/shopify-app-store-scraper.md
- **Developed by:** [Alex Burton](https://apify.com/winterlock) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 app with full details

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: Apps, Reviews & Categories

Listings and merchant reviews from the Shopify App Store, including the developer's replies. No Shopify account, API key or browser needed.

| Mode | What you get |
|---|---|
| **App details** | Name, description, icon, star rating, review count, pricing summary and launch date |
| **Reviews** | Star rating, full text, merchant shop name, country, how long they have used the app, the date, and the developer's reply |
| **Category listing** | Every app in a category, in the store's own order across all its pages, optionally with full details |

### Why use this one

- **Reviews carry the whole story.** Most scrapers return a star and a blob of text. This one also returns the merchant's country, how long they had been using the app when they wrote the review, whether the review was edited, and the developer's reply with its own date. That is what makes review data useful for competitor research rather than just sentiment counting.
- **Monitor mode.** Turn on *Only new reviews since the last run* and schedule the Actor daily. It remembers which reviews it has already delivered for each app and returns only new ones, so you pay only for what's new.
- **It respects the store's rules.** The Shopify App Store's `robots.txt` disallows any URL carrying a `q=` parameter, so this Actor has no keyword-search mode. Category listings do the same job and are permitted.
- **Built to survive redesigns.** App facts come from Open Graph meta tags, and reviews are anchored on the store's own "N days using the app" line rather than CSS classes that change every release.

### How to use it

1. Choose **What to scrape**.
2. Add **Apps** (store links or handles) or **Categories** (a category link, or just the slug after `/categories/`).
3. Click **Start**, then download results as JSON, CSV, Excel or HTML, or fetch them through the Apify API.

Apps can be given in either form:

```
https://apps.shopify.com/klaviyo-email-marketing
klaviyo-email-marketing
```

#### Example input: daily review monitor

```json
{
  "mode": "reviews",
  "apps": ["klaviyo-email-marketing", "judgeme-product-reviews"],
  "onlyNewReviews": true,
  "maxReviewsPerApp": 500
}
```

#### Example input: every app in a category

```json
{
  "mode": "category",
  "categories": ["marketing-and-conversion-marketing-email-marketing"],
  "maxAppsPerCategory": 100,
  "fetchDetails": true
}
```

#### Example input: mine the complaints

```json
{
  "mode": "reviews",
  "apps": ["klaviyo-email-marketing"],
  "maxRating": 2,
  "maxReviewsPerApp": 300
}
```

### Output

**App**

```json
{
  "type": "app",
  "handle": "klaviyo-email-marketing",
  "name": "Klaviyo: Email Marketing & SMS",
  "tagline": "Email marketing, SMS, & WhatsApp that turn messages into sales",
  "description": "Power smarter digital relationships with email and SMS.",
  "url": "https://apps.shopify.com/klaviyo-email-marketing",
  "iconUrl": "https://cdn.shopify.com/app-store/listing_images/…",
  "rating": 4.7,
  "reviewCount": 3383,
  "pricingSummary": "Free to install",
  "launchedOn": "2012-09-20T00:00:00Z"
}
```

**Review**

```json
{
  "type": "review",
  "reviewId": "2396872",
  "handle": "klaviyo-email-marketing",
  "appName": "Klaviyo: Email Marketing & SMS",
  "rating": 5,
  "text": "Set up took an afternoon and the flows paid for themselves in a week.",
  "shop": "Coast and Trail",
  "country": "United States",
  "usageDuration": "24 days",
  "date": "2026-10-15T00:00:00Z",
  "edited": false,
  "replyText": "Thanks so much for the kind words!",
  "replyDate": "2026-10-16T00:00:00Z"
}
```

### Pricing

| Result | Price |
|---|---|
| Review | $1.00 per 1,000 |
| App with full details | $5.00 per 1,000 |
| Category listing row (*Load full details* off) | $0.50 per 1,000 |

Set a maximum spend per run in the run options and the Actor stops cleanly when it's reached.

### Limits to know about

- **No keyword search.** The store's `robots.txt` disallows URLs with a `q=` parameter. Use **Category listing** instead, or supply app handles directly.
- **Reviews carry the store's own ID.** `reviewId` is the identifier Shopify gives each review, so monitor mode recognises a review even after the merchant edits it. If a card ever lacks one, the Actor falls back to a fingerprint of the date, shop name and opening text.
- **Each star rating is read from its own review card**, from the store's accessible "N out of 5 stars" label. A card without a readable label gets `null` rather than a neighbour's rating. The log tells you when a page yields no reviews at all.
- **Rating, review count, pricing and launch date on app pages are best-effort**, read from visible text because the store publishes no structured data. Name, description, icon and URL come from meta tags and are reliable.
- **Pricing is a one-line summary**, such as "Free to install". The full plan table is not extracted.
- **Sponsored placements are left out of category listings.** They are adverts repeated at the top of every page, not rankings, so `position` is the app's place in the store's organic order.
- Category slugs change when Shopify reorganises its taxonomy, and an outdated slug finds nothing. Paste the link of a live category page and the Actor takes the slug from it.

### FAQ

**Do I need a Shopify account or Partner account?** No. Everything comes from public pages, with no sign-in.

**Can I watch reviews for my own app every day?** Yes. Turn on monitor mode, then create a schedule in Apify Console and connect the dataset to Slack, Google Sheets, Zapier or Make.

**Why does a review have a null rating?** That review's card carried no readable star label, so the Actor left the rating empty rather than guess. Everything else on the review is still correct.

**Where do I find a category slug?** Open a category on apps.shopify.com and paste its link, or copy the part after `/categories/`. Email marketing, for example, is `marketing-and-conversion-marketing-email-marketing`.

**Is this legal?** The Actor reads publicly available pages, does not log in, does not bypass any protection, and stays within the paths the store's `robots.txt` permits. Reviews include merchant shop names, which may count as business data under local law; turn off *Include merchant shop names* if you don't need them.

### Feedback

Found a bug or need a field that's missing? Open an issue on the Actor's **Issues** tab.

# Actor input Schema

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

Details for apps you name, their merchant reviews, or every app in a category.

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

Store links (https://apps.shopify.com/klaviyo-email-marketing) or bare app handles (klaviyo-email-marketing).

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

Category links (https://apps.shopify.com/categories/marketing-and-conversion-marketing-email-marketing) or just the slug after /categories/. Sponsored placements are skipped.

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

Each app costs one extra request when full details are loaded.

## `fetchDetails` (type: `boolean`):

Off returns just the handle and URL, which is fast and cheap.

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

Reviews are read newest-first, about 10 per page. Popular apps hold thousands, so set this to control cost.

## `reviewSort` (type: `string`):

Leave empty for the store's default order. The store also accepts values such as most_recent and highest_rating.

## `onlyNewReviews` (type: `boolean`):

Remembers which reviews it has already returned for each app, and on later runs returns only new ones. Schedule the Actor daily to get a feed of new reviews and pay only for those.

## `minRating` (type: `integer`):

Keep only reviews with at least this many stars.

## `maxRating` (type: `integer`):

Keep only reviews with at most this many stars. Set to 2 to collect only complaints.

## `includeShopNames` (type: `boolean`):

Turn off to leave out the name of the store that wrote each review.

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

Stop the run after saving this many items. Leave empty for no limit.

## `maxConcurrency` (type: `integer`):

Lower this if you see rate-limit retries in the log.

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

Not needed for small runs. Turn on Apify Proxy for large review pulls.

## Actor input object example

```json
{
  "mode": "appDetails",
  "apps": [
    "klaviyo-email-marketing"
  ],
  "maxAppsPerCategory": 30,
  "fetchDetails": true,
  "maxReviewsPerApp": 200,
  "onlyNewReviews": false,
  "includeShopNames": true,
  "maxConcurrency": 4,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "apps": [
        "klaviyo-email-marketing"
    ]
};

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

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

```

## MCP server setup

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

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/y3vSNhwMeHSGUhLeA/builds/QlCxelAckV8HfUH7F/openapi.json