# Apple App Store Scraper (`karamelo/apple-app-store-scraper`) Actor

Extract Apple App Store app details, ratings, reviews, charts, and search results by keyword or direct app ID/URL.

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

## Pricing

from $1.70 / 1,000 detail scrapeds

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/actors/running/actors-in-store.md#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** extracts comprehensive public mobile application data, customer reviews, rating statistics, and top chart rankings from the official [Apple App Store](https://apps.apple.com/). Designed for high-throughput market analysis, competitive intelligence, and automated product tracking, this Actor delivers structured, analysis-ready datasets without requiring personal login credentials, private access tokens, or developer account subscriptions.

Whether you need to monitor competitor pricing and version release notes, evaluate user feedback across international storefronts, track categorical shifts, or feed high-volume sentiment models, Apple App Store Scraper provides immediate access to over 30 distinct app metadata fields and granular user review entries.

#### Key capabilities at a glance

- **Four specialized scraping modes**: Discover new apps through keyword search, look up target applications by direct URL or numeric ID, extract customer review feeds with star ratings, or track category leaders via App Store top charts.
- **Over 30 comprehensive metadata fields**: Collect technical specifications, developer details, ratings distribution, release history, device compatibility, file sizes, pricing, and localized category classifications.
- **Full international coverage**: Query any regional App Store storefront across more than 150 supported territories using standard two-letter country codes (such as US, GB, DE, FR, JP, CA, and AU).
- **In-depth customer review extraction**: Gather customer review titles, full written feedback, star ratings, author profile links, referenced app versions, dates, and helpfulness vote tallies (up to 500 reviews per app per region).
- **Flexible output formats**: Seamlessly export your collected records to JSON, CSV, Excel (XLSX), XML, or HTML tables, or stream records directly into downstream business applications using the Apify API and webhooks.
- **Predictable pay-per-event pricing**: Pay only for the specific apps and reviews you scrape, with no recurring monthly software subscriptions and automated volume discounts.

***

### Who is it for?

Apple App Store Scraper is built for growth-focused professionals, analysts, and engineering teams that rely on accurate, timely mobile intelligence:

- 📱 **Mobile App Developers & Product Managers**: Monitor competitor release cycles, analyze feature adoption through update release notes, benchmark user ratings against category averages, and track customer sentiment changes following major version deployments.
- 📊 **Market Researchers & Industry Analysts**: Map mobile app market landscapes across global regions, track developer portfolios, evaluate monetization shifts between free and paid applications, and construct historical datasets of mobile application trends.
- 🎯 **ASO (App Store Optimization) & Growth Teams**: Identify high-ranking keyword opportunities, audit localized metadata across foreign storefronts, optimize visual asset positioning, and monitor rating velocity to protect brand reputation.
- 🤖 **Data Scientists & Machine Learning Engineers**: Assemble large, clean text datasets from user reviews and product descriptions for natural language processing (NLP), topic clustering, automated customer support triage, and sentiment scoring.
- 💼 **Investors & Venture Capitalists**: Gauge early user traction, review velocity, developer stability, and customer reception to identify breakout mobile applications and validate market demand before committing capital.

***

### Why use Apple App Store Scraper?

| Feature | Apple App Store Scraper | Manual Collection | App Store Connect API | Generic Web Scrapers |
|---|---|---|---|---|
| **Coverage** | Any public app globally | Very limited | Only your own apps | Unreliable & fragile |
| **Extraction Speed** | Hundreds of apps in seconds | Hours of manual copying | Restricted to account | Slow browser overhead |
| **Review Extraction** | Up to 500 reviews per app | Copy-paste only | Limited export tools | Incomplete or blocked |
| **Setup Required** | None (ready out of the box) | None | Paid Apple Developer account | Complex selector coding |
| **Multi-Storefront Support** | 150+ regional storefronts | Manual browser switching | Only account territories | Fragmented regional proxying |
| **Pricing Model** | Pay only for results scraped | High manual labor cost | $99/year fee + limitations | High compute & proxy costs |
| **Export Formats** | JSON, CSV, Excel, XML | Manual formatting | Raw reports | Inconsistent schema |

***

### Scraping modes in detail

Apple App Store Scraper offers four tailored operational modes to match your specific research objectives:

#### 1. Search Mode (`mode: "search"`)

Enter a search keyword (such as `"budget planner"`, `"language learning"`, or `"sleep tracker"`). The scraper queries the App Store catalog for the term in the chosen country storefront and returns matching applications up to your specified result limit. You can filter results to return all applications, free apps only, or paid apps only.

#### 2. Details Mode (`mode: "details"`)

Provide a list of direct App Store links (for example, `https://apps.apple.com/us/app/duolingo-language-lessons/id570060128`) or plain numeric app IDs (`570060128`). The scraper resolves full technical metadata for all requested applications in batches. If you enable the `includeReviews` parameter, the Actor automatically extracts corresponding customer reviews for each app in the same run.

#### 3. Reviews Mode (`mode: "reviews"`)

Target specific mobile applications to harvest written user reviews. For each app ID or URL provided, the Actor collects review records containing customer ratings, review titles, user feedback text, reviewer usernames, dates, and version references. You can sort reviews by most recent or most helpful.

#### 4. Charts Mode (`mode: "charts"`)

Discover leading applications by harvesting the official App Store rankings. Select either top free or top paid charts, and specify how many ranked apps to resolve (from 1 up to 200). The Actor retrieves the leaderboard and resolves full, 30+ field metadata records for every ranked app in exact leaderboard order.

***

### What data can you extract?

Every scraping run produces clean, normalized records with consistent field definitions. Below are the schema definitions for app metadata and customer review outputs.

#### 📱 App Metadata Fields (30+ attributes)

| Field Name | Type | Description | Example |
|---|---|---|---|
| `appId` | Integer | Unique Apple numeric application ID | `570060128` |
| `appName` | String | Full published application title | `"Duolingo - Language Lessons"` |
| `bundleId` | String | Technical bundle identifier | `"com.duolingo.DuolingoMobile"` |
| `developer` | String | Public artist or company name | `"Duolingo, Inc."` |
| `developerUrl` | String | Link to the developer's App Store portfolio | `"https://apps.apple.com/us/developer/duolingo/id570060131"` |
| `sellerName` | String | Registered seller entity name | `"Duolingo, Inc."` |
| `sellerUrl` | String | Official external website of the seller | `"https://www.duolingo.com"` |
| `primaryGenre` | String | Primary App Store category name | `"Education"` |
| `genres` | Array | All categories associated with the app | `["Education", "Reference"]` |
| `price` | Number | App download price in local currency | `0` |
| `formattedPrice` | String | Display price string formatted for region | `"Free"` or `"$2.99"` |
| `currency` | String | Storefront three-letter currency code | `"USD"` |
| `averageUserRating` | Number | All-time average user rating (1.0 to 5.0) | `4.75` |
| `userRatingCount` | Integer | Total number of user ratings submitted | `2480110` |
| `ratingForCurrentVersion` | Number | Average user rating for current version | `4.75` |
| `ratingCountForCurrentVersion` | Integer | Rating volume for current version | `18204` |
| `contentRating` | String | Age advisory rating tier | `"4+"` |
| `version` | String | Current published application version | `"7.42.0"` |
| `releaseDate` | String | Initial public release timestamp (ISO 8601) | `"2012-11-13T08:00:00Z"` |
| `currentVersionReleaseDate`| String | Most recent version release timestamp | `"2026-03-10T14:15:00Z"` |
| `releaseNotes` | String | Developer changelog and update summary | `"Practice speaking, reading, listening, and writing in bite-sized lessons."` |
| `minimumOsVersion` | String | Minimum required operating system version | `"16.0"` |
| `fileSizeBytes` | Integer | Exact application package size in bytes | `195412800` |
| `fileSizeMB` | Number | Application size in megabytes (MB) | `186.36` |
| `languages` | Array | Supported ISO 639-1 two-letter language codes | `["EN", "ES", "FR", "DE", "JA", "KO", "PT", "ZH"]` |
| `supportedDevicesCount` | Integer | Count of compatible Apple device models | `131` |
| `supportedDevices` | Array | Full list of supported hardware platforms | `["iPhone", "iPad", "iPodTouch"]` |
| `description` | String | Complete application store description text | `"Learn a new language with the world's most-downloaded education app!..."` |
| `iconUrl` | String | High-resolution 512x512 app icon URL | `"https://is1-ssl.mzstatic.com/icon512.jpg"` |
| `screenshotUrls` | Array | High-definition iPhone screenshot preview URLs | `["https://is1-ssl.mzstatic.com/screen1.jpg"]` |
| `ipadScreenshotUrls` | Array | iPad screenshot preview URLs | `["https://is1-ssl.mzstatic.com/ipad1.jpg"]` |
| `appStoreUrl` | String | Canonical web URL for the App Store listing | `"https://apps.apple.com/us/app/duolingo-language-lessons/id570060128"` |
| `country` | String | Storefront country code evaluated | `"us"` |
| `searchTerm` | String | Originating search query (if in search mode) | `"budget planner"` |

***

#### ⭐ Customer Review Fields

| Field Name | Type | Description | Example |
|---|---|---|---|
| `reviewId` | String | Unique App Store customer review identifier | `"14528906795"` |
| `title` | String | Headline title provided by the reviewer | `"Excellent daily utility"` |
| `content` | String | Full written body text of the customer review | `"I use this application every morning to track learning progress..."` |
| `rating` | Integer | Star rating assigned by the reviewer (1 to 5) | `5` |
| `author` | String | Public display name of the reviewer | `"CreativeUser99"` |
| `authorUrl` | String | Profile URL of the reviewer | `"https://itunes.apple.com/us/reviews/id1218042398"` |
| `appVersion` | String | Application version installed when reviewed | `"7.42.0"` |
| `date` | String | Date and time the review was submitted | `"2026-09-09T05:06:21-07:00"` |
| `voteSum` | Integer | Aggregate score of helpful votes | `14` |
| `voteCount` | Integer | Total count of user helpfulness votes | `16` |
| `appId` | Integer | Numeric ID of the reviewed app | `570060128` |
| `appName` | String | Title of the reviewed application | `"Duolingo - Language Lessons"` |

***

### Step-by-step guide: How to scrape the Apple App Store

Getting started with Apple App Store Scraper takes less than a minute. Follow these steps to execute your first extraction run:

1. **Open the Actor page**: Navigate to [Apple App Store Scraper](https://apify.com/karamelo/apple-app-store-scraper) on Apify Store.
2. **Select your Scraping Mode**:
   - Choose **Search apps** to discover new applications matching keywords.
   - Choose **App details** to extract rich metadata for specific applications.
   - Choose **App reviews** to extract user feedback and star ratings.
   - Choose **Top charts** to collect the current top free or paid leaderboards.
3. **Configure your target inputs**:
   - For search, provide one or more search keywords (e.g. `productivity`, `meditation`).
   - For details or reviews, paste full App Store URLs or numeric application IDs.
   - For charts, choose whether you want `Top Free Apps` or `Top Paid Apps`.
4. **Select Storefront Country**: Enter the two-letter region code representing your target market (default is `us`). For the United Kingdom use `gb`, for Germany use `de`, for France use `fr`, for Japan use `jp`, etc.
5. **Set Result Limits**: Configure the maximum number of records you wish to retrieve (e.g. 50 items).
6. **Click Start**: Click the green **Start** button. The Actor initializes immediately and displays real-time progress logs in the Console.
7. **Download or Integrate**: When the run finishes, navigate to the **Dataset** tab to view your data in a structured table, download it in your preferred file format (JSON, CSV, Excel), or connect it to external tools.

***

### Input configuration and examples

Below is the complete reference of configurable input parameters supported by the Actor:

| Parameter | Type | Default | Description |
|---|---|---|---|
| `mode` | String | `"search"` | Operational mode: `"search"`, `"details"`, `"reviews"`, or `"charts"`. |
| `searchTerm` | String | `"budget planner"` | Primary search keyword for search mode. Accepts a text string. Also accepts `searchTerms` as an array of strings. |
| `appIds` | Array of Strings | `[]` | Direct App Store listing URLs or numeric IDs for details and reviews modes. For example: `https://apps.apple.com/us/app/duolingo-language-lessons/id570060128`. Also accepts `appUrlsOrIds`. |
| `country` | String | `"us"` | Two-letter country code for the target storefront region (e.g. `us`, `gb`, `de`, `fr`, `jp`). |
| `maxItems` | Integer | `50` | Maximum items to extract per query (1 to 500). Set `0` for unlimited. Also accepts `limit`. |
| `priceFilter` | String | `"all"` | Filter apps by pricing: `"all"`, `"free"`, or `"paid"`. |
| `chartType` | String | `"top-free"` | Chart leaderboard to track: `"top-free"` or `"top-paid"`. |
| `chartLimit` | Integer | `50` | Number of ranked chart apps to extract (1 to 100). |
| `includeReviews`| Boolean | `false` | When enabled in details or search mode, automatically collects customer reviews. |
| `reviewSort` | String | `"mostRecent"` | Review sorting order: `"mostRecent"` or `"mostHelpful"`. |
| `proxyConfiguration` | Object | `{ "useApifyProxy": true }` | Apify Proxy configuration for high-availability extraction. |

***

#### Example 1: Keyword Search across App Store

Extract top personal finance and budget planning tools in the United States storefront:

```json
{
  "mode": "search",
  "searchTerm": "budget planner",
  "country": "us",
  "maxItems": 25,
  "priceFilter": "free"
}
```

#### Example 2: Target App Metadata Lookup

Resolve detailed technical specifications and release history for specific competitor apps:

```json
{
  "mode": "details",
  "appIds": [
    "https://apps.apple.com/us/app/duolingo-language-lessons/id570060128",
    "https://apps.apple.com/us/app/notion-notes-docs-tasks/id1232780281",
    "426826309"
  ],
  "country": "us",
  "includeReviews": false
}
```

#### Example 3: Extract Customer Reviews for Sentiment Analysis

Harvest the latest 100 written user reviews for Duolingo to evaluate user feedback and feature requests:

```json
{
  "mode": "reviews",
  "appIds": [
    "570060128"
  ],
  "country": "us",
  "maxItems": 100,
  "reviewSort": "mostRecent"
}
```

#### Example 4: Discover Top Free Chart Leaders

Collect full details for the top 50 free applications currently leading the App Store charts:

```json
{
  "mode": "charts",
  "chartType": "top-free",
  "chartLimit": 50,
  "country": "us"
}
```

***

### Sample output datasets

#### Sample App Detail Output Record

```json
{
  "appId": 570060128,
  "appName": "Duolingo - Language Lessons",
  "bundleId": "com.duolingo.DuolingoMobile",
  "developer": "Duolingo, Inc.",
  "developerUrl": "https://apps.apple.com/us/developer/duolingo/id570060131",
  "sellerName": "Duolingo, Inc.",
  "sellerUrl": "https://www.duolingo.com",
  "primaryGenre": "Education",
  "genres": [
    "Education",
    "Reference"
  ],
  "price": 0,
  "formattedPrice": "Free",
  "currency": "USD",
  "averageUserRating": 4.75,
  "userRatingCount": 2480110,
  "ratingForCurrentVersion": 4.75,
  "ratingCountForCurrentVersion": 18204,
  "contentRating": "4+",
  "version": "7.42.0",
  "releaseDate": "2012-11-13T08:00:00Z",
  "currentVersionReleaseDate": "2026-03-10T14:15:00Z",
  "releaseNotes": "Practice speaking, reading, listening, and writing in bite-sized lessons.",
  "minimumOsVersion": "16.0",
  "fileSizeBytes": 195412800,
  "fileSizeMB": 186.36,
  "languages": [
    "EN",
    "ES",
    "FR",
    "DE",
    "JA",
    "KO",
    "PT",
    "ZH"
  ],
  "supportedDevicesCount": 131,
  "supportedDevices": [
    "iPhone",
    "iPad",
    "iPodTouch"
  ],
  "description": "Learn a new language with the world's most-downloaded education app! Duolingo is the fun, free app for learning 40+ languages through quick, bite-sized lessons.",
  "iconUrl": "https://is1-ssl.mzstatic.com/image/thumb/Purple221/v4/icon512.jpg",
  "screenshotUrls": [
    "https://is1-ssl.mzstatic.com/image/thumb/Purple221/v4/screen1.jpg",
    "https://is1-ssl.mzstatic.com/image/thumb/Purple221/v4/screen2.jpg"
  ],
  "ipadScreenshotUrls": [
    "https://is1-ssl.mzstatic.com/image/thumb/Purple221/v4/ipad1.jpg"
  ],
  "appStoreUrl": "https://apps.apple.com/us/app/duolingo-language-lessons/id570060128",
  "country": "us",
  "searchTerm": "budget planner"
}
```

#### Sample Customer Review Output Record

```json
{
  "reviewId": "14528906795",
  "title": "Excellent daily practice utility",
  "content": "I use this application every morning to build consistent habits and track learning progress. The interactive bite-sized lessons keep practice engaging without feeling overwhelming.",
  "rating": 5,
  "author": "CreativeLearner42",
  "authorUrl": "https://itunes.apple.com/us/reviews/id1218042398",
  "appVersion": "7.42.0",
  "date": "2026-09-09T05:06:21-07:00",
  "voteSum": 14,
  "voteCount": 16,
  "appId": 570060128,
  "appName": "Duolingo - Language Lessons"
}
```

***

### Pricing and cost estimation

Apple App Store Scraper operates under Apify's transparent **Pay-Per-Event (PPE)** pricing model. You do not need an expensive fixed monthly software subscription; you are billed strictly for the number of applications and reviews extracted during your runs.

#### Charge Event Breakdown

- **Actor Start**: **$0.005** (one-time base fee per scraping execution).
- **Detail Scraped**: **$0.00340** per app ($3.40 / 1,000 apps; covers comprehensive 30+ field metadata extraction).
- **Review Scraped**: **$0.00120** per written review ($1.20 / 1,000 reviews).
- **Platform Usage**: **Free** (no additional compute surcharges).

#### Volume Tier Pricing

As your extraction volume increases across monthly runs, Apify automatically applies tiered volume discounts according to your subscription plan. Platinum and Diamond tiers receive the same discounted pricing as Gold:

| Subscription Plan | Discount Tier | Detail Scraped (per 1,000) | Review Scraped (per 1,000) | Actor Start | Platform Usage |
|---|---|---|---|---|---|
| **Free** | No discount | $3.40 | $1.20 | $0.005 | Free |
| **Starter** | Bronze discount | $2.80 | $1.00 | $0.005 | Free |
| **Scale** | Silver discount | $2.30 | $0.80 | $0.005 | Free |
| **Business** | Gold discount | $1.70 | $0.60 | $0.005 | Free |
| **Platinum** | Gold discount rate | $1.70 | $0.60 | $0.005 | Free |
| **Diamond** | Gold discount rate | $1.70 | $0.60 | $0.005 | Free |

#### Realistic Real-World Run Scenarios

- **Quick Keyword Exploration (10 search results)**: ~3 to 5 seconds duration. Cost: ~$0.039 (~$0.04) total ($0.005 start + 10 × $0.00340).
- **Competitor Tracking (20 app details)**: ~4 to 6 seconds duration. Cost: ~$0.073 (~$0.07) total ($0.005 start + 20 × $0.00340).
- **Deep Customer Sentiment Mining (250 reviews for 1 app)**: ~12 to 15 seconds duration. Cost: ~$0.308 (~$0.31) total ($0.005 start + 1 × $0.00340 app detail + 250 × $0.00120 reviews).
- **Top 50 Chart Leaderboard Extraction (50 full app details)**: ~8 to 10 seconds duration. Cost: ~$0.175 (~$0.18) total ($0.005 start + 50 × $0.00340).

> **Included Free Platform Credit**: Every Apify account receives **$5.00 of free monthly usage credit**. This free allowance allows you to scrape up to **1,470 full app details** or more than **4,100 customer reviews** every single month at zero out-of-pocket cost.

***

### Best practices and optimization tips

1. **Start with focused limits**: When setting up a new workflow, test your parameters with `limit: 5` or `limit: 10` to confirm that the extracted fields and country storefront match your requirements before scaling to large batches.
2. **Leverage direct URLs for precision**: If you already track a specific list of competitors or portfolio companies, paste full App Store URLs directly into `appUrlsOrIds`. The Actor automatically parses the numeric identifier regardless of localized URL formatting.
3. **Select the correct storefront**: App Store descriptions, pricing, localized categories, and user reviews differ dramatically between countries. Always specify the two-letter region code corresponding to your target audience (`us`, `gb`, `de`, `fr`, `jp`, etc.).
4. **Understand catalog limits**: Apple caps keyword search responses at 200 items per query. To construct larger category datasets, query multiple complementary keywords (e.g. `"workout tracker"`, `"gym log"`, `"calorie counter"`) and deduplicate records by `appId`.
5. **Deduplicate reviews over time**: Apple publishes up to 500 reviews per application per country storefront via its public review feeds. For recurring monitoring, schedule daily or weekly runs and use `reviewId` as your unique primary key to detect newly posted user feedback.
6. **Combine review sorts**: To balance recent feedback with high-impact community reviews, perform one extraction run using `reviewSort: "mostRecent"` and a companion run using `reviewSort: "mostHelpful"`.

***

### Automated workflows and integrations

Apple App Store Scraper integrates directly into modern data stacks and automation platforms:

- **Google Sheets & Airtable**: Pipe scraped app metadata and customer review tables directly into spreadsheets for automated competitor dashboards and collaborative team analysis.
- **Slack & Microsoft Teams Alerts**: Trigger webhook notifications whenever a competitor app drops below a target rating threshold (e.g. rating < 4.2) or when a critical negative review appears.
- **Make & Zapier Automations**: Automatically push new 1-star and 2-star customer reviews into Jira or Zendesk as customer feedback tickets for your product development team.
- **Scheduled Weekly Monitoring**: Set up an automated recurring cron schedule in Apify Console to audit pricing changes, rating fluctuations, and version updates across your competitive set every Monday morning.
- **Cloud Storage & Data Warehouses**: Export bulk JSON and CSV datasets directly into Amazon S3, Google Cloud Storage, BigQuery, or Snowflake for longitudinal ASO modeling and business intelligence reporting.

***

### Programmatic API usage

You can trigger and control Apple App Store Scraper programmatically via the Apify REST API or official client libraries.

#### Node.js / JavaScript

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

const client = new ApifyClient({
    token: 'YOUR_APIFY_TOKEN',
});

// Start the scraper run and wait for it to complete
const run = await client.actor('karamelo/apple-app-store-scraper').call({
    mode: 'search',
    searchTerm: 'budget planner',
    country: 'us',
    maxItems: 25,
    priceFilter: 'all',
});

// Fetch output records from the resulting dataset
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Extracted ${items.length} apps:`);
for (const app of items) {
    console.log(`- ${app.appName} (${app.formattedPrice}) - Rating: ${app.averageUserRating}`);
}
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')

    # Prepare input configuration
    run_input = {
        'mode': 'reviews',
        'appIds': ['https://apps.apple.com/us/app/duolingo-language-lessons/id570060128'],
        'country': 'us',
        'maxItems': 50,
        'reviewSort': 'mostRecent',
    }

    # Run the Actor and wait for completion
    run = client.actor('karamelo/apple-app-store-scraper').call(run_input=run_input)

    # Fetch results from dataset
    dataset = client.dataset(run['defaultDatasetId'])
    for review in dataset.iterate_items():
        print(f"[{review['rating']} stars] {review['author']}: {review['title']}")
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/karamelo~apple-app-store-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "mode": "charts",
    "chartType": "top-free",
    "chartLimit": 20,
    "country": "us"
  }'
```

***

### Use with AI agents and MCP

Apple App Store Scraper supports the **Model Context Protocol (MCP)**, allowing autonomous AI agents, LLMs, and development assistants to retrieve live mobile market data directly into conversational workflows.

#### Claude Code Setup

Connect the Actor directly to Claude Code via terminal:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=karamelo/apple-app-store-scraper"
```

#### Cursor, Claude Desktop, and VS Code Setup

Add the Apify MCP endpoint to your client configuration file (`claude_desktop_config.json` or Cursor MCP settings):

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=karamelo/apple-app-store-scraper"
    }
  }
}
```

#### Example AI Agent Prompts

Once connected, your AI assistants can execute tasks using natural language:

- *"Identify the top 15 budget planner apps in the US App Store, compare their user ratings and file sizes, and present the results in a comparative markdown table."*
- *"Extract the latest 100 customer reviews for Duolingo on the App Store and perform a thematic analysis identifying the top 3 user friction points."*
- *"Analyze recent version changelog notes across leading productivity apps to summarize emerging feature trends this quarter."*

***

### Limitations and platform considerations

To ensure smooth automated execution, keep the following platform constraints in mind:

- **Search result volume limit**: Apple's public catalog index returns a maximum of 200 applications per individual keyword search query. For wider category coverage, submit multiple granular search keywords in the `searchTerms` list.
- **Review pagination limit**: Apple's customer review feeds provide a maximum of 10 pages containing up to 50 reviews each, yielding a hard ceiling of 500 reviews per application per storefront region. To extract larger historical review datasets, query multiple regional storefronts where the app is published.
- **Regional catalog availability**: Certain applications and games are published exclusively in specific countries. If an application ID fails to return metadata in the `us` storefront, verify whether the app is restricted to another storefront territory (e.g. `jp` or `cn`).
- **Conditional metadata fields**: When an application has received fewer than five user ratings, Apple does not display an aggregated score, causing `averageUserRating` and `userRatingCount` to return `null`. Similarly, `releaseNotes` may be empty if a developer omitted update notes for their release.

***

### Frequently Asked Questions (FAQ)

#### How fast does Apple App Store Scraper execute?

The Actor completes search queries and batch lookups in approximately 3 to 6 seconds for typical batches of 25 to 50 applications. Review extraction runs of 100 customer reviews typically finish in under 12 seconds.

#### How much does it cost to scrape 1,000 applications?

Under the Free plan, extracting 1,000 comprehensive application detail records costs $3.405 ($0.005 run start + $3.40 data charge). On higher subscription tiers (Business, Platinum, Diamond) with automated volume discounts, 1,000 application details cost as low as $1.705 ($0.005 run start + $1.70 data charge).

#### Can I scrape customer reviews in languages other than English?

Yes. User reviews in the Apple App Store are partitioned by geographic storefront. Setting `country: "fr"` retrieves reviews submitted by French storefront users, `country: "de"` returns German reviews, and `country: "jp"` returns Japanese reviews.

#### Does this Actor require an Apple ID or Apple Developer account?

No. The scraper accesses only public App Store storefront information. You do not need an Apple account, login credentials, private certificates, or an active Apple Developer subscription.

#### How do I track competitor ratings and version changes over time?

Configure a scheduled run in Apify Console set to `mode: "details"` with your target competitor app IDs. Schedule the run to trigger weekly and connect the output dataset to Google Sheets in append mode. This creates an ongoing audit log of rating fluctuations, version increments, and changelog updates.

#### Can I extract both iPad and iPhone applications?

Yes. The scraper returns applications across all iOS and iPadOS platforms, and distinguishes between device-specific screenshot previews with dedicated `screenshotUrls` and `ipadScreenshotUrls` arrays.

#### What happens if an app ID does not exist?

If an invalid or defunct numeric ID is provided, the Actor safely logs an informative warning, skips the missing entry without throwing unhandled exceptions, and continues processing the remainder of your requested apps.

#### Is scraping public App Store data compliant with web standards?

Yes. Apple App Store Scraper collects exclusively publicly accessible product metadata and customer reviews published on open storefront listings. The Actor respects public server rate limits, avoids unnecessary request overhead, and does not access private account information or bypass authenticated paywalls. Always ensure your specific downstream data processing activities comply with applicable regional privacy and data handling regulations.

# Actor input Schema

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

Choose what to scrape: search apps by keyword, look up app details by ID/URL, extract customer reviews, or discover top charts.

## `searchTerm` (type: `string`):

Keyword to search the App Store for in search mode. For example: "budget planner", "language learning".

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

Apple App Store URLs or numeric app IDs. Used in 'details' and 'reviews' modes. For example: "https://apps.apple.com/us/app/duolingo-language-lessons/id570060128" or "570060128".

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

Apple chart feed to discover in 'charts' mode: Top Free or Top Paid apps.

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

Number of ranked apps to resolve from the ranking feed in 'charts' mode (1–100).

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

Two-letter country code for the target App Store storefront (e.g. "us", "gb", "de", "fr", "jp"). Affects pricing currency, availability, and review language.

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

Filter results by app pricing tier: all apps, free apps only, or paid apps only.

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

Maximum records to output for each requested item type per query. In details mode with reviews enabled, this limits app rows and review rows independently. Set 0 for unlimited.

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

When in 'details' or 'search' mode, also fetch customer reviews for each resolved app alongside its metadata.

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

How to sort customer reviews. Used in 'reviews' mode or when 'Include reviews' is enabled.

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

Apify Proxy or custom proxy settings to ensure high concurrency, speed, and avoid rate limits.

## Actor input object example

```json
{
  "mode": "search",
  "searchTerm": "budget planner",
  "appIds": [
    "https://apps.apple.com/us/app/duolingo-language-lessons/id570060128"
  ],
  "chartType": "top-free",
  "chartLimit": 20,
  "country": "us",
  "priceFilter": "all",
  "maxItems": 20,
  "includeReviews": false,
  "reviewSort": "mostRecent",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

The apps and 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 = {
    "searchTerm": "budget planner",
    "appIds": [
        "https://apps.apple.com/us/app/duolingo-language-lessons/id570060128"
    ],
    "chartLimit": 20,
    "country": "us",
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("karamelo/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 = {
    "searchTerm": "budget planner",
    "appIds": ["https://apps.apple.com/us/app/duolingo-language-lessons/id570060128"],
    "chartLimit": 20,
    "country": "us",
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("karamelo/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 '{
  "searchTerm": "budget planner",
  "appIds": [
    "https://apps.apple.com/us/app/duolingo-language-lessons/id570060128"
  ],
  "chartLimit": 20,
  "country": "us",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call karamelo/apple-app-store-scraper --silent --output-dataset

```

## MCP server setup

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