# Apple App Store Reviews API - Review Intelligence (`webdata_labs/apple-app-store-reviews-api`) Actor

\[💵 $2.50 / 1K] Export Apple App Store reviews with app metadata, rating distribution, complaint themes, version signals, and summary rows. Not just raw review text.

- **URL**: https://apify.com/webdata\_labs/apple-app-store-reviews-api.md
- **Developed by:** [WebData Labs](https://apify.com/webdata_labs) (community)
- **Categories:** Developer tools, Automation, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 review intelligence records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

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

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

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

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

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

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

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


# README

## Apple App Store Reviews API - Review Intelligence

**Export Apple App Store reviews with app metadata, rating distribution, complaint themes, version signals, and summary rows.**

This Actor is for teams that need **Apple App Store review data** as a clean API output, not a messy RSS dump. It uses Apple's public Search, Lookup, and Customer Reviews RSS endpoints, then adds light review intelligence so product, ASO, and competitor teams can see what users complain about.

### ✅ What you get / ❌ What this isn't

✅ Apple App Store reviews by app ID, App Store URL, or app name  
✅ Country-specific reviews from public Apple RSS feeds  
✅ Rating, title, body, author, version, update time, vote metadata  
✅ App metadata from Apple Lookup: seller, bundle ID, genre, current version, store URL  
✅ Summary rows with average rating, rating distribution, negative-review share, and top themes  
✅ Complaint themes for bugs, performance, login, pricing, ads, support, privacy, UX, feature requests, and update regressions  

❌ Not Google Play reviews  
❌ Not private user data or reviews behind an account  
❌ Not a full ASO suite  
❌ Not a guarantee that Apple exposes every historical review in every country  

### 🔎 Why use this Actor

- **Built for review intelligence** - every run returns both review rows and app summary rows.
- **Useful for competitor monitoring** - compare apps across countries and versions.
- **Cleaner than raw RSS** - normalized fields, app metadata, and theme tags are ready for CSV, dashboards, or downstream analysis.
- **Low-friction API path** - no browser, no login, and no heavy proxy setup for normal use.

### 📊 What data you get

| Field | Type | Description |
|---|---|---|
| `recordType` | string | `review`, `app_summary`, or `error` |
| `appId` | string | Apple numeric app ID |
| `appName` | string | App name from Apple Lookup |
| `country` | string | App Store country code |
| `rating` | integer | 1-5 star review rating |
| `sentiment` | string | `negative`, `mixed`, or `positive` |
| `title` | string | Review title |
| `reviewText` | string | Review body |
| `version` | string | App version attached to the review |
| `themes` | array | Detected complaint or praise themes |
| `averageRating` | number | Summary average across fetched reviews |
| `negativeReviewShare` | number | Share of fetched reviews rated 1 or 2 stars |
| `topThemes` | array | Most common theme tags for the app/country |

### 👥 Who it's for

- App founders watching early review pain.
- Product managers triaging complaints after a release.
- ASO and lifecycle teams comparing country-specific review language.
- Agencies monitoring competitor app reviews.
- Investors or operators doing fast app-market research.

### ⚙️ How to export Apple App Store reviews

1. Enter one or more Apple app IDs, App Store URLs, or app names.
2. Choose countries such as `us`, `gb`, or `ca`.
3. Set `maxReviewsPerApp` to control cost and output size.
4. Optionally filter to 1-2 star reviews for complaint mining.
5. Run the Actor and download the dataset as JSON, CSV, Excel, or via API.

### 📥 Input

```json
{
  "appIds": ["618783545"],
  "countries": ["us"],
  "sortBy": "mostrecent",
  "ratings": [1, 2, 3],
  "includePositiveReviews": false,
  "maxReviewsPerApp": 100
}
````

| Field | Type | Default | Description |
|---|---|---:|---|
| `appIds` | array | `["618783545"]` | Apple numeric app IDs |
| `appUrls` | array | none | App Store URLs containing `/id123456` |
| `appNames` | array | none | App names resolved through Apple Search |
| `countries` | array | `["us"]` | Country-specific App Store review feeds |
| `sortBy` | string | `mostrecent` | `mostrecent` or `mosthelpful` |
| `ratings` | array | all | Optional star-rating filter |
| `includePositiveReviews` | boolean | `true` | Set false for complaint-only rows |
| `maxReviewsPerApp` | integer | `100` | Max review rows per app/country |

### 📤 Output

```json
{
  "recordType": "review",
  "appId": "618783545",
  "appName": "Slack",
  "country": "us",
  "rating": 2,
  "sentiment": "negative",
  "title": "Broken after update",
  "reviewText": "The latest version crashes on login.",
  "version": "25.07.10",
  "themes": ["bugs_crashes", "login_account", "update_regression"],
  "source": "apple_rss_customer_reviews"
}
```

The dataset has three views:

| View | Description |
|---|---|
| Review rows | One row per normalized review |
| App summaries | One row per app/country with aggregate metrics |
| Errors | Lookup, search, or review-feed failures |

### 💵 How much does it cost?

The price is **$2.50 per 1,000 review intelligence records**. A 100-record run costs about **$0.25**, plus any platform usage shown before the run. Summary and error rows remain visible so you can audit coverage.

### 🔁 Run it on the Apify platform

Schedule review monitoring, call it from the API, send datasets to Make or Zapier, or trigger a webhook after each run.

### ⚠️ Limits and caveats

- Apple review RSS is country-specific, so US and UK reviews are different feeds.
- Apple may not expose every historical review through RSS.
- App-name search can match the wrong app. Use app IDs for production runs.
- Theme detection is deterministic keyword tagging, not a substitute for full LLM analysis.
- Use this Actor only for public review data and respect Apple's terms and applicable privacy rules.

### 🧩 Related Actors

- Website Contact Extractor
- Trustpilot Review Scraper
- TikTok Creative Center Ad Intelligence
- Lead List Deduplicator

### ❓ FAQ

#### Is this an Apple App Store reviews scraper?

Yes. It exports public Apple App Store customer reviews through Apple's public RSS endpoints and normalizes them into structured rows.

#### Does it scrape Google Play reviews?

No. This Actor is focused on Apple App Store reviews. Google Play uses a different data source and is not included.

#### Can I monitor competitor app reviews?

Yes. Add competitor app IDs, choose the countries you care about, and schedule recurring runs.

#### Why are reviews different by country?

Apple exposes App Store reviews per country storefront. A US review feed will not necessarily match the UK or Canadian feed.

### 🛠️ Support

Open an issue with the run URL, input JSON, and the app/country you expected to retrieve.

# Actor input Schema

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

Apple numeric app IDs. Example: Slack is 618783545. If app URLs are provided too, both lists are merged and deduplicated.

## `appUrls` (type: `array`):

Apple App Store app URLs. The Actor extracts the numeric id from URLs like https://apps.apple.com/us/app/slack/id618783545.

## `appNames` (type: `array`):

Optional app names to resolve through Apple's public Search API. Direct app IDs are more reliable.

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

Two-letter App Store country codes. Reviews are country-specific, so use the markets you care about.

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

Apple RSS review sort. Most recent is best for monitoring; most helpful is useful for complaint mining.

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

Optional star ratings to keep. Leave empty for all ratings. Use 1 and 2 for complaint mining.

## `includePositiveReviews` (type: `boolean`):

When false, keep only 1-3 star reviews in the review rows but still compute summary metrics from fetched reviews.

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

Maximum review rows to return for each app and country. Low default keeps trial runs fast and cheap.

## `maxSearchResults` (type: `integer`):

When using appNames, resolve up to this many apps per name and country.

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

Optional. Apple's public RSS/Search endpoints usually work without a proxy.

## Actor input object example

```json
{
  "appIds": [
    "618783545",
    "389801252"
  ],
  "appUrls": [
    "https://apps.apple.com/us/app/slack/id618783545"
  ],
  "appNames": [
    "Slack",
    "Shopify"
  ],
  "countries": [
    "us",
    "gb",
    "ca"
  ],
  "sortBy": "mostrecent",
  "ratings": [],
  "includePositiveReviews": true,
  "maxReviewsPerApp": 100,
  "maxSearchResults": 1,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

## `summaries` (type: `string`):

No description

## `errors` (type: `string`):

No description

## `output` (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": [
        "618783545"
    ],
    "countries": [
        "us"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("webdata_labs/apple-app-store-reviews-api").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": ["618783545"],
    "countries": ["us"],
}

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

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

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

```

## CLI example

```bash
echo '{
  "appIds": [
    "618783545"
  ],
  "countries": [
    "us"
  ]
}' |
apify call webdata_labs/apple-app-store-reviews-api --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Apple App Store Reviews API - Review Intelligence",
        "description": "[💵 $2.50 / 1K] Export Apple App Store reviews with app metadata, rating distribution, complaint themes, version signals, and summary rows. Not just raw review text.",
        "version": "0.1",
        "x-build-id": "0PRiQLhWoZDOcidYC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/webdata_labs~apple-app-store-reviews-api/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-webdata_labs-apple-app-store-reviews-api",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/webdata_labs~apple-app-store-reviews-api/runs": {
            "post": {
                "operationId": "runs-sync-webdata_labs-apple-app-store-reviews-api",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/webdata_labs~apple-app-store-reviews-api/run-sync": {
            "post": {
                "operationId": "run-sync-webdata_labs-apple-app-store-reviews-api",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "appIds": {
                        "title": "Apple app IDs",
                        "type": "array",
                        "description": "Apple numeric app IDs. Example: Slack is 618783545. If app URLs are provided too, both lists are merged and deduplicated.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "appUrls": {
                        "title": "App Store URLs",
                        "type": "array",
                        "description": "Apple App Store app URLs. The Actor extracts the numeric id from URLs like https://apps.apple.com/us/app/slack/id618783545.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "appNames": {
                        "title": "App names to search",
                        "type": "array",
                        "description": "Optional app names to resolve through Apple's public Search API. Direct app IDs are more reliable.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "countries": {
                        "title": "Countries",
                        "type": "array",
                        "description": "Two-letter App Store country codes. Reviews are country-specific, so use the markets you care about.",
                        "default": [
                            "us"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "sortBy": {
                        "title": "Review sort",
                        "enum": [
                            "mostrecent",
                            "mosthelpful"
                        ],
                        "type": "string",
                        "description": "Apple RSS review sort. Most recent is best for monitoring; most helpful is useful for complaint mining.",
                        "default": "mostrecent"
                    },
                    "ratings": {
                        "title": "Ratings filter",
                        "type": "array",
                        "description": "Optional star ratings to keep. Leave empty for all ratings. Use 1 and 2 for complaint mining.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3",
                                "4",
                                "5"
                            ],
                            "enumTitles": [
                                "1 star",
                                "2 stars",
                                "3 stars",
                                "4 stars",
                                "5 stars"
                            ]
                        },
                        "default": []
                    },
                    "includePositiveReviews": {
                        "title": "Include positive reviews",
                        "type": "boolean",
                        "description": "When false, keep only 1-3 star reviews in the review rows but still compute summary metrics from fetched reviews.",
                        "default": true
                    },
                    "maxReviewsPerApp": {
                        "title": "Max reviews per app/country",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum review rows to return for each app and country. Low default keeps trial runs fast and cheap.",
                        "default": 100
                    },
                    "maxSearchResults": {
                        "title": "Max app search results",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "When using appNames, resolve up to this many apps per name and country.",
                        "default": 1
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Optional. Apple's public RSS/Search endpoints usually work without a proxy.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
