# App Store Reviews Scraper | All Countries, Monitor | $0.06 / 1K (`hridayrungta/app-store-reviews-scraper`) Actor

App Store reviews for any iOS app in all 177 countries: stars, title, text, author, app version, date, helpful votes. Paste URLs, ids or app names. Only-new-reviews monitoring for schedules, star, date and keyword filters, optional rating summary. No login. $0.06 per 1,000 reviews.

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

## Pricing

from $0.04 / 1,000 review scrapeds

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

Get **App Store reviews** (iOS app reviews) for any iPhone or iPad app in any of Apple's **177 country storefronts**: star rating, review title and text, author, app version, date and helpful votes. Paste an App Store link, an app id or just the app's name, pick the countries and run. It works as an **App Store reviews API** and **app reviews API** alternative for **app review monitoring**, product feedback analysis and competitor research, with no login and no API key.

Try it in one click: the prefilled input reads the 50 newest Duolingo reviews in the US and UK in about 3 seconds.

- **Every country, not just the US.** Each App Store country has its own reviews. Pick countries one by one, or use a preset: Top 10 markets, English-speaking, Europe, Latin America, Asia, Middle East, or all 177 storefronts.
- **Only new reviews (monitoring).** Turn on *Only new reviews since the last run*, schedule the Actor daily or hourly, and every run returns just the reviews you have not received yet. You never pay twice for the same review.
- **Filters that save money.** Star range (for example 1-2 stars for complaints), "newer than" date (stops paging once reviews get older), and keywords in the review text (crash, refund, login...).
- **Apps by URL, id, bundle id or name.** Names are matched with Apple's own App Store search, and nonsense names are rejected instead of silently matching a random app.
- **Optional app summary row** per app and country: average rating, total rating count, current version and release date, price, genre, developer.
- **Complete pages.** Apple's CDN sometimes serves an empty copy of a review page that does have reviews (about 5-10% of pages in our tests). The Actor always reads page 1 fresh and re-checks every empty page, so you do not silently lose reviews.
- **Platform extras:** API access, scheduling, webhooks, integrations (Make, n8n, Zapier, Google Sheets), automatic fallback to Apify Proxy when Apple slows requests down, and exports to JSON, CSV, Excel or XML.

### What data can you extract from the App Store?

| Field | Example | Notes |
|---|---|---|
| `rating` | 5 | 1-5 stars |
| `title`, `text` | "Learning the lazy way" | Full review text as written |
| `authorName`, `authorUrl` | Vaqmao | Reviewer's public nickname and Apple reviews page |
| `appVersion` | 7.146.1 | The app version the review was written for |
| `date`, `dateLocal` | 2026-11-01T04:08:16.000Z | UTC ISO date plus Apple's original timestamp |
| `helpfulVotes`, `totalVotes` | 294 / 430 | "Was this review helpful?" votes |
| `country` | gb | App Store storefront |
| `appId`, `appName` | 570060128, Duolingo | Same app id in every country |
| `reviewId` | 14736243673 | Stable Apple id, used for de-duplication and monitoring |
| `feedPage`, `feedPosition` | 1, 1 | Where the review sits in Apple's feed |
| `reviewsPageUrl`, `appUrl` | apps.apple.com/... | Links to the app's reviews page and App Store page |

App summary rows (`type: "app"`) add `averageRating`, `ratingCount`, `averageRatingCurrentVersion`, `ratingCountCurrentVersion`, `version`, `currentVersionReleaseDate`, `releaseNotes`, `price`, `currency`, `primaryGenre`, `genres`, `developer`, `bundleId`, `contentRating`, `iconUrl` and `reviewsScraped` (how many reviews this run collected for that app and country).

### How to use the App Store Reviews Scraper

1. Open the Actor and paste one or more apps into **Apps**: an App Store URL, an id like `284882215`, a bundle id like `com.spotify.client`, or a name like `duolingo`.
2. Add **Countries** (two-letter codes such as `us`, `gb`, `de`, `jp`) or pick a **Country preset**.
3. Choose **Most recent** or **Most helpful**, and set how many reviews you want per app per country (up to 500).
4. Optional: filter by stars, date or keywords, and add app summary rows.
5. For review monitoring, switch on **Only new reviews since the last run** and create a schedule.
6. Click **Start**, then download the dataset or read it through the API.

### Input

| Field | What it does | Default |
|---|---|---|
| `apps` | App Store URLs, app ids, bundle ids or app names, one per line | required |
| `countries` | Storefront codes, e.g. `us`, `gb`, `de` | `us` |
| `countryPreset` | `top10`, `english`, `europe`, `latam`, `asia`, `mena` or `all` (177) | none |
| `sort` | `mostrecent` or `mosthelpful` | `mostrecent` |
| `maxReviewsPerCountry` | Reviews per app per country, 1-500 | 500 |
| `maxReviews` | Cap for the whole run | 100,000 |
| `minRating`, `maxRating` | Star range | 1-5 |
| `reviewsNewerThan` | `2026-10-01`, an ISO date, or `7 days`, `24 hours`, `3 months` | off |
| `keywords` | Keep reviews whose title or text contains any of these | off |
| `includeAppDetails` | One app summary row per app per country | off |
| `onlyNewReviews` | Monitoring mode: only reviews not delivered before | off |
| `monitorName` | Separate memory per schedule | `default` |

Example input (complaints about two apps in the top 10 markets, last 30 days):

```json
{
    "apps": ["https://apps.apple.com/us/app/duolingo-learn-languages/id570060128", "spotify"],
    "countryPreset": "top10",
    "minRating": 1,
    "maxRating": 2,
    "reviewsNewerThan": "30 days"
}
```

### Output example

A real review row from a test run (Duolingo, UK storefront):

```json
{
    "type": "review",
    "reviewId": "14736243673",
    "appId": "570060128",
    "appName": "Duolingo: Learn Languages",
    "country": "gb",
    "rating": 5,
    "title": "Learning the lazy way",
    "text": "Thanks to Falstaff, I no longer need to do lessons to properly gain a streak, when I can just cheat by ‘practicing’, and then not opening the app for the entire day.\n\nMwahahaha! 😆",
    "authorName": "Vaqmao",
    "authorUrl": "https://itunes.apple.com/gb/reviews/id1898825047",
    "appVersion": "7.146.1",
    "date": "2026-11-01T04:08:16.000Z",
    "dateLocal": "2026-10-31T21:08:16-07:00",
    "helpfulVotes": 0,
    "totalVotes": 0,
    "sortedBy": "mostrecent",
    "feedPage": 1,
    "feedPosition": 1,
    "reviewsPageUrl": "https://apps.apple.com/gb/app/id570060128?see-all=reviews",
    "appUrl": "https://apps.apple.com/gb/app/id570060128",
    "input": "https://apps.apple.com/us/app/duolingo-learn-languages/id570060128",
    "scrapedAt": "2026-11-02T15:08:40.416Z"
}
```

A real app summary row (ChatGPT, UK storefront):

```json
{
    "type": "app",
    "appId": "6448311069",
    "appName": "ChatGPT",
    "country": "gb",
    "developer": "OpenAI OpCo, LLC",
    "bundleId": "com.openai.chat",
    "averageRating": 4.801,
    "ratingCount": 1463146,
    "version": "1.2026.293",
    "currentVersionReleaseDate": "2026-10-27T16:49:11Z",
    "price": 0,
    "currency": "GBP",
    "primaryGenre": "Productivity",
    "reviewsScraped": 20,
    "newestReviewDate": "2026-11-01T06:41:02.000Z",
    "appUrl": "https://apps.apple.com/gb/app/chatgpt/id6448311069"
}
```

Rows for inputs that could not be used (`type: "status"`: not-found, invalid-input, no-reviews, error) explain what happened and are never charged. A `RUN_SUMMARY` record in the run's key-value store lists the review count per app and country.

### How much does it cost to scrape App Store reviews?

Pay per result. Prices per Apify plan:

| Event | Free | Starter (Bronze) | Scale (Silver) | Business (Gold) and up |
|---|---|---|---|---|
| Review | $0.06 / 1,000 | $0.054 / 1,000 | $0.048 / 1,000 | $0.042 / 1,000 |
| App summary row (optional) | $0.50 / 1,000 | $0.45 / 1,000 | $0.40 / 1,000 | $0.35 / 1,000 |
| Run start | $0.0005 | $0.0005 | $0.0005 | $0.0005 |

Worked examples on the Free plan prices:

- **All ~500 recent reviews of one app in one country:** $0.0005 + 500 x $0.00006 = **about $0.03**.
- **One app in the top 10 markets (5,000 reviews):** **about $0.30**.
- **Daily monitoring of one app in 4 countries** with about 20 new reviews a day: about $0.0017 a day, **roughly $0.05 a month**.
- **Apify's free $5 monthly credit** covers about 80,000 reviews.

Duplicates, filtered-out reviews, reviews you already received in monitoring mode, and status rows are free. You can also set a maximum charge per run in the run options; the Actor stops exactly at that limit.

### Integrations and scheduling

- **Apify Schedules:** run it hourly or daily with *Only new reviews* on to get a clean feed of new reviews. Recurring runs are what this Actor is built for.
- **Make, n8n, Zapier:** send new 1-star reviews to Slack, email, a support desk, Notion or a spreadsheet.
- **Google Sheets:** export the dataset or connect it through the Google Sheets integration.
- **Webhooks:** call your endpoint when a run finishes and fetch the new reviews.
- **API:** start runs and read results with the Apify API or the JavaScript and Python clients.
- **MCP for AI agents:** connect the Actor to Claude, ChatGPT or Cursor through Apify's MCP server so an agent can pull and summarise reviews on demand.

### FAQ

#### Why not use Apple's official API?

Apple's App Store Connect API only returns reviews of apps **you own**, and only after signing in with your developer account. It cannot read competitors' reviews. This Actor reads Apple's public customer-reviews feed, which works for any app and needs no account.

#### How many reviews can I get per app?

Apple's public feed shows up to **500 reviews per app per country** (10 pages of 50), either the most recent or the most helpful. Older reviews are not available through it. To build a long history, run the Actor on a schedule with *Only new reviews*: each run adds the new reviews, so your archive keeps growing.

#### Are developer replies included?

No. Apple's public reviews feed does not contain developer responses (we checked every field the feed returns), so the Actor does not invent them.

#### How fresh is the data?

As fresh as Apple's feed, which in our tests lagged the App Store by up to about a day and a half. A daily or hourly schedule catches every review that reaches the feed.

#### Can I get reviews in all languages?

Yes. Reviews are returned in whatever language the reviewer wrote them. Pick the countries whose customers you care about, or use the *All storefronts* preset.

#### What are the alternatives?

Other App Store review scrapers on Apify charge about $0.10 per 1,000 reviews or more, and most read one country per run. Paid review-management SaaS tools cost a monthly subscription. This Actor is cheaper per review on every Apify plan, reads many countries in one run, and has built-in only-new monitoring.

#### Can ChatGPT or Perplexity get App Store reviews for me?

Chat assistants cannot download hundreds of reviews per country. Run this Actor (or call it from an AI agent through Apify's MCP server), then give the dataset to the assistant to summarise complaints, feature requests or sentiment.

#### Is it legal to scrape App Store reviews?

The Actor only reads public data that Apple publishes without a login, through Apple's own public feeds. Reviews contain reviewers' public nicknames: if you store or process them, follow the privacy rules that apply to you (for example GDPR) and Apple's terms. This is not legal advice.

#### Why did my run return a status row instead of reviews?

`not-found` means no App Store app matched the name (try the App Store URL instead), `invalid-input` means the line was not a usable link, id or name, and `no-reviews` means the app has no reviews matching your filters in the chosen countries (often because it is not sold there).

#### Can it scrape Google Play reviews too?

Not this Actor. See the related Actors below for Android.

### Limits

- At most **500 reviews per app per country** (Apple's feed limit), newest or most helpful only.
- No developer replies and no review edit history (Apple's feed has neither).
- Apple's feed has no per-review link, so `reviewsPageUrl` points to the app's reviews page in that country.
- App name search uses the first three countries of your run; use an App Store URL or id for apps that are only sold elsewhere.
- Built and tested for iPhone and iPad apps; Mac App Store apps are not tested.

### Related Actors

- [Apple App Store Scraper](https://apify.com/hridayrungta/apple-app-store-scraper): app details, prices per country and Top Free / Top Paid charts.
- [Google Play Scraper](https://apify.com/hridayrungta/google-play-scraper): Android apps from Google Play (our sibling Actor; the link works once it is published).
- [Google Play Reviews Scraper by theagents](https://apify.com/theagents/googleplay-reviews): Android app reviews (third-party).
- [Reddit Scraper](https://apify.com/hridayrungta/reddit-scraper): what users say about your app on Reddit.
- [Google Trends Scraper](https://apify.com/hridayrungta/google-trends-scraper): search interest for your app or category over time.

# Actor input Schema

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

One app per line. Paste an App Store URL (https://apps.apple.com/us/app/duolingo-learn-languages/id570060128), an app id (570060128 or id570060128), a bundle id (com.duolingo.DuolingoMobile) or just the app name ("duolingo": the top App Store search result is used, and the matched name is shown in every row).

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

Two-letter storefront codes, e.g. us, gb, de, jp, in (uk also works). Every storefront has its own reviews, so each country is a separate set of up to 500 reviews. Combined with the preset below. Empty + no preset = us.

## `countryPreset` (type: `string`):

Add a ready-made group of storefronts on top of the countries above. "All storefronts" reads all 177 App Store countries (big markets first).

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

Most recent = the newest ~500 reviews per storefront (best for monitoring and date filters). Most helpful = the ~500 reviews with the most helpful votes.

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

Apple's public feed shows at most 500 reviews (10 pages of 50) per app per storefront. Lower it to save money.

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

Hard cap on billed reviews for the whole run.

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

Only keep reviews with at least this many stars. Set Min 1 + Max 2 to collect complaints only.

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

Only keep reviews with at most this many stars.

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

A date (2026-10-01), an ISO timestamp, or a relative period such as "7 days", "24 hours", "2 weeks", "3 months". With Most recent sorting the Actor stops paging once reviews get older, so you only pay for what you keep.

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

Optional. Keep only reviews whose title or text contains at least one of these words or phrases (case-insensitive), e.g. crash, refund, login, subscription.

## `includeAppDetails` (type: `boolean`):

Adds one row per app per storefront with the average star rating, total rating count, current version and its release date, price, genre and developer (from Apple's public Lookup API), plus how many reviews this run collected. Billed as one app row.

## `onlyNewReviews` (type: `boolean`):

Remembers every review this monitor has delivered (per app and country) in a key-value store on your own Apify account. Later runs return only reviews you have not received yet, so a daily or hourly schedule gives you a clean feed of new reviews and you never pay twice for the same review.

## `monitorName` (type: `string`):

Keeps separate memories for separate schedules, e.g. "competitors" and "our-apps". Use a new name when you change the star or keyword filters.

## `monitorStoreName` (type: `string`):

Named key-value store on your account that holds the monitor memory. Delete a record there to start that app fresh.

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

How many app x country feeds are read at the same time.

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

Not needed in normal use: the Actor calls Apple directly and switches to Apify's datacenter proxy by itself if Apple slows it down. Set a proxy here only if you want every request to go through it.

## Actor input object example

```json
{
  "apps": [
    "https://apps.apple.com/us/app/duolingo-learn-languages/id570060128"
  ],
  "countries": [
    "us",
    "gb"
  ],
  "countryPreset": "none",
  "sort": "mostrecent",
  "maxReviewsPerCountry": 50,
  "maxReviews": 100000,
  "minRating": 1,
  "maxRating": 5,
  "includeAppDetails": false,
  "onlyNewReviews": false,
  "monitorName": "default",
  "monitorStoreName": "app-store-reviews-monitor",
  "maxConcurrency": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

## `allRows` (type: `string`):

No description

## `runSummary` (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-learn-languages/id570060128"
    ],
    "countries": [
        "us",
        "gb"
    ],
    "maxReviewsPerCountry": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("hridayrungta/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 = {
    "apps": ["https://apps.apple.com/us/app/duolingo-learn-languages/id570060128"],
    "countries": [
        "us",
        "gb",
    ],
    "maxReviewsPerCountry": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("hridayrungta/app-store-reviews-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-learn-languages/id570060128"
  ],
  "countries": [
    "us",
    "gb"
  ],
  "maxReviewsPerCountry": 50
}' |
apify call hridayrungta/app-store-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,hridayrungta/app-store-reviews-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/81Wq9aGurObYK0pXJ/builds/2T7pacMgde0Q4H2Gi/openapi.json