# Apple App Store Review Scraper (`crawl_craft/apple-app-store-review-scraper`) Actor

▎ Reading App Store reviews one by one hides what users really think. Scrape reviews for any app in every country: stars, text, app version, helpful votes and developer replies. Filter by rating, date or keyword and track only new reviews. No login.

- **URL**: https://apify.com/crawl_craft/apple-app-store-review-scraper.md
- **Developed by:** [Crawl Craft](https://apify.com/crawl_craft) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 1,000 results

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

### What is Apple App Store Review Scraper?

Apple App Store Review Scraper is an Apify Actor that collects public ratings, review text, app versions, helpful votes and developer replies for the apps you list and the App Store countries you choose. Paste app links, IDs or names, set filters, and receive a clean dataset ready for export.

- **Every storefront:** read one country, several countries or all storefronts in a single run.
- **Filters before saving:** keep only the stars, dates, keywords, reply status and edited reviews you ask for.
- **Monitoring mode:** schedule runs to track new App Store reviews, because each run can return only reviews newer than the previous one.
- **Built-in summary:** get average stars, star distribution and reply rate for every app and country.

Use this Apple App Store reviews scraper when you want a full export instead of scrolling an app page. Among the Apify App Store scraper Actors, this one is built around reviews, developer replies and monitoring.

Click **Try for free**, paste an App Store link and press **Start**.

### What data can you extract from the App Store?

The dataset covers public iOS App Store reviews for the apps and countries you choose. Each run saves one row per review, so you can get App Store reviews into a spreadsheet or BI tool without copying anything by hand. The field names below match the dataset schema, and the example values come from the schema.

| Field | Description | Example |
|---|---|---|
| `parentId` | Identifier of the review thread (same as the review ID). | `14645265928` |
| `id` | Unique App Store review identifier. | `14645265928` |
| `date` | When the review was written, in store-local time (ISO 8601). | `2026-10-09T03:14:23-07:00` |
| `userName` | Public display name of the reviewer. | `Ahdheididh` |
| `userUrl` | Link to the reviewer's public review profile. | `https://itunes.apple.com/us/reviews/id1874752662` |
| `version` | App version the review was written for, when Apple provides it. | `47.1.0` |
| `score` | Star rating from 1 to 5. | `5` |
| `title` | Title the reviewer gave the review. | `Great app` |
| `text` | Full text of the review. | `Works perfectly for me.` |
| `url` | Link to the review. | `https://itunes.apple.com/us/review?id=835599320&type=Purple%20Software` |
| `country` | Two-letter App Store storefront code in capitals. | `US` |
| `appId` | Numeric App Store ID of the app. | `835599320` |
| `appName` | Name of the app (added when Add app name is on). | `TikTok - Videos, Shop & LIVE` |
| `isEdited` | Whether the reviewer edited the review after posting. | `false` |
| `developerResponse` | Reply from the developer with id, text and date, or null when unanswered. | `null` |
| `responseTimeHours` | Hours between the review and the developer reply. | `32.5` |
| `helpfulVotes` | How many people marked the review helpful. | `3` |
| `totalVotes` | How many people voted on the review. | `4` |
| `wordCount` | Number of words in the review text. | `10` |
| `reviewsPageUrl` | Link to the app's reviews page in the App Store. | `https://apps.apple.com/us/app/id835599320?see-all=reviews` |
| `app` | Nested app details (added when Add full app details is on). | `null` |

#### Developer replies table

Reviews that the developer answered are also saved to a separate Developer replies table. Use it as an Apple App Store review extractor when you want the replies on their own, without filtering the main table.

| Field | Description | Example |
|---|---|---|
| `reviewId` | ID of the review that was answered. | `14645265928` |
| `appId` | Numeric App Store ID. | `835599320` |
| `appName` | Name of the app. | `TikTok - Videos, Shop & LIVE` |
| `country` | Storefront code in capitals. | `US` |
| `score` | Star rating of the review. | `1` |
| `reviewTitle` | Title of the review. | `Important` |
| `reviewText` | Text of the review. | `Text` |
| `reviewDate` | When the review was written. | `2026-10-09T03:14:23-07:00` |
| `userName` | Reviewer display name. | `Name` |
| `replyId` | ID of the developer reply. | `123` |
| `replyText` | Text of the developer reply. | `Thanks for your feedback.` |
| `replyDate` | When the developer replied. | `2026-10-10T11:00:00-07:00` |
| `responseTimeHours` | Hours between the review and the reply. | `32.5` |
| `reviewUrl` | Link to the review. | `https://itunes.apple.com/us/review?id=835599320&type=Purple%20Software` |

#### App summary table

When Save app summary is on, one summary row is saved per app and country.

| Field | Description | Example |
|---|---|---|
| `appId` | Numeric App Store ID. | `835599320` |
| `appName` | Name of the app. | `TikTok - Videos, Shop & LIVE` |
| `country` | Storefront code in capitals. | `US` |
| `reviews` | Reviews saved for this app and country in this run. | `10` |
| `averageScore` | Average star rating of the saved reviews. | `2.9` |
| `scoreDistribution` | Count of saved reviews per star rating 1 to 5. | `{"1": 4, "2": 1, "3": 1, "4": 1, "5": 3}` |
| `developerResponseRate` | Share of saved reviews the developer answered (0 to 1). | `0.7` |
| `medianResponseTimeHours` | Median hours until the developer replied. | `32.5` |
| `editedReviews` | How many saved reviews were edited. | `1` |
| `oldestReview` | Date of the oldest saved review. | `2026-10-05T19:01:01-07:00` |
| `newestReview` | Date of the newest saved review. | `2026-10-09T03:14:23-07:00` |
| `app` | App name, developer, rating, version, price and genres. | `null` |

### Why pick this App Store reviews tool?

Many apps and countries fit in one run, which makes the Actor a practical App Store reviews extractor for agencies and product teams. Reviews reach the dataset while the run is still going, so it doubles as an App Store review downloader for long jobs.

Schedule the Actor with Apify schedules and it behaves like an App Store review exporter that runs without you. You do not need to build an App Store review crawler or maintain servers, because the input form and the **Start** button are enough.

Setup is limited to an Apify account, since this App Store review scraping tool asks for no Apple login or API key. It is not a generic App Store web scraper that you configure page by page, because the form only asks for apps, countries and filters.

### Use cases for App Store review data

- **Sentiment research:** feed `text` and `score` into App Store review sentiment analysis to see which themes drive low ratings.
- **Trend analysis:** run an App Store review analysis over time using `date` and `score`.
- **Release checks:** group iOS app reviews by `version` to spot a release that changed ratings, when Apple provides the version.
- **Competitor benchmarking:** collect App Store reviews for competitor analysis by running rival apps beside your own and comparing the summary table.
- **Support triage:** filter App Store reviews by rating to send one- and two-star complaints to your support team.
- **Reply audits:** study developer replies to App Store reviews, including `responseTimeHours`, to see how fast and how often a team answers.
- **Regional insight:** compare App Store reviews by country to see how ratings and complaints differ between markets.
- **Research data:** build an App Store reviews dataset for language experiments or academic projects.
- **Ongoing watch:** set up App Store review monitoring with a schedule and the Only new reviews since last run option.

### How to scrape App Store reviews

1. Create a free Apify account and open Apple App Store Review Scraper in the Apify Store.
2. Paste one or more app links into **App Store URLs**, or add numeric IDs under **App Store IDs**, or type app names under **Find apps by name**.
3. Pick the **App Store countries** to read, or choose All storefronts.
4. Set **Max reviews** and any filters such as stars, dates, keywords or developer reply.
5. Click **Start** and wait while the Apple app reviews scraper collects your reviews.
6. Open the **Output** tab or the **Storage** tab and download the dataset.

#### How to export App Store reviews

Open the finished run, choose the dataset and pick a download format such as JSON, CSV or Excel. To export App Store reviews to CSV without the dataset menu, switch on **Also save a CSV file**, and the run saves a flattened `reviews.csv` file in its key-value store.

#### How to download App Store reviews

Set **Max reviews** to the number you need and start the run. To download all App Store reviews that are available for an app, set **Max reviews** to 0, which means the full available history. Free plan runs stop at 10 reviews.

#### How to read App Store reviews in bulk

Add several app links or app names to one run and select the countries you want. The Actor reads every app and country pair as its own job and writes all rows to one dataset, with `country` and `appId` on each row.

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

Apple App Store Review Scraper uses tiered pay-per-event pricing: $1 per 1,000 results on the Free plan, and less on paid plans. Each saved review is one result, billed as the `main_result` event that the Console shows as Results.

| Apify plan | Price per 1,000 results |
|---|---|
| Free | $1 |
| Bronze | $0.9 |
| Silver | $0.8 |
| Gold / Platinum / Diamond | $0.7 |

A small Actor Start event of $0.00005 is also charged for each run start. On the Free plan, a run that saves 1,000 reviews therefore costs $1 for the results plus the start event.

The free plan saves up to 10 reviews per run, and paid Apify plans have no limit on reviews per run. If you set a maximum spend for a run, the Actor stops cleanly when that limit is reached. See the **Pricing** tab for current rates.

### Input

The only required field is **App Store URLs** (`startUrls`). Everything else is optional.

![Apple App Store Review Scraper input form with App Store URLs and filters](IMAGE_URL_PLACEHOLDER "apple-app-store-review-scraper-input-form.png")

See the **Input** tab for every option. This is an example input using the prefilled and default values from the input form:

```json
{
  "startUrls": ["https://apps.apple.com/us/app/tiktok-videos-shop-live/id835599320"],
  "countries": ["us"],
  "sort": "recent",
  "maxItems": 10
}
```

#### Main input options

| Input | What it does | Default |
|---|---|---|
| `startUrls` | App Store app links. The country in a link is used when no storefront is chosen. | Required, prefilled with one link |
| `appIds` | Optional numeric App Store IDs added to the same run. | Empty |
| `searchTerms` | Optional app names to look up. The top matches are added to the apps to scrape. | Empty |
| `searchResultsPerTerm` | How many matching apps to take for each name (1 to 20). | `3` |
| `countries` | Storefront codes, or `all` for every storefront. Leave empty to use the country found in your links, otherwise United States. | `["us"]` |
| `sort` | Review order: `recent`, `helpful`, `favorable` or `critical`. Monitoring runs always use newest first. | `recent` |
| `maxItems` | Maximum reviews saved in one run across all apps and countries. 0 means the full available history. | `10` |
| `sinceDate`, `untilDate` | Keep reviews on or after, or on or before, a date. Use YYYY-MM-DD or a relative value such as 30 days. | None |
| `minRating`, `maxRating` | Keep reviews with at least or at most this many stars (1 to 5). | None |
| `keywords` | Keep reviews whose title or text contains at least one of these whole words or phrases. | Empty |
| `developerResponse` | Keep every review (`any`), only answered reviews (`with`) or only unanswered reviews (`without`). | `any` |
| `editedOnly` | Keep only reviews that the reviewer edited after posting. | `false` |
| `incremental` | Monitoring mode: return only reviews newer than the previous run for each app and country. | `false` |
| `includeVotes` | Switch on to collect App Store reviews with helpful votes and total votes in every row. | `true` |
| `includeDeveloperResponse` | Add the developer reply and the reply time in hours to every row. Needed for the replies table and the reply rate. | `true` |
| `includeAppName`, `includeAppInfo`, `includeTextStats` | Add the app name, a nested app details object, or the word count to every row. | `true`, `false`, `true` |
| `writeSummary`, `exportCsv` | Save the app summary table and the SUMMARY file, or also save a `reviews.csv` file. | `true`, `false` |

The **Advanced** section has optional speed, depth and proxy settings. The defaults work for most runs.

### Output

The scraped results are shown as a dataset in the **Storage** tab. The table view is for convenience and doesn't show **all the fields**.

![App Store review dataset table with stars, review text and developer replies](IMAGE_URL_PLACEHOLDER "apple-app-store-review-dataset-output-table.png")

Every run produces an App Store review dataset with a **Reviews** view and a **Votes and replies** view, plus separate tables for developer replies and the app summary. Use the **Storage** tab for an App Store reviews export in JSON, CSV, Excel and other formats that Apify supports. The optional `SUMMARY` file and `reviews.csv` file are in the key-value store.

This is an example output for one review. The values are the field examples from the dataset schema, so they are illustrative and not a captured run.

```json
{
  "parentId": "14645265928",
  "id": "14645265928",
  "date": "2026-10-09T03:14:23-07:00",
  "userName": "Ahdheididh",
  "userUrl": "https://itunes.apple.com/us/reviews/id1874752662",
  "version": "47.1.0",
  "score": 5,
  "title": "Great app",
  "text": "Works perfectly for me.",
  "url": "https://itunes.apple.com/us/review?id=835599320&type=Purple%20Software",
  "country": "US",
  "appId": "835599320",
  "appName": "TikTok - Videos, Shop & LIVE",
  "isEdited": false,
  "developerResponse": null,
  "responseTimeHours": 32.5,
  "helpfulVotes": 3,
  "totalVotes": 4,
  "wordCount": 10,
  "reviewsPageUrl": "https://apps.apple.com/us/app/id835599320?see-all=reviews",
  "app": null
}
```

#### App summary output

This is an example summary row, built from the field examples in the app summary schema.

```json
{
  "appId": "835599320",
  "appName": "TikTok - Videos, Shop & LIVE",
  "country": "US",
  "reviews": 10,
  "averageScore": 2.9,
  "scoreDistribution": {"1": 4, "2": 1, "3": 1, "4": 1, "5": 3},
  "developerResponseRate": 0.7,
  "medianResponseTimeHours": 32.5,
  "editedReviews": 1,
  "oldestReview": "2026-10-05T19:01:01-07:00",
  "newestReview": "2026-10-09T03:14:23-07:00",
  "app": null
}
```

#### Developer replies output

This is an example row from the Developer replies table, built from the field examples in its schema.

```json
{
  "reviewId": "14645265928",
  "appId": "835599320",
  "appName": "TikTok - Videos, Shop & LIVE",
  "country": "US",
  "score": 1,
  "reviewTitle": "Important",
  "reviewText": "Text",
  "reviewDate": "2026-10-09T03:14:23-07:00",
  "userName": "Name",
  "replyId": "123",
  "replyText": "Thanks for your feedback.",
  "replyDate": "2026-10-10T11:00:00-07:00",
  "responseTimeHours": 32.5,
  "reviewUrl": "https://itunes.apple.com/us/review?id=835599320&type=Purple%20Software"
}
```

### Limitations and error handling

- The Actor reads public App Store reviews only. It does not collect private data.
- The number of reviews depends on what Apple makes available for each app and country. Run a small test first, then raise **Max reviews**.
- The free plan saves up to 10 reviews per run.
- `version` stays empty when Apple does not provide the app version for a review.
- `developerResponse` and `responseTimeHours` are empty for reviews the developer has not answered.
- **Max reviews examined** (`maxScanned`, default 20000) stops reading an app and country after that many reviews were checked against your filters. Very strict filters can end a job early.
- The **Latest reviews only** review source option returns up to 500 reviews per app and country.
- Invalid links, IDs and storefront codes are skipped and written to the run log.
- The Actor does not write error rows to the dataset. Problems appear in the run log and the run status message.

| Message | What it means | What to do |
|---|---|---|
| Add at least one App Store URL, App ID or app name. | The run had no apps to read. | Fill in **App Store URLs**, **App Store IDs** or **Find apps by name**. |
| Invalid input: ... | A filter or date could not be used, for example a star rating outside 1 to 5, a lowest rating above the highest, or a start date after the end date. | Correct the input and start again. |
| No reviews matched - check the apps, countries and filters | The run finished without saving a review. | Loosen the filters or try another country. |
| Nothing could be collected - see the log | Every app and country job failed. | Open the run log and try again later. |
| Spend limit reached | Your maximum spend for the run was reached, so the run stopped cleanly. | Raise the spend limit if you need more reviews. |

### Integrating Apple App Store Review Scraper with other apps

Start runs, schedule them and read results through the Apify API. The **API** tab has ready-made JavaScript, Python and CLI snippets. Because every run is reachable over that API, it can serve as an Apple reviews API for dashboards and scripts.

Developers who search for an App Store scraper Python example can start the Actor with the Apify Python client and read the dataset items as JSON. Point a dashboard that expects an Apple store reviews API feed at the dataset items of the latest run.

Combine the Apify API with webhooks to build an App Store scraper API pipeline that stores new reviews automatically. Add a schedule and a webhook to export Apple App Store reviews to your own systems after each run. See the Apify documentation for [integrations](https://docs.apify.com/platform/integrations), [schedules](https://docs.apify.com/platform/schedules) and [webhooks](https://docs.apify.com/platform/integrations/webhooks).

### More Apify Actors by crawl_craft

These Actors cover other platforms and are not related to App Store data. They come from the same Apify account.

| Actor | What it extracts | When to use it |
|---|---|---|
| [TikTok Video Scraper](https://apify.com/crawl_craft/tiktok-video-scraper) | Captions, hashtags, views, likes, comments, shares, author and music data from TikTok video links. | When your data lives on TikTok. |
| [Telegram Scraper](https://apify.com/crawl_craft/telegram-scraper) | Messages, views, reactions, media, links and subscriber counts from public Telegram channels. | When you track public channels instead of app reviews. |
| [Google Job Scraper](https://apify.com/crawl_craft/google-job-scraper) | Job listings from Google Jobs with title, company, location, salary, posting date and apply links. | When you need job listings instead of app reviews. |

### Is it legal to scrape App Store reviews?

Apple App Store Review Scraper only collects reviews that people have published publicly in the App Store, and it does not collect private data such as email addresses or location. Results can still contain personal data such as reviewer display names, so collect it only with a legitimate reason, consider GDPR (Regulation (EU) 2016/679) and Apple's terms, and consult a lawyer if you are unsure. Apify's guides on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/) and [ethical web scraping](https://blog.apify.com/what-is-ethical-web-scraping-and-how-do-you-do-it/) are a good starting point.

### FAQ

#### How much does it cost to run Apple App Store Review Scraper?

It costs $1 per 1,000 results on the Free plan and less on paid plans (see the pricing table above), plus $0.00005 for each run start. The free plan saves up to 10 reviews per run.

#### Do I need an Apple account or API key?

No. The input form has no login or API key fields, so you only paste public App Store links, IDs or app names.

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

Set **Max reviews** to the number you need, or to 0 for the full available history. The real number depends on what Apple makes available for that app and country, and free plan runs stop at 10 reviews.

#### Can I get reviews from every country?

Yes. Choose All storefronts, or pick several countries. Each app and country pair is read as its own job, and every row carries a `country` value.

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

Switch on **Only new reviews since last run** and schedule the Actor. It remembers the newest review for each app and country and returns only newer reviews on the next run, always in newest-first order.

#### Can I use it as an Apple App Store reviews API?

Yes, in the sense that you can start runs and fetch dataset items as JSON over the Apify API. The Actor is not an official Apple service.

#### Can I scrape private data?

No. The Actor reads public reviews only and does not collect private data.

#### Do I need proxies?

Proxy settings are optional. Leave the default if you are unsure.

#### Do I need to write code?

No. Fill in the input form, press **Start** and download the dataset. Developers can also call the Actor through the Apify API.

### Your feedback

Found a bug or missing a feature? Open an issue in the **Issues** tab of this Actor. For custom solutions, email hello.crawlcraft@gmail.com.

# Actor input Schema

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

Paste one or more App Store app links (for example https://apps.apple.com/us/app/tiktok-videos-shop-live/id835599320). Bulk input is supported. The country in a link is used when no storefront is chosen below.

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

Optional extra numeric App Store IDs (the digits after id in an app link, for example 835599320). Added to the links above.

## `searchTerms` (type: `array`):

Optional app names to look up, for example habit tracker. The top matches are added to the apps to scrape.

## `searchResultsPerTerm` (type: `integer`):

How many matching apps to take for each name above.

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

Storefronts to read reviews from. Pick several, or pick All storefronts for every country. Leave empty to use the country found in your links, otherwise United States.

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

Newest first is the default. Monitoring runs always use newest first.

## `maxItems` (type: `integer`):

Maximum number of reviews saved in one run across all apps and countries. 0 means the full available history. Free plan users are limited to 10 reviews per run; paid plans have no limit.

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

Keep only reviews on or after this date. Use YYYY-MM-DD or a relative value such as 30 days.

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

Keep only reviews on or before this date. Use YYYY-MM-DD or a relative value such as 7 days.

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

Keep reviews with at least this many stars (1 to 5). Leave empty for no lower limit.

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

Keep reviews with at most this many stars (1 to 5). Leave empty for no upper limit.

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

Keep only reviews whose title or text contains at least one of these whole words or phrases.

## `developerResponse` (type: `string`):

Choose whether to keep every review, only reviews the developer answered, or only unanswered reviews.

## `editedOnly` (type: `boolean`):

Keep only reviews that the reviewer edited after posting.

## `incremental` (type: `boolean`):

Monitoring mode: remember the newest review per app and country and return only newer reviews on the next run. Uses newest-first order.

## `includeAppName` (type: `boolean`):

Add the app name to every review row.

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

Add a nested app object to every review with rating, rating histogram, version, bundle ID, price and genres.

## `includeDeveloperResponse` (type: `boolean`):

Add the developer reply and the reply time in hours to every review row. Needed for the Developer replies table and the reply rate in the app summary.

## `includeVotes` (type: `boolean`):

Add helpful and total vote counts to every review row.

## `includeTextStats` (type: `boolean`):

Add the word count of the review text to every review row.

## `writeSummary` (type: `boolean`):

Save one summary row per app and country (average score, score distribution, reply rate) in its own table and as the SUMMARY file.

## `exportCsv` (type: `boolean`):

Save the reviews as a flattened reviews.csv file in the key-value store at the end of the run.

## `source` (type: `string`):

Leave on Automatic for the best result in each country. The other choices limit the run to one kind of review data.

## `enrichFromRss` (type: `boolean`):

Add the app version, reviewer link and vote counts to the newest reviews when available.

## `maxScanned` (type: `integer`):

Stop reading an app and country after this many reviews have been checked against your filters. 0 means no limit.

## `requestsPerSecond` (type: `number`):

Overall speed of the run, shared by all parallel jobs. Lower it for a gentler run.

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

How many app and country combinations are read at the same time.

## `maxRetries` (type: `integer`):

How many times the run tries again after a failed attempt. 0 means no retries.

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

Proxy settings are optional. Leave the default if you are unsure.

## Actor input object example

```json
{
  "startUrls": [
    "https://apps.apple.com/us/app/tiktok-videos-shop-live/id835599320"
  ],
  "appIds": [],
  "searchTerms": [],
  "searchResultsPerTerm": 3,
  "countries": [
    "us"
  ],
  "sort": "recent",
  "maxItems": 10,
  "keywords": [],
  "developerResponse": "any",
  "editedOnly": false,
  "incremental": false,
  "includeAppName": true,
  "includeAppInfo": false,
  "includeDeveloperResponse": true,
  "includeVotes": true,
  "includeTextStats": true,
  "writeSummary": true,
  "exportCsv": false,
  "source": "auto",
  "enrichFromRss": true,
  "maxScanned": 20000,
  "requestsPerSecond": 3,
  "concurrency": 4,
  "maxRetries": 3,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

One row per App Store review.

## `engagement` (type: `string`):

Reviews with helpful votes, word count and the developer reply.

## `developerReplies` (type: `string`):

Only reviews that the developer answered, with the reply text and reply time.

## `appSummary` (type: `string`):

One row per app and country: average stars, star distribution, reply rate and more.

## `summaryFile` (type: `string`):

SUMMARY file with the per app and country roll-up.

## `csvFile` (type: `string`):

reviews.csv when CSV export is on.

# 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 = {
    "startUrls": [
        "https://apps.apple.com/us/app/tiktok-videos-shop-live/id835599320"
    ],
    "appIds": [],
    "searchTerms": [],
    "keywords": [],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawl_craft/apple-app-store-review-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 = {
    "startUrls": ["https://apps.apple.com/us/app/tiktok-videos-shop-live/id835599320"],
    "appIds": [],
    "searchTerms": [],
    "keywords": [],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("crawl_craft/apple-app-store-review-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 '{
  "startUrls": [
    "https://apps.apple.com/us/app/tiktok-videos-shop-live/id835599320"
  ],
  "appIds": [],
  "searchTerms": [],
  "keywords": [],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call crawl_craft/apple-app-store-review-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,crawl_craft/apple-app-store-review-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/vIbE9ZNwgPAzahMUr/builds/gLHUynAJfDPXxet4U/openapi.json