# Apple App Store Scraper (`michael.g/apple-app-store-scraper`) Actor

Extract Apple App Store apps, customer reviews, ratings, developer details, pricing, and top charts. Export data, schedule via API, and integrate with other tools or AI workflows.

- **URL**: https://apify.com/michael.g/apple-app-store-scraper.md
- **Developed by:** [Michael G](https://apify.com/michael.g) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 4 total users, 4 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 1,000 apps

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

### What does Apple App Store Scraper do?

Apple App Store Scraper allows you to extract data about apps and customer reviews from the [Apple App Store](https://www.apple.com/app-store/): app name, developer, price, ratings, categories, descriptions, screenshots, supported devices, release information, customer reviews, and more.

You can search apps by keyword, retrieve specific apps by App Store ID or URL, or collect ranked apps from Apple App Store charts. Select an App Store storefront, optionally include available customer reviews, and export the results or access them through the Apify API.

### About the Apple App Store

The Apple App Store is Apple's marketplace for iPhone and iPad applications. App listings contain useful public information about developers, categories, pricing, ratings, compatibility, releases, screenshots, and customer feedback.

Because of this, the App Store is a practical source for app discovery, competitor research, App Store optimization (ASO), product research, review analysis, and mobile market research.

### App data fields

| Field Name | Type | Description |
| --- | --- | --- |
| Record Type (`type`) | String | Dataset record type |
| App ID (`appId`) | Integer | Apple's numeric App Store identifier |
| App Name (`appName`) | String | App name |
| Bundle ID (`bundleId`) | String | App bundle identifier |
| Developer (`developer`) | String | App developer or publisher name |
| Seller Name (`sellerName`) | String | Legal seller name |
| Seller URL (`sellerUrl`) | String (URL) | Developer or product website URL |
| Primary Genre (`primaryGenre`) | String | Primary App Store genre |
| Genres (`genres`) | List | App Store genres assigned to the app |
| Price (`price`) | Number | Numeric price in the selected storefront |
| Formatted Price (`formattedPrice`) | String | Storefront-formatted price |
| Currency (`currency`) | String | Storefront currency code |
| Average User Rating (`averageUserRating`) | Number | Overall app rating in the selected storefront |
| User Rating Count (`userRatingCount`) | Integer | Total number of app ratings |
| Rating for Current Version (`ratingForCurrentVersion`) | Number | Average rating for the current app version |
| Rating Count for Current Version (`ratingCountForCurrentVersion`) | Integer | Number of ratings for the current app version |
| Content Rating (`contentRating`) | String | App age or content rating |
| Version (`version`) | String | Current app version |
| Release Date (`releaseDate`) | String (Date) | Original App Store release date |
| Current Version Release Date (`currentVersionReleaseDate`) | String (Date) | Release date of the current version |
| Release Notes (`releaseNotes`) | String | Release notes for the current version |
| Minimum iOS Version (`minimumOsVersion`) | String | Minimum supported iOS version |
| File Size in Bytes (`fileSizeBytes`) | Integer | App file size in bytes |
| File Size in MB (`fileSizeMB`) | Number | App file size in megabytes |
| Languages (`languages`) | List | Supported language codes |
| Features (`features`) | List | Apple feature flags, such as `iosUniversal` |
| Supported Devices (`supportedDevices`) | List | Supported Apple device identifiers |
| Supported Devices Count (`supportedDevicesCount`) | Integer | Number of supported device identifiers |
| Description (`description`) | String | Full App Store description |
| App Icon (`icon`) | String (URL) | App icon URL |
| Screenshot URLs (`screenshotUrls`) | List | iPhone screenshot URLs |
| iPad Screenshot URLs (`ipadScreenshotUrls`) | List | iPad screenshot URLs |
| App Store URL (`appStoreUrl`) | String (URL) | Public App Store listing URL |
| Developer URL (`developerUrl`) | String (URL) | App Store developer page URL |
| Country (`country`) | String | Two-letter storefront code used for the request |
| Search Term (`searchTerm`) | String | Search keyword that returned the app; `null` outside Search apps mode |
| Chart Rank (`chartRank`) | Integer | App position in the selected chart; `null` outside Top charts mode |
| Chart Type (`chartType`) | String | Selected chart type; `null` outside Top charts mode |
| Chart Category (`chartCategory`) | String | Selected chart category; `null` outside Top charts mode |
| Scraped At (`scrapedAt`) | String (Date) | UTC timestamp when the app record was created |
| Reviews (`reviews`) | List | Nested customer reviews collected for the app |

Apple may not provide every optional value for every listing. Missing scalar values are returned as `null`, while some list fields use an empty list.

### Review data fields

| Field Name | Type | Description |
| --- | --- | --- |
| App Name (`appName`) | String | Name of the app the review belongs to |
| App Rating (`averageUserRating`) | Number | Overall storefront rating of the app |
| Review ID (`reviews[].reviewId`) | String | Apple review identifier |
| Rating (`reviews[].rating`) | Integer | Customer rating from 1 to 5 |
| Title (`reviews[].title`) | String | Review title |
| Review Text (`reviews[].text`) | String | Full review text |
| Author (`reviews[].author`) | String | Public review author name |
| Author URL (`reviews[].authorUrl`) | String (URL) | Public URL associated with the review author |
| Date (`reviews[].date`) | String (Date) | Review publication date in UTC |
| App Version (`reviews[].appVersion`) | String | App version reviewed by the customer |
| Vote Count (`reviews[].voteCount`) | Integer | Number of votes recorded for the review |
| Vote Sum (`reviews[].voteSum`) | Integer | Total vote score reported by Apple |
| Country (`reviews[].country`) | String | App Store storefront used to collect the review |

Customer reviews are stored inside the parent app's `reviews` array. The Reviews Dataset view expands this array and presents app-level context alongside each review.

### Why scrape the Apple App Store?

- App discovery: find iPhone and iPad apps by keyword, category, or chart.
- Competitor research: compare competing apps, developers, positioning, prices, ratings, and releases.
- App Store optimization: analyze titles, categories, ratings, descriptions, screenshots, and other ASO data.
- Product research: identify user complaints, recurring issues, and requested features in available reviews.
- Review analysis: collect customer feedback for sentiment analysis or internal research in your own workflow.
- Market research: study app categories, pricing, publishers, compatibility, and release activity.
- Chart monitoring: track top free, paid, and grossing apps for a selected storefront.
- Lead generation: identify relevant app developers and publishers for targeted research or outreach.

### Example Input

The Actor provides a straightforward input form where you can choose how to collect apps, select an App Store country, and optionally include customer reviews.

![Apple App Store Scraper input configuration](https://i.imghippo.com/files/jbun8720QCk.png)

#### Example A: Search apps by keyword

```json
{
  "mode": "search",
  "searchTerms": [
    "fitness",
    "workout tracker"
  ],
  "limit": 20,
  "priceFilter": "all",
  "country": "us",
  "includeReviews": false
}
```

#### Example B: Get specific apps and include reviews

```json
{
  "mode": "details",
  "appUrlsOrIds": [
    "587366035",
    "998411110"
  ],
  "country": "us",
  "includeReviews": true,
  "maxReviewsPerApp": 25,
  "reviewSort": "mostRecent"
}
```

#### Example C: Scrape top charts

```json
{
  "mode": "charts",
  "chartType": "top-free",
  "chartCategory": "all",
  "chartLimit": 20,
  "country": "us",
  "includeReviews": false
}
```

The Input form is divided into mode-specific and shared sections:

- Search apps uses Search keywords, Max apps per keyword, and Price filter.
- App details uses App IDs or URLs.
- Top charts uses Chart, Category, and Chart results.
- Storefront and Reviews are shared settings.

Only the fields that belong to the selected mode affect how apps are collected.

### Output sample

The results will be wrapped into a dataset which you can find in the Storage tab. Note that the output is organized in a table for viewing convenience.

The Overview Dataset view provides a compact summary of collected apps, including app icons, names, developers, ratings, prices, and other essential information.

![Apple App Store Scraper Overview dataset view](https://i.imghippo.com/files/RPjX7274sr.png)

The Apps Dataset view contains additional app-level metadata for more detailed research and analysis.

![Apple App Store Scraper Apps dataset view](https://i.imghippo.com/files/uEJ6156vo.png)

The Reviews Dataset view displays each available customer review as its own row, alongside app-level information such as the app name and overall rating.

![Apple App Store Scraper Reviews dataset view](https://i.imghippo.com/files/MAU8809eQA.png)

The Dataset provides the following views:

- Overview: one row per app with compact listing information.
- Apps: one row per app with additional app-level metadata.
- Reviews: one row per available customer review, created by expanding the nested `reviews` array.
- All fields: complete app objects, including the optional nested `reviews[]` data.

Each physical Dataset item represents one app. Reviews are not stored as separate physical Dataset items; they remain inside that app's `reviews` array.

```json
{
  "type": "app",
  "appId": 329218549,
  "appName": "Chess - Play and Learn",
  "bundleId": "com.chess.iphone",
  "developer": "Chess.com",
  "sellerName": "Chess.com, LLC",
  "sellerUrl": "https://www.chess.com/",
  "primaryGenre": "Games",
  "genres": [
    "Games",
    "Strategy"
  ],
  "price": 0,
  "formattedPrice": "Free",
  "currency": "USD",
  "averageUserRating": 4.8,
  "userRatingCount": 807749,
  "ratingForCurrentVersion": 4.8,
  "ratingCountForCurrentVersion": 807749,
  "contentRating": "4+",
  "version": "4.10.25",
  "releaseDate": "2009-10-29T03:18:55Z",
  "currentVersionReleaseDate": "2026-08-18T17:58:49Z",
  "releaseNotes": "Bug fixes and performance improvements.",
  "minimumOsVersion": "17.0",
  "fileSizeBytes": 444999999,
  "fileSizeMB": 424.39,
  "languages": [
    "EN"
  ],
  "features": [
    "iosUniversal"
  ],
  "supportedDevices": [
    "iPhone",
    "iPad"
  ],
  "supportedDevicesCount": 2,
  "description": "Play chess online and learn with lessons and puzzles.",
  "icon": "https://example.com/chess-icon.png",
  "screenshotUrls": [
    "https://example.com/chess-screenshot.png"
  ],
  "ipadScreenshotUrls": [
    "https://example.com/chess-ipad-screenshot.png"
  ],
  "appStoreUrl": "https://apps.apple.com/us/app/id329218549",
  "developerUrl": "https://apps.apple.com/us/developer/id329218552",
  "country": "us",
  "searchTerm": "chess",
  "chartRank": null,
  "chartType": null,
  "chartCategory": null,
  "scrapedAt": "2026-08-20T12:00:00.000Z",
  "reviews": [
    {
      "reviewId": "14442485456",
      "rating": 5,
      "title": "Great learning tools",
      "text": "The lessons and puzzles are very helpful.",
      "author": "Example player",
      "authorUrl": "https://itunes.apple.com/us/reviews/id123456",
      "date": "2026-08-18T16:00:00Z",
      "appVersion": "4.10.25",
      "voteCount": 12,
      "voteSum": 11,
      "country": "us"
    }
  ]
}
```

By clicking the Export button, you can download the Dataset in formats supported by Apify, including JSON, CSV, Excel, XML, and HTML. You can also access the results through the Apify API.

### How do I use Apple App Store Scraper?

Apple App Store Scraper is designed to help you collect app metadata and available App Store reviews even if you have no prior scraping experience. Follow these steps:

1. Choose Search apps, App details, or Top charts.
2. Enter search keywords, App Store IDs or URLs, or chart settings for the selected mode.
3. Select the App Store country used for app data, charts, and reviews.
4. Optionally enable customer reviews and choose the review limit and sort order.
5. Click Start and wait for the run to finish.
6. Open the Dataset and export the results in your preferred format.

Only settings corresponding to the selected mode affect how apps are collected. Storefront and review settings are shared by all three modes.

### Features

- Keyword Search: search one or more keywords and collect up to 200 apps per keyword.
- App Details by ID or URL: retrieve exact listings using numeric IDs or full App Store URLs.
- Top Charts: collect Top Free, Top Paid, or Top Grossing apps.
- Chart Categories: choose All apps or one of the supported App Store categories in the Input form.
- Country Selection: use a two-letter storefront code for app data, charts, and reviews.
- Customer Reviews: optionally attach reviews returned by Apple's public feed to each app.
- Review Sorting: request Most recent or Most helpful reviews.
- Price Filtering: return all, free, or paid apps in Search apps mode.
- Multiple Apps per Run: search multiple keywords or look up multiple IDs and URLs.
- Rich App Metadata: collect ratings, pricing, releases, compatibility, media, developer data, and more.
- Structured Dataset Views: inspect Overview, Apps, Reviews, or the complete All fields output.
- Export and API Access: use Apify export formats, API endpoints, schedules, and platform integrations.

Apple's public review feed can expose up to 500 available reviews per app and storefront. This is an upper limit, not a guarantee that every app or storefront will return that many reviews.

### Reviews and Apple feed limitations

Reviews are collected from Apple's publicly available review feed. Availability depends on the selected storefront and Apple's current response. Some apps may temporarily return no reviews even when their App Store page displays ratings or review activity, and the same behavior can affect other tools that use this public feed.

The Actor retries temporarily empty responses up to three total attempts per page, then continues. Apps are still returned when reviews are unavailable, and the selected storefront is never changed automatically.

The public feed exposes up to 50 reviews per page and up to ten pages for the selected app, storefront, and sort order. Pagination can stop earlier when Apple returns an empty page, omits a valid next-page link, repeats review IDs, or reports fewer available reviews.

### How much does Apple App Store Scraper cost?

Apple App Store Scraper uses pay-per-event pricing with three event types: Actor start, collected app, and collected customer review. You pay once when the Actor starts and for each app collected. Review charges apply only when customer reviews are included and successfully collected. Apps without available reviews do not generate review charges.

| Event | Free | Starter | Scale | Business |
| --- | ---: | ---: | ---: | ---: |
| 1,000 apps | $1.20 | $1.00 | $0.80 | $0.60 |
| 1,000 reviews | $0.12 | $0.10 | $0.08 | $0.06 |
| Actor start | $0.0012 | $0.0010 | $0.0008 | $0.0006 |

App and review prices are listed per 1,000 collected results, while the Actor start price applies once per run.

Apify provides you with $5 in free usage credits every month on the [Apify Free plan](https://apify.com/pricing?fpr=home), allowing you to **collect up to approximately 4,100 apps or 40,000 customer reviews** for free using those credits.

For regular data collection, consider upgrading to the [$29/month Starter plan](https://apify.com/pricing?fpr=home), which can **get you up to approximately 28,000 apps or 280,000 customer reviews every month.**

The exact number of results depends on whether you collect app data only or include customer reviews.

#### Starter plan examples

- 1 app with 100 reviews: $0.0010 Actor start + $0.0010 app + $0.0100 reviews = **$0.0120**
- 100 apps without reviews: $0.0010 Actor start + $0.1000 apps = **$0.1010**
- 180 apps with 12,667 reviews: $0.0010 Actor start + $0.1800 apps + $1.2667 reviews = **$1.4477**

You can set a maximum cost per run in Apify Console to control spending.

### Integrations and Apple App Store Scraper

Apple App Store Scraper can be connected with almost any cloud service or web app thanks to integrations on the Apify platform. You can use results with Make, n8n, Zapier, Google Sheets, Google Drive, Slack, Airbyte, GitHub, Clay, API-based workflows, AI workflows, and [more Apify integrations](https://apify.com/integrations).

These integrations are provided by the Apify platform and are not separate features built directly into this Actor.

### Your feedback

We're always working on improving the performance of our Actors. If you've got any technical feedback for Apple App Store Scraper or simply found a bug, please create an issue on the Actor's [Issues tab](https://console.apify.com/actors/pd5GOvXrOnrg1IVP7/issues) in Apify Console.

# Actor input Schema

## `mode` (type: `string`):

Search apps - find apps by keywords. App details - get specific apps by App Store ID or URL. Top charts - get ranked apps from Apple charts.

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

Enter one or more keywords to search in the App Store. Used only when Mode is Search apps.

## `limit` (type: `integer`):

Maximum number of apps returned for each search keyword. Used only when Mode is Search apps. Apple Search supports up to 200 apps per keyword.

## `priceFilter` (type: `string`):

Filter search results by price. Used only when Mode is Search apps.

## `appUrlsOrIds` (type: `array`):

Enter one or more Apple App Store IDs or full App Store URLs. Used only when Mode is App details.

## `chartType` (type: `string`):

Choose the Apple chart to scrape. Used only when Mode is Top charts.

## `chartCategory` (type: `string`):

Choose the App Store category for the selected chart. Used only when Mode is Top charts.

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

Maximum number of ranked apps to return. Used only when Mode is Top charts.

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

Select the App Store storefront used for search, app details, charts, and customer reviews.

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

Fetch customer reviews for every app returned by Search apps, App details, or Top charts.

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

Maximum number of customer reviews to fetch for each app. Apple's public review feed exposes up to 500 reviews per app and storefront.

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

Choose how customer reviews are ordered.

## Actor input object example

```json
{
  "mode": "search",
  "searchTerms": [
    "chess"
  ],
  "limit": 50,
  "priceFilter": "all",
  "appUrlsOrIds": [
    "389801252",
    "587366035",
    "998411110"
  ],
  "chartType": "top-free",
  "chartCategory": "all",
  "chartLimit": 100,
  "country": "us",
  "includeReviews": false,
  "maxReviewsPerApp": 100,
  "reviewSort": "mostRecent"
}
```

# Actor output Schema

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

All searched, looked-up, or ranked apps with optional nested customer reviews scraped in this run.

# 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 = {
    "searchTerms": [
        "chess"
    ],
    "limit": 50,
    "appUrlsOrIds": [
        "389801252",
        "587366035",
        "998411110"
    ],
    "country": "us"
};

// Run the Actor and wait for it to finish
const run = await client.actor("michael.g/apple-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 = {
    "searchTerms": ["chess"],
    "limit": 50,
    "appUrlsOrIds": [
        "389801252",
        "587366035",
        "998411110",
    ],
    "country": "us",
}

# Run the Actor and wait for it to finish
run = client.actor("michael.g/apple-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 '{
  "searchTerms": [
    "chess"
  ],
  "limit": 50,
  "appUrlsOrIds": [
    "389801252",
    "587366035",
    "998411110"
  ],
  "country": "us"
}' |
apify call michael.g/apple-app-store-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,michael.g/apple-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/pd5GOvXrOnrg1IVP7/builds/ZmjrG94L7c6TO7cQi/openapi.json