# Apple App Store Reviews Scraper | Unlimited Reviews | Feedback (`ahmed_jasarevic/apple-scraper`) Actor

Scrape Apple App Store reviews — full text, star rating, reviewer name, date, app version, and helpful votes — for app review sentiment analysis and ASO. Bypass the API limit for unlimited review history per app.

- **URL**: https://apify.com/ahmed\_jasarevic/apple-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Categories:**
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#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

## Apple App Store Reviews Scraper — Extract iOS Reviews, Ratings & App Feedback Without API Limits

Collect every customer review for any Apple App Store app — review title, full text, star rating, reviewer name, date, app version, and helpful votes — for **app review sentiment analysis**, **App Store Optimization (ASO)**, **competitor app monitoring**, and **product feedback research**. This actor uses Apple's own same-origin relay to the App Store media API to pull **unlimited-offset review history** per app (plus an RSS fallback), bypassing the usual Apple API limits.

### Main Use Cases

- **App review sentiment analysis** — analyze review text, star ratings, and reviewer tone for your iOS app or competitors
- **App Store Optimization (ASO) research** — study what users praise and complain about to guide listing and feature decisions
- **Competitor app monitoring** — track competitor reviews and rating trends to spot gaps and feature requests
- **App feedback & product research** — collect structured customer voice before roadmap decisions and investor/PM research
- **Release-impact tracking** — see how sentiment shifts after each app update by version and rating
- **Building labeled review datasets** — feed review text, star ratings, and helpful votes into NLP or LLM pipelines

### How It Works

You give the actor an App Store URL or app ID (or several). It fetches Apple's public review sources — the internal App Store media API by default (for unlimited review history) or the public RSS feed (for up to 500 reviews with extra metadata like app version and helpful votes). It handles pagination, retry/backoff, request pacing, proxy handling, and de-duplication, then writes one clean record per review to the Apify dataset.

### Get Complete App Review Histories Without App Store Connect Access

Apple does not offer a public reviews API, and App Store Connect only exposes reviews for apps you own. The standard public RSS feed is capped at ~500 reviews with limited metadata. This actor gets around those limits by using Apple's same-origin relay to the internal App Store media API, which supports paging far deeper into each app's review history, alongside the RSS path when you want app-version and helpful-vote data.

### Input

Configure which apps and how many reviews to scrape. All values come from the actor's input schema.

| Parameter | Type | Description |
|-----------|------|-------------|
| `appUrls` | array | Apple App Store URLs or numeric app IDs, one per line. Example: `https://apps.apple.com/us/app/instagram/id389801252` or `389801252`. **Required.** |
| `maxReviews` | integer | Max reviews to scrape per app. Unlimited (any number) via the internal API; capped at 500 with the RSS source. Default `1000`. |
| `reviewSource` | enum | `internal` = unlimited via Apple's App Store media API (default); `rss` = public RSS feed, max 500 per app but includes app version and helpful votes. |
| `sortBy` | enum | `mostrecent`, `mosthelpful`, `mostfavorable`, or `mostcritical`. |
| `country` | string | ISO-3166-1 alpha-2 storefront code (e.g. `us`, `gb`, `de`). Overrides the country in the URL; leave empty to auto-detect. |
| `requestDelayMs` | integer | Milliseconds between paginated requests to avoid Apple rate limiting. Default `800`. |
| `useApifyProxy` | boolean | Route through the Apify proxy. Defaults OFF for the internal source (Apple rate-limits proxy IPs there) and ON for RSS. |
| `apifyProxyGroups` | array | Apify proxy groups, e.g. `BUYPROXIES94952` for residential. |

### Output

Each review is returned as a structured record with the following fields (verified from actual runs):

| Field | Type | Description |
|-------|------|-------------|
| `appId` | string | Numeric Apple App Store ID of the app |
| `appTitle` | string | App name on the store |
| `url` | string | Canonical App Store URL for the app |
| `storefront` | string | Two-letter country store code the review came from |
| `reviewId` | string | Apple's unique review identifier (use for de-duplication) |
| `title` | string | Review headline |
| `text` | string | Full review body |
| `rating` | integer | Star rating 1–5 |
| `reviewerName` | string | Reviewer display name |
| `reviewerUrl` | string | Link to reviewer profile (when available) |
| `date` | string | ISO timestamp of the review |
| `appVersion` | string | App version reviewed (RSS source / when available) |
| `helpfulVotes` | integer | "Found this helpful" vote count (RSS source / when available) |
| `scrapedAt` | string | ISO timestamp when the record was collected |

### Example Input

```json
{
  "appUrls": [
    "https://apps.apple.com/us/app/instagram/id389801252"
  ],
  "maxReviews": 1000,
  "reviewSource": "internal",
  "sortBy": "mostrecent",
  "requestDelayMs": 800
}
```

### Example Output

```json
[
  {
    "appId": "389801252",
    "appTitle": "Instagram App",
    "url": "https://apps.apple.com/us/app/instagram/id389801252",
    "storefront": "us",
    "reviewId": "13539617732",
    "title": "Great app but needs improvements",
    "text": "Love using it daily, but the latest update crashes...",
    "rating": 4,
    "reviewerName": "JJLin283",
    "reviewerUrl": null,
    "date": "2025-12-21T18:38:52Z",
    "appVersion": null,
    "helpfulVotes": null,
    "scrapedAt": "2026-08-27T21:19:45.226Z"
  }
]
```

### Automate & Integrate App Review Monitoring

Every run writes a structured dataset you can download as **JSON, CSV, or Excel** or deliver via the **Apify API**, **webhooks**, n8n, Zapier, Make, or Slack. Sort by `mostrecent` to catch new feedback or `mostcritical` for a clean negative-review triage queue.

**For continuous app review monitoring, schedule a nightly run.** Re-running daily against your app (and competitors) lets you catch rating drops, new one-star reviews, and version-specific complaints before they hurt your store ranking. De-duplicate on the unique `reviewId` field to keep only new reviews between runs.

### Related Actors

- [Google Play Reviews Scraper](https://apify.com/compass/crawler-google-places) — Android review data for cross-platform iOS + Android sentiment mapping
- [Apple App Store Reviews API (topic anchor)](https://apify.com/johnvc/apple-app-store-reviews-api) — a comparable high-traffic actor in the same cluster
- [App Store Reviews Scraper & AI insights](https://apify.com/agents/appstore-reviews) — performant App Store review scraping for the topic cluster
- [Product Hunt Scraper](https://apify.com) — adjacent tech-product launch and feedback data

### FAQ

#### Why use this actor instead of Apple's official API?

Apple does not provide a public reviews API. App Store Connect exposes reviews **only for apps you own**, and it's a developer-account-only surface. The public RSS feed is capped at ~500 reviews per app and can silently return zero entries. This actor instead uses the internal App Store media API (via Apple's same-origin relay) to read the **full review history** with pagination and de-duplication, with the RSS feed as a fallback for app-version and helpful-vote metadata — no App Store Connect account, no API key, no login.

#### Can I get app reviews for an app I don't own (competitors)?

Yes. This actor reads public App Store reviews by app URL or ID, so you can monitor any app — including competitors — for sentiment, feature requests, and rating trends.

#### How do I do app review sentiment analysis?

Run the actor over your app (or a competitor set), export the reviews, and analyze the `text`, `title`, `rating`, `date`, and `appVersion` fields. Star ratings provide a labeled baseline, while the full text gives your LLM or NLP model the actual user voice. Sort by `mostrecent` to tie sentiment to specific releases or `mosthelpful` for the most impactful feedback.

#### What are the alternatives to this actor for App Store reviews?

Other App Store review scrapers on Apify include the Apple App Store Reviews API (johnvc), the skootle App Store Reviews Monitor, and the Agents Fast App Store Reviews Scraper. This actor's differentiator is unlimited-offset review history via the internal media API and the flexible internal/RSS source choice.

#### How do I monitor competitor app reviews on a schedule?

Save a task with the competitor app URL, set `sortBy` to `mostrecent`, and schedule a daily run. De-duplicate across runs by `reviewId` to get only new reviews, then track rating and sentiment movement week over week.

# Actor input Schema

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

Apple App Store URLs or app IDs, one per line. Examples: https://apps.apple.com/us/app/instagram/id389801252 or 389801252

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

Maximum number of reviews to scrape per app. With the internal API (default) this can be any number (unlimited review history). With the RSS source it is capped at 500.

## `reviewSource` (type: `string`):

internal = unlimited via Apple's App Store media API (default). rss = Apple's public RSS feed, max 500 per app but includes app version and helpful votes.

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

Order in which reviews are returned.

## `country` (type: `string`):

ISO-3166-1 alpha-2 country code, e.g. "us", "gb", "de". Overrides the country found in the app URL. Leave empty to auto-detect from the URL.

## `requestDelayMs` (type: `integer`):

Milliseconds to wait between paginated requests to avoid Apple rate limiting (default: 800). Increase if requests get throttled.

## `useApifyProxy` (type: `boolean`):

Route requests through the Apify proxy. Defaults to OFF for the internal source (Apple rate-limits the proxy IPs for that endpoint) and ON for the rss source. An explicit value overrides the default.

## `apifyProxyGroups` (type: `array`):

Apify proxy groups to use (e.g. BUYPROXIES94952 for residential). Leave empty for the default.

## Actor input object example

```json
{
  "appUrls": [
    "https://apps.apple.com/us/app/instagram/id389801252"
  ],
  "maxReviews": 1000,
  "reviewSource": "internal",
  "sortBy": "mostrecent",
  "requestDelayMs": 800,
  "useApifyProxy": false,
  "apifyProxyGroups": [
    "BUYPROXIES94952"
  ]
}
```

# Actor output Schema

## `datasetUrl` (type: `string`):

All extracted app reviews as JSON rows.

## `publicDatasetUrl` (type: `string`):

View the scraped reviews in the dataset viewer.

## `runUrl` (type: `string`):

Link to this actor run.

# 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 = {
    "appUrls": [
        "https://apps.apple.com/us/app/instagram/id389801252"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/apple-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 = { "appUrls": ["https://apps.apple.com/us/app/instagram/id389801252"] }

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/apple-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 '{
  "appUrls": [
    "https://apps.apple.com/us/app/instagram/id389801252"
  ]
}' |
apify call ahmed_jasarevic/apple-scraper --silent --output-dataset

```

## MCP server setup

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