# App Store Apps Scraper — Search, Top Charts & App Details (`fabrikit/app-store-apps-scraper`) Actor

Apple App Store scraper: find apps by keyword, app ID, bundle ID, URL, developer or Top Free / Top Paid chart in any country and get price, rating, ratings count, category, version, update date, size, age rating, languages, icon and description as flat JSON. No API key. From US$2.40 per 1,000 apps.

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

## Pricing

from $2.40 / 1,000 app scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## App Store Apps Scraper — Search, Top Charts & App Details

**App Store Apps Scraper extracts app listings from apps.apple.com**: search any keyword, paste app IDs, bundle IDs, App Store or developer URLs, or read the Top Free and Top Paid charts of any country, and get one flat record per app with name, developer, price and currency, average rating and number of ratings, category and genres, current version, release and last-update dates, download size, age rating, languages, icon, screenshots and the description. It talks to Apple's public JSON endpoints, so there is no API key, no login and no browser, and you pay only per app saved.

It belongs to the same family as our [Google Play Reviews Scraper](https://apify.com/fabrikit/google-play-reviews-scraper) and [App Reviews Scraper (App Store & Google Play)](https://apify.com/fabrikit/app-reviews-unified). Those return user reviews; this one returns the app listings themselves.

### What data does it return?

| Field | Example | Notes |
|---|---|---|
| `appId`, `bundleId` | `407558537`, `com.capitalone.enterprisemobilebanking` | Apple ID and bundle identifier |
| `name`, `url` | `Capital One Mobile`, `https://apps.apple.com/us/app/capital-one-mobile/id407558537` | |
| `developer`, `developerId`, `developerUrl` | `Capital One`, `339644101` | developer page in the store |
| `sellerName`, `sellerUrl` | `Capital One Services, LLC`, `https://www.capitalone.com/...` | legal seller and website |
| `price`, `currency`, `priceFormatted`, `isFree` | `0`, `USD`, `Free`, `true` | storefront prices |
| `rating`, `ratingCount` | `4.85`, `11207398` | all versions; `ratingCurrentVersion`, `ratingCountCurrentVersion` for the current one |
| `primaryGenre`, `genres`, `genreIds` | `Finance`, `["Finance"]` | |
| `version`, `releaseDate`, `lastUpdated`, `releaseNotes` | `6.55.1`, `2010-12-13T08:00:00.000Z`, `2026-10-05T15:22:57.000Z` | ISO dates |
| `fileSizeBytes`, `fileSizeMB` | `421811200`, `402.3` | |
| `contentRating`, `advisories` | `4+`, `[]` | age rating |
| `minimumOsVersion`, `languages`, `supportedDevicesCount`, `features`, `kind` | `17.0`, `["EN","ES"]`, `118`, `["iosUniversal"]`, `software` | |
| `description`, `iconUrl`, `screenshotUrls` | first 1,000 characters (or all with `fullDescription`) | e-mails and phone numbers are removed from texts |
| `country`, `source`, `sourceInput`, `position` | `us`, `search`, `weather`, `3` | where the record came from and its rank there |
| `chartType`, `chartRank` | `top-free`, `12` | chart records only |

### Use cases

- **ASO and keyword research** — `position` is the rank of each app for a search term in a given country; run the same terms every week to follow movements, ratings and update cadence of your competitors.
- **Market and category research** — Top Free / Top Paid charts of 170+ storefronts with genres, prices and rating counts in one table.
- **Competitor monitoring** — schedule a run on a list of app IDs or bundle IDs and diff `version`, `price`, `ratingCount` or `lastUpdated` over time.
- **Developer catalogues** — a developer URL returns every app that company publishes in the chosen store.
- **Sales intelligence** — seller names and websites of the apps in a category (company data, not personal data).
- **AI agents and datasets** — clean JSON for LLM pipelines, dashboards and spreadsheets.

### How to use it

1. Type one or more **search terms**, and/or paste **app IDs / bundle IDs / URLs / developer URLs**, and/or tick a **chart**.
2. Choose the **store country** (`us`, `gb`, `de`, `jp`, `br`, ...) and, if needed, the **platform** (iPhone, iPad or Mac apps).
3. Set **Maximum apps** and run. Download JSON, CSV, Excel or HTML, or read the dataset through the API.

#### Input example: keyword research in the UK store

```json
{
  "searchTerms": ["budget planner", "expense tracker"],
  "country": "gb",
  "maxItems": 200
}
```

#### Input example: Top Free and Top Paid charts in Germany

```json
{
  "charts": ["top-free", "top-paid"],
  "chartSize": 100,
  "country": "de",
  "maxItems": 200
}
```

#### Input example: a watch list of apps and a developer

```json
{
  "appIds": [
    "407558537",
    "com.spotify.client",
    "https://apps.apple.com/jp/app/id310633997",
    "https://apps.apple.com/us/developer/capital-one/id339644101"
  ],
  "fullDescription": true,
  "maxItems": 100
}
```

Mixing sources is fine: the Actor processes IDs first, then charts, then search terms, skips an app that already appeared (one record per app and country) and stops exactly at `maxItems`.

### Output example

A real record from a local run on 19 October 2026 (description shortened):

```json
{
  "appId": 407558537,
  "bundleId": "com.capitalone.enterprisemobilebanking",
  "name": "Capital One Mobile",
  "url": "https://apps.apple.com/us/app/capital-one-mobile/id407558537",
  "developer": "Capital One",
  "developerId": 339644101,
  "developerUrl": "https://apps.apple.com/us/developer/capital-one/id339644101",
  "sellerName": "Capital One Services, LLC",
  "sellerUrl": "https://www.capitalone.com/applications/mobile/",
  "price": 0,
  "currency": "USD",
  "priceFormatted": "Free",
  "isFree": true,
  "rating": 4.85,
  "ratingCount": 11207398,
  "ratingCurrentVersion": 4.85,
  "ratingCountCurrentVersion": 11207398,
  "primaryGenre": "Finance",
  "primaryGenreId": 6015,
  "genres": ["Finance"],
  "genreIds": [6015],
  "version": "6.55.1",
  "releaseDate": "2010-12-13T08:00:00.000Z",
  "lastUpdated": "2026-10-05T15:22:57.000Z",
  "releaseNotes": "Thanks for using Capital One Mobile. We make regular updates to our app ...",
  "fileSizeBytes": 421811200,
  "fileSizeMB": 402.3,
  "contentRating": "4+",
  "advisories": [],
  "minimumOsVersion": "17.0",
  "languages": ["EN", "ES"],
  "supportedDevicesCount": 118,
  "features": ["iosUniversal"],
  "kind": "software",
  "isGameCenterEnabled": false,
  "description": "Manage your money anytime, anywhere ...",
  "iconUrl": "https://is1-ssl.mzstatic.com/image/thumb/Purple221/v4/29/54/f0/.../512x512bb.jpg",
  "screenshotUrls": ["https://is1-ssl.mzstatic.com/image/thumb/.../392x696bb.jpg"],
  "country": "us",
  "source": "chart",
  "sourceInput": "top-free",
  "position": 1,
  "chartType": "top-free",
  "chartRank": 1,
  "scrapedAt": "2026-10-19T22:40:11.512Z"
}
```

A `SUMMARY` record in the key-value store lists, per source, how many apps Apple returned and how many were saved, the IDs that were not found, the number of requests and the proxy used.

### Pricing

Pay per event: **US$2.40 per 1,000 apps** saved (US$0.0024 each), proxy and compute included.

- 100 apps ≈ US$0.24
- 1,000 apps = US$2.40
- 10,000 apps = US$24

Duplicates and apps Apple does not return are never charged. With a maximum cost per run set in Apify, the Actor stops cleanly at that limit.

### How it compares

- **Calling Apple's endpoints yourself** is free but raw: one search gives at most 200 results, lookups must be batched, the charts feed has only IDs and names, and responses carry hundreds of device strings per app. This Actor batches the calls, enriches the charts, de-duplicates, flattens the fields, respects Apple's per-IP rate limit and gives you scheduling, storage and integrations.
- **Other App Store scrapers in Apify Store** charge from about US$0.10 to US$3.45 per 1,000 apps. This one sits at US$2.40 with the full lookup field set, search positions, chart ranks, developer catalogues and automatic proxy fallback. If you only need a couple of fields, a cheaper option may be enough.
- **Limits that come from Apple:** 200 apps per search term (no paging — use several or more specific terms), charts of up to 100 apps and only Top Free / Top Paid (the public feed has no Top Grossing), and about 20 search/lookup calls per minute per IP, so a run with many terms advances at roughly one term every 3 seconds.

### Integrations

Run it from the Apify API, the JavaScript or Python client, or on a schedule in Apify Console, and push the dataset to Google Sheets, Airtable, n8n, Make, Zapier or a webhook. AI agents (Claude, ChatGPT, Cursor and any MCP client) can call it through the Apify MCP server, for example "list the top 50 free finance apps in Brazil with their ratings".

### FAQ

**Is it legal to scrape the App Store?** The Actor reads public product metadata that Apple publishes through its open search and chart endpoints. App names, prices, ratings and category data describe products and companies; when a developer is a private person their name can be personal data under laws such as GDPR, CCPA or Chile's Ley 21.719, so handle the data accordingly. E-mail addresses and phone numbers are stripped from descriptions and release notes. This Actor is not affiliated with Apple and this is not legal advice.

**Do I need a proxy?** Normally no. Apify's datacenter proxy is used by default; if Apple answers with its rate limit (HTTP 403 or 429) the Actor waits and retries, and after repeated blocks switches to a residential proxy in the store country.

**Why do I get fewer than 200 apps for a term?** Apple returns only what matches; many terms have fewer results. `offset` is ignored by Apple, so 200 is the ceiling per term.

**Can I get the user reviews?** Not with this Actor. Use our [App Reviews Scraper](https://apify.com/fabrikit/app-reviews-unified) for App Store and Google Play reviews.

**Why is an app missing from the results?** It is not available in that storefront, or the ID / bundle ID has a typo. Not-found IDs are listed in `SUMMARY.notFound` and in the log.

**Does `rating` change by country?** Yes. Ratings, prices and charts are specific to each storefront; set `country` to the one you need.

### Changelog

- **2026-10-19** — First version: keyword search (iPhone, iPad, Mac catalogues), lookup by app ID / bundle ID / URL, developer catalogues, Top Free and Top Paid charts with full details, exact `maxItems`, pay per app.

### En español

**App Store Apps Scraper** extrae fichas de apps de la App Store de Apple sin API key ni login: busca por palabra clave, por ID, bundle ID o URL de la app, por desarrollador o desde los rankings Top Free y Top Paid de cualquier país. Por cada app entrega nombre, desarrollador, precio y moneda, valoración media y cantidad de valoraciones, categoría, versión, fecha de lanzamiento y de última actualización, tamaño, edad mínima, idiomas, ícono, capturas y descripción (correos y teléfonos eliminados). Cuesta US$2,40 por cada 1.000 apps guardadas. Si lo que necesitas son las reseñas, usa nuestro [App Reviews Scraper](https://apify.com/fabrikit/app-reviews-unified) o el [Google Play Reviews Scraper](https://apify.com/fabrikit/google-play-reviews-scraper).

# Actor input Schema

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

Keywords to search in the App Store, one search per entry (for example: weather, photo editor, budget planner). Apple returns at most 200 apps per term; the position of each app in the results is saved as `position`.

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

Specific apps: numeric App Store IDs (407558537 or id407558537), bundle IDs (com.spotify.client), App Store URLs (https://apps.apple.com/us/app/capital-one-mobile/id407558537) or developer URLs (https://apps.apple.com/us/developer/capital-one/id339644101 = every app of that developer). A plain app name is resolved to the top search match. The country in a URL overrides the Store country below.

## `charts` (type: `array`):

Read Apple's top charts for the Store country: Top Free and/or Top Paid apps (up to 100 entries each, `chartRank` is saved on every record).

## `chartSize` (type: `integer`):

How many ranked apps to read from each chart (1 to 100, Apple's maximum).

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

Two-letter App Store country code (us, gb, de, fr, es, br, mx, jp, in, ...). Prices, currency, ratings and charts are specific to each storefront.

## `platform` (type: `string`):

Which catalogue to search: iPhone apps (also universal iPad apps), iPad apps or Mac apps. Charts are always the iPhone charts.

## `fullDescription` (type: `boolean`):

Save the complete store description instead of the first 1,000 characters.

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

Stop after this many apps in total (exact; duplicates across sources are skipped and not charged).

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

Apify Proxy settings. Apple's endpoints normally work from datacenter IPs; if they answer with their per-IP rate limit (HTTP 403/429) the Actor retries with backoff and switches to a residential proxy in the Store country.

## Actor input object example

```json
{
  "searchTerms": [
    "weather"
  ],
  "chartSize": 50,
  "country": "us",
  "platform": "iphone",
  "fullDescription": false,
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `apps` (type: `string`):

All apps collected during the run (one record per app and store country)

# 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": [
        "weather"
    ],
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fabrikit/app-store-apps-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": ["weather"],
    "maxItems": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("fabrikit/app-store-apps-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchTerms": [
    "weather"
  ],
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call fabrikit/app-store-apps-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,fabrikit/app-store-apps-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/PStlXEie4iqsALLXS/builds/lP2CrTyG8Igvf9xfc/openapi.json