# Shopify App Store Scraper — Apps, Pricing Plans & Reviews (`yugenox/shopify-app-store-scraper`) Actor

Scrape the Shopify App Store: apps with rating, review count, rating breakdown, pricing plans, categories, features, languages, integrations, developer and launch date, plus merchant reviews with developer replies. By app URL, category, developer or the whole store. No login.

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

## Pricing

from $2.00 / 1,000 apps

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, Pricing Plans & Reviews

Scrape the **Shopify App Store** (apps.shopify.com) into clean rows: every app's **rating, review count and star breakdown, pricing plans (with USD prices and free trials), categories and features, languages, integrations, "Built for Shopify" badge, developer, launch date and data access** — plus the **merchant reviews** with store name, country, time using the app and the developer's reply.

Start from **app URLs**, **categories** (by link or simply by name, e.g. "Email marketing"), **developers**, or the **whole store** (about 29,000 apps). No login, no cookies, no browser.

### What you can do with it

- **Competitor research for app developers** — pricing plans, trial lengths, features, languages and integrations of every app in your category, in one table.
- **Category rank tracking** — the position of each app in a category listing, its rating and review count, run daily or weekly.
- **Review monitoring** — new reviews of your app (or your competitors') every day with "Only new reviews"; filter 1–2 star reviews to catch complaints early.
- **Market sizing & lead lists** — every app in a category or the whole store with its developer, website and business support mailbox.
- **New app launches** — "Whole store" + "Only new apps" returns only apps that weren't there on your last run.

### Input

| Field | What it does |
|---|---|
| **App URLs or handles** | `https://apps.shopify.com/klaviyo-email-marketing` or just `klaviyo-email-marketing` |
| **Categories** | A category link, its handle (`store-design-seo`) or its name (`Email marketing`, `Product reviews`, `Upsell and bundles`) |
| **Developers** | `https://apps.shopify.com/partners/klaviyo` or `klaviyo` |
| **Whole store** | Every listed app (~29,000; about an hour with the default 2-hour Timeout, longer with reviews — raise Timeout for those) |
| **Max apps** | Apps per run, shared fairly between categories / developers (0 = no limit) |
| **Scrape app details** | On: the full app page for every app. Off: only what category / developer listings show (faster) |
| **Include reviews** | Merchant reviews as separate rows, with **Max reviews per app**, **Sort** (newest / most relevant), **star ratings** filter and **Reviews newer than** (a date or "30 days") |
| **Only new reviews / Only new apps** | Skip what an earlier run with the same settings already saved — perfect for scheduled monitors |

Example — the 50 top email marketing apps with their 20 newest reviews each:

```json
{
  "categories": ["Email marketing"],
  "maxApps": 50,
  "includeReviews": true,
  "maxReviewsPerApp": 20
}
```

### Output

One dataset with two row types — `"type": "app"` and `"type": "review"` — and two table views (Apps, Reviews). Export to JSON, CSV, Excel or straight into your tools.

An app row (trimmed):

```json
{
  "type": "app",
  "appHandle": "judgeme",
  "appUrl": "https://apps.shopify.com/judgeme",
  "name": "Judge.me Product Reviews App",
  "tagline": "Collect unlimited product reviews, star ratings, testimonials",
  "rating": 5,
  "reviewCount": 49324,
  "ratingDistribution": { "1": 154, "2": 37, "3": 74, "4": 818, "5": 48242 },
  "pricingSummary": "Free plan available. Free trial available.",
  "hasFreePlan": true,
  "freeTrialDays": 15,
  "lowestMonthlyPriceUsd": 15,
  "pricingPlans": [
    { "name": "Forever Free", "priceText": "Free", "price": 0, "priceUsd": 0, "features": ["Unlimited product and store reviews", "…"] },
    { "name": "Awesome", "priceText": "$20.98 CAD/month", "price": 20.98, "currency": "CAD", "period": "month", "priceUsd": 15, "freeTrialDays": 15, "features": ["130+ integrations, inc. Klaviyo, Gorgias", "…"] }
  ],
  "priceCurrency": "CAD",
  "exchangeRateToUsd": 0.715,
  "builtForShopify": true,
  "developerName": "Judge.me",
  "developerUrl": "https://apps.shopify.com/partners/judge-me",
  "supportEmail": "support@judge.me",
  "launchedAt": "2015-06-25",
  "languages": ["English", "Spanish", "French", "Italian", "…"],
  "worksWith": ["Checkout", "Customer accounts", "Shopify Flow", "…"],
  "categories": ["Product reviews", "SEO"],
  "similarApps": ["yotpo-social-reviews", "reviews-co-uk-product-and-merchant-review-collection", "proviews"],
  "detailsScraped": true,
  "source": "category",
  "position": 1,
  "scrapedAt": "2026-10-30T05:33:00.402Z"
}
```

Also on every app row: short description, full description, key benefits, icon, screenshots, videos, category features, data access (what store data the app asks for), the App Store's summary of what merchants say, developer website and address, changelog and privacy policy links.

A review row:

```json
{
  "type": "review",
  "reviewId": "2412151",
  "reviewUrl": "https://apps.shopify.com/reviews/2412151",
  "appHandle": "klaviyo-email-marketing",
  "appName": "Klaviyo: Email Marketing & SMS",
  "rating": 5,
  "date": "2026-10-29",
  "edited": false,
  "text": "KLaviyo has definitely increase our revenue beyond our expectations. …",
  "storeName": "Uncle Otis Clothing",
  "storeCountry": "Canada",
  "usageDuration": "2 months using the app",
  "developerReply": null,
  "sortBy": "newest",
  "position": 3
}
```

### Pricing

Pay only for what you get:

- **$2.00 per 1,000 apps** (one app row, with or without the full details)
- **$0.20 per 1,000 reviews**
- **$0.002 per run start**

Apps that don't exist, rows you filtered out and anything already saved by "Only new" runs are never charged. Example: 50 apps with 20 reviews each = $0.10 + $0.20 + $0.002 ≈ **$0.30**.

### Tips

- **Prices** are shown in the currency of the visitor's location; every plan also has `priceUsd`, converted with the exchange rate the App Store itself shows.
- **Ranking**: `position` is the app's place in the category listing, in the App Store's own order. Paid "Ad" placements at the top of a category page are left out, so every app appears once, at its own rank.
- **Daily review monitor**: list your apps under App URLs, turn on "Include reviews" + "Only new reviews", and schedule the run.
- **Complaints only**: "Only these star ratings" = 1 and 2.
- **Faster, cheaper listings**: turn "Scrape app details" off to get name, rating, review count, pricing summary and rank straight from the category pages.
- The App Store's keyword search is not used (its search pages are off-limits to crawlers); use categories or developers instead.

### FAQ

**Is it legal to scrape the Shopify App Store?**
This actor reads only public pages that anyone can open without an account — app listings, category listings, developer pages and public reviews — and it follows the site's robots.txt. It doesn't log in and doesn't get around any access control. As with any data, check that your use (for example, storing or republishing it) complies with the laws that apply to you, such as GDPR, and consult a lawyer if you are unsure.

**Does it access any private data?**
No. Everything comes from public App Store pages. Reviews carry the merchant's store name and country as the App Store shows them; personal e-mail addresses and phone numbers inside review texts are masked, and only business support mailboxes of app developers are kept.

**Why are some ratings null?**
Apps with no reviews yet have no rating (`rating: null`, `reviewCount: 0`). Some reviews are star-only, so their `text` is empty.

**Why are some taglines cut with "…"?**
The app page itself shortens long taglines. When the app comes from a category or developer listing, the full tagline is used.

**How fresh is the data?**
Every run reads the live App Store pages at that moment.

**Something isn't right?**
Open an issue on the actor's Issues tab with the run link.

# Actor input Schema

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

Shopify App Store app pages, e.g. https://apps.shopify.com/klaviyo-email-marketing, or just the handle (klaviyo-email-marketing). Category and developer links pasted here are recognised too.

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

Category links (https://apps.shopify.com/categories/store-design-seo), handles (store-design-seo) or names ("Email marketing", "Upsell and bundles", "Product reviews"). Every app the category lists is saved, in the category's own order (its rank is in "position").

## `developers` (type: `array`):

Developer (partner) pages, e.g. https://apps.shopify.com/partners/klaviyo, or just the partner handle (klaviyo). Every app the developer publishes is saved.

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

Every app listed on the Shopify App Store (about 29,000). Combine with "Only new apps" to get only apps launched since your last run. A full crawl takes about an hour (the default Timeout is 2 hours; raise it when you also want reviews).

## `maxApps` (type: `integer`):

Maximum number of apps for the whole run, shared fairly between your categories and developers. 0 = no limit.

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

Open every app's page for the full details: pricing plans, rating breakdown, categories and features, languages, integrations, developer, launch date, data access. Turn off to save only what category and developer listings show (name, rating, review count, pricing summary, tagline, Built for Shopify, position). App URLs and the whole store always open the app page.

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

Also save each app's merchant reviews: rating, date, text, store name, store country, time using the app and the developer's reply. Reviews are separate rows (type "review").

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

Maximum reviews per app. 0 = all of them.

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

Newest first (default) or the Shopify App Store's "Most relevant" order.

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

Only reviews with these star ratings, e.g. 1 and 2 for complaints. Empty = all ratings.

## `reviewsNewerThan` (type: `string`):

Only reviews from this date on: a date (2026-10-01) or a period (7 days, 4 weeks, 6 months, 1 year). Older pages are not read.

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

Skip reviews that an earlier run with the same review settings already saved (they are not charged). Ideal for a daily or weekly review monitor.

## `onlyNewApps` (type: `boolean`):

For categories, developers and the whole store: skip apps that an earlier run with the same input already saved (not fetched, not charged). Apps you list under App URLs are always scraped.

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

Apify Proxy (datacenter) is the default and comes with every Apify plan. If the Shopify App Store keeps rate-limiting datacenter IPs, the run switches to residential proxies when your account has them.

## `_noResidential` (type: `boolean`):

Internal (canaries): behave exactly like an account without the RESIDENTIAL proxy group.

## Actor input object example

```json
{
  "appUrls": [
    "https://apps.shopify.com/klaviyo-email-marketing"
  ],
  "allApps": false,
  "maxApps": 10,
  "scrapeAppDetails": true,
  "includeReviews": true,
  "maxReviewsPerApp": 10,
  "reviewsSort": "newest",
  "onlyNewReviews": false,
  "onlyNewApps": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "_noResidential": false
}
```

# Actor output Schema

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

All scraped apps and reviews.

## `run` (type: `string`):

Status and statistics for this run.

## `report` (type: `string`):

RUN_REPORT: how the run ended, counts, requests and proxy use.

# 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/klaviyo-email-marketing"
    ],
    "maxApps": 10,
    "includeReviews": true,
    "maxReviewsPerApp": 10,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("yugenox/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/klaviyo-email-marketing"],
    "maxApps": 10,
    "includeReviews": True,
    "maxReviewsPerApp": 10,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("yugenox/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/klaviyo-email-marketing"
  ],
  "maxApps": 10,
  "includeReviews": true,
  "maxReviewsPerApp": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call yugenox/shopify-app-store-scraper --silent --output-dataset

```

## MCP server setup

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