# App Store Reviews Scraper: Apple App Reviews by Country (`pulsedata/app-store-reviews-scraper`) Actor

Scrape Apple App Store reviews of any iOS app: rating, title, text, date, app version and storefront country, from one or many countries. Newest or most helpful. No Apple API key. $0.20 per 1,000 reviews.

- **URL**: https://apify.com/pulsedata/app-store-reviews-scraper.md
- **Developed by:** [PulseData](https://apify.com/pulsedata) (community)
- **Categories:** E-commerce, Business, AI
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 app scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## App Store Reviews Scraper

Export Apple App Store reviews of any iOS app: star rating, review title, text, date, app version, reviewer name and storefront country, from one or many countries in a single run. Each app also gets one app details row (title, developer, rating, price, version). Reviews cost $0.20 per 1,000 and each app row costs $0.001.

### Features

- **Export App Store reviews to CSV, JSON or Excel** for one iOS app or a list of apps.
- **Scrape App Store reviews from many countries** in one dataset, each row tagged with its `country`.
- **Get the most recent or the most helpful App Store reviews** with `reviewsSort`.
- **Review titles and app versions** on every row, so you can tie complaints to a specific release.
- **Monitor new App Store reviews of an app**: with `onlyNewReviews` a scheduled run returns and charges only reviews it has not delivered before, per country.
- **App details row per app** with bundle ID, rating histogram, price, size, required iOS version and release notes.

The actor reads Apple's public customer reviews feed and app lookup. No Apple ID, no App Store Connect access and no API key.

### Use cases

- **Product teams**: after an iOS release, pull the newest reviews and filter by `version` to see what users say about the update.
- **Localization QA**: compare reviews from the US, Germany and Japan to find translation problems or market-specific bugs.
- **Competitor research and sentiment analysis**: export reviews of rival apps per market, with title, text and a 1 to 5 star label for classification or topic clustering.

### Input

```json
{
  "apps": [
    "https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580",
    "284882215"
  ],
  "reviewsCountries": ["us", "gb", "de", "fr", "jp"],
  "maxReviewsPerApp": 500,
  "reviewsSort": "newest"
}
```

| Field | Type | Default | What it does |
|---|---|---|---|
| `apps` | array (required) | none | App Store URLs or numeric app IDs, one per line. |
| `reviewsCountries` | array | `["us"]` | Storefront country codes to read reviews from. |
| `maxReviewsPerApp` | integer | `500` | Review cap per app and country in `reviewsCountries`. `0` means all available. |
| `reviewsSort` | string | `newest` | `newest` or `helpfulness`. `rating` is accepted but behaves like `newest` on the App Store. |
| `language` | string | `en` | Passed to the app details lookup. It does not filter reviews; review language follows the storefront. |
| `proxyConfiguration` | object | off | Usually not needed. |
| `onlyNewReviews` | boolean | `false` | Monitor mode: output and charge only reviews not delivered on an earlier run. |
| `monitorStoreName` | string | empty | Key-value store that remembers delivered reviews. Empty means a name derived from the apps and filters. |

The app details row is read from the country in the app URL (`/us/`, `/gb/`, ...), or from the US storefront when you pass a bare ID.

### Monitor new App Store reviews of an app

Turn on `onlyNewReviews` to get only the reviews written since your last run:

```json
{
  "apps": ["https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580"],
  "reviewsCountries": ["us", "gb", "de"],
  "maxReviewsPerApp": 500,
  "reviewsSort": "newest",
  "onlyNewReviews": true
}
```

The actor remembers delivered reviews by app, country and review ID in a named key-value store in your Apify account and drops them on the next run, so they are neither output nor charged. With `reviewsSort: "newest"` it stops reading a country at the first page that holds a known review.

For new-review alerts, save the input as an Apify task, add an [Apify schedule](https://docs.apify.com/platform/schedules) and an integration (email, Slack, Google Sheets, Make, Zapier or a webhook) that fires when a run succeeds.

Details:

- The app details row comes once, on the first run, which returns up to `maxReviewsPerApp` per app and country and fills the store.
- Apple's feed holds only the newest 500 per country, so run often enough that fewer than 500 new reviews per country arrive between two runs.
- Without `monitorStoreName` each different input keeps its own history; the run log names the store. Schedule one run per store.

### Output

One row per review. The "Reviews" view in the dataset shows the main columns; the full item looks like this:

```json
{
  "type": "review",
  "store": "app-store",
  "appId": "324684580",
  "reviewId": "11734221890",
  "url": "https://itunes.apple.com/gb/review?id=324684580&type=Purple%20Software",
  "userName": "jsmith",
  "userUrl": "https://itunes.apple.com/gb/reviews/id123456789",
  "score": 4,
  "title": "Great, but the queue could be smarter",
  "text": "Love the podcasts, but the queue keeps resetting after an update ...",
  "date": "2026-08-26T10:41:00.000Z",
  "version": "9.0.50",
  "thumbsUp": null,
  "replyText": null,
  "replyDate": null,
  "country": "gb",
  "scrapedAt": "2026-09-25T08:31:47.920Z"
}
```

`thumbsUp`, `replyText` and `replyDate` are always `null` here; they keep the columns in line with Google Play exports.

Each app also produces one `type: "app"` row (the "Apps" view) with `title`, `bundleId`, `developer`, `developerWebsite`, `genre`, `score`, `ratings`, `histogram`, `currentVersionScore`, `price`, `currency`, `size`, `contentRating`, `requiredOsVersion`, `version`, `released`, `updated`, `releaseNotes`, `languages`, `icon`, `screenshots`, `url` and `country`. Join reviews to apps on `appId`.

An app that cannot be loaded gives an uncharged `type: "error"` row with the message.

### Pricing

Pay per event, no monthly fee:

- **$0.0002 per review** (`review-scraped`), that is $0.20 per 1,000 reviews.
- **$0.001 per app** (`app-scraped`), one per app in `apps`.

Worked example: 2 apps, 5 countries each, `maxReviewsPerApp: 500`. If Apple serves the full 500 per country, that is 5,000 reviews ($1.00) plus 2 app rows ($0.002), about $1.00 in total. A single app in the US with the default settings costs at most $0.101. Platform usage is included in the event prices.

In monitor mode only new reviews are charged, and the app row only on the first run. A daily run on Spotify in the US, UK and Germany that finds 30 new reviews costs 30 x $0.0002 = $0.006. The actor has no start event, so a run that finds nothing new costs nothing.

### FAQ

**Is there a limit of 500 reviews?**
Per app and storefront, yes. Apple's public review feed stops after 10 pages of 50 reviews. `maxReviewsPerApp` applies per country, so 5 countries at `500` return up to about 2,500 reviews per app.

**Do I need an Apple API key or an Apple ID?**
No. The customer reviews feed and the app lookup are public.

**Does it return developer responses?**
No. Apple's public review feed does not include them. The Google Play sister actor does return replies.

**Can I sort by star rating?**
No. Export the reviews and filter on `score` afterwards.

**How do I schedule it or call it from code?**
Use an Apify schedule, or start runs through the Apify API and SDKs. Export as JSON, CSV or Excel, or send results to Google Sheets, Make, Zapier or n8n.

**What can it not do?**
It does not read Google Play, it cannot access App Store Connect data (downloads, revenue, full review history) and it does not search the store or read top charts.

### Use it from Claude, ChatGPT or Cursor (Apify MCP server)

The actor can be called as a tool by any AI assistant that speaks the Model Context Protocol. Add the Apify MCP server to your client with this URL, which loads only this actor as a tool:

```text
https://mcp.apify.com?tools=pulsedata/app-store-reviews-scraper
```

You sign in to Apify on first connection, then ask in plain language, for example "get the 300 newest App Store reviews of Revolut in the UK and the US and summarise what users dislike". Billing is the same as a normal run.

### Paying from an AI agent without an Apify account (x402 and Skyfire)

An agent can buy a prepaid, spend-capped Apify token at [Apify AGI](https://agi.apify.com), paid in USDC through [x402](https://docs.apify.com/platform/integrations/x402) or from a [Skyfire](https://docs.apify.com/platform/integrations/skyfire) wallet, and use it for both the API and the MCP server. This actor runs with limited permissions, so it works with these tokens. The smallest token is $1, tokens expire 14 days after purchase, and Apify marks agentic payments as experimental.

### Related actors

- [Google Play Reviews Scraper](https://apify.com/pulsedata/google-play-reviews-scraper): the Android counterpart, with developer replies and thumbs-up counts and no 500 review limit.
- [App Store & Google Play Scraper](https://apify.com/pulsedata/app-store-google-play-scraper): both stores in one actor, plus keyword search, top charts and developer portfolios.
- [YouTube Comments Scraper](https://apify.com/pulsedata/youtube-comments-scraper): user feedback on app reviews and tutorials posted on YouTube.
- [TikTok Ad Library Scraper](https://apify.com/pulsedata/tiktok-ad-library-scraper): app install ads that competing publishers run on TikTok.
- [Website Tech Stack Detector](https://apify.com/pulsedata/website-tech-stack-detector): check the tech stack behind an app developer's website.

# Actor input Schema

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

App Store URLs (`https://apps.apple.com/us/app/…/id324684580`) or numeric app IDs such as `324684580`.

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

Maximum reviews per app and country. Apple serves up to 500 per country; add more countries in `reviewsCountries` to get more.

## `reviewsSort` (type: `string`):

Order in which reviews are collected: newest first or most helpful. Apple offers no order by rating, so "Rating" runs as newest.

## `reviewsCountries` (type: `array`):

App Store countries to collect reviews from (ISO codes, e.g. `us`, `gb`, `de`, `fr`, `jp`). Reviews are separate per country.

## `language` (type: `string`):

Language code for the app details (title, description). Reviews are not filtered by language; the countries in `reviewsCountries` decide which reviews you get.

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

Output and charge only reviews this monitor has not delivered on an earlier run. The review IDs are remembered in a named key-value store in your account, so a scheduled daily or weekly run returns just the reviews written since the last run. With newest-first order the run stops reading an app once it reaches a known review. The app details row comes once, on the first run. The first run returns up to "Max reviews per app" and fills the store.

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

Name of the key-value store that remembers delivered reviews. Leave empty to name it after the apps and filters, so each different input keeps its own history. Set a name to share one history between inputs, or to start over by picking a new one. Letters, digits and hyphens.

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

Usually not needed. Enable Apify Proxy if you run very large volumes.

## Actor input object example

```json
{
  "apps": [
    "https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580"
  ],
  "maxReviewsPerApp": 500,
  "reviewsSort": "newest",
  "reviewsCountries": [
    "us",
    "gb",
    "de"
  ],
  "language": "en",
  "onlyNewReviews": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Results stored in the default dataset (JSON/CSV/Excel via the dataset API).

# 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/spotify-music-and-podcasts/id324684580"
    ],
    "maxReviewsPerApp": 500,
    "reviewsCountries": [
        "us",
        "gb",
        "de"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("pulsedata/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/spotify-music-and-podcasts/id324684580"],
    "maxReviewsPerApp": 500,
    "reviewsCountries": [
        "us",
        "gb",
        "de",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("pulsedata/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/spotify-music-and-podcasts/id324684580"
  ],
  "maxReviewsPerApp": 500,
  "reviewsCountries": [
    "us",
    "gb",
    "de"
  ]
}' |
apify call pulsedata/app-store-reviews-scraper --silent --output-dataset

```

## MCP server setup

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