# Shopify App Reviews Scraper & Monitor (`fetch_cat/shopify-app-reviews-scraper`) Actor

Export and monitor Shopify App Store reviews. Filter by rating, date, keyword, country, usage, text, and developer replies; track new and archived feedback.

- **URL**: https://apify.com/fetch\_cat/shopify-app-reviews-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** E-commerce, Marketing, Developer tools
- **Stats:** 8 total users, 8 monthly users, 96.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.06 / 1,000 review records

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Shopify App Reviews Scraper

Scrape public Shopify App Store reviews, star ratings, merchant feedback, developer replies, and app-level rating metrics from Shopify app listings.

Use it to monitor competitor sentiment, discover merchant pain points, track support quality, and build review datasets for ecommerce app research.

### At a glance

- **Extracts:** review text, ratings, merchant details, developer replies, app handles, aggregate rating, review count, and scrape timestamps.
- **Inputs:** Shopify App Store app URLs, app handles, review limits, star-rating filters, locale, and page limits.
- **Best for:** competitor review monitoring, voice-of-customer research, app selection, product roadmap research, and reputation tracking.
- **Exports:** Apify dataset rows downloadable as CSV, JSON, Excel, or available through the API.
- **Login:** no Shopify merchant account or App Store API key is required for public review pages.

### Ready-to-run examples

Use these saved Store examples as starting points. Open any example to prefill the Actor input, then adjust URLs, keywords, limits, or filters for your own run.

- **[Download Shopify social proof app reviews](https://apify.com/fetch_cat/shopify-app-reviews-scraper/examples/download-shopify-social-proof-reviews)**
- **[Scrape Shopify page builder reviews](https://apify.com/fetch_cat/shopify-app-reviews-scraper/examples/scrape-shopify-page-builder-reviews)**
- **[Monitor Shopify support app feedback](https://apify.com/fetch_cat/shopify-app-reviews-scraper/examples/monitor-shopify-support-app-feedback)**
- **[Research Shopify email app reviews](https://apify.com/fetch_cat/shopify-app-reviews-scraper/examples/research-shopify-email-app-reviews)**
- **[Track developer replies on Shopify apps](https://apify.com/fetch_cat/shopify-app-reviews-scraper/examples/track-developer-replies-on-shopify-apps)**
- **[Collect five-star Shopify app testimonials](https://apify.com/fetch_cat/shopify-app-reviews-scraper/examples/collect-five-star-shopify-testimonials)**
- **[View all ready-to-run examples](https://apify.com/fetch_cat/shopify-app-reviews-scraper/examples)** (10 examples)

### What can it do?

Shopify App Reviews Scraper collects public review records from Shopify App Store app pages.

It accepts app listing URLs or app handles and returns structured review rows in an Apify dataset.

Each row includes the app context, review rating, review text, date, merchant details when visible, and app-level rating totals.

### Who is it for?

- **Shopify app developers:** understand what merchants praise, what frustrates them, and where competing apps leave gaps.
- **Ecommerce agencies:** compare Shopify apps before recommending tools to clients.
- **Product managers:** track sentiment changes and prioritize roadmap ideas from merchant feedback.
- **Investors and analysts:** measure market traction and customer happiness across Shopify ecosystem apps.
- **Support and success teams:** find recurring support complaints and developer response patterns.

### Why use this scraper?

- **Review text and ratings:** collect merchant feedback and star ratings in one dataset.
- **Competitor monitoring:** track sentiment changes across competing Shopify apps over time.
- **Developer replies:** capture public developer replies when visible.
- **Rating filters:** focus on 1-star complaints, 5-star praise, or specific review bands.
- **Newest-first sorting:** request Shopify App Store reviews sorted from newest to oldest.
- **Clean exports:** send CSV, JSON, Excel, API, or BI-ready rows to your workflow.
- **Scheduling:** run recurring monitoring jobs on Apify.

### Output fields

| Field | Description |
| --- | --- |
| `appHandle` | Shopify App Store app handle |
| `appName` | App name shown on the listing |
| `appUrl` | Shopify App Store app URL |
| `reviewsUrl` | Review page URL used for the record |
| `aggregateRating` | App-level rating |
| `aggregateReviewCount` | App-level review count |
| `ratingDistribution` | Visible count by star rating |
| `reviewId` | Unique review identifier |
| `reviewUrl` | Direct review share URL |
| `rating` | Review star rating |
| `reviewText` | Merchant review text |
| `reviewDate` | Public review date text |
| `merchantName` | Merchant/store name when visible |
| `merchantCountry` | Merchant country when visible |
| `merchantUsage` | How long the merchant used the app, when visible |
| `developerReplyText` | Developer reply text when visible |
| `developerReplyDate` | Developer reply date when available |
| `pageNumber` | Review page number |
| `scrapedAt` | Timestamp when the record was scraped |

### Pricing

This Actor uses pay-per-event pricing: one small start fee, then a charge for each Shopify App Store review successfully saved to the dataset.

| Event | When it is charged | Price |
| --- | --- | ---: |
| `start` | Once when the run starts | `$0.005` per run |

#### Price per saved review

| Apify Store tier | Price per review | Approx. price per 1,000 reviews |
| --- | ---: | ---: |
| Free | `$0.000575` | `$0.575` |
| Starter / Bronze | `$0.000500` | `$0.500` |
| Scale / Silver | `$0.000390` | `$0.390` |
| Business / Gold | `$0.000300` | `$0.300` |
| Custom / Platinum | `$0.000200` | `$0.200` |
| Custom / Diamond | `$0.000140` | `$0.140` |

The `result` event is charged only after a review is successfully saved. Failed requests, retries, skipped duplicates, and runs that return no reviews do not create review charges. Apify platform usage for compute, storage, proxies, or data transfer may be billed separately; check the run's Pricing tab for the final amount.

### Quick start

1. Open the actor on Apify.
2. Paste one or more Shopify App Store app URLs.
3. Set the maximum number of reviews per app.
4. Optionally select star ratings to filter.
5. Click **Start**.
6. Download the results from the dataset.

### Input configuration

| Setting | JSON key | Description |
| --- | --- | --- |
| Shopify App Store app URLs | `appUrls` | Listing or review URLs such as `https://apps.shopify.com/judgeme/reviews`. |
| App handles | `appHandles` | Direct Shopify App Store handles such as `judgeme` or `klaviyo-email-marketing`. |
| Maximum reviews per app | `maxReviewsPerApp` | Maximum review rows saved for each app. Start with 25 for quick tests. |
| Rating filter | `ratings` | Optional star ratings to scrape, for example 1-2 stars for complaint research or 5 stars for testimonials. |
| Sort reviews by | `sortBy` | `newest` returns Shopify App Store reviews from newest to oldest; `relevance` keeps Shopify's relevance sort. |
| Locale | `locale` | Shopify App Store locale code such as `en`, `de`, `fr`, `es`, `ja`, or `pt-BR`. |
| Maximum pages per app | `maxPagesPerApp` | Safety cap for pagination. Each Shopify App Store review page usually contains around ten reviews. |

### Input example

```json
{
  "appHandles": ["judgeme"],
  "maxReviewsPerApp": 25,
  "maxPagesPerApp": 3,
  "sortBy": "newest",
  "ratings": ["5"],
  "locale": "en"
}
```

### Output example

```json
{
  "appHandle": "judgeme",
  "appName": "Judge.me Product Reviews App",
  "appUrl": "https://apps.shopify.com/judgeme",
  "reviewId": "2238961",
  "rating": 5,
  "reviewText": "Juge.me supports everything we could ask of a review platform...",
  "reviewDate": "June 10, 2026",
  "merchantName": "Makeup A Murder, INC",
  "merchantCountry": "United States",
  "merchantUsage": "Over 6 years using the app",
  "aggregateRating": 5,
  "aggregateReviewCount": 40553,
  "scrapedAt": "2026-06-27T19:14:07.583Z"
}
```

### Tips for better results

- Start with one app and a low review limit.
- Use rating filters for focused sentiment research.
- Schedule repeated runs if you want review monitoring.
- Use app handles when you already have a list of competitors.
- Keep page limits aligned with your maximum review count.

### Common workflows

- **Competitor review monitoring:** track competing Shopify apps and identify new complaints or praised features.
- **Voice-of-customer research:** export review text to analyze merchant language and buying triggers.
- **Product roadmap research:** find repeated feature requests and workflow blockers.
- **Agency app selection:** compare apps by merchant sentiment before recommending them to clients.
- **Reputation tracking:** monitor your own app reviews and developer reply coverage.

### Integrations

Use Apify integrations to send results to:

- Google Sheets for review dashboards
- Slack for new negative-review alerts
- Make or Zapier for automated workflows
- BigQuery or Snowflake for analytics
- Webhooks for custom monitoring systems

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/shopify-app-reviews-scraper').call({
  appUrls: [{ url: 'https://apps.shopify.com/judgeme/reviews' }],
  maxReviewsPerApp: 25
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/shopify-app-reviews-scraper').call(run_input={
    'appUrls': [{'url': 'https://apps.shopify.com/judgeme/reviews'}],
    'maxReviewsPerApp': 25,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~shopify-app-reviews-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"appUrls":[{"url":"https://apps.shopify.com/judgeme/reviews"}],"maxReviewsPerApp":25}'
```

### MCP and AI agents

Connect this actor to MCP-compatible tools through Apify MCP Server.

Use this MCP URL pattern:

```text
https://mcp.apify.com/?tools=fetch_cat/shopify-app-reviews-scraper
```

Claude Code setup example:

```bash
claude mcp add apify-shopify-reviews https://mcp.apify.com/?tools=fetch_cat/shopify-app-reviews-scraper
```

MCP JSON configuration example:

```json
{
  "mcpServers": {
    "apify-shopify-reviews": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/shopify-app-reviews-scraper"
    }
  }
}
```

Example prompts:

- "Scrape the latest 50 reviews for the Judge.me Shopify app."
- "Find 1-star reviews for this Shopify app and summarize merchant complaints."
- "Compare review sentiment for these three Shopify apps."

### Scheduling

Create an Apify schedule to run the scraper daily, weekly, or monthly.

This is useful for ongoing monitoring of your app or competitors.

### Export formats

Dataset results can be downloaded as:

- JSON
- CSV
- Excel
- XML
- RSS
- HTML table

### Data quality notes

The actor returns fields that are publicly visible on Shopify App Store review pages.

Some merchant details or developer replies may be absent on specific reviews.

When a field is not visible, the value is returned as `null`.

### Limits

Shopify App Store review availability depends on the public listing.

Very old pages or filtered views may return fewer records than requested.

Use sensible review and page limits for predictable run time.

### FAQ

#### Can I use the scraper through the API?

Yes. Use the API examples above or call the actor from any Apify client with app URLs, handles, limits, and filters.

#### Can I use it with MCP?

Yes. Use the MCP URL and configuration examples above to connect the actor to compatible AI tools.

### Troubleshooting

#### The run returned no reviews

Check that the app handle or URL is valid and that the app has public reviews.

Try the app listing URL in a browser, then rerun with a small limit.

#### I got fewer reviews than requested

The selected rating filter may have fewer matching reviews, or the page limit may be too low.

Increase `maxPagesPerApp` or remove rating filters.

#### Some reply fields are empty

Developer replies are only returned when they are visible for a review.

### Legality

#### Is it legal to scrape Shopify App Store reviews?

This actor collects publicly available information from Shopify App Store pages.

You are responsible for using the data in line with applicable laws, Shopify terms, and privacy requirements.

Avoid collecting or using personal data in a way that violates regulations or platform rules.

### Related actors

- [Shopify App Store Scraper](https://apify.com/fetch_cat/shopify-app-store-scraper)
- [Shopify Products Scraper for Catalogs & Variants](https://apify.com/fetch_cat/shopify-products-scraper)
- [Google Play Reviews Scraper](https://apify.com/fetch_cat/google-play-reviews-scraper)
- [Apple App Store Reviews Scraper](https://apify.com/fetch_cat/apple-app-store-reviews-scraper)

### Support

If a run fails, returns no data, or a field looks wrong, open an issue from the Actor page.

Please include the Apify run ID or run URL, input JSON, one example public URL, query, or input item, what you expected, and what the dataset returned. Small reproducible inputs make parsing or site-layout issues much faster to fix.

### Changelog

- 2026-07-10 - Feature: Added a Sort reviews by option so reviews can be exported newest-first or by relevance.

### Privacy and data handling

This Actor only requests the permissions needed to run the input you provide. It uses your input (such as URLs, search terms, identifiers, filters, and limits) only to fetch the requested public data from the relevant source site or API for this Actor, then writes results to your Apify dataset/key-value store.

Data may pass through Apify platform services and Apify Proxy during the run, and requests are sent only to the target site or public data provider required for this Actor's results. FetchCat does not send your inputs or outputs to advertising networks, data brokers, or model-training services, and does not retain run data outside Apify storage after the run except when you explicitly share run details for transient support debugging.

You are responsible for using this Actor lawfully, respecting the target site's terms, and avoiding unnecessary personal or sensitive data in inputs. Review the output before storing, sharing, or combining it with other data.

# Actor input Schema

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

Paste Shopify App Store listing or reviews URLs, such as https://apps.shopify.com/judgeme or https://apps.shopify.com/judgeme/reviews.

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

Optional Shopify App Store handles. Use this when you already know the handle, for example judgeme.

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

Maximum number of review records to save for each app.

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

Optional star ratings to scrape. Leave empty to include all ratings.

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

Choose the Shopify App Store review sort order. Newest first returns reviews sorted from newest to oldest.

## `locale` (type: `string`):

Optional Shopify App Store locale code, for example en, de, fr, es, ja, pt-BR.

## `maxPagesPerApp` (type: `integer`):

Safety cap for review pagination. Each page usually contains around 10 reviews.

## `maxRunSeconds` (type: `integer`):

Optional shared time limit for all apps. The scraper saves completed reviews and records pending apps before this limit.

## `resumeCursors` (type: `array`):

Optional checkpoint cursors from PENDING\_REVIEW\_CURSORS. Advanced use: resume each app at its next unfinished review page.

## Actor input object example

```json
{
  "appUrls": [
    {
      "url": "https://apps.shopify.com/judgeme/reviews"
    }
  ],
  "appHandles": [
    "judgeme"
  ],
  "maxReviewsPerApp": 20,
  "sortBy": "newest",
  "locale": "en",
  "maxPagesPerApp": 5,
  "maxRunSeconds": 270
}
```

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

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

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/shopify-app-reviews-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": [
    {
      "url": "https://apps.shopify.com/judgeme/reviews"
    }
  ],
  "appHandles": [
    "judgeme"
  ]
}' |
apify call fetch_cat/shopify-app-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=fetch_cat/shopify-app-reviews-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/Zmw1t0sjxZybalRCz/builds/TBjKIE04iwBZ1XIRv/openapi.json