# Apple App Store Scraper – Reviews, Keyword Ranks & Charts (`pinkish_armada/app-store-scraper`) Actor

Apple App Store data from Apple's official public endpoints: app details by URL, ID or bundle ID, customer reviews with new-review monitoring, keyword search rankings (ASO) and top charts in 150+ countries. No login or proxies; pay only for rows you get.

- **URL**: https://apify.com/pinkish_armada/app-store-scraper.md
- **Developed by:** [Phuc Tiet](https://apify.com/pinkish_armada) (community)
- **Categories:** Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 app with details

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

## Apple App Store Scraper – App Details, Reviews, Keyword Ranks & Top Charts

Get **Apple App Store data** as clean JSON, CSV or Excel: **app details** by URL, ID or bundle ID, **customer reviews** (with a monitor mode that returns only new reviews), **keyword search rankings** for ASO, and **top charts** (free, paid, grossing, new; iPhone, iPad, Mac) in any of the 150+ App Store countries.

Everything comes from **Apple's own public endpoints** (the iTunes Search/Lookup API and Apple's RSS feeds). No login, no proxies, no browser, so runs are fast and reliable, and you **only pay for rows you actually get**. Errors and apps that don't exist are free.

### What can I use it for?

- **App review monitoring:** get new 1–2 star reviews every morning in Slack, email or a Google Sheet (monitor mode + Apify Schedule).
- **ASO keyword rank tracking:** where does your app rank for "habit tracker" in the US, UK and Australia today?
- **Competitor tracking:** ratings, rating counts, prices, versions and release notes of competing apps, across countries.
- **Market research:** top free / paid / grossing charts per country and category, with full app details.
- **Sentiment analysis and AI:** feed review text into an LLM to find bugs, feature requests and churn reasons.
- **Lead lists of app developers:** developer name, seller website and app portfolio (company-level data).

### How much does it cost?

Pay per result, no monthly fee, no platform usage charges on top:

| Row | Price | Per 1,000 |
|---|---|---|
| App details | $0.001 | $1.00 |
| Keyword search result (with rank) | $0.0005 | $0.50 |
| Top-chart entry (with full details) | $0.0003 | $0.30 |
| Customer review | $0.0001 | $0.10 |

Plus a tiny run-start fee ($0.00005). Examples: daily new-review alerts for 5 apps cost a few cents a month; tracking 20 keywords × top 50 apps in 3 countries is $1.50 per check; the top 100 grossing apps in 10 countries is $0.30.

### Input

| Field | What it does |
|---|---|
| `apps` | App Store links (`https://apps.apple.com/us/app/notion/id1232780281`), numeric IDs (`1232780281`) or bundle IDs (`com.spotify.client`) |
| `searchTerms` | Keywords to search; each result has its `rank` |
| `charts` | `topFree`, `topPaid`, `topGrossing`, `topFreeIpad`, `topPaidIpad`, `topGrossingIpad`, `newApps`, `newFree`, `newPaid`, `topFreeMac` |
| `countries` | Two-letter country codes, default `["us"]`. Everything is fetched per country |
| `includeReviews` | Download customer reviews for each app (default off) |
| `maxReviewsPerApp` | Up to 500 per app, country and sort order (Apple's limit) |
| `reviewSort` | `mostRecent` or `mostHelpful` |
| `reviewsSince` | `2026-09-01` or `7 days` |
| `minRating` / `maxRating` | e.g. `maxRating: 2` for negative reviews only |
| `onlyNewReviews` | Monitor mode: return only reviews not returned before |
| `anonymizeReviewers` | Drop reviewer nicknames and profile links |
| `maxSearchResults`, `chartLimit`, `chartGenreId`, `chartDetails` | Search and chart options |

Example: negative US/UK reviews of two apps from the last week, plus a keyword rank check:

```json
{
  "apps": ["https://apps.apple.com/us/app/notion-notes-tasks-ai/id1232780281", "com.spotify.client"],
  "countries": ["us", "gb"],
  "includeReviews": true,
  "reviewsSince": "7 days",
  "maxRating": 2,
  "searchTerms": ["note taking app"],
  "maxSearchResults": 25
}
```

### Output

Every dataset row has a `type`: `app`, `review`, `searchResult`, `chartEntry` or `error`. The dataset has ready-made views (Apps, Reviews, Keyword ranks, Top charts, Errors) and a run summary is saved as `OUTPUT`.

App details (also included in search results and chart entries):

```json
{
  "type": "app", "appId": "1232780281", "bundleId": "notion.id", "name": "Notion: Notes, Tasks, AI",
  "country": "us", "developer": "Notion Labs, Incorporated", "price": 0, "currency": "USD",
  "rating": 4.78, "ratingCount": 90333, "version": "1.7.345", "currentVersionReleaseDate": "2026-10-07T16:42:39Z",
  "primaryGenre": "Productivity", "contentRating": "4+", "fileSizeBytes": 751456256,
  "releaseNotes": "...", "description": "...", "icon": "https://is1-ssl.mzstatic.com/...", "screenshots": ["..."]
}
```

Review:

```json
{
  "type": "review", "appId": "1232780281", "appName": "Notion: Notes, Tasks, AI", "country": "us",
  "reviewId": "14633493869", "rating": 1, "title": "...", "text": "...", "appVersion": "1.7.344",
  "date": "2026-10-06T00:46:08-07:00", "voteSum": 0, "voteCount": 0, "userName": "..."
}
```

Search results add `searchTerm` and `rank`; chart entries add `chart`, `rank`, `category` and `fetchedAt`.

### Monitoring new reviews on a schedule

1. Set `includeReviews: true`, `onlyNewReviews: true` (optionally `maxRating: 2`).
2. Create a **Schedule** in Apify Console (e.g. daily at 8:00).
3. Add an **integration** (Slack, email, webhook, Google Sheets, Make, Zapier, n8n) on "Run succeeded". Each run's dataset contains only reviews you haven't seen.

The first monitor run returns the current reviews and remembers them. Use a different `stateStoreName` per monitor. Turn off `includeAppDetails` if you only want the reviews.

### Use it from code or AI agents

```bash
curl -X POST "https://api.apify.com/v2/acts/pinkish_armada~app-store-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchTerms":["habit tracker"],"countries":["us"],"maxSearchResults":10}'
```

Works with the Apify JavaScript/Python clients, Make, Zapier, n8n, and as a tool in the **Apify MCP server** (`https://mcp.apify.com?tools=pinkish_armada/app-store-scraper`) for Claude, Cursor, ChatGPT and other MCP clients, so an agent can answer "what are users complaining about in this app this week?".

### FAQ

**Where does the data come from?** Only Apple's official public endpoints: the iTunes Search and Lookup APIs and Apple's customer-review and top-chart RSS feeds. No login, no scraping of private data, no anti-bot workarounds.

**How many reviews can I get?** Apple's public review feed gives up to 500 reviews per app, per country and per sort order. To get more, add countries or run both sort orders. For ongoing collection, use monitor mode on a schedule so nothing is missed.

**Does it work for Google Play?** No, Apple App Store only (iPhone, iPad and Mac apps).

**Why is an app "not found"?** It was removed, or isn't available in that country's store. You get a free `APP_NOT_FOUND` row.

**Is it legal?** The data is public and provided by Apple for these purposes. Reviews contain public nicknames: if you don't need them, enable `anonymizeReviewers`, and handle any personal data according to GDPR/CCPA. Respect Apple's terms; don't republish review text in bulk as your own content.

**What if Apple rate-limits?** The Actor paces its requests and retries automatically. If a request still fails you get a free error row, not a failed run.

### Related Actors

- **Website Tech Stack Detector**: find what an app developer's website is built with
- **Domain Lookup**: domain registration, DNS and email security for seller websites
- **RSS Feed Reader & Monitor**: track app developers' blogs and changelogs

### Support

Something missing or wrong? Open an issue on the **Issues** tab with your input. Fixes usually ship within a day.

# Actor input Schema

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

App Store links (https://apps.apple.com/us/app/notion/id1232780281), numeric app IDs (1232780281) or bundle IDs (com.spotify.client). Returns one app-details row per app and country.

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

Keywords to search in the App Store. Each result row includes its rank position for that keyword, which is how you track ASO keyword rankings over time.

## `charts` (type: `array`):

Charts to download (up to 100–200 apps each).

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

Two-letter App Store country codes (us, gb, au, de, jp...). Every app, keyword and chart is fetched for each country. Default: us.

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

Return one row per app with name, developer, price, rating, rating count, version, release notes, size, genres, description and screenshots. Turn off if you only want reviews.

## `includeReviews` (type: `boolean`):

Also download written customer reviews for each app (rating, title, text, app version, date, helpfulness votes).

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

Apple's public review feed returns up to 500 reviews per app, country and sort order. Add more countries to get more.

## `reviewSort` (type: `string`):

Most recent (best for monitoring) or most helpful first.

## `reviewsSince` (type: `string`):

Absolute date (2026-09-01) or relative period (24 hours, 7 days, 2 weeks). Leave empty for no date filter.

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

Only return reviews with at least this many stars (1–5).

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

Only return reviews with at most this many stars. Set to 2 to get only negative reviews.

## `onlyNewReviews` (type: `boolean`):

Remember which reviews were already returned (in a named key-value store) and return only reviews you haven't seen before. Ideal with an Apify Schedule for daily review alerts. The first run returns the current reviews.

## `stateStoreName` (type: `string`):

Named key-value store used by monitor mode. Use different names for independent monitors.

## `anonymizeReviewers` (type: `boolean`):

Drop reviewer nicknames and profile links from review rows (recommended if you don't need them, e.g. for GDPR data minimisation).

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

How many ranked apps to return per keyword and country (Apple returns at most 200).

## `chartLimit` (type: `integer`):

How many ranked apps to request per chart (Apple usually returns up to 100).

## `chartGenreId` (type: `string`):

Restrict charts to one App Store category, e.g. 6014 Games, 6017 Education, 6015 Finance, 6013 Health & Fitness, 6007 Productivity, 6016 Entertainment, 6005 Social Networking. Empty = all apps.

## `chartDetails` (type: `boolean`):

Add rating, rating count, version, size and other details to every chart entry (no extra charge).

## Actor input object example

```json
{
  "apps": [
    "https://apps.apple.com/us/app/notion-notes-tasks-ai/id1232780281",
    "com.spotify.client"
  ],
  "searchTerms": [
    "habit tracker"
  ],
  "countries": [
    "us"
  ],
  "includeAppDetails": true,
  "includeReviews": false,
  "maxReviewsPerApp": 100,
  "reviewSort": "mostRecent",
  "minRating": 1,
  "maxRating": 5,
  "onlyNewReviews": false,
  "stateStoreName": "app-store-scraper-state",
  "anonymizeReviewers": false,
  "maxSearchResults": 50,
  "chartLimit": 100,
  "chartDetails": true
}
```

# Actor output Schema

## `results` (type: `string`):

App details (name, developer, rating, price, version).

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

Customer reviews.

## `allFields` (type: `string`):

Every row with every field.

## `summary` (type: `string`):

Counts per type, apps, searches, charts and errors.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "apps": [
        "https://apps.apple.com/us/app/notion-notes-tasks-ai/id1232780281",
        "com.spotify.client"
    ],
    "searchTerms": [
        "habit tracker"
    ],
    "countries": [
        "us"
    ]
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "apps": [
        "https://apps.apple.com/us/app/notion-notes-tasks-ai/id1232780281",
        "com.spotify.client",
    ],
    "searchTerms": ["habit tracker"],
    "countries": ["us"],
}

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

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

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

```

## CLI example

```bash
echo '{
  "apps": [
    "https://apps.apple.com/us/app/notion-notes-tasks-ai/id1232780281",
    "com.spotify.client"
  ],
  "searchTerms": [
    "habit tracker"
  ],
  "countries": [
    "us"
  ]
}' |
apify call pinkish_armada/app-store-scraper --silent --output-dataset

```

## MCP server setup

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