# App Store Review Scraper & Feedback Monitor (`vdb997/app-store-review-watch`) Actor

Monitor public App Store reviews by app and country. Detect new and edited reviews, filter low-star feedback, and export review text, versions and store rating snapshots. Persistent history, failure-safe checks and flat pricing per app-country check.

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

## Pricing

from $25.00 / 1,000 app-country checks

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 Review Scraper & Feedback Monitor

Build an ongoing stream of new and edited iOS app reviews, with star ratings, review text, app versions and country storefronts. Watch your own app or a competitor and send the structured output to a product-feedback database, n8n, Make or an AI analysis workflow.

The Actor also checks Apple's app metadata: current version, store average rating and rating count. These store-wide figures are separate from the average of the reviews returned in this run.

### Who this is for

**iOS product feedback and low-star review monitoring.** Use the App Store review scraper to collect public iOS feedback by storefront, app version and rating. Connect newly observed or edited reviews to a product-feedback database. Review-window metrics and store-wide ratings are reported separately.

### Quick start

For an immediate export:

```json
{
  "apps": ["324684580"],
  "countries": ["us", "es"],
  "maxReviewsPerCheck": 100,
  "outputMode": "all"
}
```

Monitor negative feedback on a schedule:

```json
{
  "apps": ["324684580"],
  "countries": ["us"],
  "maxReviewsPerCheck": 200,
  "maxRating": 2,
  "watchId": "app-complaints",
  "outputMode": "changes"
}
```

In changes mode, the first successful run establishes a baseline without review alerts. Later runs with the same Watch ID emit new or edited reviews, and changed app metadata. A review edited from five stars to one star can trigger an alert even when the original five-star review was filtered out. Star filters affect output only, so all scanned reviews are remembered.

App Store URLs are accepted alongside numeric IDs. **Countries are selected explicitly in `countries`; a country embedded in a pasted URL does not override that list.** Duplicate IDs and country codes are removed. At most 20 unique app-country pairs can be checked per run.

### Output

- `recordType=review`: `reviewId`, `appId`, `appName`, `country`, `rating`, `title`, `text`, `appVersion`, `updatedAt`, `publicReviewerName`, `appUrl`, `changeType`, `changedFields`, `previousRating` and `observedAt`.
- `recordType=app`: current app metadata, changed fields, previous version and previous store rating/count. App records are unaffected by star filters.
- `recordType=check_summary`: health, pages checked, reviews scanned, baseline/new/changed/unchanged counts and store rating snapshot. Summaries are always included.
- `recordType=source_error`: failed source checks; the previous history is preserved. `SUMMARY` in the default key-value store contains the overall run report and spending-limit status.

The public review's `updatedAt` is Apple's timestamp; it may describe an edit rather than the original publication date. `new` means newly observed by your watch. The tool reports review changes; it does not generate sentiment labels or send replies to reviewers. Store rating changes also include star-only ratings, which the written-review feed does not expose.

### Pricing

**$0.025 per successful app-country check**, including app metadata and up to 500 recent reviews, plus **$0.00005 per run start** at fixed 512 MB memory. Platform usage is included. There is no per-review or per-summary charge.

An app checked in three countries is three checks. Empty or unchanged review feeds still count when the app lookup and requested feed pages succeed. Failed checks do not trigger the app-country event. A failure after an earlier page causes the entire check to fail without replacing history or charging the check event. The standard start fee still applies.

Example: five apps in two countries cost $0.25005 per run, or $7.5015 if run daily for 30 days. These are buyer costs, not creator earnings. Use Maximum cost per run to stop before additional app-country checks exceed the event budget.

### Limits and history

Apple's public review feed provides a recent window, commonly up to ten pages of fifty reviews per app-country. This Actor scans the number of pages needed for your review cap, including later pages after an empty middle page, and deduplicates repeated review IDs. Pagination can change while a run is in progress, so this is not a guaranteed complete archive.

`maxReviewsPerCheck` defaults to 100 and ranges from 1 to 500. Reviews not scanned are not added to history. Increasing the cap can therefore surface older reviews as newly observed. Missing reviews are not classified as deleted. Reviews may disappear from the feed or fall outside its window.

Watch history retains review IDs and comparison hashes for 90 days since last observation, with a 20,000-ID cap per app-country. Full historical review bodies are not retained in the named watch store. Use the same Watch ID for non-overlapping schedules; a new ID resets history. Snapshots live in the caller's account. Do not run the same watch concurrently.

Only public iOS App Store data is read. No Apple account, App Store Connect key, cookies or proxy is required. Unavailable apps or unsupported country codes produce errors. Developer replies and private support messages are not part of the feed. This independent tool is not affiliated with Apple.

Source: Apple's public `itunes.apple.com` review feed and [iTunes lookup API](https://developer.apple.com/library/archive/documentation/AudioVideo/Conceptual/iTuneSearchAPI/LookupExamples.html).

Related tools: [ATS Job Watch](https://apify.com/vdb997/ats-job-watch), [Shopify Price & Restock Watch](https://apify.com/vdb997/shopify-price-restock-watch), and [WordPress Content Watch](https://apify.com/vdb997/wordpress-content-watch).

### Try one source before scheduling

1. Open the Input tab and use one supported source with `outputMode: "all"` for an immediate export.
2. Check the returned records and the check summary. Confirm the source, coverage and price suit your workflow.
3. To monitor, set a stable Watch ID and `outputMode: "changes"`. The first successful run establishes a silent baseline.
4. Reuse that Watch ID on later runs. A summary without change records means the check completed without matching changes.
5. Add an Apify schedule after the manual checks work. Avoid overlapping runs with the same Watch ID. Use Maximum cost per run to cap event charges.

Public-data monitors by the same developer: [browse the catalog](https://apify.com/vdb997).

# Actor input Schema

## `apps` (type: `array`):

Numeric iOS App Store IDs or public apps.apple.com URLs. Country comes from Countries below, not from the pasted URL.

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

Two-letter Apple country codes, such as us, gb, es or de. Each app-country pair is a separate paid check. At most 20 unique pairs per run.

## `maxReviewsPerCheck` (type: `integer`):

Scan up to this many reviews from the public feed. Up to 10 pages; this is a recent review window, not an all-time archive.

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

Output filter only. History and summary counts still consider all scanned reviews.

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

Set to 2 for complaints. Output filtering does not alter the watch baseline or the flat check fee.

## `watchId` (type: `string`):

Reuse an ID to keep snapshots in your account. Leave blank for a one-off extraction. Use a new ID to reset; do not run the same watch concurrently.

## `outputMode` (type: `string`):

Changes mode establishes a silent baseline on the first run. Check summaries and source errors are always included.

## Actor input object example

```json
{
  "apps": [
    "324684580"
  ],
  "countries": [
    "us"
  ],
  "maxReviewsPerCheck": 100,
  "minRating": 1,
  "maxRating": 5,
  "outputMode": "all"
}
```

# Actor output Schema

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

No description

## `summary` (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 = {
    "apps": [
        "324684580"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("vdb997/app-store-review-watch").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 = { "apps": ["324684580"] }

# Run the Actor and wait for it to finish
run = client.actor("vdb997/app-store-review-watch").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 '{
  "apps": [
    "324684580"
  ]
}' |
apify call vdb997/app-store-review-watch --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,vdb997/app-store-review-watch"
        }
    }
}
```

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/d0ZrJYC9LrHkuYINl/builds/dWqAbEKjpdgx2h4pn/openapi.json