# App Store Reviews Scraper - iOS App Reviews & Ratings (`cirkit/app-store-reviews-scraper`) Actor

Scrape Apple App Store reviews for any iPhone or iPad app without a login or API key. Get star rating, title, review text, date, reviewer, developer responses and app rating breakdown, in any country. Goes past Apple's 500-review RSS limit.

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

## Pricing

from $0.07 / 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.

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

### What is App Store Reviews Scraper?

**App Store Reviews Scraper** lets you extract customer reviews from the Apple App Store for any iPhone, iPad or Mac app, with the star rating, review title, full text, date, reviewer name and the developer's response, helping you track what users say about your app and your competitors, catch bugs and feature requests early, and feed real customer language into product, support and marketing work.

- 📈 **Go past Apple's 500-review limit:** Apple's public RSS feed stops at 500 reviews per app. This scraper reads the same review list the App Store website uses and keeps paging, so a popular app gives you tens of thousands of reviews, and a small app gives you its full history back to its first review.
- 😠 **Pull complaints first:** sort by "Most critical" and the App Store returns 1-star reviews first, so a bug hunt or a churn study does not page through praise to find them.
- 📅 **Monitor new reviews on a schedule:** set "Only reviews since" to `7d` and a weekly run collects exactly last week's reviews, no more.
- 🌍 **Every country's store in one run:** Apple keeps reviews separately per storefront. List `us`, `gb`, `de`, `jp` and get each market's reviews side by side, tagged by country.
- 🆚 **Benchmark competitors:** add every app in your category and every row carries the app's name, developer, genre, overall rating and full 1 to 5 star rating breakdown.
- 💬 **See how developers answer:** every developer response comes with its text and date, so you can measure response rate and tone.

Apple has no public reviews API for apps you do not own. App Store Reviews Scraper works with no login, no cookies, no Apple ID and no App Store Connect key, and it runs on cheap datacenter proxies, which is why it costs $0.07 per 1,000 reviews.

### What data does App Store Reviews Scraper extract?

- 🆔 Review ID (`reviewId`)
- ⭐️ Star rating, 1 to 5 (`rating`)
- 🏷 Review title (`title`)
- 📝 Full review text and its length (`text`, `textLength`)
- 📅 Date and time the review was posted, in UTC (`reviewedAt`)
- ✏️ Whether the reviewer edited the review (`isEdited`)
- 💬 Developer response text and response date (`hasDeveloperResponse`, `developerResponse`, `developerResponseAt`)
- 👤 Reviewer nickname, as shown publicly on the App Store (`userName`)
- 📱 App context on every row: App Store ID, link, name, developer, bundle ID, genre, icon, current version and price (`appId`, `appUrl`, `appName`, `appDeveloper`, `appBundleId`, `appGenre`, `appIcon`, `appVersion`, `appPrice`)
- 📊 App rating summary: average rating, total number of ratings and the count of 1, 2, 3, 4 and 5 star ratings (`appRating`, `appRatingCount`, `appRatingHistogram`)
- 🔎 The settings that produced the row: country, sort order, position and scrape time

### How to use App Store Reviews Scraper

1. Click **Try for free** and open the Input tab.
2. Paste one or more apps. The App Store link works, for example `https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580`, and so does the numeric ID `324684580`.
3. Pick the countries, how many reviews per app, the sort order and, if you like, a date cutoff.
4. Click **Start**. Reviews appear in the Output tab as they are collected.
5. Download them as Excel, CSV, JSON or HTML, or read them through the Apify API.

### Input

| Field | What it does | Default |
|---|---|---|
| `apps` | App Store links or numeric app IDs. Required. | Spotify |
| `countries` | Two-letter storefront codes, for example `us`, `gb`, `de`. Each app is scraped once per country. | `us` |
| `maxReviewsPerApp` | Reviews per app and country. 0 means every review the App Store serves. | 200 |
| `sort` | `recent`, `helpful`, `critical` (1 star first) or `favorable` (5 stars first) | `recent` |
| `reviewsSince` | `YYYY-MM-DD` or a number of days such as `30d`. Forces most recent first. | none |
| `maxItems` | Hard cap on rows for the whole run, a spending limit. 0 means none. | 0 |

Example input for last month's reviews of three competing apps in the US and UK:

```json
{
    "apps": ["324684580", "1108187390", "1017492454"],
    "countries": ["us", "gb"],
    "reviewsSince": "30d",
    "maxReviewsPerApp": 0
}
```

### Output

One row per review. A trimmed example:

```json
{
    "appId": "324684580",
    "appName": "Spotify: Music and Podcasts",
    "appDeveloper": "Spotify",
    "appBundleId": "com.spotify.client",
    "appGenre": "Music",
    "appVersion": "9.1.88",
    "appRating": 4.8,
    "appRatingCount": 42394544,
    "appRatingHistogram": {"1": 926790, "2": 366275, "3": 939397, "4": 2971414, "5": 37190668},
    "country": "us",
    "reviewId": "14617330566",
    "rating": 1,
    "title": "Glitches",
    "text": "What is up with all of the glitches and lagging lately?? And playlists not loading/updating?",
    "userName": "gilmorepal",
    "reviewedAt": "2026-10-02T03:19:14Z",
    "isEdited": true,
    "hasDeveloperResponse": true,
    "developerResponse": "Hi. Thanks for sharing your experience. We suggest clean reinstalling the app...",
    "developerResponseAt": "2026-08-24T17:34:54Z",
    "sort": "recent",
    "position": 39
}
```

The Output tab has three ready-made views: **Reviews** (the main table), **Developer responses** (review next to response, with both dates) and **App context** (the app each review belongs to, with its rating summary).

If an app cannot return anything, for example a mistyped ID, an app not sold in that country, or a date range with no reviews, the run still succeeds and writes one row with `noResults: true` and a plain English `message` explaining why, so a scheduled pipeline never breaks on an empty answer.

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

**$0.07 per 1,000 reviews**, flat, plus $0.00005 per run start. No monthly rental, no tiers.

| Reviews | Cost |
|---|---|
| 1,000 | $0.07 |
| 10,000 | $0.70 |
| 100,000 | $7.00 |
| 1,000,000 | $70.00 |

Apify's free plan includes monthly credit, which covers tens of thousands of reviews at this price. Use `maxItems` as a hard spending cap.

### Measured performance

Measured on 2026-10-03 through the default Apify datacenter proxy, across 15 test inputs:

- 100 Spotify reviews in 4.5 seconds, 1,500 in 49 seconds, with zero duplicates.
- A 2008 app returned its complete history, 102 reviews from July 2008 to April 2026, with the run ending cleanly at the last review.
- 100% of review rows carry review ID, rating, title, text, date, reviewer name and every app context field, including the star breakdown.
- About 2% of Spotify's newest reviews had a developer response, and 2% were edited. Those are Apple's numbers, not gaps.

### Limits

- Reviews are kept per country. An app's US reviews and German reviews are different lists, so add every storefront you care about.
- The App Store shows reviews with written text. Star-only ratings are counted in `appRatingCount` and `appRatingHistogram` but have no row of their own.
- "Most critical" and "Most favorable" order the list by rating; they are a sort, not a strict filter, so once an app runs out of 1-star (or 5-star) reviews, other ratings follow.
- The newest reviews can take several hours to appear on Apple's public list.

### FAQ

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

The scraper only collects reviews that Apple publishes openly to anyone, with no login. Reviews include public nicknames, and personal data is protected by laws such as GDPR in the EU, so only collect what you have a legitimate reason to process, and ask a lawyer if you are unsure. Read Apify's post on [the legality of web scraping](https://blog.apify.com/is-web-scraping-legal/) for more.

#### How much does App Store Reviews Scraper cost?

$0.07 per 1,000 reviews plus $0.00005 per run. A 10,000 review competitor study costs about 70 cents.

#### Do I need an Apple ID, cookies or an App Store Connect API key?

No. It works without logging in. App Store Connect only covers apps you publish yourself; this works for any app.

#### Can I get more than 500 reviews per app?

Yes. Apple's RSS feed, which most free tools use, stops at 500 reviews per app and country. This scraper uses the App Store website's own review list, which goes much deeper. Set `maxReviewsPerApp` to 0 to take everything.

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

Open the app on apps.apple.com. The number after `id` in the link is the ID: `https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580` is `324684580`. You can also paste the whole link.

#### How do I monitor new reviews every day?

Save a task with `reviewsSince` set to `1d` and schedule it daily in Apify. Each run collects only the previous day's reviews, and an integration can post them to Slack, a Google Sheet or your support tool.

#### Can I only get negative reviews?

Set `sort` to `critical`. Apple returns 1-star reviews first, so a capped run gets complaints, not praise.

#### Can I use App Store Reviews Scraper as an API?

Yes. Every run is available through the Apify API, and there are official clients for JavaScript and Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("cirkit/app-store-reviews-scraper").call(
    run_input={"apps": ["324684580"], "countries": ["us"], "maxReviewsPerApp": 500}
)
for review in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(review["rating"], review["title"], review["text"])
```

#### Can I integrate it with other apps?

Yes, through Apify integrations with Make, Zapier, Google Sheets, Google Drive, Slack, Airbyte, webhooks and more.

#### Why did I get fewer reviews than I asked for?

Either the app has fewer written reviews in that country, or your date cutoff removed the rest. The run log says how many reviews each app and country returned. Try the app's home country if a storefront looks empty.

#### Does it scrape Google Play reviews?

No, this actor covers the Apple App Store. Use [Google Play Reviews Scraper](https://apify.com/cirkit/google-play-reviews-scraper) for Android apps.

### You might also like

- [App Store Search Scraper](https://apify.com/cirkit/app-store-search-scraper) for iOS app details and search results
- [Google Play Reviews Scraper](https://apify.com/cirkit/google-play-reviews-scraper) for Android app reviews
- [Google Play Store Scraper](https://apify.com/cirkit/google-play-store-scraper) for Android app details, charts and search

### Changelog

- **0.1** (2026-10-03): first release. Unlimited depth past the 500-review RSS cap, four sort orders, date cutoff, multiple countries, developer responses and rating breakdown on every row.

# Actor input Schema

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

App Store apps to pull reviews for. Paste the app's App Store link (https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580) or just its numeric ID (324684580). Add as many as you like; they run in parallel.

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

Two-letter country codes of the App Store storefronts to read (us, gb, de, fr, jp, br...). Apple keeps reviews separately per country, so each app is scraped once per country you list. Leave empty for the US store.

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

Stop after this many reviews for each app in each country. 0 means every review the App Store will serve, which for popular apps runs well past the 500-review limit of Apple's RSS feed.

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

Order the App Store returns reviews in. 'Most recent' is best for monitoring and is required for the date cutoff below. 'Most critical' returns 1-star complaints first, 'Most favorable' returns 5-star praise first.

## `reviewsSince` (type: `string`):

Stop at reviews older than this date. Use YYYY-MM-DD, or a number of days such as 30d for 'the last 30 days' so a scheduled run keeps working. Forces most-recent sorting. Leave empty for no date limit.

## `maxItems` (type: `integer`):

Hard cap on rows written across all apps and countries, useful as a spending limit. 0 means no cap.

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

The default Apify proxy works well. The App Store serves datacenter IPs normally, so residential proxy is not needed.

## Actor input object example

```json
{
  "apps": [
    "https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580"
  ],
  "countries": [
    "us"
  ],
  "maxReviewsPerApp": 100,
  "sort": "recent",
  "maxItems": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Every review this run collected as the Reviews table.

## `responses` (type: `string`):

Reviews alongside the developer's public response and its date.

## `reviewsCsv` (type: `string`):

The full result set as CSV, ready for a spreadsheet or a BI tool.

## `consoleRun` (type: `string`):

The Apify Console page for this run, including the live log.

# 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"
    ],
    "countries": [
        "us"
    ],
    "maxReviewsPerApp": 100,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("cirkit/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"],
    "countries": ["us"],
    "maxReviewsPerApp": 100,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("cirkit/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"
  ],
  "countries": [
    "us"
  ],
  "maxReviewsPerApp": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call cirkit/app-store-reviews-scraper --silent --output-dataset

```

## MCP server setup

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