# Fast App Store Reviews Scraper API | iOS Reviews & Ratings (`theagents/appstore-reviews`) Actor

Lightning-fast App Store review scraper that fetches up to 200 reviews per second across multiple countries. Extract valuable user feedback via App IDs or URLs, with custom mapping options. Affordable at $0.1 per 1000 reviews. Perfect for developers, marketers, and researchers.

- **URL**: https://apify.com/theagents/appstore-reviews.md
- **Developed by:** [Agents](https://apify.com/theagents) (community)
- **Categories:** Developer tools, Lead generation, Other
- **Stats:** 729 total users, 57 monthly users, 99.8% runs succeeded, 22 bookmarks
- **User rating**: 3.53 out of 5 stars

## Pricing

$0.10 / 1,000 reviews

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Fast Apple App Store Reviews Scraper API: Extract iOS App Reviews, Ratings & User Feedback at Scale

The **App Store Reviews Scraper** is an Apify Actor that extracts user reviews, star ratings, review titles, reviewer profiles, and app version data from any Apple App Store listing. This **app store review scraper api** collects 11 structured fields per review at speeds up to **200 reviews per second**—across any country or all countries simultaneously.

**$0.10 per 1,000 reviews.** Extract iOS app reviews from the Apple App Store at scale with no API key, no developer account, and no complex authentication. Target specific apps by ID or URL, filter by country, and retrieve reviews with date filtering using the `until` parameter for continuous monitoring.

Use this **apple app store review extractor** for app sentiment analysis, user feedback monitoring, competitive benchmarking, or NLP training data. **Download App Store reviews** to JSON, CSV, or Excel for product analytics, feature prioritization, and app store optimization (ASO).

> **Note:** Due to Apple's API limitations, you can retrieve a maximum of **500 reviews per country**. Set `country` to `all` to collect reviews across every App Store locale.

**Pricing:** $0.10 per 1,000 reviews | **No API key required** | **Up to 200 reviews/second**

***

### Table of Contents

1. [What Does the App Store Reviews Scraper Do?](#what-does-the-app-store-reviews-scraper-do)
2. [Features and Capabilities](#features-and-capabilities)
3. [Pricing](#pricing)
4. [Input Parameters](#input-parameters)
5. [Output Format and Data Fields](#output-format-and-data-fields)
6. [Custom Map Function](#custom-map-function)
7. [AI Agent Integration via MCP](#ai-agent-integration-via-mcp)
8. [Related Tools](#related-tools)
9. [Demo Mode and Free Testing](#demo-mode-and-free-testing)
10. [Automated Scheduling and Monitoring](#automated-scheduling-and-monitoring)
11. [Quick Start Guide](#quick-start-guide)
12. [Use Cases and Industries](#use-cases-and-industries)
13. [Troubleshooting](#troubleshooting)
14. [Frequently Asked Questions](#frequently-asked-questions)
15. [Contact](#contact)

***

### What Does the App Store Reviews Scraper Do?

**App Store review extraction** is the automated process of collecting user reviews, ratings, feedback text, and metadata from iOS app listings on the Apple App Store. The App Store hosts over 1.8 million apps with millions of user reviews—making it a critical source of structured user feedback for iOS and macOS applications.

The **Agents App Store Reviews Scraper** is a high-performance data extraction tool built to scrape App Store reviews from any app listing at scale. Extract structured review data at up to **200 reviews per second**—without needing an Apple Developer account, App Store Connect access, or complex authentication flows.

This tool delivers comprehensive review data at **$0.10 per 1,000 reviews**, including review titles, user profiles, app version data, and country-specific feedback that's essential for global app intelligence.

#### What You Get From Every Review

When you extract App Store reviews, you receive:

**Review Content and Rating**

- Full review text and review title
- Star rating (1–5)
- Publication date (ISO 8601)
- Direct review URL on iTunes

**App and Version Context**

- App ID (numeric App Store identifier)
- App version at time of review
- Country code of the App Store locale

**Reviewer Profile**

- Reviewer username
- Reviewer profile URL on iTunes

***

### Features and Capabilities

#### Input Flexibility

| Input Type     | Example                                               | Best For                               |
| -------------- | ----------------------------------------------------- | -------------------------------------- |
| **App ID**     | `389801252`                                           | Targeting specific apps by numeric ID  |
| **Direct URL** | `https://apps.apple.com/us/app/instagram/id389801252` | Scraping from an App Store listing URL |

#### Core Features

- **High-Speed Extraction** — Up to 200 reviews per second
- **Global Coverage** — Extract reviews from any country or all countries simultaneously
- **Date Filtering** — Use `until` parameter to extract only reviews newer than a specific date
- **Review Titles** — Capture both title and body text (unique to App Store reviews)
- **App Version Tracking** — See which version each reviewer was using
- **Reviewer Profiles** — Username and iTunes profile URL for each reviewer
- **Multiple Export Formats** — JSON, CSV, Excel direct download
- **Custom Transformations** — Reshape output with custom JavaScript map functions
- **API Integration** — RESTful API for Python, Node.js, or any HTTP client
- **Scheduled Runs** — Automate recurring extraction for continuous monitoring
- **Multi-Country Support** — Set country to `all` to fetch reviews from every App Store locale

> **Apple API Limitation:** Maximum 500 reviews per country per app. To maximize coverage, use `country: "all"` to collect up to 500 reviews from each country.

***

### Pricing

#### Simple Per-Review Pricing

No subscriptions, no hidden fees. This **app store reviews scraper** uses straightforward per-review pricing:

| Metric                | Price   |
| --------------------- | ------- |
| **Per 1,000 reviews** | $0.10   |
| **Per review**        | $0.0001 |

> **Example:** Extracting 500 reviews from 10 countries (5,000 reviews total) costs **$0.50**. Extracting reviews from all available countries for a popular app costs under **$5.00**.

**Free users:** Limited to **5 runs per month**, each capped at **10 items**.

***

### Input Parameters

| Field               | Type   | Description                                                                                       | Default    |
| ------------------- | ------ | ------------------------------------------------------------------------------------------------- | ---------- |
| `appIds`            | array  | App IDs extracted from the App Store URL (exclude any trailing "id" part)                         | `[]`       |
| `country`           | string | Country code for the App Store locale. Set to `all` to fetch reviews from each country separately | `us`       |
| `startUrls`         | array  | Direct App Store review URLs—scraping begins immediately from these endpoints                     | `[]`       |
| `maxItems`          | number | Maximum number of reviews to output                                                               | `Infinity` |
| `until`             | string | Returns only reviews newer than this date                                                         | `null`     |
| `customMapFunction` | string | JavaScript function to transform each review object (transformation only, not filtering)          | `null`     |

#### Input Examples

**Single App — US Store:**

```json
{
    "appIds": ["389801252"],
    "country": "us",
    "maxItems": 500
}
```

**Multiple Apps — Competitive Comparison:**

```json
{
    "appIds": ["389801252", "686449807", "835599320"],
    "country": "us",
    "maxItems": 500
}
```

**Global Coverage — All Countries:**

```json
{
    "appIds": ["389801252"],
    "country": "all",
    "maxItems": 500
}
```

**Date-Filtered — Recent Reviews Only:**

```json
{
    "appIds": ["389801252"],
    "country": "us",
    "until": "2025-01-01",
    "maxItems": 500
}
```

***

### Output Format and Data Fields

Each extracted review is a structured JSON object containing 11 fields. Here is a sample:

```json
{
  "id": "12260365349",
  "date": "2025-02-01T22:53:54-07:00",
  "userName": "Fox3782",
  "userUrl": "https://itunes.apple.com/gb/reviews/id566053959",
  "version": "365.0.0",
  "score": 1,
  "title": "Filters",
  "text": "INSTAGRAM WHERE ARE MY CUTE FILTERS?! Bring them back.",
  "url": "https://itunes.apple.com/gb/review?id=389801252&type=Purple%20Software",
  "country": "GB",
  "appId": "389801252"
}
```

#### Complete Field Reference

| Field      | Type   | Description                         |
| ---------- | ------ | ----------------------------------- |
| `id`       | string | Unique review identifier            |
| `date`     | string | ISO 8601 review publication date    |
| `userName` | string | Reviewer's display name             |
| `userUrl`  | string | Reviewer's iTunes profile URL       |
| `version`  | string | App version the reviewer was using  |
| `score`    | number | Star rating (1-5)                   |
| `title`    | string | Review title (headline)             |
| `text`     | string | Full review body text               |
| `url`      | string | Direct link to the review on iTunes |
| `country`  | string | App Store country code              |
| `appId`    | string | Numeric App Store application ID    |

#### Data Fields by Use Case

| Use Case                         | Key Fields                                     |
| -------------------------------- | ---------------------------------------------- |
| **Sentiment Analysis**           | `text`, `title`, `score`, `date`, `country`    |
| **App Store Optimization (ASO)** | `score`, `text`, `title`, `version`, `country` |
| **Competitive Benchmarking**     | `appId`, `score`, `text`, `title`, `date`      |
| **NLP Training Data**            | `text`, `title`, `score` (as label)            |
| **Release Impact Tracking**      | `version`, `score`, `text`, `date`             |
| **Global Market Research**       | `country`, `score`, `text`, `date`, `appId`    |

***

### Custom Map Function

Transform each review before it's saved to the dataset. The `customMapFunction` parameter accepts a JavaScript function that reshapes every review object. Use this to extract specific fields, rename properties, or compute derived values.

**Important:** The custom map function is for **transformation only**, not filtering. Every review will still be saved.

#### Example: Flatten for Sentiment Analysis

```javascript
(review) => ({
    app: review.appId,
    rating: review.score,
    headline: review.title,
    body: review.text,
    date: review.date,
    version: review.version,
    country: review.country
})
```

#### Example: Extract for Cross-Platform Comparison

```javascript
(review) => ({
    platform: "App Store",
    appId: review.appId,
    rating: review.score,
    text: review.text,
    date: review.date,
    country: review.country,
    reviewer: review.userName
})
```

***

### AI Agent Integration via MCP

Apify provides a hosted **Model Context Protocol (MCP) server** at `mcp.apify.com` that allows AI agents and LLM-based applications to discover and run Apify Actors as tools—including this App Store Reviews Scraper.

#### What This Means

If you're building AI agents using Claude Desktop, VS Code with MCP support, or any framework that implements the MCP specification, you can give your agent the ability to extract App Store reviews autonomously. The agent can call this scraper as a tool, receive structured JSON results, and use them in downstream analysis.

#### How to Connect

Add this scraper to your MCP client configuration:

```
https://mcp.apify.com?tools=agents/appstore-reviews
```

Or use the CLI for local development:

```bash
npx @apify/actors-mcp-server --tools agents/appstore-reviews
```

#### Use Cases for AI Agent Integration

- **Automated app monitoring** — An AI agent periodically extracts new reviews and summarizes sentiment trends, flagging negative spikes for product teams.
- **Cross-platform analysis** — Combine App Store reviews with [Google Play Reviews](https://apify.com/theagents/googleplay-reviews?fpr=yhdrb) in a single agent workflow for unified iOS + Android sentiment reporting.
- **Multi-step research pipelines** — Extract reviews, run sentiment classification, and generate actionable product recommendations within one agent session.

For full setup instructions, see the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp).

***

### Related Tools

#### Agents Data Intelligence Suite

All tools below are built and maintained by [Agents](https://apify.com/theagents?fpr=yhdrb)—a team of ex-Big Tech engineers, former ad agency strategists, and data specialists delivering intelligence, precision, and impact at scale.

| Tool                                                                                        | What It Extracts                                                 | Best For                                |
| ------------------------------------------------------------------------------------------- | ---------------------------------------------------------------- | --------------------------------------- |
| **App Store Reviews Scraper**                                                               | iOS app reviews, ratings, titles, reviewer profiles              | iOS app intelligence **(You are here)** |
| **[Google Play Reviews Scraper](https://apify.com/theagents/googleplay-reviews?fpr=yhdrb)**    | Android app reviews, ratings, developer replies, feature ratings | Android app intelligence                |
| **[Google Maps Reviews Scraper](https://apify.com/theagents/google-maps-reviews?fpr=yhdrb)**   | Business reviews, ratings, reviewer profiles, location data      | Local business intelligence             |
| **[Google Maps Search Scraper](https://apify.com/theagents/google-maps-search?fpr=yhdrb)**     | Business listings, contact, ratings, hours                       | Lead generation, directories            |
| **[Google Maps Business Scraper](https://apify.com/theagents/google-maps-business?fpr=yhdrb)** | Full business profiles, attributes, review distribution          | Deep profiling, due diligence           |
| **[Trustpilot Reviews Scraper](https://apify.com/theagents/trustpilot-reviews?fpr=yhdrb)**     | Reviews, TrustScores, company replies                            | SaaS/B2B analysis                       |
| **[Yelp Reviews Scraper](https://apify.com/theagents/yelp-reviews?fpr=yhdrb)**                 | Reviews, ratings, reviewer profiles                              | Restaurant/hospitality                  |
| **[Yelp Business Scraper](https://apify.com/theagents/yelp-business?fpr=yhdrb)**               | Business profiles, ratings, contact                              | Business data, prospecting              |
| **[TripAdvisor Reviews Scraper](https://apify.com/theagents/tripadvisor-reviews?fpr=yhdrb)**   | Hotel/restaurant reviews, ratings                                | Hospitality intelligence                |

#### App Store Reviews vs. Google Play Reviews

| Feature                         | App Store (This Tool)    | Google Play                       |
| ------------------------------- | ------------------------ | --------------------------------- |
| **Platform**                    | iOS / macOS              | Android                           |
| **Review titles**               | Yes                      | No (title field often null)       |
| **Developer replies**           | No                       | Yes (`replyText`, `replyDate`)    |
| **Feature ratings (criterias)** | No                       | Yes (per-feature quality ratings) |
| **Max reviews per country**     | 500 (Apple limitation)   | No hard limit                     |
| **Speed**                       | Up to 200 reviews/second | High-speed                        |
| **Multi-country**               | `country: "all"`         | `country` parameter               |

***

### Demo Mode and Free Testing

You can test this **app store reviews scraper** on Apify's Free plan in Demo Mode. **Free users can run the actor up to 5 times per month**, with each run capped at a maximum of 10 items — just enough to test it out. Free users also cannot use the actor via API. Validate the output format, data quality, and field coverage before scaling.

**How to Test:**

- Run the scraper with a small `maxItems` value (e.g., 10-50 reviews)
- Verify the output structure matches your pipeline requirements
- Confirm country filtering works for your target market
- Test the `customMapFunction` with a sample transformation

***

### Automated Scheduling and Monitoring

App reviews appear continuously. For **product teams** and **reputation managers**, set up automated recurring runs to capture new reviews as they're posted.

#### Why Schedule Review Extraction?

- **Release monitoring** — Track user sentiment after each app update by filtering with `until`
- **Continuous feedback loop** — Feed fresh reviews into product analytics dashboards
- **Competitor tracking** — Monitor competitor iOS app reviews weekly for feature gaps
- **Rating trend analysis** — Detect rating drops before they impact App Store ranking
- **Agency reporting** — Automated data for client app performance dashboards

#### How to Set Up Scheduled Runs

1. Open the Actor in Apify Console
2. Configure your input parameters (appIds, country, until)
3. Click **Schedule** and set frequency (daily, weekly, after each release)
4. Optionally add a **webhook** to push new data to your pipeline

#### Webhook Integration

Combine scheduled runs with webhooks to build fully automated review monitoring:

```
Scheduled Run -> New Reviews Extracted -> Webhook fires -> Your system receives data
```

Use webhooks to trigger:

- Slack alerts for 1-star reviews mentioning crashes or bugs
- Database updates with new review data
- Dashboard refreshes with latest sentiment metrics
- Jira ticket creation for critical user-reported issues

***

### Quick Start Guide

#### For Non-Technical Users (Apify Console)

1. Go to **[App Store Reviews Scraper](https://apify.com/theagents/appstore-reviews?fpr=yhdrb)** on Apify
2. Click **Try for free**
3. Enter an App ID (e.g., `389801252` for Instagram) in the `appIds` field
4. Set `country` and `maxItems`
5. Click **Start** and wait for results
6. **Export App Store reviews to CSV** from the Storage tab

#### For Developers (Python API)

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_TOKEN")
run = client.actor("agents/appstore-reviews").call(run_input={
    "appIds": ["389801252"],
    "country": "us",
    "maxItems": 500
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
```

#### For Product Teams (Release Monitoring)

```json
{
    "appIds": ["YOUR_APP_ID"],
    "country": "us",
    "until": "2025-03-01",
    "maxItems": 500
}
```

> Schedule after each release. Use the `until` parameter set to the release date to capture only post-update feedback. Compare sentiment before and after to measure release impact.

#### For Cross-Platform Analysis (iOS + Android)

Run this scraper for App Store reviews, then run the [Google Play Reviews Scraper](https://apify.com/theagents/googleplay-reviews?fpr=yhdrb) for the same app on Android. Use matching `customMapFunction` outputs to normalize fields across platforms:

```javascript
// Use this customMapFunction on both scrapers for unified output
(review) => ({
    platform: "App Store",
    rating: review.score,
    text: review.text || review.title,
    date: review.date,
    country: review.country,
    appId: review.appId
})
```

***

### Use Cases and Industries

#### iOS App Sentiment Analysis and NLP

Extract hundreds of App Store reviews with full text, titles, and star ratings for training sentiment classifiers, topic modeling, or aspect-based sentiment analysis. App Store reviews uniquely include **review titles** (headlines) that often summarize the user's core sentiment—providing a natural short-text label for NLP training alongside the full review body.

**Key fields:** `text`, `title`, `score`, `date`, `version`, `country`

#### App Store Optimization (ASO)

Analyze review content to identify keywords users associate with your app. Track how ratings change across versions and countries. Discover what features drive positive reviews and what pain points cause negative ones. Review titles are particularly valuable for ASO—they often contain the exact phrases users search for in the App Store.

**Key fields:** `score`, `text`, `title`, `version`, `country`

#### Cross-Platform App Intelligence

Compare user sentiment between iOS (App Store) and Android (Google Play) for the same app. Identify platform-specific issues, feature gaps, and satisfaction differences. Combine with the [Google Play Reviews Scraper](https://apify.com/theagents/googleplay-reviews?fpr=yhdrb) for unified cross-platform dashboards.

**Key fields:** `appId`, `score`, `text`, `date`, `country`

#### Product Management and Feature Prioritization

Feed review data into product analytics to identify the most-requested features and the most-reported bugs. Cross-reference with `version` to track whether fixes in new releases actually improved user satisfaction. Review titles provide quick-scan summaries of user priorities.

**Key fields:** `text`, `title`, `score`, `version`, `date`

#### Competitive Benchmarking

Extract reviews from competing apps in the same App Store category to compare user sentiment, feature gaps, and pain points. Run multi-app extractions in a single scraper run by providing multiple App IDs. Identify where competitors are weak and where they excel.

**Key fields:** `appId`, `score`, `text`, `title`, `date`

#### Global Market Research

Collect reviews from multiple App Store locales to understand how user sentiment varies by country. Cultural preferences, localization quality, and regional feature availability all affect reviews. Use `country: "all"` to build a comprehensive global dataset, then segment analysis by country code.

**Key fields:** `country`, `score`, `text`, `date`, `appId`

***

### Troubleshooting

#### Common Issues and Solutions

| Issue                           | Cause                                        | Solution                                                                                                 |
| ------------------------------- | -------------------------------------------- | -------------------------------------------------------------------------------------------------------- |
| **Only 500 reviews returned**   | Apple's API limit per country                | This is an Apple platform limitation—use `country: "all"` to collect up to 500 reviews from each country |
| **Fewer reviews than expected** | App has fewer reviews in target country      | Check the app's review count in the target App Store locale                                              |
| **Unexpected result quantity**  | `maxItems` set higher than available reviews | Adjust `maxItems` or check available reviews in the target country                                       |
| **Missing data in output**      | Results stored in Apify dataset              | Check the "Storage" section in your task results for the complete dataset                                |
| **Empty results**               | Invalid App ID format                        | Ensure you're using the numeric App ID (e.g., `389801252`), not the app name or bundle ID                |

#### Performance Tips

- **Start small:** Test with `maxItems: 50` to validate your setup before scaling
- **Use date filtering:** Set the `until` parameter to avoid re-extracting old reviews on scheduled runs
- **Maximize coverage:** Set `country: "all"` to collect reviews from every App Store locale (up to 500 per country)
- **Multiple apps in one run:** Provide multiple App IDs in the `appIds` array for competitive analysis
- **Monitor billing:** You are billed per review extracted, not per `maxItems` setting—if fewer reviews exist, you pay only for what's delivered

***

### Frequently Asked Questions

#### What App Store review data can I extract?

Extract **review text**, **review titles** (headlines), **star ratings (1-5)**, **review dates**, **reviewer usernames**, **reviewer profile URLs**, **app version at review time**, **country codes**, **App Store IDs**, and **direct review URLs**—all in structured JSON or CSV format.

#### Can I export App Store reviews to CSV?

Yes. **Download App Store reviews** directly from Apify Console in JSON, CSV, or Excel format. This is ideal for spreadsheet analysis, database import, and product analytics dashboards.

#### Can I scrape reviews from multiple apps at once?

Yes. Provide multiple App IDs in the `appIds` array (e.g., `["389801252", "686449807"]`). Each app's reviews are extracted within a single Actor run, with the `appId` field identifying which app each review belongs to.

#### Can I filter reviews by date?

Yes. Use the `until` parameter to extract only reviews newer than a specific date. This is ideal for continuous monitoring—on each scheduled run, set `until` to the date of your last extraction to avoid duplicates.

#### Can I scrape reviews from all countries?

Yes. Set the `country` parameter to `all` to fetch reviews from every App Store locale separately. Due to Apple's API limitations, each country returns a maximum of 500 reviews. This is the best way to maximize review coverage for popular apps.

#### Why is there a 500-review limit per country?

This is an **Apple platform limitation**, not a scraper limitation. Apple's public API returns a maximum of 500 reviews per country per app. To maximize your dataset, use `country: "all"` to collect up to 500 reviews from each available App Store locale.

#### Does this extract developer replies?

No. Unlike Google Play, the Apple App Store public API does not expose developer replies in review data. For app review data that includes developer responses, use the **[Google Play Reviews Scraper](https://apify.com/theagents/googleplay-reviews?fpr=yhdrb)**.

#### How is this different from the Google Play Reviews Scraper?

The **App Store Reviews Scraper** extracts iOS app reviews with review titles (headlines) and reviewer profile URLs. The **Google Play Reviews Scraper** extracts Android app reviews with developer replies, feature-specific quality ratings (criterias), and thumbs-up counts. Use both for cross-platform app intelligence. See the comparison table in [Related Tools](#related-tools).

#### Can I use Python to scrape App Store reviews?

Yes. Full Python support via the Apify Client library. See the [Quick Start Guide](#quick-start-guide) above for Python integration with `client.actor("agents/appstore-reviews")`.

#### Can AI agents use this scraper?

Yes. Through Apify's **Model Context Protocol (MCP) server**, AI agents built with Claude Desktop, VS Code, or any MCP-compatible framework can call this scraper as a tool. This enables automated app monitoring, cross-platform analysis, and multi-step research pipelines. See the [AI Agent Integration via MCP](#ai-agent-integration-via-mcp) section for setup details.

#### How fast is the extraction?

Up to **200 reviews per second**. Speed depends on the number of reviews available and Apple's response times, but this scraper is optimized for maximum throughput.

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

Due to Apple's API limitations, the maximum is **500 reviews per country** per app. To maximize coverage, set `country: "all"` to collect up to 500 reviews from each available App Store locale. For a popular app available in 40+ countries, this can yield 20,000+ reviews.

***

### Contact

**Built by [Agents](https://apify.com/theagents?fpr=yhdrb)** — Where others search, we uncover. Our team of ex-Big Tech engineers, growth hackers, and data specialists builds high-performance scraping tools engineered for speed, precision, and reliability.

For questions or further assistance:

- **Email:** Reach out at **whoaretheagents@gmail.com**
- **Discord:** Join our community to connect with our support team

***

**Ready to start extracting App Store review data?** At $0.10 per 1,000 reviews with up to 200 reviews/second and no API key required, this **App Store Reviews Scraper API** by [Agents](https://apify.com/theagents?fpr=yhdrb) is the definitive tool for **iOS app sentiment analysis**, **ASO research**, **competitive benchmarking**, and **cross-platform app intelligence**. Start scraping today.

# Actor input Schema

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

App Store IDs you want to retrieve the data from. They can be found at the end of the URL of the app in the App Store. It should be without `id`.

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

The App Store country that you would like to get the reviews from. If set to `all`, requests will be sent for each country separately.

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

URLs to start with. It should be an application URL

## `until` (type: `string`):

Returns reviews newer than this date.

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

Maximum number of items that you want as output.

## `customMapFunction` (type: `string`):

Function that takes each of the objects as argument and returns data that will be mapped by the function itself. This function is not intended for filtering, please don't use it for filtering purposes or you will get banned automatically.

## Actor input object example

```json
{
  "appIds": [
    "284882215",
    "408709785"
  ],
  "country": "us",
  "startUrls": [
    "https://apps.apple.com/gb/app/instagram/id389801252",
    "https://apps.apple.com/ca/app/tiktok/id835599320"
  ],
  "until": "2024-12-31",
  "maxItems": 1000,
  "customMapFunction": "(object) => { return {...object} }"
}
```

# Actor output Schema

## `overview` (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 = {
    "appIds": [
        "284882215",
        "408709785"
    ],
    "startUrls": [
        "https://apps.apple.com/gb/app/instagram/id389801252",
        "https://apps.apple.com/ca/app/tiktok/id835599320"
    ],
    "until": "2024-12-31",
    "maxItems": 1000,
    "customMapFunction": (object) => { return {...object} }
};

// Run the Actor and wait for it to finish
const run = await client.actor("theagents/appstore-reviews").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": [
        "284882215",
        "408709785",
    ],
    "startUrls": [
        "https://apps.apple.com/gb/app/instagram/id389801252",
        "https://apps.apple.com/ca/app/tiktok/id835599320",
    ],
    "until": "2024-12-31",
    "maxItems": 1000,
    "customMapFunction": "(object) => { return {...object} }",
}

# Run the Actor and wait for it to finish
run = client.actor("theagents/appstore-reviews").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 '{
  "appIds": [
    "284882215",
    "408709785"
  ],
  "startUrls": [
    "https://apps.apple.com/gb/app/instagram/id389801252",
    "https://apps.apple.com/ca/app/tiktok/id835599320"
  ],
  "until": "2024-12-31",
  "maxItems": 1000,
  "customMapFunction": "(object) => { return {...object} }"
}' |
apify call theagents/appstore-reviews --silent --output-dataset

```

## MCP server setup

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

```

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/cS9boBgQBnUglDSWX/builds/9u2I5KpURQfqQ0xsS/openapi.json