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

Scrape Apple App Store apps by keyword, App ID, bundle ID, developer or URL: ratings, prices, versions, release notes, screenshots, genres and sizes, plus optional reviews and similar apps from 115 country stores.

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

## Pricing

from $0.10 / 1,000 data

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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### Apple App Store Scraper

**Apple App Store Scraper** extracts app data from the [Apple App Store](https://apps.apple.com/us/iphone/today) by keyword, App ID, bundle ID, developer ID, or App Store URL. You get ratings, rating counts, prices, versions, release notes, file sizes, genres, screenshots, and age ratings, plus optional customer reviews and similar apps, as clean JSON, CSV, or Excel.

<table><tr>
<td style="border-left:4px solid #007AFF;padding:12px 16px;font-weight:600">
Search any of 115 country stores in Apple's own ranking order, or look up apps by ID, bundle ID, developer, or URL, and get 45+ fields per app, with up to 5,000 reviews per app (4 sort orders, developer replies included) and about 60 "You Might Also Like" apps.
</td>
</tr></table>

##### Copy to your AI assistant

Copy this block into ChatGPT, Claude, Cursor, or any LLM to start using this actor.

```
Apify Actor: parsebird/app-store-scraper. Scrapes the Apple App Store (apps.apple.com): app details, ratings, prices, versions, release notes, screenshots, genres, age ratings, plus optional customer reviews and similar apps. Call via ApifyClient: client.actor("parsebird/app-store-scraper").call(run_input={"term": "photo editor", "country": "us", "endPage": 1, "maxItems": 20, "includeReviews": true, "reviewsSort": "mostRecent"}). Inputs: term (string keyword; results in App Store ranking order, up to ~250 apps, 50 per page), startUrls (array of App Store app URLs like https://apps.apple.com/us/app/instagram/id389801252 or developer URLs like https://apps.apple.com/us/developer/meta-platforms-inc/id284882218), appIds (array of numeric App Store IDs), bundleIds (array, e.g. com.burbn.instagram), developerIds (array of numeric developer IDs; returns up to 200 apps each), mode (optional: "search" = keyword only, "lookup" = IDs/URLs only; empty = run everything given), country (two-letter store code, default us, 115 stores), lang (optional language such as en, es, fr-CA, pt-BR), page (first search page, default 1), endPage (last search page; also max review pages per app; empty = unbounded), maxItems (max apps saved, empty = all), includeReviews (boolean, 20 reviews per page, max 5,000 per app), reviewsSort (mostRecent, mostHelpful, mostFavorable, mostCritical), includeSimilarApps (boolean, "You Might Also Like" list), customMapFunction (JavaScript function string to reshape each item), outputConnector/deliverTarget/deliverMode/deliverMaxItems (optional delivery to Notion, Todoist and other apps via Apify MCP connectors). Output fields per app: inputSource (flow, sourceId, page, position), country, trackId, bundleId, trackName, trackViewUrl, artworkUrl60/100/512, description, primaryGenreName, genres, contentAdvisoryRating, advisories, languageCodesISO2A, fileSizeBytes, minimumOsVersion, releaseDate, currentVersionReleaseDate, releaseNotes, version, price, formattedPrice, currency, artistId, artistName, sellerName, sellerUrl, averageUserRating, userRatingCount, averageUserRatingForCurrentVersion, userRatingCountForCurrentVersion, screenshotUrls, ipadScreenshotUrls, supportedDevices, similarApps, reviews (id, userName, title, review, rating, date, isEdited, developerResponse), scrapedAt. Pricing: pay per event (app saved, direct lookup, search page, review page, similar-apps lookup, developer lookup). Full API spec: https://apify.com/parsebird/app-store-scraper/api. Get your token: https://console.apify.com/settings/integrations.
```

### What is Apple App Store Scraper?

**Apple App Store Scraper** turns the [App Store](https://www.apple.com/app-store/) into a dataset. Type a keyword to get the apps in the same order the App Store ranks them, or paste App IDs, bundle IDs, developer IDs, or App Store links to pull exact apps. It's an easy **App Store API alternative**: you don't need an Apple developer account, an API key, or any code.

Use it to track competitors, monitor ratings and releases, research keywords and app store optimization (ASO), or collect app reviews for analysis.

### What can Apple App Store Scraper do?

- 🔎 **Keyword search in App Store ranking order.** Get up to about 250 apps per keyword in the order the App Store shows them, with each app's search position saved in `inputSource.position`.
- 🆔 **Lookups by ID, bundle ID, or URL.** Pull exact apps by numeric App ID (`389801252`), bundle ID (`com.burbn.instagram`), or App Store link. Mix all of them in one run.
- 🏢 **Every app by a developer.** Add a developer ID or developer page URL to get up to 200 apps that developer publishes in the chosen store.
- 💬 **App Store reviews.** Collect up to 5,000 customer reviews per app, sorted by most recent, most helpful, most favorable, or most critical, with the developer's reply when there is one.
- 🧭 **Similar apps.** Get the app's "You Might Also Like" list, usually about 60 apps, with names, bundle IDs, prices, and ratings.
- 🌍 **115 country stores.** Read prices, currencies, rankings, ratings, and reviews from any of 115 App Store storefronts, with an optional language such as `es` or `fr-CA`.
- 🧩 **Custom output.** Reshape every item with your own JavaScript map function, or send results straight to Notion, Todoist, and other apps through [Apify MCP connectors](https://docs.apify.com/platform/integrations/mcp).
- 📅 **Scheduling, API, and integrations.** Run daily with [Apify Schedules](https://docs.apify.com/platform/schedules), call it from the [Apify API](https://docs.apify.com/api/v2), and connect Google Sheets, Zapier, Make, Slack, or webhooks with [Apify integrations](https://docs.apify.com/platform/integrations).

### What data can you extract from the App Store?

| Field | Description |
|-------|-------------|
| `trackId` / `bundleId` / `trackName` / `trackViewUrl` | App Store ID, bundle ID, app name, and App Store link |
| `averageUserRating` / `userRatingCount` | Average star rating and total number of ratings |
| `averageUserRatingForCurrentVersion` / `userRatingCountForCurrentVersion` | Rating and rating count for the current version |
| `price` / `formattedPrice` / `currency` | Price in the store's currency (`0` and `Free` for free apps) |
| `version` / `currentVersionReleaseDate` / `releaseNotes` | Latest version, when it shipped, and its "What's New" text |
| `releaseDate` | Date the app was first released |
| `artistId` / `artistName` / `sellerName` / `sellerUrl` | Developer ID and name, seller, and developer website |
| `primaryGenreName` / `genres` / `genreIds` | Primary category and all categories |
| `contentAdvisoryRating` / `advisories` | Age rating (like `12+`) and content warnings |
| `description` | Full App Store description |
| `fileSizeBytes` / `minimumOsVersion` / `supportedDevices` | Download size, minimum iOS version, and supported devices |
| `languageCodesISO2A` | Languages the app supports |
| `artworkUrl60` / `artworkUrl100` / `artworkUrl512` | App icon in three sizes |
| `screenshotUrls` / `ipadScreenshotUrls` / `appletvScreenshotUrls` | Screenshot image URLs |
| `features` / `isGameCenterEnabled` | Features such as `iosUniversal`, and Game Center support |
| `inputSource` | How the app was found: `search`, `lookup-app`, `lookup-bundle`, or `developer`, plus the keyword or ID, and the search page and position |
| `reviews` | Customer reviews: `id`, `userName`, `title`, `review`, `rating`, `date`, `isEdited`, `developerResponse` |
| `similarApps` | "You Might Also Like" apps: `trackId`, `bundleId`, `trackName`, `artistName`, `price`, `averageUserRating`, and more |

### How to scrape the Apple App Store

1. Open [Apple App Store Scraper](https://apify.com/parsebird/app-store-scraper) on Apify Store and click **Try for free**.
2. Enter a **Search keyword**, like `photo editor`, or add **App Store URLs**, **App IDs**, **Bundle IDs**, or **Developer IDs**.
3. Pick a **Store country**, and optionally a **Language**.
4. Set **Last page** and **Max apps** to control how many apps you get. Each search page holds up to 50 apps.
5. Turn on **Include reviews** or **Include similar apps** if you need them, and choose a **Review sort order**.
6. Click **Start** and wait for the run to finish.
7. Download the data as JSON, CSV, Excel, XML, or HTML from the **Output** tab, or read it with the API.

### How much does it cost to scrape the App Store?

Apple App Store Scraper uses **pay-per-event** pricing, so you only pay for what the run actually does. Compute and proxy costs are included in the event prices.

| Event | When it's charged | Free | Bronze | Silver | Gold |
|-------|-------------------|------|--------|--------|------|
| `app-data` | Each app saved to the dataset | $0.10 / 1,000 | $0.10 / 1,000 | $0.10 / 1,000 | $0.10 / 1,000 |
| `app-detail` | Each app found by a direct App ID, bundle ID, or app URL lookup | $0.20 / 1,000 | $0.20 / 1,000 | $0.20 / 1,000 | $0.20 / 1,000 |
| `search-page` | Each page of keyword search results (up to 50 apps) | $3.99 / 1,000 | $3.79 / 1,000 | $3.59 / 1,000 | $3.39 / 1,000 |
| `review-page` | Each page of reviews (20 reviews) when **Include reviews** is on | $4.99 / 1,000 | $4.49 / 1,000 | $3.99 / 1,000 | $3.49 / 1,000 |
| `similar-apps` | Each app's similar-apps list when **Include similar apps** is on | $1.49 / 1,000 | $1.39 / 1,000 | $1.29 / 1,000 | $1.19 / 1,000 |
| `developer-profile` | Each developer lookup, which returns all of that developer's apps | $2.99 / 1,000 | $2.79 / 1,000 | $2.59 / 1,000 | $2.39 / 1,000 |

Examples on the Free plan:

- **Full keyword search** (5 pages, about 245 apps): 5 × $0.00399 + 245 × $0.0001 ≈ **$0.04**
- **One app with 1,000 reviews** (50 review pages): $0.0002 + $0.0001 + 50 × $0.00499 ≈ **$0.25**
- **A developer with 17 apps:** $0.00299 + 17 × $0.0001 ≈ **$0.005**
- **100 search results with similar apps:** 2 × $0.00399 + 100 × $0.0001 + 100 × $0.00149 ≈ **$0.17**

You can set a maximum cost per run in Apify Console. The Actor stops when it's reached and keeps everything collected so far.

### Input

Every field is optional, but each run needs a keyword or at least one ID or URL. See the [Input tab](https://apify.com/parsebird/app-store-scraper/input-schema) for every option.

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `term` | string | No\* | — | Keyword to search the App Store for |
| `startUrls` | array | No\* | — | App Store app pages (`…/app/…/id123`) or developer pages (`…/developer/…/id123`). The country in the URL is used for that lookup |
| `appIds` | array | No\* | — | Numeric App Store IDs, like `389801252` |
| `bundleIds` | array | No\* | — | Bundle IDs, like `com.burbn.instagram` |
| `developerIds` | array | No\* | — | Numeric developer IDs. Returns up to 200 apps per developer |
| `mode` | string | No | — | `search` (keyword only) or `lookup` (IDs and URLs only). Empty runs everything you entered |
| `country` | string | No | `us` | App Store country (115 stores) |
| `lang` | string | No | — | Language for names, descriptions, and genres, like `en`, `es`, `fr-CA`. Falls back to the store's language |
| `page` | integer | No | `1` | First search page (50 apps per page) |
| `endPage` | integer | No | — | Last search page. With reviews on, also the maximum review pages per app. Empty = no limit |
| `maxItems` | integer | No | — | Maximum apps to save. Empty = all |
| `includeReviews` | boolean | No | `false` | Attach customer reviews to each app |
| `reviewsSort` | string | No | `mostRecent` | `mostRecent`, `mostHelpful`, `mostFavorable`, or `mostCritical` |
| `includeSimilarApps` | boolean | No | `false` | Attach the "You Might Also Like" list to each app |
| `customMapFunction` | string | No | — | JavaScript function that reshapes each item before it's saved |
| `outputConnector` | string | No | — | MCP connector (Notion, Todoist, …) to send results to |
| `deliverTarget` | string | No | — | Where the connector writes, like a Notion page URL |
| `deliverMode` | string | No | `perPost` | `perPost` (one record per app) or `summary` (one roll-up per run) |
| `deliverMaxItems` | integer | No | — | Cap on records delivered in `perPost` mode |

\* Add a `term`, or at least one of `startUrls`, `appIds`, `bundleIds`, or `developerIds`.

#### How do you run an App Store keyword search?

Set a keyword and a page range. The Actor stops at `endPage`, at `maxItems`, or when the results run out.

```json
{
    "term": "photo editor",
    "mode": "search",
    "country": "us",
    "page": 1,
    "endPage": 5,
    "maxItems": 200
}
```

#### How do you look up apps by App ID, bundle ID, or developer?

Combine any identifiers in one run.

```json
{
    "mode": "lookup",
    "appIds": ["389801252"],
    "bundleIds": ["com.burbn.barcelona"],
    "developerIds": ["284882218"],
    "startUrls": ["https://apps.apple.com/gb/app/instagram/id389801252"],
    "country": "us",
    "lang": "en"
}
```

#### How do you scrape App Store reviews?

Turn on `includeReviews`. Reviews come in pages of 20, and `endPage` caps the pages per app. Leave `endPage` empty to collect up to 5,000 reviews per app.

```json
{
    "appIds": ["389801252"],
    "includeReviews": true,
    "reviewsSort": "mostCritical",
    "endPage": 3
}
```

#### How do you get similar apps?

Turn on `includeSimilarApps`. If that step fails for an app, the app is still saved, with `similarApps` set to `null`.

```json
{
    "term": "meditation",
    "endPage": 1,
    "maxItems": 10,
    "includeSimilarApps": true
}
```

#### How do you reshape the output with a custom map function?

`customMapFunction` runs on each app right before it's saved. It must be a plain synchronous function that returns an object. Async functions, generators, and functions that contain `new Date`, `Date.now`, or `1970` are rejected. If the function is rejected or fails on an item, the original item is saved and the log says why.

```json
{
    "appIds": ["389801252", "6446901002"],
    "customMapFunction": "(app) => ({ name: app.trackName, rating: app.averageUserRating, ratings: app.userRatingCount })"
}
```

#### How do you send App Store results to Notion, Todoist, and more?

1. Authorize a connector once in Apify Console → **Settings → API & Integrations → MCP connectors**. Any service whose MCP server offers non-destructive write tools works.
2. Pick it in **Send results to Notion, Todoist, …**.
3. Set **Destination target**. For Notion, paste a page URL and the Actor creates a typed database there, or paste an existing database URL to fill the columns it already has. Share the page with your connector first through Notion's **••• → Connections** menu. For Todoist, paste a project URL or ID.
4. Pick **Write mode**: `perPost` writes one record per app, and `summary` writes one roll-up for the run.

Lists like `genres` become comma-joined columns. Long fields such as descriptions and reviews go into each row's page body. The connector only uses non-destructive write tools, so it can't delete or overwrite your existing data. Delivery runs after scraping and is best-effort: if it fails, the run still finishes with all results in the dataset, and the log explains the failure.

### Output example

Each app is one item in the dataset. Lists are shortened here.

```json
{
    "inputSource": { "flow": "search", "sourceId": "photo editor", "page": 1, "position": 1 },
    "country": "us",
    "wrapperType": "software",
    "kind": "software",
    "trackId": 587366035,
    "bundleId": "com.picsart.studio",
    "trackName": "Picsart AI Photo Editor, Video",
    "trackCensoredName": "Picsart AI Photo Editor, Video",
    "trackViewUrl": "https://apps.apple.com/us/app/picsart-ai-photo-editor-video/id587366035",
    "artworkUrl60": "https://is1-ssl.mzstatic.com/image/thumb/Purple221/v4/29/70/0f/29700f73-1932-2d9a-d03d-971142f9ea57/AppIcon-0-0-1x_U007emarketing-0-8-0-sRGB-85-220.png/60x60bb.jpg",
    "artworkUrl100": "https://is1-ssl.mzstatic.com/image/thumb/Purple221/v4/29/70/0f/29700f73-1932-2d9a-d03d-971142f9ea57/AppIcon-0-0-1x_U007emarketing-0-8-0-sRGB-85-220.png/100x100bb.jpg",
    "artworkUrl512": "https://is1-ssl.mzstatic.com/image/thumb/Purple221/v4/29/70/0f/29700f73-1932-2d9a-d03d-971142f9ea57/AppIcon-0-0-1x_U007emarketing-0-8-0-sRGB-85-220.png/512x512bb.jpg",
    "description": "Ignite your creative potential with Picsart — the all-in-one AI photo editor, AI video editor, and design studio ...",
    "primaryGenreName": "Photo & Video",
    "primaryGenreId": "6008",
    "genres": ["Photo & Video", "Graphics & Design"],
    "genreIds": ["6008", "6027"],
    "contentAdvisoryRating": "12+",
    "trackContentRating": "12+",
    "advisories": ["Infrequent/Mild Profanity or Crude Humor"],
    "languageCodesISO2A": ["SQ", "AR", "HY", "BN", "HR", "CS", "EN", "FR"],
    "fileSizeBytes": "270485504",
    "minimumOsVersion": "15.0",
    "releaseDate": "2013-01-02T22:14:40Z",
    "currentVersionReleaseDate": "2026-10-06T04:02:28Z",
    "releaseNotes": "Most of what we build doesn't wait for an app update. While this one tidies up a few bugs, ...",
    "version": "30.9.2",
    "price": 0.0,
    "formattedPrice": "Free",
    "currency": "USD",
    "artistId": 587366038,
    "artistName": "PicsArt, Inc.",
    "artistViewUrl": "https://apps.apple.com/us/developer/picsart-inc/id587366038",
    "sellerName": "PicsArt, Inc.",
    "sellerUrl": "https://picsart.com",
    "averageUserRating": 4.66523,
    "userRatingCount": 1195866,
    "averageUserRatingForCurrentVersion": 4.66523,
    "userRatingCountForCurrentVersion": 1195866,
    "features": ["iosUniversal"],
    "isGameCenterEnabled": false,
    "isVppDeviceBasedLicensingEnabled": true,
    "screenshotUrls": ["https://is1-ssl.mzstatic.com/image/thumb/PurpleSource221/v4/18/66/70/1866705a-8f24-0fe8-78e5-99cf0a4490cd/1.AI_Try-on.jpg/320x480bb.jpg"],
    "ipadScreenshotUrls": [],
    "appletvScreenshotUrls": [],
    "supportedDevices": ["iPhone5s-iPhone5s", "iPadAir-iPadAir"],
    "similarApps": [
        {
            "trackId": 1481174327,
            "bundleId": "com.photoeditor.polish",
            "trackName": "Polish - AI Photo Editor",
            "artistName": "SHANTANU PTE. LTD.",
            "primaryGenreName": "Photo & Video",
            "trackViewUrl": "https://apps.apple.com/us/app/polish-ai-photo-editor/id1481174327",
            "artworkUrl100": "https://is1-ssl.mzstatic.com/image/thumb/Purple211/v4/c4/0a/fb/c40afb42-bb37-005c-e46c-c11550d0b782/AppIcon-0-0-1x_U007ephone-0-1-0-85-220.png/100x100bb.jpg",
            "price": 0.0,
            "formattedPrice": "Free",
            "currency": "USD",
            "averageUserRating": 4.75889,
            "userRatingCount": 12961
        }
    ],
    "reviews": [
        {
            "id": "14643925441",
            "userName": "Gackersry",
            "title": "iPad viewing",
            "review": "Why the hell is everything so small on an iPad? ...",
            "rating": 1,
            "date": "2026-10-09T00:23:53Z",
            "isEdited": false,
            "developerResponse": null
        }
    ],
    "scrapedAt": "2026-10-10T10:47:37Z"
}
```

When reviews or similar apps aren't requested, `reviews` and `similarApps` are `null`.

### Use the Apple App Store Scraper API

Call the Actor from your own code with the [Apify API client](https://docs.apify.com/api/client/python). Find your token in [Apify Console → Settings → Integrations](https://console.apify.com/settings/integrations).

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("parsebird/app-store-scraper").call(run_input={
    "term": "budget planner",
    "country": "us",
    "endPage": 2,
    "maxItems": 100,
})

for app in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(app["inputSource"]["position"], app["trackName"], app["averageUserRating"], app["userRatingCount"])
```

**JavaScript**

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('parsebird/app-store-scraper').call({
    appIds: ['389801252'],
    includeReviews: true,
    reviewsSort: 'mostRecent',
    endPage: 5,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const review of items[0].reviews) {
    console.log(review.rating, review.title, review.date);
}
```

You can also start runs over plain HTTP from the [API tab](https://apify.com/parsebird/app-store-scraper/api), or connect the Actor to AI agents through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp).

### Use cases

- **App Store keyword ranking (ASO).** Track where your app and your competitors rank for a keyword, in any country, with scheduled runs.
- **Competitor monitoring.** Watch competitors' versions, release notes, prices, and ratings over time.
- **Review analysis.** Collect the most recent or most critical reviews to find bugs, feature requests, and sentiment trends.
- **Market research.** Map a category: which apps rank, how they're priced, how many ratings they have, and who publishes them.
- **Lead generation.** Build lists of developers and seller websites in a niche.
- **App databases.** Enrich your own catalog with icons, screenshots, genres, sizes, and age ratings.

### How it works

1. **Keyword search** reads the App Store's own search results for the selected country, so apps come in the order the App Store ranks them. Results are split into pages of 50 apps.
2. **Lookups** read app details from Apple's public [iTunes Search API](https://performance-partners.apple.com/search-api) for App IDs, bundle IDs, developer IDs, and App Store URLs.
3. **Reviews and similar apps** come from the public App Store website for the same country.
4. Each app is saved once per source in the run, in the order it was found, and the run stops at your page range, `maxItems`, or maximum cost.

### FAQ

**Do I need an Apple developer account or API key?**
No. The Actor reads public App Store data that anyone can see without signing in.

**How many apps does a keyword search return?**
The App Store returns up to about 250 apps per keyword. In our October 2026 tests, "photo editor" in the US returned 245 apps and "notes" in the UK returned 247. Very specific or made-up keywords return fewer.

**How is this different from Apple's iTunes Search API?**
The [iTunes Search API](https://performance-partners.apple.com/search-api) returns at most 200 results, has no reliable paging, and its results don't always match what the App Store shows. In our test, its "photo editor" results skipped the App Store's 5th app. It also has no reviews or similar apps. This Actor gives you the App Store's own search order, reviews, and similar apps, and handles retries and throttling for you.

**How many reviews can I get per app?**
Up to 5,000 per app in one run (250 pages of 20). Reviews are attached to the app's dataset item, and this cap keeps the item within Apify's dataset item size limit. Reviews are per country store, so run other countries to get their reviews. In our test on Apify, 5,000 reviews for one app took about 75 seconds.

**Why does an app have fewer reviews than its rating count?**
Many people leave a star rating without writing a review. `userRatingCount` counts all ratings, and `reviews` contains written reviews only.

**What does the `lang` setting change?**
It changes the language of names, descriptions, release notes, and genres when the store offers that language. For example, `es` works in the US store. Reviews are always in the language their authors wrote them in.

**How long does a run take?**
In our October 2026 tests on Apify, 20 apps took about 5 seconds, a full 247-app keyword search took about 40 seconds, 10 apps with 200 reviews each took about 10 seconds, and 12 apps with similar apps took about 25 seconds.

**Why wasn't an app found?**
The app isn't sold in the selected country store, the ID is wrong, or the app was removed. The log names every ID that wasn't found, and you aren't charged for it.

**Can I schedule runs or export to Google Sheets?**
Yes. Use [Apify Schedules](https://docs.apify.com/platform/schedules) for recurring runs and [integrations](https://docs.apify.com/platform/integrations) for Google Sheets, Zapier, Make, Slack, and webhooks.

**Something is missing or broken?**
Open an issue on the [Issues tab](https://apify.com/parsebird/app-store-scraper/issues). Feedback and feature requests are welcome there too.

### Is it legal to scrape the Apple App Store?

The Actor collects only public information that the App Store shows to every visitor, like app names, prices, ratings, and published reviews. It doesn't sign in or access any account data. Reviews include public usernames, which can be personal data, so handle them in line with laws such as the GDPR. You are responsible for how you use the data. Follow [Apple's terms](https://www.apple.com/legal/internet-services/itunes/) and copyright rules when you republish descriptions, icons, or screenshots. Read more in Apify's blog post [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/)

### Other scrapers you might like

| Actor | What it does |
|-------|--------------|
| [Apple Podcasts Scraper](https://apify.com/parsebird/apple-podcasts-scraper) | Scrape Apple Podcasts episodes, show notes, audio URLs, and transcripts |
| [Product Hunt Scraper](https://apify.com/parsebird/product-hunt-scraper) | Collect Product Hunt launches, upvotes, makers, and reviews |
| [Similarweb Scraper](https://apify.com/parsebird/similarweb-scraper) | Get website traffic, rankings, and audience data |
| [Capterra Review Scraper](https://apify.com/parsebird/capterra-review-scraper) | Collect software reviews and ratings from Capterra |
| [Trustpilot Reviews Scraper](https://apify.com/parsebird/trustpilot-reviews-scraper) | Collect company reviews and ratings from Trustpilot |

# Changelog

This Actor's version history is a separate document: https://apify.com/parsebird/app-store-scraper/changelog.md

# Actor input Schema

## `term` (type: `string`):

Enter a keyword to search the App Store, e.g. <code>photo editor</code>. Results come in Apple's own ranking order, up to about 250 apps per keyword.

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

Add App Store app pages (<code>apps.apple.com/us/app/instagram/id389801252</code>) or developer pages (<code>apps.apple.com/us/developer/meta-platforms-inc/id284882218</code>). The store country in the URL is used for that lookup.

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

Add numeric App Store IDs, the digits after <code>id</code> in an app URL (e.g. <code>389801252</code> for Instagram).

## `bundleIds` (type: `array`):

Add bundle identifiers, e.g. <code>com.burbn.instagram</code>.

## `developerIds` (type: `array`):

Add numeric developer IDs (the digits after <code>id</code> in a developer URL). Returns every app the developer publishes in the chosen store (up to 200 per developer).

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

Optional. <b>Search</b> uses only the keyword; <b>Lookup</b> uses only IDs and URLs. Leave empty to run everything you entered.

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

App Store storefront to read prices, rankings, ratings and reviews from.

## `lang` (type: `string`):

Optional language for app names, descriptions and genres, e.g. <code>en</code>, <code>es</code>, <code>fr-CA</code> or <code>pt-BR</code>. Works when the store offers that language; otherwise the store's default language is used.

## `page` (type: `integer`):

Search results page to start from. Each page holds up to 50 apps.

## `endPage` (type: `integer`):

Last search results page to request. When reviews are on, it also caps the number of review pages per app (20 reviews per page). Leave empty to page until results run out or <b>Max apps</b> is reached.

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

Maximum number of apps to save in this run (across search and lookups). Leave empty for no limit.

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

Fetch customer reviews for every app and attach them in the <code>reviews</code> array. Billed per page of 20 reviews.

## `reviewsSort` (type: `string`):

Order of the reviews. Only used when <b>Include reviews</b> is on.

## `includeSimilarApps` (type: `boolean`):

Fetch the app's "You Might Also Like" list and attach it in the <code>similarApps</code> array.

## `customMapFunction` (type: `string`):

Optional JavaScript function applied to each app before it is saved, e.g. <code>(app) => ({ name: app.trackName, rating: app.averageUserRating })</code>. It must be a plain synchronous function that returns an object. Functions containing <code>new Date</code>, <code>Date.now</code> or <code>1970</code> are rejected. If it fails, the original item is saved.

## `outputConnector` (type: `string`):

Optional MCP connector to deliver the results to. Authorize it first in Apify Console → Settings → API & Integrations → MCP connectors.

## `deliverTarget` (type: `string`):

URL or ID of where the connector writes. Notion: a page URL (a typed database is created for you) or an existing database URL. Todoist: a project URL or ID. Some services need none.

## `deliverMode` (type: `string`):

perPost writes one record per app; summary writes a single roll-up for the run.

## `deliverMaxItems` (type: `integer`):

Optional cap on how many records perPost delivers (ignored in summary mode).

## Actor input object example

```json
{
  "term": "photo editor",
  "country": "us",
  "page": 1,
  "endPage": 1,
  "maxItems": 20,
  "includeReviews": false,
  "reviewsSort": "mostRecent",
  "includeSimilarApps": false,
  "deliverMode": "perPost"
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# 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 = {
    "term": "photo editor",
    "country": "us",
    "endPage": 1,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("parsebird/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 = {
    "term": "photo editor",
    "country": "us",
    "endPage": 1,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("parsebird/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 '{
  "term": "photo editor",
  "country": "us",
  "endPage": 1,
  "maxItems": 20
}' |
apify call parsebird/app-store-scraper --silent --output-dataset

```

## MCP server setup

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