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

Apple App Store Scraper collects app listings and reviews by search term or app ID, with country targeting and review sorting. 📱 Use it for ASO keyword research, competitor tracking, rating monitoring and mobile app market analysis.

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

## Pricing

from $1.99 / 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.

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

### 🍎 Apple App Store Scraper – Scrape iOS App Data, Ratings, Reviews & ASO

The **Apple App Store Scraper** extracts iOS app data from the Apple App Store — app name, bundle ID, developer, description, version history, price, ratings, screenshots, supported devices, and user reviews. Use it to **scrape App Store apps and reviews** for ASO research, competitor tracking, and iOS market intelligence, with 41 structured fields per app. 📲

No API key, no Apple Developer account, no login. Search by keyword or pass specific app IDs, and the Actor returns clean JSON ready for CSV, Excel, or your analytics stack.

***

### 📊 What Data Can You Extract with This App Store Scraper?

This Apple App Store scraper returns **41 fields**, split between app metadata and optional review data:

| Data Category | Fields You Get |
|---|---|
| 🏷️ **App Identity** | `appId`, `appName`, `bundleId`, `appUrl`, `primaryGenre`, `genres` |
| 📝 **ASO Text** | `description`, `releaseNotes` |
| 💰 **Pricing** | `price`, `formattedPrice`, `currency` |
| ⭐ **Ratings** | `rating`, `ratingCount`, `ratingCountCurrentVersion` |
| 🏢 **Developer & Seller** | `developer`, `developerUrl`, `sellerName`, `sellerUrl` |
| 🎨 **Creative Assets** | `iconUrl`, `screenshotUrls`, `ipadScreenshotUrls` |
| ⚙️ **Technical Specs** | `minimumOsVersion`, `fileSizeBytes`, `supportedDevices`, `languages`, `features` |
| 🗓️ **Version History** | `version`, `currentVersionDate`, `releaseDate` |
| 💬 **Reviews** *(optional)* | `reviewId`, `title`, `content`, `author`, `authorUrl`, `appVersion`, `date`, `voteSum`, `voteCount` |

`ratingCountCurrentVersion` alongside total `ratingCount` is a genuinely useful pair — it tells you whether an app's reputation reflects the version shipping today or years of accumulated history.

***

### 🌟 Key Features of the Apple App Store Scraper

| Feature | Description |
|---|---|
| 🔍 **Search or Lookup Mode** | Find iOS apps by keyword, or pull exact apps by their App Store IDs. |
| 💬 **Optional Review Scraping** | Toggle `includeReviews` to attach user reviews with ratings, titles, and authors. |
| 🌍 **Country Storefronts** | Target any App Store country for local pricing, ranking, and availability. |
| ⭐ **Ratings Breakdown** | Overall rating, total rating count, and ratings for the current version only. |
| 🖼️ **Device-Specific Screenshots** | Separate iPhone and iPad screenshot URL lists. |
| 📝 **Release Notes & Version History** | Current version, release date, update date, and full changelog text. |
| 🏢 **Developer & Seller Details** | Developer name, developer page URL, seller name, and seller website. |
| ⚙️ **Technical Metadata** | Minimum iOS version, file size, supported devices, and localisation list. |
| 🔀 **Review Sorting** | Sort reviews by most recent or most helpful. |

***

### 🚀 Why Choose This Apple App Store Scraper?

**No Apple Developer account required.** App Store Connect only exposes data for apps you own. This scraper reads Apple's public lookup endpoints, so you can research any app on the store — including every competitor.

**Search and lookup in one Actor.** Discover apps by keyword when you're exploring a category, then switch to exact-ID lookup once you know which apps you're tracking. No second tool needed.

**Reviews are optional, not mandatory.** Review scraping meaningfully increases run time. Keeping it behind a toggle means metadata-only runs stay fast and cheap.

**Complete creative assets.** `screenshotUrls` and `ipadScreenshotUrls` are separated by device class, which matters because iPhone and iPad listings often use entirely different creative strategies.

***

### 📥 Input

**Search mode:**

```json
{
  "mode": "search",
  "searchTerm": "photo editor",
  "country": "us",
  "maxItems": 50,
  "includeReviews": false
}
```

**Lookup mode with reviews:**

```json
{
  "mode": "lookup",
  "appIds": ["587366035"],
  "country": "us",
  "includeReviews": true,
  "reviewSort": "mostRecent"
}
```

#### 🔧 App Store Scraper Input Fields

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `mode` | `string` | ✅ Yes | `search` | `search` by keyword or look up specific app IDs. |
| `searchTerm` | `string` | ❌ No | `photo editor` | Keyword to search the App Store with. |
| `appIds` | `array` | ❌ No | `[]` | Specific Apple App Store IDs to fetch. |
| `country` | `string` | ❌ No | `us` | App Store country storefront. |
| `maxItems` | `integer` | ❌ No | `50` | Maximum apps to return. |
| `includeReviews` | `boolean` | ❌ No | `false` | Also scrape user reviews for each app. |
| `reviewSort` | `string` | ❌ No | `mostRecent` | Sort order for the reviews. |

#### 💡 Input Examples

**Research a category on the UK App Store:**

```json
{ "mode": "search", "searchTerm": "meditation", "country": "gb", "maxItems": 100 }
```

**Track specific competitor apps with reviews:**

```json
{ "mode": "lookup", "appIds": ["587366035", "284882215"],
  "includeReviews": true, "reviewSort": "mostRecent" }
```

***

### 📤 Output

Each dataset item is one iOS app. Real sample from an actual run:

```json
{
  "appId": 587366035,
  "appName": "Picsart AI Photo Editor, Video",
  "bundleId": "com.picsart.studio",
  "developer": "PicsArt, Inc.",
  "sellerUrl": "https://picsart.com",
  "version": "30.5.2",
  "currentVersionDate": "2026-08-11T04:48:21Z",
  "releaseDate": "2013-01-02T22:14:40Z",
  "price": 0,
  "formattedPrice": "Free",
  "currency": "USD",
  "rating": 4.66606,
  "primaryGenre": "Photo & Video"
}
```

#### 🧾 iOS App Output Fields

| Field | Description |
|---|---|
| `appId` / `bundleId` | Apple's numeric app ID and the reverse-DNS bundle identifier. |
| `appName` / `appUrl` | App title and its App Store listing URL. |
| `description` / `releaseNotes` | Full listing copy and latest changelog — the core ASO text. |
| `version` / `currentVersionDate` / `releaseDate` | Current version, its release date, and original launch date. |
| `price` / `formattedPrice` / `currency` | Numeric price, display price, and currency code. |
| `rating` / `ratingCount` / `ratingCountCurrentVersion` | Average rating and rating volumes. |
| `developer` / `developerUrl` / `sellerName` / `sellerUrl` | Publisher identity and website. |
| `genres` / `primaryGenre` | App Store category taxonomy. |
| `iconUrl` / `screenshotUrls` / `ipadScreenshotUrls` | Creative assets by device class. |
| `minimumOsVersion` / `fileSizeBytes` / `supportedDevices` | Technical requirements. |
| `languages` / `contentRating` / `features` | Localisation and content metadata. |
| `scrapedAt` | UTC timestamp of extraction. |

#### 🧾 App Store Review Output Fields

*(returned when `includeReviews` is enabled)*

| Field | Description |
|---|---|
| `reviewId` / `title` / `content` | Review ID, headline, and body text. |
| `author` / `authorUrl` | Reviewer name and profile link. |
| `appVersion` / `date` | App version reviewed and the review date. |
| `voteSum` / `voteCount` | Helpfulness votes on the review. |

***

### 💻 How to Use the Apple App Store Scraper (Step by Step)

#### Step 1: Pick Search or Lookup Mode

Use `search` when you're exploring a category and don't yet know which apps matter. Use `lookup` when you have a fixed list of competitors to track over time.

#### Step 2: Find Your App Store IDs

The app ID is the number after `id` in any App Store URL. In `apps.apple.com/us/app/picsart/id587366035`, the app ID is `587366035`. You can pass several at once in `appIds`.

#### Step 3: Choose Your Country Storefront

Set `country` to a two-letter code such as `us`, `gb`, `de`, `jp`, or `in`. Pricing, availability, and ranking all differ by storefront — research the market you actually sell into.

#### Step 4: Decide Whether You Need Reviews

Leave `includeReviews` off for fast metadata-only runs. Turn it on when you're doing sentiment work, and set `reviewSort` to `mostRecent` for freshness or most-helpful for signal.

#### Step 5: Set Your Result Limit

`maxItems` caps how many apps come back. Search mode with a broad term can match a very large number of apps, so start conservative.

#### Step 6: Run the App Store Scraper

Click **Start**. The Actor queries Apple's public lookup endpoints, normalises the response, and streams structured results into your dataset.

#### Step 7: Export and Schedule for ASO Tracking

Export as JSON, CSV, Excel, or XML — or schedule recurring runs to build a version and rating history for every app you track.

***

### 🔌 API Access & Integrations

**Scrape App Store data in one call:**

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapers-hub~apple-app-store-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"search","searchTerm":"meditation","country":"us","maxItems":50}'
```

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("scrapers-hub/apple-app-store-scraper").call(run_input={
    "mode": "lookup",
    "appIds": ["587366035"],
    "includeReviews": True,
})

for app in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(app.get("appName"), app.get("rating"), app.get("version"))
```

Send iOS app data to **Google Sheets, Slack, Zapier, Make, Airbyte, or a webhook** through the standard Apify integrations.

***

### 💡 Best Use Cases for Apple App Store Data

#### 🔝 App Store Optimization (ASO)

Search your target keywords, pull the top results, and analyse their `appName`, `description`, and `primaryGenre`. Because Apple weights the app title heavily, comparing titles across ranking apps is one of the highest-signal ASO exercises available.

#### 🥊 Competitor Monitoring

Track a rival's `version`, `currentVersionDate`, `rating`, and `formattedPrice` on a schedule. Shipping cadence is a reliable proxy for team size and investment, and price changes often precede a bigger strategy shift.

#### 💬 Review Sentiment Analysis

Enable `includeReviews` and mine `content` for recurring complaints. Grouping by `appVersion` tells you whether an issue is new or long-standing — and `voteSum` surfaces which complaints other users agree with.

#### 📊 iOS Market Research

Scrape a whole category to measure saturation, the free-versus-paid split, average rating, and typical file size. `minimumOsVersion` across a category also reveals how aggressively that market drops support for older devices.

#### 🎨 Creative & Screenshot Benchmarking

Pull `screenshotUrls` and `ipadScreenshotUrls` for top-ranking apps to see current visual conventions before briefing a designer. Device-split assets show how competitors adapt their message per form factor.

#### 🌍 Localisation Strategy

`languages` shows which locales competitors support. Run the same search across several `country` values to find markets where strong demand meets weak localised competition.

#### 🤝 Publisher Lead Generation

`developer`, `developerUrl`, `sellerName`, and `sellerUrl` build a prospect list of app publishers — useful for agencies selling ASO, UA, or QA services.

***

### ⚙️ Tips for Better App Store Scraping Results

- **Keep reviews off for discovery runs.** Metadata-only scraping is much faster when you're still narrowing your app list.
- **Compare `ratingCountCurrentVersion` to `ratingCount`.** A tiny current-version count under a huge total means the headline rating is mostly historical.
- **Run the same search across countries.** The gap between storefronts is where under-served markets show up.
- **Snapshot `description` regularly.** Competitors rewrite listings often; a periodic capture builds an ASO change history.
- **Use lookup mode for tracking.** Search results shift; a fixed `appIds` list keeps your time series consistent.
- **Check `minimumOsVersion` before benchmarking.** Apps targeting older iOS versions serve a different audience.

***

### 🛠️ Troubleshooting

**Search returns fewer apps than `maxItems`.**
Apple's search endpoint caps results per query. Narrow or vary your `searchTerm` to surface more of the category.

**No reviews came back.**
Confirm `includeReviews` is `true`. Newly released apps and niche storefronts often have very few public reviews.

**The app ID isn't recognised.**
Use the numeric ID only — `587366035`, not `id587366035` and not the full URL.

**Prices show as 0.**
That's a free app. Check `formattedPrice` — it will read "Free".

**Results differ from what I see in the App Store app.**
Apple personalises in-app results by account and device. The scraper returns a clean, unpersonalised storefront view.

***

### ❓ Frequently Asked Questions About App Store Scraping

**How do I scrape Apple App Store data?**
Choose `search` mode, enter a keyword, and run the Actor. It returns full app metadata for every matching iOS app — no Apple Developer account needed.

**Can I get App Store reviews too?**
Yes. Set `includeReviews` to `true` and each app returns with its reviews, including author, title, body, app version, and helpfulness votes.

**Where do I find an app's App Store ID?**
It's the number after `id` in the App Store URL — e.g. `587366035` in `apps.apple.com/us/app/picsart/id587366035`.

**Can I scrape a different country's App Store?**
Yes. Set `country` to the storefront code such as `us`, `gb`, `de`, `fr`, `jp`, or `in`.

**Do I need an Apple API key?**
No. The scraper uses Apple's public iTunes lookup endpoints, so no key or authentication is required.

**Can I scrape multiple apps at once?**
Yes — pass several IDs in the `appIds` array and they're all scraped in a single run.

**Does it return app screenshots?**
Yes, and they're split by device: `screenshotUrls` for iPhone and `ipadScreenshotUrls` for iPad.

**Can I track an app's version history?**
Each run captures `version`, `currentVersionDate`, and `releaseNotes`. Schedule recurring runs and store each snapshot to build a release timeline.

**What is `ratingCountCurrentVersion`?**
The number of ratings for the currently shipping version only, versus `ratingCount` for the app's entire history. Comparing them shows whether the current release is well received.

**Can I find the developer's website?**
Yes — `developerUrl` links to their App Store developer page and `sellerUrl` to their own website.

**Does it work for iPad and Apple TV apps?**
iPad data is included via `ipadScreenshotUrls` and `supportedDevices`. Coverage follows whatever Apple exposes on the public listing.

**How do I do ASO keyword research with this scraper?**
Run `search` mode across your keyword list and record which apps appear for each term, then analyse their titles and descriptions for patterns.

**What export formats are supported?**
JSON, CSV, Excel, XML, plus direct API access and integrations with Google Sheets, Zapier, Make, and Slack.

**Is scraping the Apple App Store legal?**
The Actor reads only publicly accessible listings and Apple's public lookup endpoints. Review data contains personal names and opinions, so privacy regulations apply. See the disclaimer below.

***

### 🆘 Support & Feedback

💬 Need an extra App Store field, a different sort order, or another storefront? Open a ticket in the **Issues** tab of this Actor.

📩 For custom iOS app datasets, ASO pipelines, or enterprise volume, email **<scraperhubapi@gmail.com>**.

⭐ If this Apple App Store scraper saves you time, a review helps other ASO and product teams find it.

***

### ⚖️ Disclaimer

This Apple App Store scraper collects data solely from **publicly accessible** App Store listings and Apple's public lookup endpoints. It does not access private accounts, App Store Connect, or content behind a login. Review data includes reviewer names and opinions — handle it in line with GDPR, CCPA, and other privacy regulations, and with Apple's terms of service. App descriptions, icons, and screenshots remain the property of their developers.

For data removal requests, contact **<scraperhubapi@gmail.com>**. Use this scraper responsibly, ethically, and only for legitimate research or business purposes.

# Actor input Schema

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

"search" finds apps by searchTerm, "details" fetches specific apps by appIds, "reviews" extracts reviews for appIds

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

Keyword to search for on the App Store. Required when mode is "search".

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

App Store URLs or numeric app IDs. Required when mode is "details" or "reviews".

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

Two-letter App Store storefront country code

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

Maximum apps (search/details, capped at 200) or reviews per app (reviews mode, capped at 500) to extract. 0 = maximum allowed.

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

Also fetch reviews for each app. Used in "search" and "details" modes.

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

Sort order for reviews. Used when includeReviews is true or mode is "reviews".

## Actor input object example

```json
{
  "mode": "search",
  "searchTerm": "photo editor",
  "appIds": [],
  "country": "us",
  "maxItems": 50,
  "includeReviews": false,
  "reviewSort": "mostRecent"
}
```

# Actor output Schema

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

Records scraped by Apple App Store Scraper, stored in the run's default dataset.

# 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": "photo editor"
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers-hub/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": "photo editor" }

# Run the Actor and wait for it to finish
run = client.actor("scrapers-hub/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": "photo editor"
}' |
apify call scrapers-hub/apple-app-store-scraper --silent --output-dataset

```

## MCP server setup

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