# App Store Reviews Scraper & Monitor: 176 Countries (`contented_catwalk/app-store-reviews-monitor`) Actor

Apple App Store reviews from all 176 storefronts via Apple's official public review feed. Only-new-since-last-run monitoring, per-version rating trends, competitor comparison, deduplicated rows. $0.15 per 1,000 reviews; empty runs free.

- **URL**: https://apify.com/contented_catwalk/app-store-reviews-monitor.md
- **Developed by:** [Orvix](https://apify.com/contented_catwalk) (community)
- **Categories:** Developer tools, AI, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## App Store Reviews Monitor: 176 Countries, New-Only Mode, Version Trends

Get **Apple App Store reviews for any iPhone/iPad app from all 176 storefronts in one run**, then **only the new reviews on every scheduled run after that**. You also get **star-rating trends per app version** and a **side-by-side comparison of your app and its competitors**.

- ✅ **Official data source.** Uses Apple's public customer-review feed and the iTunes Lookup API. No login, no proxies, no browser. It adapts its pace automatically when Apple rate-limits, instead of failing.
- ✅ **Never pay for nothing.** Empty runs and failed runs cost $0. You're charged only for reviews actually delivered.
- ✅ **Clean output.** One deduplicated row per review, with UTC dates corrected for a known Apple feed quirk (see FAQ).

### What it does

| Feature | What you get |
|---|---|
| All countries | `countries: ["ALL"]` scans all 176 App Store storefronts. Apple only shows the latest 500 reviews per country, so multi-country is how you get volume: a full 176-country pull of two big apps returned 107,316 reviews in one cloud run (about 22 minutes, because the Actor paces itself politely to stay unblocked). |
| Only new since last run | `onlyNew: true` remembers what it already sent you, per app and per country. Schedule it daily and you get only fresh reviews: ideal for Slack/email alerts. |
| Version trends | Average stars, 1–5★ distribution, negative share and change vs. the previous version, for every app version. Spot a bad release within hours. |
| Competitor comparison | Put your app and up to dozens of competitors in `appIds` to get one table: store rating, rating count, review sentiment, latest version score, top countries. |
| Filters | `maxRating: 2` for complaints only, `minRating`, `since` date, per-country and total caps. |

### Output

**Dataset: one row per review**

| Field | Example |
|---|---|
| reviewId | `14660454834` |
| appId / appName | `324684580` / `Spotify: Music and Podcasts` |
| country | `us` |
| rating | `4` |
| title / text | review title and full body |
| version | `9.1.90` (app version the reviewer used) |
| author / authorProfileUrl | public nickname |
| date | `2026-10-13T05:09:49.000Z` (UTC) |
| voteSum / voteCount | helpfulness votes |
| appStoreUrl | link to the app's reviews page in that storefront |
| scrapedAt | run timestamp |

**Key-value store records**

- `VERSION_TRENDS`: per app, per version: `reviews, avgRating, stars{1..5}, negativeShare, changeVsPrevious, firstReview, lastReview`. In only-new mode, trends accumulate across all runs of the same monitor.
- `COMPARISON`: per app: `storeAvgRating` (weighted across the storefronts you chose), `storeRatingCount`, `reviewsThisRun`, `avgRatingAnalyzed`, `negativeShare`, `positiveShare`, `latestReviewedVersion`, `latestVersionAvgRating`, `latestVersionChange`, `topCountries`.
- `SUMMARY`: counts, apps not found, ignored inputs, errors, charges.

### How to use

1. Paste app IDs or App Store URLs into **Apps**, for example `https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580`.
2. Pick countries (`us`, `gb`, `de` … or `ALL`).
3. Run. For monitoring, switch on **Only new since last run** and add a daily **Schedule**.

#### Example inputs

All countries, one app:

```json
{ "appIds": ["324684580"], "countries": ["ALL"] }
```

Daily complaint monitor for you and two competitors:

```json
{ "appIds": ["570060128", "493145008", "571800810"], "countries": ["us", "gb", "ca", "au"], "onlyNew": true, "stateKey": "meditation-apps", "maxRating": 2 }
```

Reviews of the latest release only:

```json
{ "appIds": ["https://apps.apple.com/us/app/duolingo-language-lessons/id570060128"], "countries": ["ALL"], "since": "2026-10-01" }
```

### Pricing (pay per event)

- **$0.15 per 1,000 reviews** ($0.00015 per review delivered).
- **$0.005 per run that delivers at least one review.** Empty runs and failed runs are free.

Worked examples:

- 500 US reviews = $0.005 + $0.075 = **$0.08**.
- A daily monitor that finds 20 new reviews a day = 30 × ($0.005 + $0.003) = **about $0.24/month**. Days with no new reviews cost $0.
- A full 176-country pull of a big app (~50,000 reviews) = **about $7.50**.
- A 4-app competitor snapshot, US + UK (~4,000 reviews) = **about $0.61**.

Your maximum cost per run is always respected: the Actor stops and saves only the reviews you paid for.

### Use with AI agents, n8n, Make, Zapier

Run it through the Apify API, the Apify MCP server or the Make/n8n/Zapier integrations. A typical flow is: scheduled run with `onlyNew` → filter `rating <= 2` → post to Slack, or summarize with an LLM.

### FAQ

**Is this allowed?** It reads Apple's own public customer-review RSS feed and the iTunes Lookup API, which Apple provides for programmatic access. It doesn't log in, doesn't scrape app pages and doesn't bypass any protection. Reviews include public nicknames, which may be personal data, so process them under your own GDPR/CCPA basis.

**Why at most 500 reviews per country?** Apple's feed exposes the 500 most recent (or most helpful) reviews per app per storefront. Use `ALL` countries for breadth, and only-new mode on a schedule to build a complete history going forward.

**Dates look 1 hour different from other tools?** Apple's feed labels every timestamp with `-07:00`, even in winter when Pacific time is `-08:00`. We correct this, so our dates match apps.apple.com exactly (verified). Tools that parse the feed naively are 1 hour off for winter reviews.

**Missing pages?** Apple's feed sometimes returns an empty page in the middle (for example page 5 of 10). We retry it and continue to the next pages instead of stopping, so you get the full set.

**Google Play?** Not included. This Actor uses only Apple's official sources.

**Found it useful?** A short review on the Store helps a lot. Problems? Open an Issue and we usually reply within 24 hours.

# Actor input Schema

## `appIds` (type: `array`):

One or more apps. Numeric ID (e.g. 324684580) or App Store URL (https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580). Add competitors to get a side-by-side comparison.

## `countries` (type: `array`):

Two-letter storefront codes such as us, gb, de. Use ALL for all 176 App Store storefronts.

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

Order of Apple's feed. Only-new mode always uses Most recent.

## `maxReviewsPerCountry` (type: `integer`):

Apple's feed exposes at most the latest 500 reviews per app per country.

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

Optional overall cap for the run (cost control).

## `onlyNew` (type: `boolean`):

Remember which reviews were already delivered (per app and country) and return only new ones. Ideal for scheduled monitoring. The first run returns everything and sets the baseline.

## `stateKey` (type: `string`):

Separate memory for different monitors when using only-new mode. Letters, digits and dashes.

## `minRating` (type: `integer`):

Only return reviews with at least this many stars.

## `maxRating` (type: `integer`):

Only return reviews with at most this many stars (e.g. 2 to catch complaints).

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

Optional ISO date, e.g. 2026-09-01. Older reviews are skipped.

## Actor input object example

```json
{
  "appIds": [
    "324684580"
  ],
  "countries": [
    "us"
  ],
  "sortBy": "mostrecent",
  "maxReviewsPerCountry": 500,
  "onlyNew": false,
  "stateKey": "default"
}
```

# Actor output Schema

## `reviews` (type: `string`):

One deduplicated row per review.

## `versionTrends` (type: `string`):

Average stars and star distribution per app version.

## `comparison` (type: `string`):

Side-by-side stats for every app in the run.

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

Counts, errors and charges.

# 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 = {
    "appIds": [
        "324684580"
    ],
    "countries": [
        "us"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("contented_catwalk/app-store-reviews-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 = {
    "appIds": ["324684580"],
    "countries": ["us"],
}

# Run the Actor and wait for it to finish
run = client.actor("contented_catwalk/app-store-reviews-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 '{
  "appIds": [
    "324684580"
  ],
  "countries": [
    "us"
  ]
}' |
apify call contented_catwalk/app-store-reviews-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,contented_catwalk/app-store-reviews-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/Ih7W4NGweSDIeG9G0/builds/9JuomXm4GbwRvdfEU/openapi.json