# App Store Reviews Scraper API (`automly/appstore-reviews-scraper`) Actor

Extract iOS app reviews from the Apple App Store: ratings, review titles, full text, app versions, and reviewer profiles. Sweep multiple country storefronts in one run, up to 500 reviews per app per country. No API key or proxy needed. Export as JSON, CSV, or Excel.

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

## Pricing

from $0.09 / 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## App Store Reviews Scraper

### 📱 What does App Store Reviews Scraper do?

**App Store Reviews Scraper** extracts **iOS app reviews, star ratings, review titles, app versions, and reviewer info** from any **Apple App Store** listing. Point it at an app ID or an App Store URL, pick your country storefronts, and download the reviews as **JSON, CSV, or Excel** — no Apple account, no API key, no proxy setup.

Apple caps its public review feed at **500 reviews per app per country**, so the fastest way to more data is more countries. This actor takes a **list of countries in one input** and walks every storefront in a single run — one run covers `us`, `gb`, `ca`, `de`, `au`, and any other locale you add.

### 🧾 What data can I extract?

<table>
<tr>
<td>⭐️ Star rating (1–5)</td>
<td>📝 Review title + full body text</td>
</tr>
<tr>
<td>📅 Publication date (ISO 8601)</td>
<td>📦 App version the reviewer was using</td>
</tr>
<tr>
<td>🧑 Reviewer username + iTunes profile URL</td>
<td>🌍 Country storefront per review</td>
</tr>
<tr>
<td>👍 Helpful vote counts</td>
<td>🔗 Direct review link + review IDs</td>
</tr>
</table>

Non-English reviews come out with **correct accents and characters** — the raw Apple feed often double-encodes text like "está" into "está", and this actor repairs that automatically instead of passing the garbage through.

### 🎯 Use cases

- **App sentiment analysis** — build labeled datasets (`text` + `score`) for NLP straight from real users
- **Release impact tracking** — group reviews by `version` to see how each update landed
- **Competitive benchmarking** — pull reviews for your competitors' apps into one dataset
- **Global market research** — compare ratings and complaints across country storefronts
- **App Store Optimization (ASO)** — mine review titles and text for the words users actually use

### ⬇️ How to use

1. Open the actor in Apify Console and click **Try for free**.
2. Enter one or more numeric **App IDs** (the digits after `id` in any App Store URL — `389801252` for Instagram), or paste full **App Store URLs** like `https://apps.apple.com/us/app/instagram/id389801252`.
3. List the **Countries** you want, e.g. `us`, `gb`, `de`. Each adds up to 500 reviews per app.
4. Set **Maximum reviews per app per country** (default 100, max 500) and the sort order (most recent or most helpful).
5. Click **Start**. Runs take seconds — the feed serves 50 reviews per request.
6. Open the **Output** tab for the review table, or export from the **Dataset** tab as JSON, CSV, or Excel.

#### Example input

```json
{
    "appIds": ["389801252", "835599320"],
    "countries": ["us", "gb", "ca"],
    "maxReviewsPerApp": 500,
    "sortBy": "mostRecent"
}
````

That single input collects up to 3,000 reviews (2 apps × 3 countries × 500).

### ⚙️ Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `appIds` | array | `[]` | Numeric App Store app IDs, e.g. `389801252`. Combined with every country in `countries`. |
| `countries` | array | `["us"]` | Storefront country codes (`us`, `gb`, `ca`, `de`, …). Each returns up to 500 reviews per app. |
| `startUrls` | array | `[]` | Full App Store URLs — country and app ID are read from each URL. |
| `maxReviewsPerApp` | integer | `100` | Reviews saved per app per country (1–500). |
| `sortBy` | string | `mostRecent` | `mostRecent` or `mostHelpful`. |
| `requestTimeoutSecs` | integer | `30` | Per-request timeout in seconds. |
| `useApifyProxy` | boolean | `false` | Route requests through Apify Proxy. Rarely needed. |
| `proxyGroups` | array | `[]` | Optional proxy groups when proxying is enabled. |

Provide `appIds` + `countries`, or `startUrls`, or both.

### ⬆️ Output example

One review per dataset row — real output from an Instagram (US) run:

```json
{
    "appId": "389801252",
    "country": "US",
    "id": "14288247378",
    "parentId": "14288247378",
    "score": 1,
    "title": "Instagram está fallando",
    "text": "Instagram es muy bueno y todo pero desde que metieron a meta ai solo suspenden cuentas sin ningúna razón",
    "version": "437.2.0",
    "date": "2026-07-10T18:19:36-07:00",
    "userName": "Ig 🤨",
    "userUrl": "https://itunes.apple.com/us/reviews/id1672997068",
    "voteSum": 0,
    "voteCount": 0,
    "url": "https://itunes.apple.com/us/review?id=389801252&type=Purple%20Software",
    "scrapedAt": "2026-07-12T12:01:14Z"
}
```

Note the accented text and emoji arriving intact.

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

Very little — the actor talks straight to Apple's public feed with lightweight HTTP requests, no browser and no proxy. Measured on a real cloud run (180 reviews across 3 storefronts, finished in 5 seconds):

- **1,000 reviews ≈ 0.03 compute units ≈ $0.02** on the Apify Starter plan
- The Apify free plan's monthly credit covers hundreds of thousands of reviews

A full sweep of one app across 10 countries (up to 5,000 reviews) costs well under a cent of platform usage.

### ❓ FAQ

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

Apple's public feed serves at most **500 reviews per app per country** (10 pages × 50). That is an Apple platform limit, not a scraper limit. To get more coverage, add more countries — the `countries` input array sweeps them all in one run.

#### Where do I find the app ID?

In the app's App Store URL: `https://apps.apple.com/us/app/instagram/id389801252` → the ID is `389801252`. Or just paste the whole URL into **App Store URLs** and skip the lookup.

#### Do I need a proxy or an Apple account?

No. The feed is public and served without bot challenges in normal use. Proxy support is built in for the rare case a shared IP gets rate-limited — flip **Use Apify Proxy** on and rerun.

#### Which countries are supported?

Every App Store storefront: `us`, `gb`, `ca`, `au`, `de`, `fr`, `it`, `es`, `br`, `mx`, `jp`, `kr`, `in`, and the rest. Use the two-letter storefront code.

#### Can I get reviews sorted by helpfulness?

Yes — set `sortBy` to `mostHelpful` to have Apple return its most-helpful ordering instead of newest-first. Useful when you want the reviews users actually vote on rather than the latest batch.

#### What export formats are supported?

JSON, CSV, Excel (XLSX), XML, and HTML — download from the Dataset tab or fetch via the API. The Output tab shows a clean review table with rating, title, text, version, and date columns.

#### Can I run it via API, MCP, or on a schedule?

Yes. Start runs and fetch results through the Apify REST API or the JavaScript/Python clients — the **API** tab has ready-made code. AI agents can call it through the Apify MCP server. Use Apify Schedules for recurring pulls, such as a daily check for new reviews with `sortBy: mostRecent`.

#### Does it cover Google Play reviews too?

No — this actor is App Store only, so it can do that one job reliably. Pair it with a Google Play reviews scraper if you need both platforms in one pipeline.

### 🔗 Related actors

- [Google Maps Scraper](https://apify.com/automly/google-maps-scraper) — extract places, ratings, and reviews from Google Maps
- [Tripadvisor Reviews Scraper](https://apify.com/automly/tripadvisor-reviews-scraper) — extract hotel, restaurant, and attraction reviews with reviewer profiles
- [Facebook Ad Library Scraper](https://apify.com/automly/facebook-ad-library-scraper) — see which apps and brands are running Meta ads
- [TikTok Ads Library Scraper](https://apify.com/automly/tiktok-ads-library-scraper) — collect ads from TikTok's Creative Center

# Actor input Schema

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

Numeric App Store app IDs, e.g. 389801252 for Instagram. Find the ID in the app's URL after "id". Use together with Countries.

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

App Store country codes to fetch reviews from, e.g. us, gb, ca, de. Each country returns up to 500 reviews per app (Apple's limit). Add several to multiply coverage in one run.

## `startUrls` (type: `array`):

Direct App Store app URLs like https://apps.apple.com/us/app/instagram/id389801252. Country and app ID are read from each URL. Works alongside or instead of App IDs.

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

Cap on reviews saved for each app in each country. Apple serves at most 500 per app per country.

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

Order in which Apple returns reviews.

## `requestTimeoutSecs` (type: `integer`):

Maximum time to wait for each feed request before retrying or skipping.

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

Route requests through Apify Proxy. Rarely needed — Apple's public review feed does not usually block direct connections.

## `proxyGroups` (type: `array`):

Optional Apify Proxy groups to use when proxying is enabled.

## Actor input object example

```json
{
  "appIds": [
    "389801252"
  ],
  "countries": [
    "us"
  ],
  "maxReviewsPerApp": 100,
  "sortBy": "mostRecent",
  "requestTimeoutSecs": 30,
  "useApifyProxy": false
}
```

# Actor output Schema

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

One row per review: app, rating, title, text, version, date, and country.

## `fullData` (type: `string`):

All fields including reviewer profile URL, vote counts, and review links.

## `runSummary` (type: `string`):

Per app and country: reviews saved and any failures.

# 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": [
        "389801252"
    ],
    "countries": [
        "us"
    ]
};

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

# Run the Actor and wait for it to finish
run = client.actor("automly/appstore-reviews-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": [
    "389801252"
  ],
  "countries": [
    "us"
  ]
}' |
apify call automly/appstore-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automly/appstore-reviews-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "App Store Reviews Scraper API",
        "description": "Extract iOS app reviews from the Apple App Store: ratings, review titles, full text, app versions, and reviewer profiles. Sweep multiple country storefronts in one run, up to 500 reviews per app per country. No API key or proxy needed. Export as JSON, CSV, or Excel.",
        "version": "1.0",
        "x-build-id": "COB81FJVHz35K7JO7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automly~appstore-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automly-appstore-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automly~appstore-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automly-appstore-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automly~appstore-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automly-appstore-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "appIds": {
                        "title": "App IDs",
                        "type": "array",
                        "description": "Numeric App Store app IDs, e.g. 389801252 for Instagram. Find the ID in the app's URL after \"id\". Use together with Countries.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "countries": {
                        "title": "Countries",
                        "type": "array",
                        "description": "App Store country codes to fetch reviews from, e.g. us, gb, ca, de. Each country returns up to 500 reviews per app (Apple's limit). Add several to multiply coverage in one run.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "us"
                        ]
                    },
                    "startUrls": {
                        "title": "App Store URLs",
                        "type": "array",
                        "description": "Direct App Store app URLs like https://apps.apple.com/us/app/instagram/id389801252. Country and app ID are read from each URL. Works alongside or instead of App IDs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerApp": {
                        "title": "Maximum reviews per app per country",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Cap on reviews saved for each app in each country. Apple serves at most 500 per app per country.",
                        "default": 100
                    },
                    "sortBy": {
                        "title": "Sort reviews by",
                        "enum": [
                            "mostRecent",
                            "mostHelpful"
                        ],
                        "type": "string",
                        "description": "Order in which Apple returns reviews.",
                        "default": "mostRecent"
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout in seconds",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Maximum time to wait for each feed request before retrying or skipping.",
                        "default": 30
                    },
                    "useApifyProxy": {
                        "title": "Use Apify Proxy",
                        "type": "boolean",
                        "description": "Route requests through Apify Proxy. Rarely needed — Apple's public review feed does not usually block direct connections.",
                        "default": false
                    },
                    "proxyGroups": {
                        "title": "Proxy groups",
                        "type": "array",
                        "description": "Optional Apify Proxy groups to use when proxying is enabled.",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```