# App Store & Google Play Reviews Scraper · $0.15/1k (`leoworks/app-review-scraper`) Actor

Scrape App Store + Google Play reviews: 5,000+ per app, filters by stars, date or keyword, developer replies on Google Play, retries Apple's empty pages. No login. $0.15/1k; optional AI labels +$0.5/1k.

- **URL**: https://apify.com/leoworks/app-review-scraper.md
- **Developed by:** [Leoworks](https://apify.com/leoworks) (community)
- **Categories:** AI, Social media, Agents
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.13 / 1,000 reviews

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

**Part of LeoWorks review classifiers:** [Google Maps](https://apify.com/leoworks/google-maps-review-classifier) · [AliExpress](https://apify.com/leoworks/aliexpress-reviews-classifier) · [Amazon](https://apify.com/leoworks/amazon-review-classifier) · [Naver Place](https://apify.com/leoworks/naver-place-review-classifier) · [Korean](https://apify.com/leoworks/korean-review-classifier) — and this one for mobile apps.

**Scrape App Store and Google Play reviews — paste an app link, a numeric App Store ID or a Google Play package name.** This Actor collects the reviews of each app from the Apple App Store and Google Play into one clean table: stars, title, text, date, app version, helpful votes and, on Google Play, the developer's reply. Choose newest or most helpful, filter by stars, date or keyword, and go **5,000+ reviews deep on Google Play** (App Store: 500 per country and sort order). Apple's feed sometimes answers with a valid but empty page; the Actor retries it in steps instead of silently returning less. Collecting costs **$0.15 per 1,000 reviews** and the free $5 monthly Apify credit covers about **33,333 reviews**. **Optional AI labels** (complaint types, praise, sentiment, serious-issue alerts, reviews that need a reply, a per-app summary with a one-sentence headline) add **$0.50 per 1,000**. No login, no LLM key.

### Why use it

- **Product or app manager** — see what users complain about this week, by type and share, and whether it got worse after the last release.
- **Developer or support lead** — start with the unanswered 1–2 star Google Play reviews: the reply queue is sorted lowest stars first.
- **Growth, ASO and marketing** — compare complaint and praise mix across your app and its competitors, per country.
- **Investor or analyst** — track an app's rating and complaint rate over time with the Monitor key.
- **Safety, privacy and legal** — catch reports of hacked accounts, unauthorised charges, child-safety problems and legal threats the same day, whatever the star rating.
- **Developer or AI agent** — structured labels with probabilities through the API or MCP; no prompts, no LLM key.

### Performance at a glance

| | Result |
|---|---|
| Complaint types | **81%** of reviews labelled right (113 hand-labelled App Store and Google Play reviews of 12 popular apps, 2026-10-19; strict scoring, see **Accuracy and limits**) |
| Sentiment | **100%** (101 of those reviews with a clear overall sentiment) |
| Depth | App Store: up to 500 reviews per country and sort order. Google Play: 5,000 reviews per app measured, no limit seen |
| Speed | about 20 reviews per second collected (measured, gentle rate); classification runs 10 reviews at a time |
| Cost | **$0.15 per 1,000 reviews** collected; AI labels are optional, **$0.65 per 1,000** with them |

### Compliance and privacy

- **Public data, no login.** The reviews are the publicly visible reviews of each app. Nothing needs your Apple or Google account, cookies or a login, and no CAPTCHA or block is worked around: if a store refuses a request, that app is recorded as failed in `SUMMARY`.
- **No personal profiles.** Reviewer names, avatars and profile links are never collected or output. Only the review title and text, its stars, date and app version (and the developer's public reply on Google Play) are used.
- **Nothing is kept unless you ask.** If you set **Monitor key**, the Actor saves only summary figures (average rating, review count, newest review date, unanswered count) in a key-value store named `monitor-app-reviews` in your own Apify account, to compare with the next run. No review text, names or IDs are stored.
- **Where the data comes from.** App Store reviews come from Apple's public customer-review feed. Google Play reviews come from the same web endpoint the Play Store page itself calls; that endpoint is not covered by Google's published crawling permissions (it is listed under `Disallow` in the site's robots.txt), and Google's terms apply to collecting the data. **You stay responsible for the use.** This is not legal advice.

### What can the App Reviews Scraper do?

- **Collects the reviews for you** — App Store and Google Play in one run, from links, IDs or package names, with the same fields from both stores
- **Deep and sorted your way** — newest or most helpful; Google Play 5,000+ reviews per app, App Store 500 per country and sort order; several countries in one run, duplicates removed
- **Free filters** — maximum stars, only reviews newer than a date, must mention a word; filtered reviews are neither stored nor charged
- **Developer replies** — Google Play reviews include the developer's public reply and its date
- **Reliable on Apple's flaky feed** — empty pages are retried in steps (same address, XML version, residential proxy, two later tries); if the feed stays empty the app is reported as failed and nothing is charged
- **Change since the last run** — with a Monitor key: rating change and new reviews, to run it weekly
- **Optional AI labels** — turn on **Add AI labels** for the features below, or classify a dataset you already have
- **Complaint types** — bugs and crashes, performance, design and usability, missing features, price and billing, ads, account and login, support, privacy and trust (multi-label, each with a probability)
- **What users praise** — the same aspects, so strengths and weaknesses line up per app
- **Serious-issue alert** — security or privacy breaches, unauthorised or fraudulent charges, child-safety problems, scam accusations and legal threats, whatever the star rating
- **Sentiment** — positive / neutral / negative
- **Reply queue** — Google Play reviews that need a developer reply and have none, lowest stars first, as a CSV
- **Summary by app and country** — a one-sentence headline, complaint and praise mix, star distribution, developer reply rate, complaint rate of the 5 newest **app versions**, monthly trend and last 90 days vs before, as JSON and CSV
- **Change since the last run** — with a Monitor key: rating change, new reviews, new serious issues and unanswered-review change
- **Your own labels** — up to 10 yes/no criteria in plain language (e.g. "mentions a competitor", "asks for dark mode")

**Use it to:** answer unanswered 1–2 star reviews first · see whether the newest release raised complaints · find out why an app loses stars (crashes? billing? ads?) and what it should keep doing · compare your app with competitors per country · report monthly to a team or client · feed labelled reviews to a dashboard or an AI agent.

**Works from Claude, Cursor or Claude Code** — add it as a tool through the Apify MCP server and ask in plain language (setup in **Use with Claude, Cursor or Claude Code** below).

### How to get App Store and Google Play reviews

Open the Actor (**Try for free** on the Store page) to get the input form. The Console remembers what you typed last time in this browser: if you see old values, click **Cancel changes**, or switch to the **JSON** tab, for example `{ "apps": ["https://apps.apple.com/us/app/duolingo/id570060128", "com.duolingo"], "reviewsPerApp": 50 }`.

1. In **Apps**, paste App Store links or numeric IDs and Google Play links or package names — one per line, mixed is fine. The store is detected from each value. Up to 50 apps.
2. Set **Reviews per app** (newest first by default) and, for the App Store, the **Store countries** (one feed per country). Google Play reviews are the same in every country, so each Play app is read once.
3. Optional: **Add AI labels** (complaint types, sentiment, alerts, summary; +$0.50 per 1,000), **Maximum stars** (e.g. 3 to read only critical reviews), **Only reviews newer than**, **Review must mention one of**, **Custom labels**, **Monitor key**. Filtered reviews are neither stored nor charged.
4. Click **Start**. Open the **Reviews** table, **Needs a reply** (Google Play), or download `REPORT_APPS.csv` and `REPLY_QUEUE.csv` from the key-value store.

#### Run it every week and see what changed

Create a **Schedule** (weekly) for the same input and set **Monitor key** to any name, e.g. `my-apps`. Each app row then shows `previousRunAt`, `ratingDelta`, `newReviews`, `newCriticalIssues` and `unrepliedDelta`. The first run with a key only saves the baseline. Add **Only reviews newer than: 7 days** to classify only fresh reviews.

#### Already have the reviews?

Pick an Apify dataset in **Dataset ID (Advanced)** instead of **Apps**. The text, rating, date, version and developer-reply fields are detected automatically, and only classification is charged ($0.5 per 1,000).

### Pricing

Pay per event — you pay only for the reviews you keep.

| Event | Price | When |
|---|---|---|
| `review` | $0.00015 ($0.15 per 1,000) | One app review collected from the App Store or Google Play (rating, text, date, app version, developer reply on Google Play). |
| `review-judged` | $0.0005 ($0.50 per 1,000) | Complaint types, praise, sentiment, serious-issue alert and needs-a-reply for one review (only when classification is on). |

Filtered, repeated and empty reviews are free: they are not stored and not charged. Reading further to find enough matching reviews is not charged either.

#### How much does it cost to analyze app reviews?

| Reviews | Collect only | Collect and classify |
|---|---|---|
| 100 | $0.01 | $0.07 |
| 1,000 | $0.15 | $0.65 |
| 10,000 | $1.50 | $6.50 |
| 100,000 | $15.00 | $65.00 |

With the free $5 monthly Apify credit you can collect and classify about **7,692 reviews**.

A default run is collection only ($0.15 per 1,000). Turning on **Add AI labels** makes it $0.65 per 1,000 (columns above show both). Set a **maximum cost per run** in the run options: the Actor stops when it is reached and never charges beyond it.

#### Is it free to try?

Yes. The form starts with two sample apps and 20 reviews each: about $0.006 for collection only ($0.03 with AI labels), well inside the free monthly credit.

### Input and output examples

#### Output sample

One row per review (abridged):

```json
{
  "platform": "android",
  "appId": "com.spotify.music",
  "appName": "Spotify: Music and Podcasts",
  "country": "us",
  "reviewId": "ca14f2bb-ca66-43f9-a520-05c91457b01c",
  "rating": 3,
  "text": "when I turn my key on to my vehicle Spotify takes over my radio, how to stop that?",
  "date": "2026-10-17T22:32:11.000Z",
  "appVersion": "9.1.92.3058",
  "helpfulVotes": 0,
  "developerReply": null,
  "complaintTypes": "none",
  "sentiment": "negative",
  "alert": false,
  "needsReply": true,
  "unanswered": true,
  "labels": { "complaint": [{ "label": "none", "probability": 0.6 }], "needsReply": { "probability": 0.88, "matched": true }, "unanswered": true },
  "reviewUrl": "https://play.google.com/store/apps/details?id=com.spotify.music&reviewId=ca14f2bb-ca66-43f9-a520-05c91457b01c"
}
```

And the first line of an app's summary row: `"headline": "Top complaint: missing features (10%); 4 unanswered reviews need a reply."`

#### Input example

```json
{
  "apps": ["https://apps.apple.com/us/app/duolingo-language-lessons/id570060128", "com.duolingo"],
  "countries": ["us", "gb"],
  "reviewsPerApp": 200,
  "maxStars": 3,
  "reviewsNewerThan": "30 days",
  "customLabels": ["mentions a competitor app", "asks for dark mode"],
  "monitorKey": "my-apps"
}
```

#### Which links and IDs can I use?

- **App Store:** the app page link (`https://apps.apple.com/us/app/…/id570060128`, any country) or the numeric ID (`570060128`, `id570060128`). A country in the link is used when **Store countries** is left at its default.
- **Google Play:** the app page link (`https://play.google.com/store/apps/details?id=com.duolingo`) or the package name (`com.duolingo`).

#### Output files and columns

**Dataset (Reviews table):** `platform` (`ios` / `android`), `appId`, `appName`, `country`, `reviewId`, `rating`, `title` (App Store only), `text`, `date`, `appVersion`, `helpfulVotes`, `developerReply` and `developerRepliedAt` (Google Play only), then the labels: `complaintTypes`, `praiseTypes`, `sentiment` + `sentimentProbability`, `alert` + `alertProbability`, `needsReply`, `unanswered` (Google Play only), `customLabelsMatched`, `reviewUrl`, and the full `labels` object with probabilities (`complaintScores` for every complaint type in Full output). A source that failed adds an error row (`type: "error"`), not charged.

**Complaint types:** `bug_crash` · `performance` · `ui_ux` · `missing_feature` · `price_billing` · `ads` · `account_login` · `support` · `privacy_trust` · `other` (`none` when there is no complaint). **Praise:** `reliability` · `performance` · `ui_ux` · `features` · `price_billing` · `account_login` · `support` · `privacy_trust`.

**Key-value store:**

| Key | Content |
|---|---|
| `REPORT` | One entry per app and country plus `overall`: `headline`, `reviews`, `classified`, `averageRating`, `starDistribution`, `complaintRate`, `complaints`, `praise`, `alerts` and `alertExamples`, `sentiment`, `needsReply`, `unansweredNeedingReply` and `developerReplyRate` (Google Play), `byVersion` (rating and complaint rate of the 5 newest app versions), `last90Days` / `before90Days`, `monthly`, `exampleComplaints`, and with a Monitor key `previousRunAt`, `ratingDelta`, `newReviews`, `newCriticalIssues`, `unrepliedDelta` |
| `REPORT_APPS.csv` | The same, one flat row per app and country, `headline` first |
| `REPLY_QUEUE.csv` | Google Play reviews that need a reply and have none, lowest stars first |
| `SUMMARY` | Counts, skipped reviews, per-source status (`sources`), requests and HTTP statuses, cost-relevant figures |

### API, MCP and integrations

#### Works with

Apify Schedules, webhooks, Zapier, Make, n8n, Google Sheets, Slack and the Apify API — anything that can start an Actor and read its dataset.

#### Call it from code

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('leoworks/app-review-scraper').call({
    apps: ['https://apps.apple.com/us/app/duolingo-language-lessons/id570060128', 'com.duolingo'],
    reviewsPerApp: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
const report = await client.keyValueStore(run.defaultKeyValueStoreId).getRecord('REPORT');
console.log(report.value.overall.headline);
```

```python
from apify_client import ApifyClient
client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("leoworks/app-review-scraper").call(run_input={"apps": ["com.duolingo"], "reviewsPerApp": 100})
items = client.dataset(run["defaultDatasetId"]).list_items().items
```

#### Use with Claude, Cursor or Claude Code (MCP)

Add the Apify MCP server (`https://mcp.apify.com`) with your Apify token, enable this Actor, then ask: *"Analyze the newest 100 Google Play reviews of com.duolingo and tell me the top complaints and whether the latest version is worse."* The agent calls the Actor and reads `REPORT` for the headline.

### Accuracy and limits

#### Accuracy

Complaint types: **81%** of 113 hand-labelled reviews of 12 popular apps (68 + 45, English plus some Spanish, Arabic and Korean; 2026-10-19). A review counts as right when at least one predicted complaint type is a labelled one and every predicted type is a labelled or an accepted alternative one, so one extra wrong label makes it a miss. Sentiment: **100%** of 101 reviews with a clear overall sentiment. This is a small internal check, not a benchmark: the labels are the developer's, one label definition was tightened after the second set, and vague or political reviews ("worse and worse", a removed search word) are the usual misses — they are often a judgement call between `other` and a specific type. The probabilities are there so you can set your own threshold.

#### Limits

- **App Store reviews stop at 500 per country and sort order** (Apple's feed ends at page 10) and carry no developer reply, so `developerReply`, `unanswered` and the reply queue exist for Google Play rows only.
- **Google Play reviews are the same in every country**; each Play app is read once. 5,000 reviews per app were read in tests with no limit seen.
- **Star-only reviews** (no text) cannot be classified; they are skipped and not charged.
- **No login, no workaround.** If a store blocks or rate-limits a request, that app/country is recorded as failed in `SUMMARY` and the rest of the run continues; reviews that were not collected are not charged.
- **Empty App Store pages are retried in steps.** Apple's feed sometimes answers with a valid but empty page, in bursts of minutes to hours, even for apps with millions of ratings; it depends on where the request comes from. If a page that should have reviews is empty, the Actor tries the same address again, then the XML version of the same feed, then the XML version through a residential proxy (where your plan has one), and finally twice more after short pauses (about 1.5 and 4 minutes later, so a run with a stuck page can take a few minutes longer). `SUMMARY.sources[].fetchPath` shows which step worked. If every step stays empty, the app is reported as `empty_feed` (nothing charged) when the store lists many ratings for it, as `no_reviews` with a note for small apps, or with a note that the feed stopped early when part of the reviews were already collected. Running again later usually returns the rest.
- **Languages:** reviews in any language are classified; English is the best tested.
- **New-review detection** (Monitor key) compares dates: reviews dated the same day as the previous run's newest review may be missed, so `newReviews` can undercount.

### Run it on a schedule

Weekly is the usual rhythm: set **Only reviews newer than** to `7 days` and a **Monitor key**, and each app row shows the rating change and new reviews since the last run. Create an [Apify Schedule](https://docs.apify.com/platform/schedules) for a saved task with your apps and competitors' apps. To start it from other tools, use the Apify [n8n](https://docs.apify.com/platform/integrations/n8n) or [Make](https://docs.apify.com/platform/integrations/make) integration, or the Apify API.

### More Actors from Leoworks

- [Google Maps Review Classifier](https://apify.com/leoworks/google-maps-review-classifier) — local-business reviews: complaints, alerts, unanswered replies.
- [AliExpress Reviews Scraper](https://apify.com/leoworks/aliexpress-reviews-classifier) — reviews with complaint types, photos and sentiment.
- [Amazon Review Classifier](https://apify.com/leoworks/amazon-review-classifier) — product reviews classified.
- [Naver Place Review Classifier](https://apify.com/leoworks/naver-place-review-classifier) — Korean place reviews and sponsored posts.
- [Korean Review Classifier](https://apify.com/leoworks/korean-review-classifier) — Korean review texts.
- [Social Comment Classifier](https://apify.com/leoworks/social-comment-classifier) — social media comments: questions, complaints, spam.

### FAQ and support

#### Why not use the official App Store or Google Play API?

Both official APIs only cover your own apps: App Store Connect returns reviews of apps in your developer account, and the Google Play Developer API returns only reviews of your own app created or changed in the last week. Neither gives competitors' reviews. This Actor reads the public App Store review feed and the Google Play web endpoint for any app, without a login.

#### What are the alternatives to App Store & Google Play Reviews Scraper?

The developer consoles (your own apps only), a paid app-intelligence subscription, or your own scraper — which has to deal with Apple's feed sometimes returning valid but empty pages. This Actor costs $0.15 per 1,000 reviews and retries those empty pages in steps.

#### How do I export App Store reviews to CSV or Excel?

Run the Actor with your app links, open the **Output** tab and export the dataset as CSV, Excel or JSON — every row has stars, title, text, date, app version and, on Google Play, the developer reply. `REPORT_APPS.csv` adds a per-app summary.

#### How do I analyze App Store and Google Play reviews?

Paste the app links, IDs or package names in **Apps** and click **Start**. The Actor collects the newest reviews; open the **Reviews** table and `REPORT_APPS.csv` (one row per app and country). With **Add AI labels** on, `REPLY_QUEUE.csv` also lists the Google Play reviews that need a developer reply. Step by step: **How to get App Store and Google Play reviews** above.

#### Does it collect reviewer names or profiles?

No. Names, avatars and profile links are never collected or output. The classification uses only the review title and text, its stars and your custom labels.

#### Can I see App Store developer replies?

No: Apple's public feed does not include them, so the reply queue and `unanswered` exist for Google Play only. App Store rows carry no reply fields.

#### Does it cover iOS app reviews and Play Store reviews?

Yes, both in one run. iOS app reviews (iPhone and iPad apps) come from the Apple App Store, per country you choose; Play Store reviews come from Google Play, in the language you choose. Mix App Store links or IDs and Google Play package names in **Apps**.

#### How many reviews can I get?

App Store: up to 500 per country and sort order — add countries or use both sort orders for more. Google Play: thousands per app (5,000 tested).

#### What happens if a store blocks the request?

The app is recorded as failed in `SUMMARY` (`sources`, with `blocked`, `http` or `not_found`) and an error row is added to the dataset. Nothing is charged for reviews that were not collected, and no workaround is attempted.

#### Is it legal to analyze app reviews?

The reviews are public. App Store reviews come from Apple's public feed; Google Play reviews from the endpoint the Play page itself uses, which Google's robots.txt lists under `Disallow` — so Google's terms apply and you are responsible for your use. This is not legal advice.

#### Which AI makes the judgments?

Jev, TypeSafe's decision model (version `jev-1.13.0`, pinned). Jev answers each label with a calibrated probability instead of generated text, so a 0.9 means the same thing for every item. Re-running the same input can change a few borderline answers — filter on probability when an item must never flip.

#### What counts as a serious issue?

A security or privacy breach (hacked account, leaked data), unauthorised or fraudulent charges, harm to children, scam accusations, health or safety danger, or a threat of legal action, a chargeback or a report to the store. Ordinary bugs, ads, prices or a disliked redesign are not serious issues.

#### Does it write the developer replies?

No. It tells you which reviews need a reply, so you can answer the right ones first.

#### Can I classify only new reviews every week?

Yes: schedule the Actor with **Only reviews newer than: 7 days** and a **Monitor key**. Older reviews are skipped and not charged.

#### Disclaimer

Not affiliated with Apple or Google. App Store and Google Play are trademarks of their owners. Reviews are public data; you are responsible for how you use them.

#### Reviews and support

Questions or a wrong label? Open an issue on the Actor's **Issues** tab with the run link. If this Actor saved you time, a short review on Apify Store helps others find it.

### Changelog

See the Actor's **Versions** tab. Latest: 0.1 — first release (App Store RSS and Google Play, 10 complaint types, praise, sentiment, serious-issue alert, reply queue, headline, app versions, Monitor key).

# Changelog

This Actor's version history is a separate document: https://apify.com/leoworks/app-review-scraper/changelog.md

# Actor input Schema

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

Apple App Store apps (URL or numeric ID, e.g. https://apps.apple.com/us/app/duolingo/id570060128 or 570060128) and Google Play apps (URL or package name, e.g. https://play.google.com/store/apps/details?id=com.duolingo or com.duolingo). The store is detected from each value. Up to 50 apps. Leave empty only when you use "Dataset ID" under Advanced.

## `reviewsPerApp` (type: `integer`):

Maximum reviews to collect for each app, country and store (charged per review: $0.15 per 1,000, or $0.65 per 1,000 with AI labels). The App Store feed stops at 500 reviews per country and sort order; Google Play goes deeper. The form starts at 20 for a quick, low-cost first run (default when omitted via API: 100).

## `classify` (type: `boolean`):

Off by default: the Actor collects the reviews and writes them to the dataset ($0.15 per 1,000). Turn on to add complaint types (bugs and crashes, performance, design and usability, missing features, price and billing, ads, account and login, support, privacy and trust), praise, sentiment, a serious-issue alert and a needs-a-reply flag to each review, plus the per-app summary with headline. Adds $0.5 per 1,000 labelled reviews. Giving Custom labels or a Dataset ID turns labels on.

## `customLabels` (type: `array`):

Up to 10 yes/no criteria in plain language, e.g. "mentions a competitor app", "asks for dark mode", "complains about the subscription price after the free trial". Giving labels turns AI labels on. Each classified review gets a probability and `matched` per label. Included in the classification price.

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

2-letter country codes, e.g. us, gb, kr, jp, de. Used for the App Store country (one feed per country) and as the Google Play region. Google Play returns the same reviews for every country, so each Google Play app is read once, using the first country.

## `sort` (type: `string`):

Newest first is best for monitoring. Most helpful (App Store: most helpful; Google Play: most relevant) shows the reviews other users found useful.

## `maxStars` (type: `integer`):

Keep only reviews with at most this many stars — e.g. 3 to read only the critical ones. Filtered reviews are not stored or charged.

## `reviewsNewerThan` (type: `string`):

A date (`2026-09-01`) or a period (`30 days`, `6 months`).

## `keywords` (type: `array`):

Keep only reviews that contain at least one of these words or phrases (any language, case-insensitive), e.g. "crash", "refund", "subscription".

## `playLanguage` (type: `string`):

Language code for the Google Play store page (en, ko, ja …). Reviews are returned in the reviewers' own languages whatever you choose here.

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

Full adds the flat label columns and probabilities for every label. Minimal stores only the label keys.

## `monitorKey` (type: `string`):

Optional name for a recurring check (e.g. `my-apps`). The summary then reports what changed since the last run with the same key: rating change, new reviews, new serious issues and unanswered-review change. Only summary figures (no review text) are kept, in the named key-value store `monitor-app-reviews` of your own Apify account.

## `datasetId` (type: `string`):

Instead of "Apps": the ID of an Apify dataset with app reviews collected elsewhere. The text, rating, date, version and developer-reply fields are detected automatically. AI labels are always on in this mode. Only classification is charged ($0.5 per 1,000).

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

How many reviews are classified at the same time.

## Actor input object example

```json
{
  "apps": [
    "https://apps.apple.com/us/app/duolingo-language-lessons/id570060128",
    "com.duolingo"
  ],
  "reviewsPerApp": 20,
  "classify": false,
  "customLabels": [],
  "countries": [
    "us"
  ],
  "sort": "newest",
  "keywords": [],
  "playLanguage": "en",
  "outputMode": "full",
  "maxConcurrency": 10
}
```

# Actor output Schema

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

No description

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

No description

## `report` (type: `string`):

No description

## `appsCsv` (type: `string`):

No description

## `replyQueue` (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": [
        "https://apps.apple.com/us/app/duolingo-language-lessons/id570060128",
        "com.duolingo"
    ],
    "reviewsPerApp": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("leoworks/app-review-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 = {
    "apps": [
        "https://apps.apple.com/us/app/duolingo-language-lessons/id570060128",
        "com.duolingo",
    ],
    "reviewsPerApp": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("leoworks/app-review-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 '{
  "apps": [
    "https://apps.apple.com/us/app/duolingo-language-lessons/id570060128",
    "com.duolingo"
  ],
  "reviewsPerApp": 20
}' |
apify call leoworks/app-review-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,leoworks/app-review-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/smWKHejtefwhr2yCv/builds/SN8e0lAdeOpeDsMT6/openapi.json