# Shopify App Store Scraper (`subimpact/shopify-app-store-scraper`) Actor

Shopify App Store apps as JSON: description, pricing plans, rating distribution, categories, developer details, screenshots and merchant reviews. Discover by app URL, category, developer or sitemap. From $0.30 per 1,000 reviews.

- **URL**: https://apify.com/subimpact/shopify-app-store-scraper.md
- **Developed by:** [subimpact network](https://apify.com/subimpact) (community)
- **Categories:** E-commerce, Lead generation, Developer tools
- **Features:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 1,000 app (full details)s

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

Scrape public Shopify App Store listings into clean JSON: the full app description and highlights, every pricing plan with its features and free trial, the rating distribution, categories and feature tags, developer contact details, screenshots, launch date, languages and what the app works with. Turn on reviews and you also get merchant reviews with rating, date, store country, usage duration and the developer's reply.

It is plain HTTP on the public pages, no browser and no login. You choose what to scrape: app URLs, category pages, developer pages, or every app in Shopify's public sitemap (about 30,800 handles).

### What you get

One dataset with app, review, error and info rows, discriminated by `rowType`:

- `app` with `detailLevel: "full"`: the complete listing (pricing plans, rating distribution, categories, developer, screenshots, links).
- `app` with `detailLevel: "card"`: the card data from a category or developer page (name, icon, rating, review count, price label, short description, badges), when you turn `scrapeAppDetails` off.
- `review`: one merchant review per row.
- `error` and `info`: uncharged notes, for example an app handle that does not exist or the review ceiling described under [Limits](#limits).

Apps are deduplicated by handle across every source, and reviews by review id across star-rating slices.

### Input example

```json
{
  "appUrls": ["https://apps.shopify.com/judgeme", "smile-io"],
  "categorySlugs": ["marketing-and-conversion-social-trust-product-reviews"],
  "developerSlugs": ["judge-me"],
  "allApps": false,
  "sinceDate": "2026-11-01",
  "scrapeAppDetails": true,
  "includeReviews": true,
  "maxReviewsPerApp": 30,
  "reviewsSort": "newest",
  "reviewRatings": ["1", "2"],
  "maxItems": 40,
  "proxyConfiguration": { "useApifyProxy": false }
}
```

Every field is optional. The smallest useful run is `{ "appUrls": ["judgeme"] }`, and an empty input `{}` scrapes the prefill app (`judgeme`) and stops at 20 charged rows.

Notes that matter for the bill:

- `maxItems` is a hard cap on **charged rows** in the whole run: app, card and review rows together. Error and info rows are free.
- With `scrapeAppDetails: false`, card rows come from category and developer pages without opening app pages (about 3x cheaper per row). Apps you list in `appUrls` are always opened in full, because a card row needs a list page to come from.
- A top-level category slug such as `store-design` is expanded automatically into its sub-categories, because Shopify serves no paginated `/all` list for top-level slugs.
- Keyword search is not offered: `robots.txt` disallows `*q=*` and `/search` answers HTTP 429 to this kind of client.

### Output example

App row (values from the public Judge.me listing; `pricingPlans` trimmed to one plan and `screenshots` to two. The
`listingKey` field, the 32-character id in the icon URL that identifies the app's media set, is also delivered):

```json
{
  "rowType": "app",
  "detailLevel": "full",
  "appHandle": "judgeme",
  "appUrl": "https://apps.shopify.com/judgeme",
  "name": "Judge.me Product Reviews App",
  "tagline": "Sell more with unlimited product reviews, UGC, star ratings, Google reviews and testimonials",
  "metaDescription": "Send unlimited, automatic review requests via email, SMS, and push. Display stars and reviews on storefront, share reviews on social media and Google Shopping.",
  "description": "Driving traffic is only half the battle – trust is what converts. Judge.me boosts conversion rate with unlimited product reviews, star ratings, and UGC (photo/video).\nAutomate review requests after fulfillment or delivery, launch review widgets and testimonial sliders, boost visibility with Google reviews & SEO page. ...",
  "highlights": [
    "Collect and manage unlimited reviews, photos, videos, testimonials, ratings",
    "Display eye-catching review widgets, testimonial sliders and product ratings"
  ],
  "iconUrl": "https://cdn.shopify.com/app-store/listing_images/8cada0f5da411a64e756606bb036f1ed/icon/CIfp9fWd34sDEAE=.png",
  "screenshots": [
    "https://cdn.shopify.com/app-store/listing_images/8cada0f5da411a64e756606bb036f1ed/promotional_image/CLKC7ZOSpJMDEAE=.png",
    "https://cdn.shopify.com/app-store/listing_images/8cada0f5da411a64e756606bb036f1ed/desktop_screenshot/CJ3w-uC_140DEAE=.png"
  ],
  "screenshotCount": 7,
  "developerName": "Judge.me",
  "developerUrl": "https://apps.shopify.com/partners/judge-me",
  "developerSupportEmail": "support@judge.me",
  "developerAddress": "C/O Buckworths 2nd Floor, 1-3 Worship Street, London, England, ENG, EC2A 2AB, GB",
  "basedIn": "France",
  "rating": 5,
  "reviewCount": 50450,
  "ratingDistribution": {
    "5": { "percent": 98, "countLabel": "49K", "countApprox": 49000 },
    "4": { "percent": 2, "countLabel": "830", "countApprox": 830 },
    "3": { "percent": 0, "countLabel": "80", "countApprox": 80 },
    "2": { "percent": 0, "countLabel": "40", "countApprox": 40 },
    "1": { "percent": 0, "countLabel": "156", "countApprox": 156 }
  },
  "pricingSummary": "Free plan available. Free trial available.",
  "pricingPlans": [
    {
      "planName": "Awesome",
      "priceLabel": "$15/month",
      "price": "$15",
      "billingPeriod": "month",
      "planNotes": [],
      "freeTrial": "15-day free trial",
      "features": ["AI (replies, summary, translations)", "130+ integrations, inc. Klaviyo, Gorgias"]
    }
  ],
  "pricingPlansComplete": false,
  "pricingFootnote": "All charges are billed in USD. Recurring and usage-based charges are billed every 30 days.",
  "builtForShopify": true,
  "awards": ["Build Award winner"],
  "categories": [
    { "name": "Product reviews", "slug": "marketing-and-conversion-social-trust-product-reviews" },
    { "name": "SEO", "slug": "store-design-site-optimization-seo" }
  ],
  "categoryFeatures": ["Testimonials", "Photo reviews", "Video reviews", "Star ratings"],
  "languages": ["English", "Spanish", "French", "Italian", "Portuguese (Brazil)", "German"],
  "worksWith": ["Checkout", "Customer accounts", "Shopify Flow", "Shopify Admin"],
  "launchedDate": "2015-06-25",
  "changelogUrl": "https://judge.me/app/changelog",
  "supportLinks": { "privacyPolicy": "https://judge.me/privacy" },
  "discoveredVia": "appUrl",
  "listPosition": null,
  "sitemapLastmod": null,
  "scrapedAt": "2026-11-20T03:52:11.000Z"
}
```

Review row:

```json
{
  "rowType": "review",
  "reviewId": "2434343",
  "reviewUrl": "https://apps.shopify.com/reviews/2434343",
  "appHandle": "judgeme",
  "rating": 5,
  "reviewDate": "2026-11-18",
  "edited": false,
  "body": "We've been using Judge.me for a couple of years now and it is working great! I was really surprised at how great the support has been. Especially Felix just helped me with doing a few things and stuck with me until it was all fixed and working perfectly. 5-stars!",
  "storeName": "The Sydney String Centre",
  "storeCountry": "Australia",
  "usageDuration": "Almost 3 years using the app",
  "developerReply": null,
  "developerReplyDate": null,
  "developerReplyBy": null,
  "developerReplyId": null,
  "reviewsSort": "newest",
  "ratingFilter": null,
  "pageNumber": 1,
  "scrapedAt": "2026-11-20T03:52:12.000Z"
}
```

### Pricing

Pay per delivered row, usage included. Nothing is charged for a row that is not pushed to your dataset, and error or info rows are never charged.

| Event | Price | What it is |
| --- | --- | --- |
| `app` | $0.0010 per row ($1.00 per 1,000) | One full-detail app row |
| `app-card` | $0.0003 per row ($0.30 per 1,000) | One card row when `scrapeAppDetails` is off |
| `review` | $0.0003 per row ($0.30 per 1,000) | One merchant review |

A default run (`{}`, one app, no reviews) costs $0.0010. 20 app rows cost $0.02, and 1,000 reviews cost $0.30. Prices shown are the Free plan prices at the time of writing.

### How this compares

Public Apify Store numbers read on 2026-11-20. Prices are the Free-plan list prices, with the cheapest paid tier in brackets. This actor includes platform usage in its price; for competitors' usage terms, see each listing.

| Actor | 30-day users | 30-day runs (ok/failed/total) | App row | Review row |
| --- | --- | --- | --- | --- |
| This actor | new | new | $0.0010 | $0.0003 |
| alwaysprimedev/shopify-app-store-scraper | 56 | 134/9/143 | $0.05 ($0.0025) | same item event |
| applora/shopify-appstore-scraper | 41 | 711/8/736 | $0.005 ($0.0029) | same event |
| fatihtahta/shopify-app-store-scraper | 12 | 228/0/233 | $0.00199 ($0.00149) | $0.00099 ($0.0007) |
| freshactors/shopify-app-store-scraper | 4 | 216/44/260 | $0.002 plus $0.001 discovery ($0.0008 plus $0.0004) | $0.0001 flat |
| scrapesage/shopify-app-store-scraper | 1 | 50/0/51 | $0.004 ($0.00322) | $0.001 ($0.00081) |

freshactors is cheaper per review. This actor is cheaper per app row than every other actor listed, and its app rows carry fields the others do not publish: per-star rating distribution with abbreviated counts, categories and category feature tags, developer address and country, awards, Shopify's AI review summary, per-plan free trial and plan notes, the review `edited` flag, developer reply author and date split, leaf-category and developer-page discovery, and star-rating slicing to reach past Shopify's 10,000 reviews per view.

### Limits

- **Reviews stop at 10,000 per app and sort/star view.** Shopify answers HTTP 404 from page 1001 of the review list. Above `maxReviewsPerApp` of 10,000 the actor pages each star rating separately and deduplicates by review id, which reaches the smaller star buckets but still cannot export all 50,000 reviews of an app like Judge.me. When the cap is what limits the export, the run adds one free `info` row saying so. This actor never promises a full review history for apps with more than 10,000 reviews.
- **No keyword search.** `robots.txt` disallows `*q=*` for generic crawlers and `/search` answers HTTP 429. Discovery is by app, category, developer or sitemap instead.
- **Rating distribution counts are abbreviated by Shopify** above 999 ("49K", "4.3K"). `countLabel` is what the page says, `countApprox` is the parsed number and is approximate.
- **Pricing plans are the plans on the listing.** When a developer links out with "See all pricing options", `pricingPlansComplete` is `false` and the actor does not follow the external link.
- **Top-level categories have no pagination.** Shopify serves a curated 30-card landing page for them; this actor expands them into their sub-categories from the public category sitemap and pages those.
- **`maxReviewsPerApp` is per app**, so a run over 100 apps with reviews can be large. Keep `maxItems` in mind: it caps charged rows for the whole run.

### Responsible use

This actor reads public Shopify App Store pages, the same pages any visitor sees, without logging in. It honours `robots.txt`, never requests the disallowed search endpoint, keeps concurrency low (3 parallel requests) with per-request timeouts and retries that back off, and switches to an Apify datacenter proxy if Shopify starts answering 429 or 503. Reviews contain merchant business names and countries, not shopper personal data. Check Shopify's terms and the terms of any app data you collect before you use the data commercially, and do not use this actor to build a competing directory that republishes the listings wholesale.

# Actor input Schema

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

Apps to scrape in full: paste https://apps.shopify.com/judgeme style URLs or bare handles such as judgeme. Each app costs one detail page request.

## `categorySlugs` (type: `array`):

Category slugs such as marketing-and-conversion-social-trust-product-reviews, or category URLs. A leaf category is paged through until it ends. A top-level slug such as store-design is expanded into its sub-categories automatically.

## `developerSlugs` (type: `array`):

Developer (partner) slugs such as judge-me, or https://apps.shopify.com/partners/judge-me URLs. Every app on that developer's page is scraped.

## `allApps` (type: `boolean`):

Read sitemap_apps_en.xml (about 30,800 app handles) and scrape each app. Use maxItems and sinceDate to keep the run small.

## `sinceDate` (type: `string`):

Only used with allApps: keep apps whose sitemap lastmod is on or after this date. ISO date, e.g. 2026-01-01.

## `scrapeAppDetails` (type: `boolean`):

On (default): open each app page and deliver the full row (pricing plans, categories, developer, screenshots, rating distribution). Off: deliver card-level rows from category and developer pages without opening app pages, which is about 3x cheaper per row. Apps listed in appUrls are always opened in full.

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

Page through merchant reviews for every app in this run (10 per page). Shopify serves at most 10,000 reviews per app and sort/star view.

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

Cap on review rows per app (1-50000). Above 10,000 the actor slices by star rating to reach past Shopify's 10,000 per view limit and deduplicates by review id.

## `reviewsSort` (type: `string`):

newest = newest reviews first. relevance = Shopify's default relevance order.

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

Deliver only reviews with these star ratings. Leave empty for all ratings. Allowed values: 1, 2, 3, 4, 5.

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

Hard cap on charged rows in the whole run (app, card and review rows together). Error and info rows are free and do not count. The run stops as soon as the cap is reached.

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

Off by default: apps.shopify.com answers plain datacentre requests. If Shopify starts rate limiting, the actor backs off and then switches to an Apify datacenter proxy on its own.

## Actor input object example

```json
{
  "appUrls": [
    "https://apps.shopify.com/judgeme"
  ],
  "allApps": false,
  "scrapeAppDetails": true,
  "includeReviews": false,
  "maxReviewsPerApp": 20,
  "reviewsSort": "newest",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Every delivered row: rowType app, review, error or info. Error and info rows are never charged.

## `summary` (type: `string`):

Counts per row type, duplicates skipped, category results and the stop reason.

# 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 = {
    "appUrls": [
        "https://apps.shopify.com/judgeme"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("subimpact/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 = { "appUrls": ["https://apps.shopify.com/judgeme"] }

# Run the Actor and wait for it to finish
run = client.actor("subimpact/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 '{
  "appUrls": [
    "https://apps.shopify.com/judgeme"
  ]
}' |
apify call subimpact/shopify-app-store-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,subimpact/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/Ba8oN0kyYoNKq7Lsc/builds/pcCdDxAfd7GElWfkL/openapi.json
