# App Store Scraper (`crawlerbros/appstore-scraper`) Actor

Scrape Apple App Store search results and app details using the public iTunes API. Extract app name, rating, reviews, price, developer info, screenshots, and more.

- **URL**: https://apify.com/crawlerbros/appstore-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Other, Developer tools, SEO tools
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 14 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.50 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## App Store Scraper

Scrape Apple App Store search results and app details at scale. Extract comprehensive app data including name, rating, reviews, price, developer info, screenshots, and more using the public iTunes Search API.

### What does App Store Scraper do?

App Store Scraper lets you extract structured data from the Apple App Store without any authentication, proxies, or browser automation. It uses Apple's official public iTunes Search API to retrieve app metadata quickly and reliably.

Use it to:

- **Search for apps** by keyword and get detailed results
- **Look up specific apps** by their App Store ID
- **Monitor competitors** by tracking ratings, reviews, and pricing
- **Analyze app categories** and market trends
- **Track app updates** and version history

### Input

| Field | Type | Description | Default |
|-------|------|-------------|---------|
| `searchTerms` | Array of strings | Keywords to search for on the App Store | `[]` |
| `appIds` | Array of strings | Specific App Store IDs to look up (e.g., `"544007664"` for YouTube) | `[]` |
| `country` | String | Two-letter ISO country code (e.g., `us`, `gb`, `de`, `jp`) | `"us"` |
| `maxResults` | Integer | Maximum number of apps to return (1-200) | `50` |

You must provide at least one of `searchTerms` or `appIds`.

#### Input example

```json
{
  "searchTerms": ["photo editor", "fitness tracker"],
  "appIds": ["544007664"],
  "country": "us",
  "maxResults": 50
}
````

### Output

Each app in the output dataset contains the following fields:

| Field | Type | Description |
|-------|------|-------------|
| `appId` | String | Unique Apple App Store ID |
| `name` | String | App name |
| `url` | String | Direct App Store URL |
| `developer` | String | Developer or seller name |
| `developerId` | String | Developer's Apple artist ID |
| `developerUrl` | String | Developer's App Store page URL |
| `developerWebsite` | String | Developer's external website |
| `price` | Number | Price in local currency (0 for free apps) |
| `formattedPrice` | String | Human-readable price (e.g., "Free", "$4.99") |
| `currency` | String | Currency code (USD, EUR, GBP, etc.) |
| `rating` | Number | Average user rating across all versions (0-5) |
| `ratingCount` | Integer | Total number of user ratings |
| `currentVersionRating` | Number | Average rating for current version |
| `currentVersionRatingCount` | Integer | Number of ratings for current version |
| `description` | String | Full app description |
| `releaseNotes` | String | Latest version release notes |
| `version` | String | Current version number |
| `releaseDate` | String | Original release date (ISO 8601) |
| `lastUpdated` | String | Latest version release date (ISO 8601) |
| `category` | String | Primary genre/category |
| `genres` | Array | All genres/categories |
| `contentRating` | String | Age rating (e.g., "4+", "12+", "17+") |
| `bundleId` | String | App bundle identifier |
| `minimumOs` | String | Minimum required iOS version |
| `fileSize` | String | File size in bytes |
| `icon` | String | App icon URL |
| `screenshots` | Array | iPhone screenshot URLs |
| `ipadScreenshots` | Array | iPad screenshot URLs |
| `languages` | Array | Supported language codes |
| `scrapedAt` | String | Scraping timestamp (ISO 8601) |

#### Output example

```json
{
  "appId": "544007664",
  "name": "YouTube: Watch, Listen, Stream",
  "url": "https://apps.apple.com/us/app/youtube-watch-listen-stream/id544007664",
  "developer": "Google LLC",
  "developerId": "544007664",
  "developerUrl": "https://apps.apple.com/us/developer/google-llc/id281956209",
  "developerWebsite": "https://www.youtube.com/",
  "price": 0,
  "formattedPrice": "Free",
  "currency": "USD",
  "rating": 4.69,
  "ratingCount": 16853204,
  "currentVersionRating": 4.69,
  "currentVersionRatingCount": 16853204,
  "description": "Watch your favorite videos, music and more...",
  "releaseNotes": "Bug fixes and stability improvements.",
  "version": "19.50.2",
  "releaseDate": "2012-09-11T07:00:00Z",
  "lastUpdated": "2024-12-16T08:00:00Z",
  "category": "Photo & Video",
  "genres": ["Photo & Video", "Entertainment"],
  "contentRating": "17+",
  "bundleId": "com.google.ios.youtube",
  "minimumOs": "16.0",
  "fileSize": "290816000",
  "icon": "https://is1-ssl.mzstatic.com/image/thumb/...",
  "screenshots": ["https://is1-ssl.mzstatic.com/image/..."],
  "ipadScreenshots": ["https://is1-ssl.mzstatic.com/image/..."],
  "languages": ["EN", "ES", "FR", "DE", "JA"],
  "scrapedAt": "2024-12-20T10:30:00.000000+00:00"
}
```

### How much does it cost to use App Store Scraper?

This scraper uses Apple's free public iTunes Search API, which requires:

- **No proxy** - Direct API calls without any proxy costs
- **No browser** - Pure HTTP requests, minimal compute usage
- **No authentication** - No cookies or login required

The cost is determined only by Apify platform compute units, which are minimal since this actor uses lightweight HTTP requests only.

### Supported countries

The scraper supports all App Store regions. Use the standard two-letter ISO 3166-1 alpha-2 country codes:

| Code | Country | Code | Country |
|------|---------|------|---------|
| `us` | United States | `gb` | United Kingdom |
| `ca` | Canada | `au` | Australia |
| `de` | Germany | `fr` | France |
| `jp` | Japan | `kr` | South Korea |
| `cn` | China | `in` | India |
| `br` | Brazil | `mx` | Mexico |

And many more. See the full list of [ISO 3166-1 alpha-2 codes](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2).

### Tips and limitations

- The iTunes Search API returns a maximum of 200 results per search term. Use multiple specific search terms for broader coverage.
- Some fields like `developerWebsite` or `releaseNotes` may be empty if the developer hasn't provided them.
- Results may vary by country due to regional app availability and localization.
- A 3-second delay is applied between API calls to respect rate limits.
- Duplicate apps across multiple search terms are automatically deduplicated.

### FAQ

**Can I scrape any app from the App Store?**
Yes, any app publicly listed on the App Store can be scraped. You can search by keyword or look up specific apps by their App Store ID.

**Where do I find an app's App Store ID?**
Open the app in a browser at `apps.apple.com`. The numeric ID is in the URL, e.g., `https://apps.apple.com/us/app/youtube/id544007664` -- the ID is `544007664`.

**How often is the data updated?**
The iTunes API returns real-time data from Apple's servers. Ratings, prices, and other metadata reflect the current state of the App Store.

**Can I get user reviews?**
This scraper focuses on app metadata (ratings, descriptions, pricing). Individual user reviews are not available through the iTunes Search API.

**Is there a rate limit?**
Apple's iTunes API has undocumented rate limits. This scraper includes built-in delays (3 seconds between requests) to stay within safe limits.

**Can I use this for market research?**
Absolutely. The structured output is ideal for competitive analysis, market sizing, pricing research, and tracking app category trends.

# Actor input Schema

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

List of keywords to search for on the App Store. Each term will return matching apps.

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

Specific Apple App Store app IDs to look up (e.g., '544007664' for YouTube).

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

Direct App Store URLs (e.g., https://apps.apple.com/us/app/youtube/id544007664). The app ID is extracted automatically.

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

Two-letter ISO country code for the App Store region (e.g., 'us', 'gb', 'de', 'jp'). Affects pricing, availability, and reviews language.

## `maxResults` (type: `integer`):

Maximum number of apps to return per search term (up to 200).

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

Fetch customer reviews for each app. Up to 50 reviews per page, controlled by Review Pages setting.

## `reviewPages` (type: `integer`):

Number of review pages to fetch per app (50 reviews per page, max 10 pages = 500 reviews). Only used when Include Reviews is enabled.

## Actor input object example

```json
{
  "searchTerms": [
    "calculator"
  ],
  "country": "us",
  "maxResults": 5,
  "includeReviews": false,
  "reviewPages": 1
}
```

# 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": [
        "calculator"
    ],
    "maxResults": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/appstore-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": ["calculator"],
    "maxResults": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/appstore-scraper").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 '{
  "searchTerms": [
    "calculator"
  ],
  "maxResults": 5
}' |
apify call crawlerbros/appstore-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/appstore-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "App Store Scraper",
        "description": "Scrape Apple App Store search results and app details using the public iTunes API. Extract app name, rating, reviews, price, developer info, screenshots, and more.",
        "version": "1.0",
        "x-build-id": "Er0dsgGchY3PepWfT"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~appstore-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-appstore-scraper",
                "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/crawlerbros~appstore-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-appstore-scraper",
                "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/crawlerbros~appstore-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-appstore-scraper",
                "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": {
                    "searchTerms": {
                        "title": "Search Terms",
                        "type": "array",
                        "description": "List of keywords to search for on the App Store. Each term will return matching apps.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "appIds": {
                        "title": "App IDs",
                        "type": "array",
                        "description": "Specific Apple App Store app IDs to look up (e.g., '544007664' for YouTube).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "App Store URLs",
                        "type": "array",
                        "description": "Direct App Store URLs (e.g., https://apps.apple.com/us/app/youtube/id544007664). The app ID is extracted automatically.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "country": {
                        "title": "Country Code",
                        "type": "string",
                        "description": "Two-letter ISO country code for the App Store region (e.g., 'us', 'gb', 'de', 'jp'). Affects pricing, availability, and reviews language.",
                        "default": "us"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of apps to return per search term (up to 200).",
                        "default": 50
                    },
                    "includeReviews": {
                        "title": "Include Reviews",
                        "type": "boolean",
                        "description": "Fetch customer reviews for each app. Up to 50 reviews per page, controlled by Review Pages setting.",
                        "default": false
                    },
                    "reviewPages": {
                        "title": "Review Pages per App",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of review pages to fetch per app (50 reviews per page, max 10 pages = 500 reviews). Only used when Include Reviews is enabled.",
                        "default": 1
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
