# App Store Reviews Scraper (`goat255/app-store-reviews-scraper`) Actor

Scrape Apple App Store (iOS) reviews by app id, app URL, and country without a login. Returns user name, star rating, title, review text, app version, and date, with an optional app summary row. Walks pages up to your chosen limit.

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

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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

Scrape Apple App Store (iOS) reviews by app id, app URL, or country storefront with no login and no API key required. Pull user names, star ratings, review titles, full review text, dates, and developer responses into clean structured rows, with automatic pagination up to the limit you set.

### What it does

- **Reviews for any iOS app** in any country storefront you list. Each review carries the user name, star rating, title, full text, edited flag, developer response, and date.
- **Multi country in one run.** Each app is scraped once per country code you provide, so you can compare sentiment across markets in a single job.
- **App summary row** (optional). Each app can lead with one record holding its name, developer, category, average rating, total rating count, current version, and icon.
- **Automatic pagination.** Pages are walked for you until your `maxReviewsPerApp` limit is reached or the storefront runs out of reviews.
- **Flexible input.** Accepts a raw numeric app id or a full App Store link, with the storefront read straight from the link when present.
- **No login, no password, no API key.**

### Use cases

- **App reputation monitoring.** Track new reviews and ratings for your own app across every market you ship in and feed them into alerts or dashboards.
- **Release impact analysis.** Watch how sentiment shifts after a release and read developer responses alongside user feedback.
- **Competitor analysis.** Pull reviews for the apps you compete with to understand what users praise and complain about.
- **Market research.** Aggregate reviews across categories and countries to spot demand, pain points, and feature gaps.
- **Voice-of-customer pipelines.** Feed review text into your own summarization, sentiment, or topic-modeling workflows.

### Input

| Field | Type | Description |
|---|---|---|
| `appIds` | array | iOS app ids or App Store links to pull reviews from. Accepts a numeric id (`389801252`) or a full app URL. Required. |
| `countries` | array | Two-letter storefront codes, for example `us`, `gb`, `de`, `in`. Each app is scraped once per code. A country embedded in an App Store URL overrides this list for that app. Default `us`. |
| `sort` | string | Order reviews by `mostRecent` or `mostHelpful`. Default `mostRecent`. |
| `maxReviewsPerApp` | integer | Cap on reviews returned per app per country. Pages are walked until this is reached or reviews run out. Default 100. |
| `includeAppInfo` | boolean | When on, each app emits one summary row (name, developer, category, average rating, rating count, version, icon) before its reviews. Summary rows are not billed. Default true. |
| `concurrency` | integer | How many app and country pairs to process in parallel. Default 5. |
| `proxyConfig` | object | Proxy configuration. Residential is the default and recommended option for the most reliable results. |

#### Example input

```json
{
  "appIds": ["389801252", "https://apps.apple.com/gb/app/example-app/id123456789"],
  "countries": ["us", "gb"],
  "sort": "mostRecent",
  "maxReviewsPerApp": 200,
  "includeAppInfo": true
}
````

### Output

Each review is one row, with keys ordered by importance (identity, then rating, then content, then metadata):

```json
{
  "type": "review",
  "reviewId": "1234567890",
  "appId": "389801252",
  "country": "us",
  "userName": "example_user",
  "rating": 5,
  "title": "Works great",
  "text": "An example review body describing the experience.",
  "edited": false,
  "developerResponse": "Thanks for the feedback, we are glad you enjoy the app.",
  "createdAt": "2026-06-01T12:00:00Z",
  "scrapedAt": "2026-06-18T09:00:00.000Z"
}
```

Key fields:

- `rating` is the star rating, 1 to 5.
- `title` and `text` are the review headline and body.
- `developerResponse` holds the developer's public reply when one exists, otherwise null.
- `edited` is true when the review was edited after first posting.
- `createdAt` is the review date; `scrapedAt` is when this row was collected.

When `includeAppInfo` is on, each app also emits one summary row carrying `appName`, `developer`, `averageRating`, `ratingCount`, `category`, `currentVersion`, `icon`, `bundleId`, and `appUrl`.

### FAQ

**Do I need an account, login, or API key?**
No. The scraper reads the public review data directly. You only need your Apify account to run it.

**How much does it cost?**
You are billed per review row returned. App summary rows are not billed. Check the pricing on this actor's page for the current per-result rate.

**How many reviews can I get per app?**
You set the cap with `maxReviewsPerApp`. The scraper walks pages automatically and returns up to your limit or as many reviews as the storefront exposes for that app and country, whichever comes first.

**Can I scrape multiple apps and countries at once?**
Yes. Pass several entries in `appIds` and several codes in `countries`. Every app and country pair is processed, with `concurrency` controlling how many run in parallel.

**How fast is it?**
Throughput depends on how many reviews you request, the number of app and country pairs, and your concurrency setting. Pages are fetched politely to stay reliable, so larger jobs take proportionally longer.

**Why use a residential proxy?**
Residential proxies give the most reliable results and are the default. You can change the proxy configuration in the input if you prefer.

**Can I get reviews in other languages or markets?**
Yes. Use the `countries` list to target different storefronts. Each storefront returns reviews from that market.

### Related actors

Part of the scraper suite by goat255:

- [Google Play Reviews Scraper](https://apify.com/goat255/google-play-reviews-scraper) - the Android equivalent: app reviews from Google Play.

# Actor input Schema

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

iOS app ids or App Store links to pull reviews from. Accepts a numeric id or a full app link. Example: 375380948, https://apps.apple.com/us/app/example-app/id375380948.

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

Two-letter storefront codes to pull reviews from. Each app is scraped once per country. Example: us, gb, de, in. A country embedded in an App Store URL overrides this list for that app.

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

Order reviews by most recent or most helpful.

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

Cap on reviews returned per app per country. Pages are walked until this is reached or the available reviews run out. Popular apps expose many pages of reviews; smaller apps may return fewer than your cap.

## `includeAppInfo` (type: `boolean`):

When on, each app emits one summary record (name, developer, category, average rating, rating count, current version) before its reviews. Summary rows are not billed.

## `concurrency` (type: `integer`):

How many app and country pairs to process in parallel.

## `proxyConfig` (type: `object`):

Apify proxy. RESIDENTIAL is the default and recommended option for the most reliable results.

## Actor input object example

```json
{
  "appIds": [
    "375380948"
  ],
  "countries": [
    "us"
  ],
  "sort": "mostRecent",
  "maxReviewsPerApp": 100,
  "includeAppInfo": true,
  "concurrency": 5,
  "proxyConfig": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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": [
        "375380948"
    ],
    "countries": [
        "us"
    ],
    "proxyConfig": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("goat255/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 = {
    "appIds": ["375380948"],
    "countries": ["us"],
    "proxyConfig": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "App Store Reviews Scraper",
        "description": "Scrape Apple App Store (iOS) reviews by app id, app URL, and country without a login. Returns user name, star rating, title, review text, app version, and date, with an optional app summary row. Walks pages up to your chosen limit.",
        "version": "0.1",
        "x-build-id": "YQKyKSVU56Ate7rQ2"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/goat255~app-store-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-goat255-app-store-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/goat255~app-store-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-goat255-app-store-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/goat255~app-store-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-goat255-app-store-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",
                "required": [
                    "appIds"
                ],
                "properties": {
                    "appIds": {
                        "title": "App ids or App Store URLs",
                        "type": "array",
                        "description": "iOS app ids or App Store links to pull reviews from. Accepts a numeric id or a full app link. Example: 375380948, https://apps.apple.com/us/app/example-app/id375380948.",
                        "default": [
                            "375380948"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "countries": {
                        "title": "Country storefronts",
                        "type": "array",
                        "description": "Two-letter storefront codes to pull reviews from. Each app is scraped once per country. Example: us, gb, de, in. A country embedded in an App Store URL overrides this list for that app.",
                        "default": [
                            "us"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "sort": {
                        "title": "Sort",
                        "enum": [
                            "mostRecent",
                            "mostHelpful"
                        ],
                        "type": "string",
                        "description": "Order reviews by most recent or most helpful.",
                        "default": "mostRecent"
                    },
                    "maxReviewsPerApp": {
                        "title": "Max reviews per app",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Cap on reviews returned per app per country. Pages are walked until this is reached or the available reviews run out. Popular apps expose many pages of reviews; smaller apps may return fewer than your cap.",
                        "default": 100
                    },
                    "includeAppInfo": {
                        "title": "Include an app summary row",
                        "type": "boolean",
                        "description": "When on, each app emits one summary record (name, developer, category, average rating, rating count, current version) before its reviews. Summary rows are not billed.",
                        "default": true
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many app and country pairs to process in parallel.",
                        "default": 5
                    },
                    "proxyConfig": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy. RESIDENTIAL is the default and recommended option for the most reliable results.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
