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

🔥 ~$0.04/1K reviews 🔥 Collect every App Store review for any app in 175 countries, with no 500-review limit: rating, title, full text, author, date, developer reply, and edited flag. Filter by rating, date, keywords, reply, and edit status.

- **URL**: https://apify.com/kaix/app-store-reviews-scraper.md
- **Developed by:** [Kai](https://apify.com/kaix) (community)
- **Stats:** 1 total users, 1 monthly users, 94.4% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.04 / 1,000 reviews

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

**Get every review of any App Store app, in all 175 countries, with no 500-review limit.**

The usual limit is the newest 500 reviews of each country. This Actor has no such limit. Slack has
12,332 reviews in the US store, and this Actor reads all of them in about 50 seconds. Choose All
countries, and you do not list the countries one by one.

### What can you do with it?

- Feedback monitoring: track the new reviews of your own app in each of your markets.
- Bug research: collect the one-star and two-star reviews of an app, and find what users complain
  about.
- Feature requests: find the reviews that ask for a feature, and leave out the bug reports.
- Praise and testimonials: find the most helpful five-star reviews.
- Support follow-up: find the reviews that have no developer reply, and answer them.
- Support analysis: see how the developer answers reviews, and with what text.
- Edited reviews: find the reviews that the reviewer edited and the developer answered.
- Competitor benchmarking: compare the reviews and the rating summaries of several apps in the
  same countries.
- Market research: compare how users in different countries rate the same app.
- All countries: read one app in all 175 countries in one run.
- Text and sentiment datasets: get the same number of reviews for each star rating, with the full
  text.
- Full archive: download every review of an app.

### What data does it extract?

| Data | When you get it |
|---|---|
| Review ID, rating, title, text, and date | Every run |
| Reviewer name | Every run |
| Developer reply: text and date | Every run, when the developer replied |
| Edited flag | Every run |
| App ID, app name, and the country of the App Store | Every run |
| App version that the reviewer used | For part of the reviews of an app |
| Helpful votes and total votes | For part of the reviews of an app |
| Reviewer ID | For part of the reviews of an app |
| App details: developer, category, price, version, release notes, description, and screenshots | `includeAppDetails` |
| Rating summary: average rating and number of ratings, for all versions and for the current version | `includeAppDetails` |
| Age rating, system requirement, languages, and file size | `includeAppDetails` |

A field without data is `null`. The app version, the votes, and the reviewer ID are available for
only part of the reviews of an app. The share changes from run to run. The other reviews have `null`
in these three fields. No filter uses these fields.

#### Why this Actor?

| | App Store Reviews Scraper |
|---|---|
| Reviews | Every review that the App Store shows for the app, not only the newest 500 of each country |
| Countries | 175 App Store countries in one run |
| Apps | As many as you list, in one run |
| Speed | All 12,332 reviews of Slack in the US store in about 50 seconds |
| Sort order | Most recent, most helpful, highest rating, or lowest rating |
| Filters | Stars, dates, keywords, developer reply, and edit status |
| Star filter | Any mix of 1 to 5 stars, with its own limit for each star rating |
| Dates | ISO 8601 in UTC |
| App details | A second Dataset, with no charge |
| Restarts | A restarted run never saves or charges a review twice |

### Quick start

1. Open the app in the App Store and copy the link.
2. Paste it into **Apps**. Add more links or app IDs for more apps.
3. Choose the **Countries**. The default is `us`. Choose **All countries** to read all 175 stores.
4. Set **Max Reviews**. Use `0` to get all the reviews that match your filters.
5. Click **Start**. Download the results as JSON, CSV, Excel, or HTML.

The same input as JSON:

```json
{
  "apps": ["https://apps.apple.com/us/app/slack/id618783545"],
  "countries": ["us"],
  "maxReviews": 100
}
```

### Examples by use case

#### Feedback monitoring

Every review of your app since 1 October 2026, in four countries. A
`maxReviews` of `0` sets no limit, and `sinceDate` stops the run as soon as it reaches older reviews.
Schedule the run in Apify, for example every week, and keep the rows whose `id` you have not saved
before:

```json
{
  "apps": ["https://apps.apple.com/us/app/slack/id618783545"],
  "countries": ["us", "gb", "de", "fr"],
  "sort": "mostRecent",
  "sinceDate": "2026-10-01",
  "maxReviews": 0
}
```

#### Bug research

The one-star and two-star reviews that mention a crash, a freeze, or a bug. The
limit applies to each star rating, so this input gives up to 200 one-star and 200 two-star reviews:

```json
{
  "apps": ["618783545"],
  "countries": ["us"],
  "ratings": ["1", "2"],
  "keywords": ["crash", "freeze", "bug"],
  "maxReviews": 200
}
```

#### Feature requests

The 200 newest reviews that ask for a feature and do not mention a crash or a
bug. A review must have at least one of the `keywords` and none of the `excludeKeywords`:

```json
{
  "apps": ["618783545"],
  "countries": ["us"],
  "keywords": ["please add", "wish", "feature request"],
  "excludeKeywords": ["crash", "bug"],
  "maxReviews": 200
}
```

#### Praise and testimonials

The 50 most helpful five-star reviews:

```json
{
  "apps": ["389801252"],
  "countries": ["us"],
  "ratings": ["5"],
  "sort": "mostHelpful",
  "maxReviews": 50
}
```

#### Support follow-up

The reviews of 2026 that have no developer reply, with the lowest ratings
first:

```json
{
  "apps": ["618783545"],
  "countries": ["us"],
  "sort": "lowestRating",
  "sinceDate": "2026-01-01",
  "untilDate": "2026-12-31",
  "developerReply": "without",
  "maxReviews": 0
}
```

#### Support analysis

The 500 most helpful reviews that have a developer reply. Read `developerReply`
to see how the developer answers, and with what text:

```json
{
  "apps": ["618783545"],
  "countries": ["us"],
  "sort": "mostHelpful",
  "developerReply": "with",
  "maxReviews": 500
}
```

#### Edited reviews

The 200 newest reviews that the reviewer edited and that have a developer reply:

```json
{
  "apps": ["618783545"],
  "countries": ["us"],
  "edited": "edited",
  "developerReply": "with",
  "maxReviews": 200
}
```

#### Competitor benchmarking

The 100 newest reviews of each of three apps, in each of two countries,
with the app details. Compare `rating` and `ratingCount` in the `apps` Dataset:

```json
{
  "apps": ["389801252", "284882215", "id310633997"],
  "countries": ["us", "gb"],
  "maxReviews": 100,
  "includeAppDetails": true
}
```

#### Market research

The 100 newest reviews of the same app in each of eight countries. Compare the
average `rating` of the reviews for each `country`:

```json
{
  "apps": ["389801252"],
  "countries": ["us", "gb", "de", "fr", "jp", "br", "in", "au"],
  "maxReviews": 100
}
```

#### All countries

The 100 newest reviews of one app in every country where the App Store offers it.
The value `all` selects all 175 countries. The run takes much longer than a run with one country:

```json
{
  "apps": ["https://apps.apple.com/us/app/slack/id618783545"],
  "countries": ["all"],
  "maxReviews": 100
}
```

#### Text and sentiment datasets

Up to 1,000 reviews for each star rating, so no rating dominates the dataset:

```json
{
  "apps": ["618783545"],
  "countries": ["us"],
  "ratings": ["1", "2", "3", "4", "5"],
  "maxReviews": 1000
}
```

#### Full archive

Every review that the App Store shows for the app, with the most helpful reviews
first:

```json
{
  "apps": ["618783545"],
  "countries": ["us"],
  "sort": "mostHelpful",
  "maxReviews": 0
}
```

### Choose the apps and countries

Give one link or one ID for each app. A link from any country's App Store works. The Actor reads only
the app ID in the link, such as `389801252` in `.../instagram/id389801252`. The forms `389801252` and
`id389801252` also work.

- `maxReviews` applies to each app, each country, and each chosen star rating.
- Each app and each country is read once. Two entries for the same app give one set of reviews.
- **All countries** is the value `all` in the API. It reads all 175 stores. The run takes much longer, and
  `maxReviews` applies to each country.
- An entry that is not an App Store link or an app ID stops the run before it starts. The status
  message names the entry.
- A country code that is not in the list stops the run before it starts. The input form shows the list.
- An app that a country's App Store does not offer gets one warning in the log, with the countries. The run
  goes on with the other apps and countries.

### Sort order and filters

A review must pass every filter that you set. A filter that you leave empty keeps all reviews.

- **Sort.** `mostRecent` returns the newest reviews first. `mostHelpful` returns the reviews with the
  most helpful votes first. `highestRating` returns 5 stars first, and `lowestRating` returns 1 star
  first. Inside one star rating, the newest reviews come first.
- **Star ratings.** With `ratings`, the Actor reads each chosen rating on its own, and `maxReviews`
  applies to each one. The reviews then come grouped by rating: the highest rating first, or the
  lowest first for `lowestRating`. Inside a group the newest reviews come first. With
  `mostHelpful`, the reviews keep the order of helpful votes.
- **Dates.** `sinceDate` and `untilDate` use UTC. A date such as `2026-01-31` covers the whole day. A
  date range makes a run faster, because the Actor skips the reviews outside the range.
- **Keywords.** `keywords` keeps a review that has at least one of the words in its title or text.
  `excludeKeywords` drops a review that has any of its words. Capital letters do not matter.
- **Developer reply.** `developerReply` is `with` or `without`.
- **Edit status.** `edited` is `edited` or `notEdited`. A review with no edit status matches neither.

### Input reference

| Field | Type | Default | Behavior |
|---|---|---:|---|
| `apps` | string\[] | required | App Store links or numeric app IDs. Each app is read once. |
| `countries` | string\[] | `["us"]` | Two-letter country codes from the list in the input form, or `all` for every country. The Actor reads every app in every country. |
| `maxReviews` | integer, 0 or greater | `100` | Maximum reviews for each app, country, and chosen star rating. Use `0` for every review that matches your filters. |
| `sort` | `mostRecent`, `mostHelpful`, `highestRating`, or `lowestRating` | `mostRecent` | Order of the reviews, and so the reviews that fit inside the limit. |
| `ratings` | string\[] | `[]` | Star ratings to keep, from `"1"` to `"5"`. An empty list keeps all ratings. |
| `sinceDate` | string | none | Keep reviews written on or after this date. |
| `untilDate` | string | none | Keep reviews written on or before this date. The whole last day counts. |
| `keywords` | string\[] | `[]` | Keep reviews that hold at least one of these words or phrases. |
| `excludeKeywords` | string\[] | `[]` | Drop reviews that hold any of these words or phrases. |
| `developerReply` | `any`, `with`, or `without` | `any` | Keep all reviews, only reviews with a developer reply, or only reviews without one. |
| `edited` | `any`, `edited`, or `notEdited` | `any` | Keep all reviews, only edited reviews, or only reviews that were never edited. |
| `includeAppDetails` | boolean | `false` | Write one record for each app and country to the `apps` Dataset. App records have no charge. |
| `proxyConfiguration` | object | Apify Proxy | Connection settings. The default works for most runs. |

A `sinceDate` that is later than `untilDate` stops the run before it starts.

#### Complete input example

This reference example covers every input field. It limits the result to 10 reviews for each app,
country, and star rating.

<details>
<summary>Open the complete input</summary>

```json
{
  "apps": [
    "https://apps.apple.com/us/app/instagram/id389801252",
    "284882215"
  ],
  "countries": ["us", "gb"],
  "maxReviews": 10,
  "sort": "mostHelpful",
  "ratings": ["1", "5"],
  "sinceDate": "2025-01-01",
  "untilDate": "2026-10-31",
  "keywords": ["update", "login"],
  "excludeKeywords": ["spam"],
  "developerReply": "any",
  "edited": "any",
  "includeAppDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

</details>

### Output

The run writes two Datasets with different shapes:

| Dataset | One item for each | When |
|---|---|---|
| default | Review | Every run |
| `apps` | App and country | `includeAppDetails: true` |

Through the API, read the ID of the `apps` Dataset from `storageIds.datasets.apps` in the run object.

#### Review fields by topic

- **Review.** Review ID, rating from 1 to 5, title, text, and date in ISO 8601 and UTC.
- **Reviewer.** Name and ID. The ID is `null` when it is not available.
- **Developer reply.** The text and the date of the reply, or `null` when the developer did not reply.
- **Edit status.** `isEdited` is `true` when the reviewer edited the review. It is `null` when the edit
  status is not available.
- **Engagement.** Helpful votes, and the total number of votes. Both are `null` when they are not available.
- **App.** App ID, app name, the app version that the reviewer used, and the country of the App Store.

#### Review example

This is a complete review from a run on 25 October 2026.

<details>
<summary>Open the review</summary>

```json
{
  "id": "14706177096",
  "appId": "389801252",
  "appName": "Instagram",
  "country": "us",
  "rating": 1,
  "title": "Anti-democratic",
  "text": "It is interfering with my country’s electoral process and undermining democracy",
  "author": {
    "name": "Brazilian_M",
    "id": "506873469"
  },
  "date": "2026-10-24T16:46:56.000Z",
  "isEdited": false,
  "developerReply": null,
  "appVersion": "452.0.0",
  "helpfulVotes": 0,
  "totalVotes": 0
}
```

</details>

#### Review field reference

| Path | Type and nullability |
| --- | --- |
| `id`, `appId`, `appName`, `country` | string |
| `rating` | number from 1 to 5 |
| `title`, `text` | string |
| `author.name` | string |
| `author.id` | string or `null` |
| `date` | string, ISO 8601 in UTC |
| `isEdited` | boolean or `null` |
| `developerReply.text` | string, or `developerReply` is `null` |
| `developerReply.date` | string, ISO 8601 in UTC |
| `appVersion` | string or `null` |
| `helpfulVotes`, `totalVotes` | number or `null`. `helpfulVotes` is never more than `totalVotes`. |

A review is saved once for each app and country in a run.

### App Dataset reference

When `includeAppDetails` is `true`, the `apps` Dataset receives one row for each app and country.

<details>
<summary>Open an app record</summary>

```json
{
  "id": "389801252",
  "name": "Instagram",
  "country": "us",
  "url": "https://apps.apple.com/us/app/instagram/id389801252?uo=4",
  "bundleId": "com.burbn.instagram",
  "iconUrl": "https://is1-ssl.mzstatic.com/image/thumb/Purple211/v4/01/2d/b1/012db1a7-249a-86e8-f025-72491c2a6475/Prod-0-0-1x_U007epad-0-0-0-1-0-0-sRGB-85-220.png/512x512bb.jpg",
  "developer": {
    "id": 389801255,
    "name": "Instagram, Inc.",
    "url": "https://apps.apple.com/us/developer/instagram-inc/id389801255?uo=4"
  },
  "category": "Photo & Video",
  "genres": ["Photo & Video", "Social Networking"],
  "price": 0,
  "formattedPrice": "Free",
  "currency": "USD",
  "version": "452.0.0",
  "releaseDate": "2010-10-06T08:12:41Z",
  "currentVersionReleaseDate": "2026-10-19T12:27:02Z",
  "releaseNotes": "Performance optimizations and stability improvements for a smoother, more reliable experience.",
  "description": "Little moments lead to big friendships. Share yours on Instagram. ...",
  "rating": 4.69057,
  "ratingCount": 29636798,
  "ratingCurrentVersion": 4.69057,
  "ratingCountCurrentVersion": 29636798,
  "contentRating": "12+",
  "minimumOsVersion": "16.3",
  "languages": ["BN", "HR", "CS", "DA", "NL", "EN"],
  "fileSizeBytes": 660901888,
  "screenshotUrls": [
    "https://is1-ssl.mzstatic.com/image/thumb/PurpleSource221/v4/50/e2/8b/50e28b44-daa5-7101-6fb6-2d0e10fc72f3/1_iOS_5.5.jpg/392x696bb.jpg"
  ]
}
```

The `description` and `languages` values in this example are shortened.

</details>

| Path | Type and nullability |
| --- | --- |
| `id`, `name`, `country`, `url`, `bundleId` | string |
| `iconUrl`, `category`, `formattedPrice`, `currency`, `version`, `releaseNotes`, `description` | string or `null` |
| `releaseDate`, `currentVersionReleaseDate` | string in ISO 8601, or `null` |
| `developer.id` | number or `null` |
| `developer.name` | string |
| `developer.url` | string or `null` |
| `genres`, `languages`, `screenshotUrls` | string array; can be empty |
| `price` | number or `null` |
| `rating`, `ratingCurrentVersion` | number from 1 to 5, or `null` |
| `ratingCount`, `ratingCountCurrentVersion` | number or `null` |
| `contentRating`, `minimumOsVersion` | string or `null` |
| `fileSizeBytes` | number or `null` |

### Run status and completeness

- The run finishes with `SUCCEEDED` when every app and country was read to the limit or to the last
  review that the App Store shows. An app that a country does not offer, and an app with no reviews,
  do not fail the run.
- The run finishes with `FAILED` when the Actor could not read part of the reviews, even after
  retries. The status message starts with `Incomplete results`, gives the number of saved reviews, and
  lists the apps and countries that stopped. The reviews saved before the stop stay in the Dataset.
- A very large app can have more reviews than the App Store shows. The Actor reads all that it can
  reach. When your limit is not filled with them, the run finishes with `FAILED`. The status message
  says `only part of the reviews could be read`, and the saved reviews stay in the Dataset.
- The Actor tries every app and country before it reports a failure.
- When the run reaches the maximum cost that you set, it stops, keeps the saved reviews, and finishes
  with `SUCCEEDED`. The status message says so.
- If the platform restarts the run, the Actor does not save or charge a review twice.

### FAQ

#### How many reviews can I get?

Every review that the App Store shows for the app in that country. For most apps this is all the
reviews. A very large app, with more than 100,000 reviews, can show less. Each country has its own
reviews, so add countries to get more.

#### How long does a run take?

A small app takes seconds. All 12,332 reviews of Slack in the US store take about 50 seconds. The
time changes with the size of the app and with how fast the connection is at that time. A date range
or a star filter makes the run faster, because the Actor skips the reviews outside it.

#### What does a run cost?

Each saved review is one billed item. The price is on the Actor page. App records have no charge. Set
a maximum cost for the run to cap the price. The Actor then stops at that cost and keeps the saved
reviews.

#### Why did I get fewer reviews than `maxReviews`?

The app has fewer reviews in that country, or your filters leave fewer. A small app can have only a
few reviews in a country. The log gives the number of reviews for each app and country.

#### Why do some reviews have `null` for the version and the votes?

These values are available for only part of the reviews of an app, and the share changes from run to
run. For the other reviews the Actor gives `null`. The rating, title, text, date, reply, and edit status
are in every review. No filter uses the version or the votes.

#### Why is a review in another language than the country?

Reviewers write in any language. The `country` field tells you which App Store the review belongs to.

#### How do I get only the new reviews?

Set `sinceDate` to the day of your last run, and keep the rows whose `id` you have not saved before.
The run reads only the reviews since that date. You can also set `sort` to `mostRecent` and a
`maxReviews` above the number of new reviews that you expect.

#### Can I get Google Play reviews?

Use [Google Play Reviews Scraper](https://apify.com/kaix/google-play-reviews-scraper).

#### A feature or field that I need is missing. What can I do?

Tell us in the **Issues** tab. Describe what you need and give an example app.

#### Where can I report a problem?

Open an issue in the **Issues** tab. Include the run ID and the input, so that we can reproduce it.

# Actor input Schema

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

App Store links or numeric app IDs. The ID is the number after <code>id</code> in the link, for example <code>389801252</code>.

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

The App Stores to read. The run collects the reviews of every app in every country. A country has its own reviews. Choose All countries to read all 175 stores. The run takes much longer, and the review limit applies to each country.

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

Maximum number of reviews for each app, country, and chosen rating. Set to 0 for every review that matches your filters.

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

The order of the reviews, and so the reviews that fit inside the limit.

## `ratings` (type: `array`):

Only collect reviews with these star ratings. An empty list means all ratings.

## `sinceDate` (type: `string`):

Only collect reviews written on or after this date. A date such as 2026-01-01 starts at 00:00:00 UTC.

## `untilDate` (type: `string`):

Only collect reviews written on or before this date. The whole last day counts, up to 23:59:59 UTC.

## `keywords` (type: `array`):

Only collect reviews whose title or text holds at least one of these words or phrases. Capital letters do not matter.

## `excludeKeywords` (type: `array`):

Skip reviews whose title or text holds any of these words or phrases.

## `developerReply` (type: `string`):

Keep all reviews, only the reviews that have a reply from the developer, or only the reviews that have none.

## `edited` (type: `string`):

Keep all reviews, only the reviews that the author edited, or only the reviews that the author did not edit.

## `includeAppDetails` (type: `boolean`):

Also save one record for each app and country, with the name, developer, price, version, release notes, and rating summary. The records go to the <code>apps</code> dataset.

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

Connection settings. The default works for most runs.

## Actor input object example

```json
{
  "apps": [
    "https://apps.apple.com/us/app/slack/id618783545"
  ],
  "countries": [
    "us"
  ],
  "maxReviews": 100,
  "sort": "mostRecent",
  "ratings": [],
  "keywords": [],
  "excludeKeywords": [],
  "developerReply": "any",
  "edited": "any",
  "includeAppDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

## `apps` (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 = {
    "apps": [
        "https://apps.apple.com/us/app/slack/id618783545"
    ],
    "countries": [
        "us"
    ],
    "maxReviews": 100,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("kaix/app-store-reviews-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "apps": ["https://apps.apple.com/us/app/slack/id618783545"],
    "countries": ["us"],
    "maxReviews": 100,
    "proxyConfiguration": { "useApifyProxy": True },
}

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

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "apps": [
    "https://apps.apple.com/us/app/slack/id618783545"
  ],
  "countries": [
    "us"
  ],
  "maxReviews": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call kaix/app-store-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,kaix/app-store-reviews-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/k1wL2oyjnMjXYKQMU/builds/QjX4qhyFIe43QtiLF/openapi.json