# App Store Reviews Scraper · Ratings, Reviews & Version History (`reapx/app-store-reviews-scraper`) Actor

App Store Reviews Scraper extracts Apple App Store reviews, star ratings, user feedback, and version history across 55 country storefronts. Filter by stars, date, or keyword for ASO and competitor analysis.

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

## Pricing

from $1.40 / 1,000 app store review returneds

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

![reapX — public sources in, addressable records out](https://reapx.dev/reapx.gif)

## App Store Reviews Scraper · Ratings, Reviews & Version History

App Store Reviews Scraper is a fast iOS App Store reviews scraper that extracts Apple App Store reviews, star ratings, customer feedback, and app version history for any iOS app across 55 country storefronts without login, API keys, or headless browsers. Provide an App Store URL, app ID, bundle ID, or search query to scrape App Store reviews into structured JSON/CSV for ASO (App Store Optimization), sentiment analysis, and competitor research.

> Maintained by **reapX**. Every row cites the Apify run that produced it — nothing is
> inferred, modelled or filled in, and a field absent from the source is absent from the row.
> The extracted archive for this source is browsable at
> [reapx.dev/data/app-store-reviews-scraper/](https://reapx.dev/data/app-store-reviews-scraper/) and mirrored as an open dataset on
> [Hugging Face](https://huggingface.co/datasets/reapxdev/app-store-reviews-scraper) and
> [Kaggle](https://www.kaggle.com/datasets/reapxdev/app-store-reviews-scraper). Questions: reapxdev@proton.me

You pay $0.002 per review returned. Blocked storefronts, unresolved apps, empty feeds and reviews your filters remove are never charged.

### How to use App Store Reviews Scraper

1. Paste one or more apps into **App Store apps** - a URL like `https://apps.apple.com/us/app/whatsapp-messenger/id310633997`, a numeric ID like `284882215`, or a bundle ID like `com.burbn.instagram`. Mixed formats are fine.
2. Or leave it and type an **App Store search term** such as `budget tracker`. The scraper resolves it to the top-ranking apps in every storefront you picked.
3. Choose your **country storefronts**. Apple keeps a separate review feed per country, so `us` and `de` give you genuinely different reviews for the same app.
4. Press **Start**. The prefilled defaults run out of the box and finish in well under a minute.

### App Store Reviews Scraper output data

Every row is one review and carries the whole app profile with it, so a single export is enough for analysis - no joining required.

| Column | What it is |
| --- | --- |
| `reviewId`, `reviewedAt` | Apple's stable review ID and the post date in ISO 8601 UTC |
| `rating` | Star rating, 1 to 5 |
| `reviewTitle`, `reviewBody` | Headline and full review text as published |
| `reviewerName`, `reviewerProfileUrl` | Public App Store nickname and the reviewer's other reviews |
| `reviewAppVersion`, `isCurrentVersion` | The app version the reviewer was running, and whether it is the live one |
| `helpfulVoteCount`, `helpfulVoteSum` | How many people voted on the review and the net score |
| `country`, `countryName` | Which storefront the review came from |
| `appName`, `appId`, `appBundleId`, `appDeveloper` | Identity of the reviewed app |
| `appAverageRating`, `appRatingCount` | Lifetime star average and rating count in that storefront |
| `appAverageRatingCurrentVersion`, `appRatingCountCurrentVersion` | The same, for the live release only |
| `appCurrentVersion`, `appCurrentVersionReleaseDate`, `appReleaseNotes` | The live release, when it shipped and its what's-new text |
| `appFirstReleaseDate`, `appMinimumOsVersion`, `appSizeBytes`, `appLanguages` | Launch date and technical profile |
| `appPrimaryGenre`, `appGenres`, `appFormattedPrice`, `appContentRating` | Category, price and age rating in that storefront |
| `appIconUrl`, `appStoreUrl`, `reviewUrl` | Artwork and links back to the listing |

Four named views are ready in the dataset tab: **Reviews**, **Version history**, **Ratings and app profile**, and **Review text for analysis**. Export any of them to JSON, CSV, Excel, XML or RSS, or read them straight from the API.

### App version history from reviews

Apple does not publish a per-release changelog feed. What this scraper does instead is stamp every review with `reviewAppVersion` - the build the reviewer was actually running - alongside the live release metadata (`appCurrentVersion`, `appCurrentVersionReleaseDate`, `appReleaseNotes`). Group the **Version history** view by `reviewAppVersion` and you get average stars per release, how fast users moved onto the new build, and which version the complaints belong to. Set **Only reviews posted after** to a release date to isolate the reaction to one update.

### Filter App Store reviews before you pay

- **Minimum / maximum star rating** - set `1`-`2` to isolate complaints, `4`-`5` for testimonials.
- **Only reviews posted after** - a date cutoff for release monitoring.
- **Only reviews mentioning** - keeps a review only if its title or body contains one of your words, such as `crash`, `refund`, `subscription`.
- **Skip reviews with an empty body** - drops star-only ratings before sentiment analysis.
- **Max reviews for the whole run** - a hard cost ceiling for the run.

Filtered-out reviews are fetched but never charged, so tight filters cost less, not more.

### Track competitor apps across country storefronts

Add several apps and several storefronts in one run. Each row is labelled with `appName` and `country`, so you can compare a competitor's German 1-star reviews to your own, or watch how the same app is received in `jp`, `br` and `ae`. Search terms work the same way - one term such as `habit tracker` becomes a live cohort of the top-ranking apps in every market you selected, which keeps working as the charts move.

### Limits you should know about

- Apple's public review feed serves **50 reviews per page and stops at page 10**, so the ceiling is **500 reviews per app, per storefront, per sort order**. Asking for more is capped, not failed.
- Review order is Apple's own: **most recent** or **most helpful**.
- Reviewer nicknames are public App Store display names. No private or personal data is collected.
- Requests are plain HTTP with exponential backoff on 429 and 5xx, and the lookup and search endpoints are throttled to Apple's stated ~20 calls per minute.
- Apple throttles busy shared cloud IPs by returning an **empty feed** rather than an error. The scraper routes each app and storefront through its own Apify Proxy session to avoid this, and retries an empty first page twice. If a feed still comes back empty, the status message names it and you are charged nothing for it.

### Input configuration

Every field is optional. The prefilled values below are what runs if you press Start without changing anything.

#### Which apps to read

Name the apps directly, or let the App Store search find them for you. You can use both at once.

| Field | Type | Accepts | What it does |
| --- | --- | --- | --- |
| `appIds` | list | one value per line | The iOS apps to read reviews for. Paste an App Store URL, a numeric app ID, or a bundle ID - one per line. Example: https://apps.apple.com/us/app/whatsapp-messenger/id310633997, 284882215, com.burbn.instagram. Prefilled with `["284882215"]`. |
| `searchTerms` | list | one value per line | App Store search queries. Each one is resolved to the top-ranking apps in every storefront you selected, so you can track a whole category without knowing its app IDs. Example: budget tracker, habit tracker. Prefilled with `[]`. |
| `appsPerSearchTerm` | integer | 1 to 25 | How many top-ranking apps to keep for each search term above. Example: 3 keeps the three best-matching apps per term. Prefilled with `3`. |

#### Which country storefronts

Reviews differ per country. Add several to compare markets in one run.

| Field | Type | Accepts | What it does |
| --- | --- | --- | --- |
| `countries` | list | one value per line | Apple runs a separate review feed per country. Pick one or many - every review row is labelled with the storefront it came from. Example: us, gb, de, jp. Prefilled with `["us"]`. |

#### How many reviews

Apple's public review feed serves at most 500 reviews per app per storefront. You pay only for the reviews you actually receive.

| Field | Type | Accepts | What it does |
| --- | --- | --- | --- |
| `sortBy` | string | `mostrecent`, `mosthelpful` | Newest first, or the reviews Apple ranks as most helpful. Example: mostrecent for monitoring, mosthelpful for research. Prefilled with `"mostrecent"`. |
| `maxReviewsPerApp` | integer | 1 to 500 | Upper limit for each app in each storefront, before filters. Apple's hard ceiling is 500. Example: 100. Prefilled with `100`. |
| `maxTotalReviews` | integer | 1 to 100000 | Hard stop for the entire run - your cost ceiling. The run ends as soon as this many reviews have been returned. Example: 500. Prefilled with `500`. |

#### Filter the reviews

Filtered-out reviews are never charged. Leave these at their defaults to keep every review.

| Field | Type | Accepts | What it does |
| --- | --- | --- | --- |
| `minRating` | integer | 1 to 5 | Keep only reviews at or above this star rating. Example: 1 keeps everything, 4 keeps positive reviews. Prefilled with `1`. |
| `maxRating` | integer | 1 to 5 | Keep only reviews at or below this star rating. Example: 2 isolates 1- and 2-star complaints. Prefilled with `5`. |
| `reviewedAfter` | string | `YYYY-MM-DD` | Drop anything older than this date. Useful for watching the reaction to a release. Example: 2026-01-01. Prefilled with `""`. |
| `keywords` | list | one value per line | Keep a review only if its title or body contains one of these words, case-insensitive. Example: crash, refund, subscription. Prefilled with `[]`. |
| `onlyReviewsWithText` | true/false | checkbox | Drop star-only reviews that carry no written text. Example: true when you plan to run sentiment analysis. Prefilled with `false`. |

#### Connection

Leave this alone unless you have a reason not to. Reviews the source never returns are never charged.

| Field | Type | Accepts | What it does |
| --- | --- | --- | --- |
| `proxyConfiguration` | object | free text | Apple throttles busy shared cloud IPs by answering with an empty review feed instead of an error. Apify Proxy gives each app and storefront its own exit IP, which avoids it. Example: leave this on. Prefilled with `{"useApifyProxy": true}`. |

### Pricing

Pay per event. The primary event is **App Store review returned** (`review-item`), charged at **$0.002 per event** on the free plan, falling to $0.0008 on the highest tier.

Charged once for each App Store review written to the dataset. Blocked storefronts, unresolved apps, empty feeds and reviews removed by your filters are never charged.

Other charged events: `apify-actor-start` (Actor Start).

Minimum charge cap per run: $0.002.

Tiered discounts apply automatically on every paid Apify plan. Platform usage is absorbed by the Actor, so the per-event price is the whole price.

### Usage examples

#### The prefilled run, which is what Start does with nothing changed

```json
{
  "appIds": [
    "284882215"
  ],
  "appsPerSearchTerm": 3,
  "countries": [
    "us"
  ],
  "sortBy": "mostrecent",
  "maxReviewsPerApp": 100,
  "maxTotalReviews": 500,
  "minRating": 1,
  "maxRating": 5,
  "onlyReviewsWithText": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

#### A larger run, with the record cap as the cost cap

```json
{
  "appIds": [
    "284882215"
  ],
  "appsPerSearchTerm": 3,
  "countries": [
    "us"
  ],
  "sortBy": "mostrecent",
  "maxReviewsPerApp": 500,
  "maxTotalReviews": 500,
  "minRating": 1,
  "maxRating": 5,
  "onlyReviewsWithText": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

### Output example

One row, exactly as the actor wrote it to the dataset:

```json
{
  "reviewId": "14375712908",
  "appId": "324684580",
  "appName": "Spotify: Music and Podcasts",
  "appBundleId": "com.spotify.client",
  "appDeveloper": "Spotify",
  "appDeveloperId": "324684583",
  "country": "us",
  "countryName": "United States",
  "rating": 5,
  "reviewTitle": "The best",
  "reviewBody": "Way better than pandora",
  "reviewerName": "Jaxon Lee grow",
  "reviewerProfileUrl": "https://itunes.apple.com/us/reviews/id1758233043",
  "reviewedAt": "2026-08-01T18:34:51Z",
  "reviewAppVersion": "9.1.68",
  "isCurrentVersion": true,
  "helpfulVoteCount": 0,
  "helpfulVoteSum": 0
}
```

That row carries 41 fields in total; 18 are shown.

#### Fields on every row

| Field | Type | What it is |
| --- | --- | --- |
| `reviewId` | string | Apple's stable identifier for this review. Unique per review, safe to use as a deduplication key. |
| `appId` | string | Apple's numeric App Store identifier (trackId) for the reviewed app. |
| `appName` | string | App title as shown in the selected country storefront. |
| `appBundleId` | string | Reverse-domain bundle identifier of the app. |
| `appDeveloper` | string | Name of the seller or developer publishing the app. |
| `appDeveloperId` | string | Apple's numeric artist identifier for the developer. |
| `country` | string | Two-letter country code of the App Store storefront this review was published in. |
| `countryName` | string | Human-readable name of the storefront country. |
| `rating` | integer | Star rating the reviewer gave, from 1 to 5. |
| `reviewTitle` | string | Headline the reviewer wrote. |
| `reviewBody` | string | Full body text of the review, as published. |
| `reviewerName` | string | Public App Store nickname of the reviewer. Apple does not expose real names. |
| `reviewerProfileUrl` | string | Public App Store page listing this reviewer's other reviews. |
| `reviewedAt` | string | When the review was posted, normalised to ISO 8601 UTC. |
| `reviewAppVersion` | string | The app version this reviewer was running. Group by this field to build a version history of sentiment. |
| `isCurrentVersion` | true/false | True when the reviewed version equals the version currently live in this storefront. |
| `helpfulVoteCount` | integer | Number of users who voted on whether this review was helpful. |
| `helpfulVoteSum` | integer | Net helpful score: positive votes minus negative votes. |
| `reviewUrl` | string | App Store page showing all reviews for this app in this storefront. |
| `sortOrder` | string | Which of Apple's review orderings this row was collected from. |
| `sourcePage` | integer | Page of Apple's review feed the row came from, 1 to 10 (50 reviews per page). |
| `appPrimaryGenre` | string | Main App Store category of the app. |
| `appGenres` | list | Every App Store category the app is listed under. |
| `appPrice` | number | Download price in the storefront's local currency. 0 for free apps. |
| `appCurrency` | string | ISO currency code the price is quoted in. |
| `appFormattedPrice` | string | Price as Apple displays it in this storefront. |
| `appContentRating` | string | Apple's content advisory rating for the app. |
| `appAverageRating` | number | Lifetime average star rating of the app in this storefront. |
| `appRatingCount` | integer | Total number of star ratings the app has received in this storefront. |
| `appAverageRatingCurrentVersion` | number | Average star rating for the version currently live in this storefront. |
| `appRatingCountCurrentVersion` | integer | Number of star ratings for the version currently live in this storefront. |
| `appCurrentVersion` | string | Version string of the release currently published in this storefront. |
| `appCurrentVersionReleaseDate` | string | ISO 8601 UTC timestamp of the latest release. |
| `appReleaseNotes` | string | What's-new text the developer published with the current version. |
| `appFirstReleaseDate` | string | ISO 8601 UTC timestamp of the app's original App Store release. |
| `appMinimumOsVersion` | string | Lowest iOS version the app supports. |
| `appSizeBytes` | integer | Download size of the app binary in bytes. |
| `appLanguages` | list | ISO 2-letter language codes the app is localised into. |
| `appIconUrl` | string | Direct link to the app's high-resolution icon artwork. |
| `appStoreUrl` | string | Public App Store listing for the app in this storefront. |
| `scrapedAt` | string | ISO 8601 UTC timestamp of when this run collected the row. |

4 named dataset views ship with it: **Reviews**, **Version history**, **Ratings and app profile**, **Review text for analysis**. They drive the Output tab in Console and the Output block on the Actor's `.md` page.

### FAQ

#### Can I scrape App Store reviews without an API key?

Yes. This scraper only reads Apple's public review RSS feed, the iTunes lookup endpoint and the iTunes search endpoint. There is no login, no cookie and no key to configure.

#### How many App Store reviews can I get for one app?

Up to 500 per app per country storefront - Apple's public feed hard-stops at page 10 of 50. To go wider, add more storefronts: 10 countries gives you up to 5,000 reviews for the same app, each labelled with its market.

#### How do I find an app's App Store ID?

You don't have to. Paste the App Store URL and the scraper reads the ID out of it, or paste the bundle ID, or type the app's name as a search term.

#### Can I get only 1-star reviews?

Set **Maximum star rating** to 1. Reviews above that are dropped before anything is charged.

#### Does this return the app's version history and release notes?

It returns the live version, its release date and its release notes on every row, plus `reviewAppVersion` - the build each reviewer was running. Grouping by that column reconstructs sentiment per release. Apple does not expose an archive of past release notes publicly, so historical changelog text is not available from any open endpoint.

#### What does a run cost?

$0.002 per review returned, discounted on every paid Apify plan. The default run (100 reviews from one app) costs about $0.20. Nothing is charged for blocked storefronts, apps that cannot be resolved, empty feeds or reviews your filters remove. Use **Max reviews for the whole run** to pin the ceiling exactly.

#### Why did one app return no reviews?

Apple sometimes serves an empty review feed for a specific app and storefront, especially to shared cloud IP ranges. The scraper retries with a fresh proxy session, and if the feed is still empty it names that app in the run status message and charges you nothing for it. Re-running usually fills the gap.

#### How fresh are the reviews?

Live. Every run reads Apple's feed at that moment; `scrapedAt` records when, and **Most recent first** puts the newest reviews at the top.

#### Can I run this on a schedule or from an agent?

Yes. Save any configuration as an Apify task and schedule it, or call the Actor from the API. The dataset schema is fully typed and documented, so agents can chain the output without guessing at columns.

***

Unofficial - not affiliated with Apple. Collects public data only. reapx.
Contact reapxdev@proton.me.

### The full published archive

- **[app store reviews scraper archive](https://reapx.dev/data/app-store-reviews-scraper/)** — every entity this Actor has observed
- **[All reapx datasets](https://reapx.dev/data/)** — 20 sources, tens of thousands of pages
- **[llms.txt](https://reapx.dev/llms.txt)** · **[feed.json](https://reapx.dev/feed.json)** ·
  **[feed.xml](https://reapx.dev/feed.xml)** — the machine-readable index, for agents

Each archive page carries Dataset JSON-LD, a canonical URL and the identifiers used, so an agent
can resolve an entity without running anything. Nothing on those pages is estimated or modelled.

### 🧪 Example input

A real, runnable configuration — this is an actual input this Actor has run with.

```json
{
  "maxReviewsPerApp": 60,
  "maxTotalReviews": 240,
  "sortBy": "mostrecent",
  "appIds": [
    "324684580",
    "1108187390",
    "1017492454",
    "336353151"
  ],
  "countries": [
    "us"
  ],
  "searchTerms": [],
  "appsPerSearchTerm": 3,
  "minRating": 1,
  "maxRating": 5,
  "reviewedAfter": "",
  "keywords": [],
  "onlyReviewsWithText": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

### 📄 Sample output

One real row from a real run of this Actor, unedited.

```json
{
  "reviewId": "14375712908",
  "appId": "324684580",
  "appName": "Spotify: Music and Podcasts",
  "appBundleId": "com.spotify.client",
  "appDeveloper": "Spotify",
  "appDeveloperId": "324684583",
  "country": "us",
  "countryName": "United States",
  "rating": 5,
  "reviewTitle": "The best",
  "reviewBody": "Way better than pandora",
  "reviewerName": "Jaxon Lee grow",
  "reviewerProfileUrl": "https://itunes.apple.com/us/reviews/id1758233043",
  "reviewedAt": "2026-08-01T18:34:51Z",
  "reviewAppVersion": "9.1.68",
  "isCurrentVersion": true,
  "helpfulVoteCount": 0,
  "helpfulVoteSum": 0,
  "reviewUrl": "https://apps.apple.com/us/app/id324684580?see-all=reviews",
  "sortOrder": "mostrecent",
  "sourcePage": 1,
  "appPrimaryGenre": "Music",
  "appGenres": [
    "Music",
    "Entertainment"
  ],
  "appPrice": 0,
  "appCurrency": "USD",
  "appFormattedPrice": "Free",
  "appContentRating": "12+",
  "appAverageRating": 4.7774,
  "appRatingCount": 41311514,
  "appAverageRatingCurrentVersion": 4.7774,
  "appRatingCountCurrentVersion": 41311514,
  "appCurrentVersion": "9.1.68",
  "appCurrentVersionReleaseDate": "2026-07-28T07:54:47Z",
  "appReleaseNotes": "We’re always making changes and improvements to Spotify. To make sure you don’t miss a thing, just keep your Updates turned on.",
  "appFirstReleaseDate": "2011-07-14T11:22:37Z",
  "appMinimumOsVersion": "16.1",
  "appSizeBytes": 289359872,
  "appLanguages": [
    "AF",
    "AM",
    "AR",
    "AZ",
    "EU",
    "BN",
    "BS",
    "BG",
    "CA",
    "HR",
    "CS",
    "DA",
    "NL",
    "EN",
    "ET",
    "FI",
    "FR",
    "GL",
    "DE",
    "EL",
    "GU",
    "HE",
    "HI",
    "HU",
    "IS",
    "ID",
    "IT",
    "JA",
    "KN",
    "KO",
    "LV",
    "LT",
    "MK",
    "MS",
    "ML",
    "MR",
    "NE",
    "NB",
    "OR",
    "FA",
    "PL",
    "PT",
    "PA",
    "RO",
    "RU",
    "SR",
    "ZH",
    "SK",
    "SL",
    "ES",
    "SW",
    "SV",
    "TA",
    "TE",
    "TH",
    "ZH",
    "TR",
    "UK",
    "UR",
    "VI",
    "ZU"
  ],
  "appIconUrl": "https://is1-ssl.mzstatic.com/image/thumb/Purple211/v4/01/b4/f5/01b4f500-a216-ede2-81dd-e6b4668e53cf/AppIcon-0-0-1x_U007epad-0-1-0-0-sRGB-85-220.png/512x512bb.jpg",
  "appStoreUrl": "https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580?uo=4",
  "scrapedAt": "2026-08-02T23:15:43Z"
}
```

### 💬 Your feedback

Found a bug, or need a field this does not return yet? Open an issue on the Actor's **Issues**
tab, or write to **reapxdev@proton.me**. Bugs get fixed and reasonable field requests get
added.

# Actor input Schema

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

The iOS apps to read reviews for. Paste an App Store URL, a numeric app ID, or a bundle ID - one per line. Example: https://apps.apple.com/us/app/whatsapp-messenger/id310633997, 284882215, com.burbn.instagram.<br><br>Leave this field empty to include every option.

## `searchTerms` (type: `array`):

App Store search queries. Each one is resolved to the top-ranking apps in every storefront you selected, so you can track a whole category without knowing its app IDs. Example: budget tracker, habit tracker.<br><br>Leave this field empty to include every option.

## `appsPerSearchTerm` (type: `integer`):

How many top-ranking apps to keep for each search term above. Example: 3 keeps the three best-matching apps per term.

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

Apple runs a separate review feed per country. Pick one or many - every review row is labelled with the storefront it came from. Example: us, gb, de, jp.<br><br>Leave this field empty to include every option.

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

Newest first, or the reviews Apple ranks as most helpful. Example: mostrecent for monitoring, mosthelpful for research.<br><br>Options: <code>mostrecent</code>, <code>mosthelpful</code>.

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

Upper limit for each app in each storefront, before filters. Apple's hard ceiling is 500. Example: 100.<br><br>The higher the number, the longer the run takes and the more you are charged, because you pay per row returned.

## `maxTotalReviews` (type: `integer`):

Hard stop for the entire run - your cost ceiling. The run ends as soon as this many reviews have been returned. Example: 500.<br><br>The higher the number, the longer the run takes and the more you are charged, because you pay per row returned.

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

Keep only reviews at or above this star rating. Example: 1 keeps everything, 4 keeps positive reviews.

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

Keep only reviews at or below this star rating. Example: 2 isolates 1- and 2-star complaints.<br><br>The higher the number, the longer the run takes and the more you are charged, because you pay per row returned.

## `reviewedAfter` (type: `string`):

Drop anything older than this date. Useful for watching the reaction to a release. Example: 2026-01-01.

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

Keep a review only if its title or body contains one of these words, case-insensitive. Example: crash, refund, subscription.<br><br>Leave this field empty to include every option.

## `onlyReviewsWithText` (type: `boolean`):

Drop star-only reviews that carry no written text. Example: true when you plan to run sentiment analysis.

## `proxyConfiguration` (type: `object`):

Apple throttles busy shared cloud IPs by answering with an empty review feed instead of an error. Apify Proxy gives each app and storefront its own exit IP, which avoids it. Example: leave this on.

## Actor input object example

```json
{
  "appIds": [
    "284882215"
  ],
  "searchTerms": [],
  "appsPerSearchTerm": 3,
  "countries": [
    "us"
  ],
  "sortBy": "mostrecent",
  "maxReviewsPerApp": 100,
  "maxTotalReviews": 500,
  "minRating": 1,
  "maxRating": 5,
  "keywords": [],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

Every review with its rating, text, date and storefront.

## `versionHistory` (type: `string`):

Which app version each reviewer was running, next to the live release. Group by app version to see how sentiment moved release over release.

## `ratings` (type: `string`):

App-level rating totals, price, category and size carried on every row - one lookup per app and storefront.

## `reviewText` (type: `string`):

Just the columns you need to feed sentiment analysis or an LLM: id, stars, title, body, version, date.

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

Every record this run produced, with all fields and no view applied. Field-level titles, types, descriptions and examples are declared in the dataset schema.

# 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": [
        "284882215"
    ],
    "searchTerms": [],
    "appsPerSearchTerm": 3,
    "countries": [
        "us"
    ],
    "sortBy": "mostrecent",
    "maxReviewsPerApp": 100,
    "maxTotalReviews": 500,
    "minRating": 1,
    "maxRating": 5,
    "reviewedAfter": "",
    "keywords": [],
    "onlyReviewsWithText": false,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("reapx/app-store-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 = {
    "appIds": ["284882215"],
    "searchTerms": [],
    "appsPerSearchTerm": 3,
    "countries": ["us"],
    "sortBy": "mostrecent",
    "maxReviewsPerApp": 100,
    "maxTotalReviews": 500,
    "minRating": 1,
    "maxRating": 5,
    "reviewedAfter": "",
    "keywords": [],
    "onlyReviewsWithText": False,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("reapx/app-store-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 '{
  "appIds": [
    "284882215"
  ],
  "searchTerms": [],
  "appsPerSearchTerm": 3,
  "countries": [
    "us"
  ],
  "sortBy": "mostrecent",
  "maxReviewsPerApp": 100,
  "maxTotalReviews": 500,
  "minRating": 1,
  "maxRating": 5,
  "reviewedAfter": "",
  "keywords": [],
  "onlyReviewsWithText": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call reapx/app-store-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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