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

Scrape the Shopify App Store: app listings with USD pricing plans, rating histogram, launch date, developer, categories and features; reviews with star filter and developer replies; developer profiles; and category snapshots with an opportunity score to find app ideas. No login.

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

## Pricing

from $2.00 / 1,000 app listings

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, Reviews, Developers & App Ideas

Extract the **Shopify App Store** into clean, analysis-ready rows: every app listing with its
**pricing plans in USD**, rating and **star histogram**, launch date, developer and business
address, categories and feature tags, languages, integrations and data access; merchant
**reviews** with a native star filter and the developer reply; **developer** profiles with all
their apps; and a **category snapshot** with a published **opportunityScore** to find app
ideas worth building. No login, no account, no API key.

### What you get

| Output type | One row per | Highlights |
|---|---|---|
| `apps` (default) | app of the categories / search terms you choose (or the whole store) | 74 columns: plans with price, billing period, trial days and usage charges; rating, review count and histogram; launch date; developer, website, country; categories with feature tags; languages; works-with; data access; similar apps; Built for Shopify |
| `app-details` | app link you paste | the same full listing |
| `reviews` | merchant review | stars, date, text, store, country, time using the app, developer reply and its date |
| `developers` | developer | every app with rating and reviews, total reviews, review-weighted rating, Built for Shopify apps, website, business address, company support e-mail |
| `category-snapshot` | category | apps, median rating, share rated below 4.0, apps launched in the last 12 months, median price, free-plan share, review concentration, top apps, weak incumbents, **opportunityScore** |

Error rows (an app that does not exist or is no longer available, a page Shopify could not
serve) are delivered with a plain-English reason and are **never charged**.

### Find app ideas: the opportunityScore

Each `category-snapshot` row scores a category from 0 to 100 with a fixed, published formula
(the same input always gives the same number, so runs are comparable):

- **Demand (40%)** = log10(1 + total reviews of the category) / 5, capped at 1 — reviews are the
  public usage signal of Shopify apps; 100,000 reviews = full demand.
- **Dissatisfaction (25%)** = share of rated apps below 4.0 stars. If no app of the category has a
  rating, it is `null`, `dissatisfactionMeasured` is false and the weights are renormalized over the
  measured components (formula v1.4; on Shopify almost every category has rated apps).
- **Staleness (20%)** = share of apps not updated for 2+ years. Shopify publishes no update date
  for apps, so this component is not measurable here: it is `null`, `stalenessMeasured` is false
  and the score is renormalized over the other three weights (formula v1.4: 50% demand, 31.25%
  dissatisfaction, 18.75% openness), so it still spans 0–100.
- **Openness (15%)** = 1 / (1 + populationCount / 50), where populationCount is the number of
  apps Shopify declares for the category (`opennessBasis` says `category`, or
  `sample` if the count was not available): fewer competitors = more room.
- Since v1.2: apps whose review count is unknown are left out of the demand medians
  (`demandKnownCount` says how many were known); an app with 0 reviews is a measured 0.

The snapshot also lists `lowRatedPopularApps` (rated below 4.0 with 20+ reviews: incumbents
merchants complain about) and `newestApps`. Measured on 17 Oct 2026 across the 122 subcategories:
total reviews per subcategory range from 36 to 99,423 (median about 7,400).

### Data coverage (measured, not promised)

Measured on 17 Oct 2026 on the **whole store** read with this actor (28,807 apps; the fill rate of
every field is also written in the dataset schema with its n):

- The store has **28,816 apps** (sitemap ∪ the 122 subcategory listings); **58% have no review
  yet** and therefore no rating (rating filled 41.7%); 6% carry the Built for Shopify badge.
- 100%: name, icon, review count, star histogram, pricing summary, launch date, categories,
  developer, business address and country code, privacy policy, screenshots. 99%: description,
  feature bullets, languages. Pricing plans 82.6% (the rest show a single price line); cheapest
  paid price 72.7%; data access 76.6%; works-with 62.8%; developer website 54.9%; demo store
  32.5%; video 28%; Shopify's AI review summary 3.4% (only apps with 100+ reviews).
- Support e-mail: delivered for 83.3% of apps (company domains); free-mail addresses are withheld.
- Reviews (n = 1,452 real reviews): stars, date, store and country 100%; text 72.9% (many
  reviews are stars only); developer reply 50.9%.
- Average non-empty fields per row: app 55 of 74, review 19 of 24, developer 19 of 22,
  category snapshot 31 of 38.

### Input examples

Default input `{}`: 20 apps in 5–15 seconds (measured on 21 Oct 2026, one app from each of the
first 20 subcategories; 15 s live, 5–8 s with the shared cache).

```json
{ "categories": ["marketing-and-conversion-marketing-email-marketing"], "sortBy": "lowest-rating", "minReviews": 50, "maxItems": 100 }
```

```json
{ "outputType": "reviews", "appUrls": ["https://apps.shopify.com/klaviyo-email-marketing"], "reviewsStars": ["1", "2"], "maxReviewsPerApp": 200 }
```

```json
{ "outputType": "category-snapshot", "categories": ["store-design", "store-management"] }
```

### Filters and how they are applied

- **Built for Shopify**, **Newest** order and **review stars** are sent to Shopify's own filters.
- **Rating, number of reviews, free plan** and the **most reviews / highest / lowest rating**
  orders are checked on the listing cards first (free) and confirmed on the app page — also for
  `reviews` and `developers` read from categories or search: an app that fails a filter gets no
  review or developer row, and nothing is charged for it.
- **Free plan** means Shopify shows *Free*, *Free plan available* or *Free to install* (some
  "Free to install" apps charge per usage: `freeToInstall` and each plan's `usageCharges` tell them
  apart).
- **Launch date** and **maximum starting price** are checked on each app page: the run checks up
  to 100 candidates per requested row (at least 200) and then stops, saying so in the status.
- Apps without reviews have no rating and never pass a rating filter.
- Pasted app links are always processed (filters are not applied to them), and categories or
  search terms filled in the same run are not read (the run log says so).
- A category or search term is read up to 80 pages (1,920 apps; the largest subcategory has
  1,671): Shopify search can match thousands of apps, and the status says when that cap was hit.

### Pricing (pay per event)

| Event | Price |
|---|---|
| App listing (`app`, primary) | **$0.002** ($2.00 per 1,000) |
| Review | $0.0001 |
| Developer profile | $0.001 |
| Category snapshot | $0.05 |
| Actor start | $0.00001 |

Why a category snapshot costs $0.05: with the default `snapshotDepth: full` one row reads **every
app page** of the category (about 300 on average, up to 1,671) plus its listing, so it replaces the
\~300 app rows ($0.60) you would otherwise export to compute the same aggregate. `listing` depth costs
the same and reads only the listing cards (faster, no launch dates or exact prices).

Error rows, duplicates within a run, unavailable apps and partial snapshots are never charged.
Rows reused from the shared cache (marked with `cachedAt`) cost the same.

### How this compares (measured 17 Oct 2026)

Compared with the output schemas that other Shopify App Store actors declare on Apify:

| | This actor | Typical app scrapers |
|---|---|---|
| Columns per app row | 74 | 15–48 (often app and review fields mixed in one table) |
| Pricing plans parsed (USD, period, trial, usage charges) | yes | price label or raw tiers |
| Rating histogram per star | yes | no |
| Reviews with native star filter + developer reply | yes | some |
| Developer profiles with all apps | yes | no |
| Category snapshot + opportunityScore | yes | no |
| Errors and duplicates charged | never | varies |
| Price per app row (free tier) | $0.002 | $0.00199–$0.05 (the most used: $0.005) |

### FAQ

**Is the data live?** Not always, by default. App pages and developer pages read by any run of
this actor in the last 24 hours (`maxCacheAgeHours`, default 24) are reused from a shared cache, and
those rows carry `cachedAt` (the time the page was read); in our 50 test runs of 17 Oct 2026, 40% of
the app rows (560 of 1,417) came from the cache. Set `maxCacheAgeHours` to 0 to read every page live.
Reviews and category listings are always read live.

**Why do some apps have no rating?** They have no review yet (58% of the store).

**Why does a renamed app show a different handle?** Shopify redirects old handles; the row keeps
the handle you asked for in `requestedHandle`.

**Does it use my Shopify account?** No. Only public pages, no login.

This actor is not affiliated with, endorsed by or sponsored by Shopify. Shopify is a trademark of
its owner. It reads public pages only and does not collect personal e-mail addresses.

# Actor input Schema

## `outputType` (type: `string`):

One row type per run. <b>apps</b>: full app listings (pricing plans in USD, rating histogram, launch date, developer, categories and features, languages, integrations, data access, similar apps) for the categories or search terms below — or for the whole store when both are empty. <b>app-details</b>: the same for the app links you paste. <b>reviews</b>: merchant reviews with star filter, store, country, time using the app and the developer reply. <b>developers</b>: developer profiles with every app, total reviews, rating, website and business address. <b>category-snapshot</b>: one aggregated row per category with an opportunityScore (demand, dissatisfaction, competition) to find app ideas.

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

Shopify App Store categories (122 subcategories with full listings; a parent category includes all of its subcategories). You can also paste category links (https://apps.shopify.com/categories/…). Empty, with no search terms or links = every category of the store.

## `search` (type: `array`):

Shopify App Store search, 24 apps per page in Shopify's relevance order. Plain words only (letters, digits, spaces and & ' + . , -). Shopify throttles its search hard (measured: a throttle response from the 1st or 2nd request on one connection); the actor switches connections automatically, so search runs are a little slower than category runs.

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

Apps to scrape directly, e.g. https://apps.shopify.com/klaviyo-email-marketing or just klaviyo-email-marketing. Used by app-details, reviews and developers. Pasting links with the type "Apps" switches the run to app details; the filters are not applied to pasted links. Renamed apps are followed to their new address.

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

Developer pages, e.g. https://apps.shopify.com/partners/klaviyo or klaviyo. Pasting them with the type "Apps" switches the run to developers.

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

Rows delivered (and charged) at most: apps, reviews, developers or category snapshots. Duplicates and error rows are never charged. The store has about 28,800 apps. Empty = 20, or every link you pasted.

## `sortBy` (type: `string`):

Relevance and Newest are Shopify's own orders (Newest applies to category listings). Most reviews, Highest rating and Lowest rating are computed by the actor: it first reads every app card of the selected categories or searches (24 per page, cheap) and then fetches the top ones.

## `minRating` (type: `number`):

Apps rated at least this (0–5). 58% of the store has no reviews and therefore no rating: those apps never pass a rating filter.

## `maxRating` (type: `number`):

Apps rated at most this — e.g. 4 finds popular apps that merchants are unhappy with.

## `minReviews` (type: `integer`):

The number of reviews is the public usage signal of a Shopify app.

## `maxReviews` (type: `integer`):

E.g. 20 to find young or niche apps.

## `launchedAfter` (type: `string`):

Date like 2025-01-01. Checked on each app page: the run checks up to 100 candidates per requested row (at least 200) and then stops, saying so in the status.

## `launchedBefore` (type: `string`):

Date like 2020-12-31. Checked on each app page (same scan limit as above).

## `maxLowestPrice` (type: `number`):

Cheapest plan at most this, 0 = apps with a free plan. Checked on each app page (same scan limit as above).

## `freePlanOnly` (type: `boolean`):

Checked on the listing label first and confirmed with the pricing plans.

## `builtForShopify` (type: `boolean`):

Shopify's own quality badge (6% of the store). Sent to Shopify as its native filter.

## `reviewsStars` (type: `array`):

Only reviews with these star ratings, e.g. \[1, 2] for complaints. Sent to Shopify as its native filter. Empty = all.

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

Newest first or Shopify's "most relevant".

## `reviewsSince` (type: `string`):

Only reviews dated on or after this date (2026-01-01). With newest first, paging stops after a page entirely older than the date (Shopify's newest order is not strictly by the displayed date).

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

Reviews delivered at most for each app (10 per page).

## `snapshotDepth` (type: `string`):

<b>full</b>: reads every app page of the category (exact cheapest price and launch dates → apps launched in the last 12 months, newest apps); a category of 300 apps takes about 30–60 s. <b>listing</b>: only the listing cards (rating, reviews, price label), 10× faster, without launch dates.

## `maxCacheAgeHours` (type: `integer`):

When the shared cache is available, an app or developer page fetched by any run in the last N hours is reused (rows carry cachedAt and cost the same). Ratings and review counts of big apps change daily. 0 = always live. Reviews are always fetched live.

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

Requests in flight at once, each on its own connection. Higher values are faster on big runs.

## Actor input object example

```json
{
  "outputType": "apps",
  "categories": [],
  "search": [],
  "appUrls": [],
  "developers": [],
  "maxItems": 20,
  "sortBy": "relevance",
  "freePlanOnly": false,
  "builtForShopify": false,
  "reviewsStars": [],
  "reviewsSort": "newest",
  "maxReviewsPerApp": 100,
  "snapshotDepth": "full",
  "maxCacheAgeHours": 24,
  "maxConcurrency": 8
}
```

# Actor output Schema

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

The rows of this run: apps, reviews, developers or category snapshots, depending on the outputType you chose.

## `errors` (type: `string`):

Every error of the run with its reason and what to do. Always present, empty when nothing failed.

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

Counts of delivered, charged, duplicate, filtered and error rows for this run.

# 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 = {
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("oswaldocarabano/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 = { "maxItems": 20 }

# Run the Actor and wait for it to finish
run = client.actor("oswaldocarabano/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 '{
  "maxItems": 20
}' |
apify call oswaldocarabano/shopify-app-store-scraper --silent --output-dataset

```

## MCP server setup

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