# Shopify App Store Reviews + Pricing Monitor (`snuggly_form/shopify-app-store-reviews-pricing-monitor`) Actor

Scrape public Shopify App Store reviews and optional pricing/badge snapshots. Supports since-based incremental filtering for monitoring competitors.

- **URL**: https://apify.com/snuggly_form/shopify-app-store-reviews-pricing-monitor.md
- **Developed by:** [Shawn li](https://apify.com/snuggly_form) (community)
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 reviews

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

### What does Shopify App Store Reviews + Pricing Monitor do?

This Actor scrapes **public** data from the [Shopify App Store](https://apps.shopify.com): merchant **reviews** and optional **pricing / badge snapshots** (for example **Built for Shopify**). Give it one or more app URLs or slugs and it writes structured dataset rows you can schedule for competitor monitoring.

It is an **API alternative** for Shopify App Store review and pricing research — no Shopify Partner login required for public pages.

### Why use this Actor?

- Track new reviews for your app or competitors with the optional `since` filter (newest-first pagination stops once older reviews are reached).
- Snapshot pricing tiers and public badges alongside reviews in a single run.
- Optionally **diff** pricing/badges against the previous run (default key-value store) so scheduled monitors can alert on plan or badge changes.
- Run on a schedule in Apify Console, export to JSON/CSV/Excel, or call via the Apify API / integrations.
- Uses lightweight HTTP + Cheerio (no headless browser) for faster, cheaper runs on public HTML.

### What data can it extract?

| Field | Type | Description |
| --- | --- | --- |
| `type` | string | `review` or `pricing_snapshot` |
| `appSlug` / `appName` | string | App handle and display name |
| `rating` | number | Star rating (1–5) |
| `body` | string | Public review text |
| `author` / `country` / `timeSpent` | string | Merchant metadata shown publicly |
| `replied` / `replyText` | bool / string | Developer reply when present |
| `reviewDate` / `reviewUrl` | string | ISO date and permalink |
| `plans[]` | array | Pricing plan name, price, currency, billing period, features |
| `badges[]` | array | e.g. Built for Shopify |

### How to scrape Shopify App Store reviews

1. Open this Actor in Apify Console.
2. Paste one or more App Store URLs or slugs into **App URLs or slugs** (for example `https://apps.shopify.com/klaviyo-email-marketing`).
3. Set **Max reviews per app** (start with 20 for a quick test).
4. Optionally enable **Include pricing snapshot** and set **Since** to an ISO date for incremental runs.
5. Click **Start**, then download results from the Dataset tab (JSON, CSV, Excel, and more).

### How much will it cost?

The Actor already calls `Actor.pushData(record, eventName)` for PPE-ready billing. Until you monetize the Actor, runs are billed as normal platform compute only (the event name is ignored when PPE is off).

#### Enable pay-per-event (after `apify push`)

1. Open the Actor in [Apify Console](https://console.apify.com) → **Publication** / **Monetization**.
2. Choose **Pay per event**.
3. Add custom events matching the code (or rely on synthetic `apify-default-dataset-item` if you prefer not to use custom names):

| Event name | When charged | Suggested starting price |
| --- | --- | --- |
| `review` | Each `type=review` row | ~$0.002 / review |
| `pricing_snapshot` | Each `type=pricing_snapshot` row | ~$0.01 / snapshot |
| `apify-actor-start` | Synthetic start (optional) | platform default |

4. Save monetization, rebuild/publish, then re-run once to verify charges in the run’s charging log.

Local PPE dry-run: `ACTOR_TEST_PAY_PER_EVENT=true apify run` (charges land in `storage/datasets/charging-log/` at $1 placeholder prices).

### Input

See the **Input** tab for the full form. Main fields:

- **`appUrls`** (required) — App Store URLs or slugs.
- **`maxReviews`** — Cap per app (`0` = unlimited).
- **`includePricing`** — Emit pricing/badge snapshots.
- **`trackPricingChanges`** — Diff plans/badges vs the previous run (default KV).
- **`since`** — ISO date; keep only newer reviews.
- **`country`** — Optional locale / country hint for the storefront.
- **`maxConcurrency`** / **`requestDelayMs`** — Politeness controls.

#### Example input

```json
{
  "appUrls": [
    "https://apps.shopify.com/klaviyo-email-marketing",
    "judgeme"
  ],
  "maxReviews": 20,
  "includePricing": true,
  "since": "2026-01-01T00:00:00.000Z"
}
```

### Output

You can download the dataset in JSON, HTML, CSV, or Excel.

#### Review example

```json
{
  "type": "review",
  "appSlug": "example-email-app",
  "appName": "Example Email App",
  "rating": 5,
  "body": "This app helped our store grow.",
  "author": "Example Store",
  "country": "United States",
  "timeSpent": "6 months using the app",
  "replied": true,
  "replyText": "Thank you for your feedback!",
  "reviewDate": "2026-01-15T00:00:00.000Z",
  "reviewUrl": "https://apps.shopify.com/reviews/2400000",
  "scrapedAt": "2026-01-15T12:00:00.000Z"
}
```

#### Pricing snapshot example

```json
{
  "type": "pricing_snapshot",
  "appSlug": "example-email-app",
  "appName": "Example Email App",
  "plans": [
    {
      "name": "Basic",
      "price": "$9.99",
      "currency": "USD",
      "billingPeriod": "month",
      "features": ["Feature A"]
    }
  ],
  "badges": ["Built for Shopify"],
  "scrapedAt": "2026-01-15T12:00:00.000Z",
  "diff": {
    "changed": false,
    "previousScrapedAt": null,
    "badgesAdded": [],
    "badgesRemoved": [],
    "plansAdded": [],
    "plansRemoved": [],
    "planPriceChanges": []
  }
}
```

### Tips

- Keep `maxConcurrency` at 3 and `requestDelayMs` around 500–1000 for datacenter IPs.
- For daily monitoring, set `since` to yesterday (or the previous run time) and a modest `maxReviews`.
- Leave **Track pricing / badge changes** on for scheduled runs; the first run seeds the KV snapshot (`changed: false`), later runs attach a `diff` when plans or badges move.
- Pricing currency can follow Shopify geo localization; use `country` / locale as a hint, not a guarantee.

### Compliance and disclaimer

This Actor collects **only publicly available** information from Shopify App Store listing and review pages. It does **not** bypass authentication, scrape private merchant data, or automate installs/reviews.

You must comply with the [Shopify Terms of Service](https://www.shopify.com/legal/terms), Shopify App Store policies, Apify Terms, and applicable laws (including GDPR and similar privacy rules). **Do not** use this Actor for harassment, spam, fake reviews, or bulk unsolicited marketing.

Store names and other fields shown on public reviews may still constitute personal data in some jurisdictions. Minimize retention, avoid collecting more than you need, and only process data when you have a legitimate purpose. If unsure, consult your counsel.

Results can change when Shopify updates page markup. Open an Issue on the Actor page if selectors break.

### FAQ

#### Can I scrape every review for a popular app?

Yes — set `maxReviews` to `0`. Expect long runtimes and many pages (10 reviews per page). Prefer `since` for incremental monitoring.

#### Does this use a browser?

No. Reviews and pricing are parsed from server-rendered HTML with Cheerio/HTTP.

#### How do I run it from code?

Use the Apify API or client SDKs with Actor ID / name after you push it to your account. See the **API** tab in Console.

# Actor input Schema

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

Shopify App Store app detail URLs (e.g. https://apps.shopify.com/klaviyo-email-marketing) or bare slugs (e.g. klaviyo-email-marketing).

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

Maximum number of reviews to keep per app (newest first). Use 0 for unlimited (paginates the full history — can be slow for popular apps).

## `includePricing` (type: `boolean`):

When enabled, also scrape pricing plans and badges (e.g. Built for Shopify) from the app detail page and emit type=pricing_snapshot rows.

## `trackPricingChanges` (type: `boolean`):

When includePricing is on, compare plans and badges to the previous run (stored in the default key-value store) and attach a `diff` object on each pricing_snapshot (changed, badgesAdded/Removed, planPriceChanges, etc.).

## `since` (type: `string`):

Optional ISO 8601 date/datetime. Only reviews on or after this timestamp are kept. Because reviews are fetched newest-first, pagination stops once older reviews are reached.

## `country` (type: `string`):

Optional locale (e.g. en, en-US) or ISO country code (e.g. US). Passed to the App Store as a locale/country hint. Pricing currency may still follow Shopify geo localization.

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

Parallel HTTP requests (1–10). Keep low to be polite to apps.shopify.com.

## `requestDelayMs` (type: `integer`):

Extra delay after each successful page parse. Default 500ms.

## Actor input object example

```json
{
  "appUrls": [
    "https://apps.shopify.com/klaviyo-email-marketing"
  ],
  "maxReviews": 20,
  "includePricing": true,
  "trackPricingChanges": true,
  "since": "2026-01-01T00:00:00.000Z",
  "country": "en",
  "maxConcurrency": 3,
  "requestDelayMs": 500
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing review and pricing_snapshot records

# 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"
    ],
    "maxReviews": 20,
    "includePricing": true,
    "trackPricingChanges": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("snuggly_form/shopify-app-store-reviews-pricing-monitor").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"],
    "maxReviews": 20,
    "includePricing": True,
    "trackPricingChanges": True,
}

# Run the Actor and wait for it to finish
run = client.actor("snuggly_form/shopify-app-store-reviews-pricing-monitor").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"
  ],
  "maxReviews": 20,
  "includePricing": true,
  "trackPricingChanges": true
}' |
apify call snuggly_form/shopify-app-store-reviews-pricing-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,snuggly_form/shopify-app-store-reviews-pricing-monitor"
        }
    }
}
```

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/Q3xeBMPWWsYq6S3w2/builds/mu4pHSjBABlnmviGi/openapi.json