# Shopify App Reviews Scraper - Merchant Reviews by App (`confidential_gnat/shopify-app-reviews-scraper`) Actor

Scrapes merchant reviews of any Shopify App Store app (apps.shopify.com), one row per review: rating, date, text, store name, country, usage time and developer reply. Use app URLs or handles, filter by stars or date, and enrich Shopify App Store scraper results.

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

## Pricing

from $0.50 / 1,000 results

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 Reviews Scraper (apps.shopify.com) - Merchant Reviews by App

**Scrape merchant reviews of any Shopify App Store app (apps.shopify.com)**: one row per review with the star rating, review date, review text, store name, store country, how long the store used the app and the developer reply. Paste an app URL or handle, press Start, and export the **Shopify app reviews** as **JSON, CSV or Excel**, or call the actor as a **Shopify App Store reviews API**. Filter by star rating or date and get only new reviews on every scheduled run. It also **enriches the apps you scraped with the Shopify App Store scraper** by adding their reviews.

![Shopify Reviews Scraper cover: a review record with app, rating, date, review text, store name, country and developer reply from apps.shopify.com as JSON](https://i.postimg.cc/zBV6cn0T/Gemini-Generated-Image-7x83077x83077x83.jpg)

**Target website:** [apps.shopify.com](https://apps.shopify.com)

### ✨ Features of this Shopify app reviews scraper

- **One row per review** — rating, date, full review text, store name, store country, usage time ("3 months using the app"), developer reply and reply date, plus the app handle, name and URL so rows join back to your app list
- **Any app, many apps per run** — app URLs, app review URLs or plain app handles such as `judgeme`
- **Pagination support** — pages through the newest-first review list until Max reviews per app is reached or the reviews run out
- **Star rating filter** — keep only 1 and 2 star reviews to find complaints, or only 5 star reviews for testimonials
- **Date filter** — only reviews posted on or after a date
- **Only new reviews** — a cache project name skips reviews you already scraped, so scheduled runs return just the new ones
- **Works with the Shopify App Store scraper** — feed it the app URLs from that actor's dataset to enrich every app with its reviews
- **Proxy support** — optional Apify Proxy, off by default
- **No browser required** — plain HTTP requests keep runs fast and cheap

### 🚀 How to scrape Shopify app reviews in 5 steps

1. [Sign up](https://apify.com/sign-up) for a free Apify account — includes **$5 monthly credit**.
2. Open the actor page and click **Try for free**.
3. Fill in the **Input** fields (an app URL or app handle is required).
4. Click **Start** and wait for the run to complete.
5. Download results from the **Output** tab in JSON, CSV, or Excel format.

You can also run this actor via the [Apify API](https://docs.apify.com/api/v2) or integrate it directly into your workflows using [Zapier](https://zapier.com/apps/apify), [Make](https://www.make.com/), or [n8n](https://n8n.io/).

### 💰 Shopify app reviews scraper pricing

This actor uses **pay-per-result** billing: you pay for each review saved to the dataset.

- New Apify accounts include **$5 of free monthly credit**.
- It uses plain HTTP requests instead of a headless browser, so it costs significantly less to run than browser-based scrapers.
- Proxies are off by default, which keeps runs cheapest.
- Reviews skipped by the cache are not charged, so scheduled runs cost only for genuinely new reviews.

### 🔧 Shopify app reviews scraper input configuration

| Field | Type | Required | Default | Description |
| ----- | ---- | -------- | ------- | ----------- |
| `startUrls` | array | — | `https://apps.shopify.com/judgeme` (prefill) | Shopify app URLs or app review URLs. A `ratings[]` filter in a reviews URL is kept. |
| `maxItems` | integer | — | `5` | Maximum reviews saved for each app, newest first. |
| `cacheProjectName` | string | — | — | Use the same name on each run to get only new reviews. Cached reviews are skipped, not charged and not counted towards Max reviews per app. Records get `changeType: new`. |
| `appHandles` | array | — | `[]` | App handles from the app URL, for example `judgeme` for `https://apps.shopify.com/judgeme`. |
| `ratings` | array | — | `[]` | Keep only these star ratings (1 to 5). Empty means all ratings. |
| `reviewsSince` | string | — | — | Only save reviews posted on or after this date. |
| `proxyConfiguration` | object | — | `{ "useApifyProxy": false }` | Optional Apify Proxy. The site works without one. |

**Supported URL types:**

- App page: `https://apps.shopify.com/judgeme`
- App reviews page: `https://apps.shopify.com/judgeme/reviews` (optionally with `?ratings[]=1` to keep only 1 star reviews)

Search, category and developer pages are not reviews pages. Use the Shopify App Store scraper to turn those into a list of apps first, then follow the enrichment steps below.

### 📦 Shopify app reviews scraper output data

Each review is one flat JSON record with the fields `reviewId`, `url`, `appHandle`, `appName`, `appUrl`, `rating`, `postedAt`, `body`, `storeName`, `storeCountry`, `usageDuration`, `developerReply`, `developerReplyDate` and `scrapedAt` (plus `changeType` when a cache project is used). The dataset has 1 view: **Overview**, a compact table with the app, rating, date, review text, store, country, usage time, developer reply and review link.

**Output at a glance:**

| App | Rating | Posted | Store | Country | Review |
| --- | ------ | ------ | ----- | ------- | ------ |
| Judge.me Product Reviews App | 5 | 2026-10-19 | [Raith Clothing](https://apps.shopify.com/reviews/2400457) | United Kingdom | Great support |
| Judge.me Product Reviews App | 5 | 2026-10-19 | [True Nutra](https://apps.shopify.com/reviews/2400441) | United States | Alles super |
| Judge.me Product Reviews App | 5 | 2026-10-19 | [Conjuro Arcano](https://apps.shopify.com/reviews/2400381) | Spain | Me ayudarón en seguido con mis ajustes. Un gran equipo! |
| Judge.me Product Reviews App | 5 | 2026-10-19 | [Micro Nutrition](https://apps.shopify.com/reviews/2400380) | Ukraine | — |
| Judge.me Product Reviews App | 5 | 2026-10-19 | [GreenTahr](https://apps.shopify.com/reviews/2400302) | Spain | — |

**Sample output (raw JSON):**

```json
{
    "reviewId": "2400457",
    "url": "https://apps.shopify.com/reviews/2400457",
    "appHandle": "judgeme",
    "appName": "Judge.me Product Reviews App",
    "appUrl": "https://apps.shopify.com/judgeme",
    "rating": 5,
    "postedAt": "2026-10-19",
    "body": "Great support",
    "storeName": "Raith Clothing",
    "storeCountry": "United Kingdom",
    "usageDuration": "6 months using the app",
    "developerReply": null,
    "developerReplyDate": null,
    "scrapedAt": "2026-10-19T18:50:55.564Z"
}
```

### 🧩 How to enrich Shopify App Store scraper results with app reviews

The **Shopify App Store scraper** returns one row per app. This actor adds the reviews for those apps. Run the app scraper first, then pass its app URLs to this actor.

**No code (Apify Console):**

1. Run the [Shopify App Store scraper](https://apify.com/confidential_gnat/shopify-app-store-scraper) for your keyword, category or developer. Open the run's **Output** tab.
2. Export the dataset as CSV or Excel with only the `url` column (one app URL per row), or copy the `url` values.
3. Open this actor, click **Bulk edit** (or **Text file**) under **Shopify app or reviews URLs** and paste the URLs.
4. Set **Max reviews per app**, add star or date filters if you need them, and click **Start**.
5. Join the two datasets on `appHandle` (this actor) = `handle` (app scraper). Every review row also carries `appName` and `appUrl`.

**With code (Python):**

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")

## Apps from a finished Shopify App Store scraper run
apps = client.dataset("<APPS_DATASET_ID>").list_items(fields=["handle", "url"]).items

run = client.actor("confidential_gnat/shopify-app-reviews-scraper").call(run_input={
    "startUrls": [{"url": app["url"]} for app in apps],
    "maxItems": 50,
})

reviews_by_app = {}
for review in client.dataset(run["defaultDatasetId"]).iterate_items():
    reviews_by_app.setdefault(review["appHandle"], []).append(review)

for app in apps:
    app["reviews"] = reviews_by_app.get(app["handle"], [])
```

Tips for enrichment: use the same **Cache project name** on every run to add only reviews you have not stored yet, set **Only these star ratings** to 1 and 2 to collect complaints about competitor apps, and keep Max reviews per app modest when you enrich hundreds of apps.

### 🔁 Scrape only new Shopify app reviews with the cache

Set the same **Cache project name** on every scheduled run and the actor remembers each review it has saved under that name.

- **Skipped and not charged**: reviews already saved are not saved again, not charged, and do not count towards **Max reviews per app**.
- **Newest first**: the actor reads the newest reviews first and stops as soon as it reaches one it already has, so a run on an app with thousands of old reviews stays short.
- **Tagged as new**: every saved record gets `changeType: "new"`.
- **Separate caches per name**: use one name per product or competitor group and each keeps its own history.

Use it with an Apify Schedule for a daily or weekly feed of new reviews.

### 🐍 How to scrape Shopify app reviews with Python, JavaScript or the API

Run the actor programmatically with the official Apify clients. Replace `<YOUR_API_TOKEN>` with the token from your [Apify Console](https://console.apify.com/account/integrations).

**Python** (`pip install apify-client`):

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")

run = client.actor("confidential_gnat/shopify-app-reviews-scraper").call(run_input={
    "startUrls": [{"url": "https://apps.shopify.com/judgeme"}],
    "maxItems": 20,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

**JavaScript** (`npm install apify-client`):

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });

const run = await client.actor('confidential_gnat/shopify-app-reviews-scraper').call({
    startUrls: [{ url: 'https://apps.shopify.com/judgeme' }],
    maxItems: 20,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**cURL** — start a run and wait for the dataset:

```bash
curl -X POST "https://api.apify.com/v2/acts/confidential_gnat~shopify-app-reviews-scraper/run-sync-get-dataset-items?token=<YOUR_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"startUrls": [{"url": "https://apps.shopify.com/judgeme"}], "maxItems": 20}'
```

### 💡 What you can use Shopify app review data for

- **Competitor research** — read what merchants complain about in competing apps and find gaps to build into your own
- **Feature requests and churn reasons** — filter 1 and 2 star reviews to see why stores leave an app
- **Developer support monitoring** — track new reviews of your own app and check whether each one got a developer reply
- **App selection for agencies** — compare ratings, review dates and merchant feedback before recommending an app to clients
- **Sentiment analysis** — feed review text and ratings into your own models or the [Sentiment Analysis actor](https://apify.com/confidential_gnat/sentiment-analysis)

Shopify app developers, ecommerce agencies, investors and market researchers use this data to understand the Shopify app ecosystem.

### ⚠️ Shopify app reviews scraper limitations

- **Newest first only** — reviews are read newest first. The other sort orders on the site were not reproducible, so oldest-first or most-helpful-first are not offered.
- **Public data only** — merchant contact details are not shown on review pages. You get the store name and country, not owner emails.
- **Some reviews have no text** — a few merchants leave only a star rating, so `body` is `null` and `usageDuration` may be `null` for those rows.
- **Large apps have thousands of pages** — popular apps hold tens of thousands of reviews. Raise Max reviews per app deliberately, or use a date filter or the cache.

### ❓ Shopify app reviews scraper FAQ

#### Can I scrape Shopify App Store reviews legally?

The actor only collects reviews that are publicly visible on apps.shopify.com without logging in. Scraping publicly available data is generally considered lawful (see *hiQ Labs v. LinkedIn*), but you are responsible for following Shopify's Terms of Service and for laws such as GDPR or CCPA when you handle store names and review text.

#### What data does the Shopify app reviews scraper return?

One row per review with the star rating, review date, review text, store name, store country, how long the store has used the app, the developer's reply and reply date, a link to the review and the app's handle, name and URL.

#### How many reviews can I scrape from one Shopify app?

**Max reviews per app** limits the reviews saved for each app. The actor reads 10 reviews per page, newest first, until that limit, the date filter or the end of the reviews. Popular apps can have tens of thousands of reviews.

#### Do I need a proxy to scrape apps.shopify.com?

No. The proxy is off by default and the site answers plain requests. If a very large run hits temporary rate limits, the actor waits and retries on its own, and you can switch on Apify Proxy for extra headroom.

#### How do I scrape Shopify app reviews with Python?

Use the Python example above: start the actor with your app URLs, then iterate over the dataset items of the finished run.

#### Can I add reviews to the apps I scraped with the Shopify App Store scraper?

Yes. Run the Shopify App Store scraper, take the `url` of each app from its dataset, and pass those URLs to this actor. Join the results on `appHandle` = `handle`. The enrichment section above has both the no-code steps and a Python example.

#### Can I run this Shopify reviews scraper on a schedule?

Yes. Create an Apify Schedule and set a **Cache project name**. Reviews already scraped under that name are skipped, are not charged and do not count towards Max reviews per app, so each scheduled run returns only new reviews marked `changeType: new`.

#### What output formats are supported?

JSON, CSV, Excel, XML and RSS, either from the **Output** tab or through the Apify API.

### 🔗 Relevant actors for Shopify and review data

| Scraper | Description |
| ------- | ----------- |
| [🛒 Shopify App Store Scraper](https://apify.com/confidential_gnat/shopify-app-store-scraper) | Shopify apps with pricing plans, developer contact, categories and launch date. |
| [📱 Google Play Store Reviews Scraper](https://apify.com/confidential_gnat/google-play-reviews-scraper) | Google Play app reviews with text, star rating and developer reply. |
| [🍷 Vivino Wine Reviews Scraper](https://apify.com/confidential_gnat/vivino-reviews-scraper) | Vivino user reviews and tasting notes with star ratings. |
| [🧠 Sentiment Analysis Using Jev](https://apify.com/confidential_gnat/sentiment-analysis) | Classifies the sentiment of any text list as positive, negative, neutral or mixed. |
| [✉️ Signal NFX Investors Scraper](https://apify.com/confidential_gnat/signal-nfx-investors-scraper) | VC and angel investor profiles with check sizes and optional emails. |

### 🔗 Other actors you may find useful

| Scraper | Description |
| ------- | ----------- |
| [📅 Facebook Events Scraper](https://apify.com/confidential_gnat/facebook-events-scraper) | Public Facebook events by keyword, location and date, without logging in. |
| [📈 Kalshi Markets Scraper](https://apify.com/confidential_gnat/kalshi-markets-scraper) | Kalshi prediction markets: yes/no prices, implied probability and volume. |
| [💼 Dice Jobs Scraper](https://apify.com/confidential_gnat/dice-jobs-scraper) | Tech job listings from Dice by keyword or URL: company, salary and location. |
| [🚗 Copart Search Scraper](https://apify.com/confidential_gnat/copart-search-scraper) | Copart auction lots: damage, odometer, current bid and location. |
| [🥾 AllTrails Scraper](https://apify.com/confidential_gnat/alltrails-scraper) | Hiking, biking and running trails by park, city, state or coordinates. |

### 💬 Support & contact

If you encounter any issues or have questions, please [open an issue](https://apify.com/confidential_gnat/shopify-app-reviews-scraper/issues/open) or reach out via the [Apify Community Forum](https://community.apify.com/).

You can also find more of our actors on the [Actor Flow](https://apify.com/confidential_gnat) page.

# Actor input Schema

## `startUrls` (type: `array`):

Shopify App Store app URLs (https://apps.shopify.com/judgeme) or app review URLs (https://apps.shopify.com/judgeme/reviews). A ratings\[] filter in a reviews URL is kept.

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

Maximum reviews saved for each app (newest first).

## `cacheProjectName` (type: `string`):

Use the same name on each scheduled run to get only new reviews. Reviews already scraped under this name are skipped and not charged, and they do not count towards Max reviews per app. Each record gets changeType: new.

## `appHandles` (type: `array`):

App handles from the app URL, for example judgeme for https://apps.shopify.com/judgeme.

## `ratings` (type: `array`):

Keep only reviews with these star ratings, for example 1 and 2 to find complaints. Empty means all ratings.

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

Only save reviews posted on or after this date.

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

This website works without a proxy. Enable Apify Proxy only if you get blocked.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://apps.shopify.com/judgeme"
    }
  ],
  "maxItems": 5,
  "appHandles": [],
  "ratings": [],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "startUrls": [
        {
            "url": "https://apps.shopify.com/judgeme"
        }
    ],
    "maxItems": 5,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("confidential_gnat/shopify-app-reviews-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 = {
    "startUrls": [{ "url": "https://apps.shopify.com/judgeme" }],
    "maxItems": 5,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("confidential_gnat/shopify-app-reviews-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 '{
  "startUrls": [
    {
      "url": "https://apps.shopify.com/judgeme"
    }
  ],
  "maxItems": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call confidential_gnat/shopify-app-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,confidential_gnat/shopify-app-reviews-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/rzqCKu8MFDrgdPfiK/builds/bGSrMFrcoZUMLLoIT/openapi.json