# ⭐ App Store Reviews Scraper - iOS & macOS Reviews (`benthepythondev/appstore-reviews-scraper`) Actor

Returns customer reviews of any iOS or macOS app on the Apple App Store: star rating, title, full text, author, country and date. Filter by stars, or use monitor mode to get only reviews written since the last run (1-star alerts). Pick the app by link or id and the country store. No login needed.

- **URL**: https://apify.com/benthepythondev/appstore-reviews-scraper.md
- **Developed by:** [Ben](https://apify.com/benthepythondev) (community)
- **Categories:** Developer tools, Automation, SEO tools
- **Security:** Limited permissions
- **Stats:** 153 total users, 3 monthly users, 100.0% runs succeeded, 4 bookmarks
- **User rating**: 4.22 out of 5 stars

## Pricing

from $1.60 / 1,000 results

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

## ⭐ App Store Reviews Scraper — iOS & macOS App Ratings, Reviews & Feedback

Extract **customer reviews from any app on the Apple App Store** — star ratings,
review titles, full review text, author, date and country — as
clean, structured data for one app or a whole list of competitors. It runs on
the App Store website's own review data across 48 country storefronts, so there's no
browser, no login, and no API key. Export to JSON/CSV/Excel, run on a schedule, call
via API, or connect to Make, Zapier or n8n.

### 📱 What is the App Store Reviews Scraper?

It turns any iOS or macOS app into a structured reviews dataset. Give it App Store
app IDs or full App Store URLs (the app ID is auto-extracted) plus the country
storefronts you care about, and it returns every matching review with rating, text,
author and date, filtered by stars or limited to new reviews — so product, marketing and research teams can
analyze sentiment without copy-pasting from the store.

#### What data does it extract?

- **`rating`** — the 1–5 star score for each review
- **`title`** and **`content`** — the review headline and full body text
- **`author_name`** — the reviewer's display name
- **`review_date`** and **`is_edited`** — when the review was written and whether it was edited
- **`country`** — the storefront the review came from (48 supported)
- **`app_id`**, **`app_name`** and **`app_url`** — the app the review belongs to
- **`review_id`** — stable review ID (used by monitor mode)

### ⬇️ Input

Target apps by ID or URL, choose your storefronts, and set the cap:

| Field | Description |
|-------|-------------|
| `appIds` | App Store app IDs, e.g. `["333903271"]` (X/Twitter) |
| `appUrls` | Full App Store URLs (app ID auto-extracted) — alternative to `appIds` |
| `countries` | Country codes to pull from, e.g. `["us", "gb", "de", "jp"]` (50+ supported) |
| `maxReviews` | Max reviews per app per country (up to 1,000; up to 2,000 with `sortBy: both`; 0 = 500) |
| `sortBy` | `mostRecent`, `mostHelpful` or `both`: reads both lists (up to 1,000 each), removes duplicates by review id, then applies `maxReviews` |
| `minRating` / `maxRating` | Keep only reviews with 1–5 stars inside this range; others are not saved and not charged |
| `monitorMode` | Only reviews written since the previous run (see below). `onlyNewReviews` is accepted as the same switch |
| `delaySeconds` | Delay between requests (0.3–5, default 0.5) |

#### Example input

```json
{
  "appIds": ["333903271", "389801252"],
  "countries": ["us", "gb", "ca"],
  "maxReviews": 300,
  "sortBy": "mostRecent"
}
```

### ⬆️ Output

Every review is one clean row (view as a **table**, or export **JSON / CSV / Excel**):

```json
{
  "review_id": "10456789123",
  "app_id": "333903271",
  "app_name": "X",
  "author_name": "JohnDoe123",
  "rating": 4,
  "title": "Great app but needs improvements",
  "content": "The app works well for basic usage. However, I wish they would add dark mode and better notification controls...",
  "is_edited": false,
  "country": "US",
  "review_date": "2026-06-15T17:30:00Z",
  "updated_date": "2026-06-15T17:30:00Z",
  "app_url": "https://apps.apple.com/us/app/x/id333903271",
  "average_user_rating": 4.58141,
  "user_rating_count": 11142233
}
```

### 🔔 Monitor new reviews (only new, 1-star alerts)

Turn on `monitorMode` and run the Actor on a schedule. The first run records the
reviews that exist now for each app and country and saves nothing. Every later run
saves, and charges, only reviews written since the run before. The seen review ids
stay on your own account in the named key-value store `appstore-reviews-monitor`,
one record per app and country.

```json
{
  "appIds": ["333903271"],
  "countries": ["us", "gb"],
  "monitorMode": true,
  "maxReviews": 200,
  "minRating": 1,
  "maxRating": 1
}
```

1. Save this input as a Task, then add a schedule to it (Console → Schedules, e.g.
   every 6 hours). Set `maxReviews` above the number of reviews the app gets between
   two runs, because the feed is read newest first.
2. In the Task's **Integrations** tab add a webhook (or the Slack or email integration)
   on the event **Run succeeded**. Its payload holds `resource.defaultDatasetId`; read
   `https://api.apify.com/v2/datasets/{defaultDatasetId}/items` and post each row to your
   channel. With `minRating` 1 and `maxRating` 1 a non-empty dataset is a new 1-star review.
3. Each app and country is its own watch. A new country in the list starts with its own
   baseline run. Delete the store record `seen-<appId>-<country>` to start a watch again.

Star filters work without monitor mode too: `"minRating": 4` returns only 4- and
5-star reviews, and `maxReviews` counts the reviews inside the range.

### 💡 Use cases

- **🔍 App Store Optimization (ASO):** track rating trends, surface complaints and feature requests for your apps.
- **🧠 Sentiment analysis & ML:** build labeled review datasets for NLP and brand-perception monitoring.
- **🥊 Competitor research:** compare review volume, ratings and weaknesses across rival apps.
- **🐞 Product & QA insights:** get every new 1- and 2-star review after a release, on a schedule.

### ❓ FAQ

**How do I scrape App Store reviews?** Give the actor one or more app IDs (or App
Store URLs) and country codes, then run. It pulls ratings, titles, full review text,
author and date from the App Store website's own review data, no browser.

**Do I need an Apple developer account or API key?** No. It reads the public review
data the App Store website shows, so no credentials are required.

**How do I find an app's ID?** It's the number after `/id` in the App Store URL — e.g.
`https://apps.apple.com/us/app/x/id333903271` has ID `333903271`. You can also paste
the full URL into `appUrls` and the ID is extracted for you.

**Can I get reviews from multiple countries?** Yes — pass a list of country codes
(50+ supported including US, GB, CA, AU, DE, FR, JP). Reviews vary significantly by
region, so multiple storefronts give wider coverage.

**Can I scrape macOS app reviews too?** Yes — any iOS or macOS app on the App Store
works the same way.

**How many reviews can I get per app?** Up to 1,000 per app per country per run with one sort order, 20 per
request. With `sortBy: both` the newest and the most helpful lists are merged and de-duplicated, so a popular app can return up to 2,000 different reviews per country. Apple's website serves about 1,000 per sort order and no more, and a small app has fewer in total. Use multiple countries to gather more.

**What are `average_user_rating` and `user_rating_count`?** The App Store rating of the whole app in that country (all ratings, not only written reviews), read once per app and country from Apple's lookup and repeated on every row.

**Why are `version`, `vote_count` and `author_uri` missing?** They came from Apple's
customer-review RSS feed, which stopped returning reviews on October 26, 2026. The
Actor now reads the App Store website's review data, which has no app version, vote
counts or profile link; those keys stay in every row as `null`. `review_date` and `is_edited` are new.

**Which sort order should I use?** `mostHelpful` surfaces the highest-signal feedback
for ASO; `mostRecent` is best for tracking the latest issues and bug reports.

**Can I scrape several apps at once?** Yes — pass multiple IDs/URLs to compare
competitors side by side in a single dataset.

**Can it return only new reviews?** Yes, with `monitorMode` (section above). The first
run is a baseline with no rows; later runs return 0 rows when nobody wrote a review.

**Can I run it on a schedule or via API?** Yes — schedule recurring runs in Apify,
call it via the API/SDK, or connect it to Make, Zapier or n8n.

**Is scraping App Store reviews legal?** It retrieves publicly available review data
from the public App Store website. Use it responsibly and respect Apple's Terms of
Service and applicable laws.

### 🔗 Related tools

- **[App-ads.txt Scraper](https://apify.com/benthepythondev/app-ads-txt-scraper)** — audit the ad sellers authorized to sell an app's inventory, from its App Store link
- **[Ads.txt Scraper](https://apify.com/benthepythondev/ads-txt-scraper)** — check the web side of the same publisher (sellers.json lookup included)
- **[Google Play Reviews Scraper](https://apify.com/benthepythondev/google-play-reviews-scraper)** — Android app reviews
- **[Trustpilot Intelligence Scraper](https://apify.com/benthepythondev/trustpilot-intelligence-scraper)** — Trustpilot business reviews
- **[Yelp Intelligence Scraper](https://apify.com/benthepythondev/yelp-intelligence-scraper)** — Yelp business reviews

***

**Keywords:** App Store reviews scraper, iOS app reviews API, Apple App Store reviews, scrape app ratings, ASO tool, app review sentiment, app review monitor, new app reviews alert, 1-star review alerts, customer review data, app store data, competitor review analysis, macOS app reviews, app feedback scraper, app rating tracker, mobile app reviews.

# Actor input Schema

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

List of App Store app IDs to scrape reviews from (e.g., 333903271 for Twitter/X). Up to 100 apps per run.

## `appUrls` (type: `array`):

List of App Store URLs to scrape reviews from (alternative to app IDs). Up to 100 per run.

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

Country codes to scrape reviews from (e.g., us, gb, de, fr, jp). Up to 48 countries.

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

Maximum number of reviews to save per app per country (up to 2,000 with sortBy both, else 1,000; 0 = 500). With a star filter it counts the reviews inside the range. Keep small for tests.

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

How to sort the reviews. Both reads the newest and the most helpful reviews (up to 1,000 each) and removes duplicates before maxReviews is applied.

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

Save only reviews with at least this many stars (1-5). Filtered reviews are not saved and not charged. Set minRating 1 and maxRating 1 for 1-star alerts.

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

Save only reviews with at most this many stars (1-5). Filtered reviews are not saved and not charged.

## `monitorMode` (type: `boolean`):

For scheduled runs. The first run records the reviews that exist now for each app and country and saves nothing. Every later run saves and charges only reviews written since the previous run. The seen review ids are kept in the named key-value store 'appstore-reviews-monitor' on your account. Reads newest first; set maxReviews to more reviews than the app gets between two runs.

## `delaySeconds` (type: `number`):

Delay between API requests

## Actor input object example

```json
{
  "appIds": [
    "333903271",
    "389801252"
  ],
  "appUrls": [
    "https://apps.apple.com/us/app/x/id333903271"
  ],
  "countries": [
    "us",
    "gb",
    "ca"
  ],
  "maxReviews": 3,
  "sortBy": "mostRecent",
  "monitorMode": false,
  "delaySeconds": 0.5
}
```

# Actor output Schema

## `results` (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 = {
    "appIds": [
        "333903271"
    ],
    "countries": [
        "us"
    ],
    "maxReviews": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("benthepythondev/appstore-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": ["333903271"],
    "countries": ["us"],
    "maxReviews": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("benthepythondev/appstore-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 '{
  "appIds": [
    "333903271"
  ],
  "countries": [
    "us"
  ],
  "maxReviews": 3
}' |
apify call benthepythondev/appstore-reviews-scraper --silent --output-dataset

```

## MCP server setup

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