# Apple App Store App Search & Reviews Scraper (`herus13/apple-app-store-scraper`) Actor

Search the Apple App Store by keyword and scrape reviews — rating, title, text, author, date. Search or direct app IDs/URLs. Fan out across countries for broader coverage. No login, no anti-bot handling. Pairs with the Google Play Reviews Scraper for cross-platform ASO coverage.

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

## Pricing

from $3.00 / 1,000 per reviews

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/platform/actors/running/actors-in-store#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 App Search & Reviews Scraper

The Apple App Store App Search & Reviews Scraper is an Apify actor that extracts **app search results** and **reviews** from the [Apple App Store](https://apps.apple.com) by keyword search or direct app ID/URL, fanned out across any number of country storefronts. It returns rating, review title, text, author, and date, plus app metadata (developer, icon, price, category) when searching by keyword.

Use it to track app ratings over time, mine user feedback for feature requests and bug reports, benchmark competitor apps, or feed an ASO (App Store Optimization) dashboard — exported to JSON, CSV, or Excel.

### Table of contents

- [What the Apple App Store scraper does](#what-the-apple-app-store-scraper-does)
- [Use cases](#use-cases)
- [How to scrape Apple App Store reviews](#how-to-scrape-apple-app-store-reviews)
- [Apple App Store scraper input](#apple-app-store-scraper-input)
- [Apple App Store data output](#apple-app-store-data-output)
- [How much it costs](#how-much-it-costs)
- [Recommended proxies for the App Store](#recommended-proxies-for-the-app-store)
- [Why this Apple App Store scraper](#why-this-apple-app-store-scraper)
- [FAQ](#faq)
- [Rate this actor](#rate-this-actor-)
- [Related actors](#related-actors)

### What the Apple App Store scraper does

- 🔎 **Keyword search** — search any term and the actor resolves matching apps, ranked as the App Store returns them.
- 🔗 **Direct app IDs or URLs** — skip search and scrape reviews for specific apps by numeric ID (`324684580`) or a pasted `apps.apple.com` URL.
- 🌍 **Country fan-out** — run any number of storefront codes (`us`, `gb`, `de`, ...); each country's product page carries a genuinely distinct review set, so more countries means more total coverage.
- ⭐ **Rating and date filters** — keep only the star ratings and date range you care about.
- 🧬 **Cross-platform pairing** — the same `platform` discriminator and matching field names as the [Google Play App Search & Reviews Scraper](https://apify.com/herus13/google-play-reviews-scraper), so both datasets merge without remapping columns.
- ⚡ **HTTP-only, no anti-bot** — no login, no CAPTCHA, no browser tier; runs are fast and proxy is optional.

### Use cases

**ASO and rating monitoring across storefronts** — The same app can be queried across any number of country storefronts in one run, which matters because App Store ratings are per-country and a problem often shows up in one market first. Track the rating trend per country rather than the global average that hides it.

**Mining user feedback for feature requests and bugs** — Review title, text, author, and date come back structured, so you can route them into a classifier or a support triage queue instead of reading the store listing by hand. Filtering by `rating_filter` isolates the 1- and 2-star reviews where the actionable complaints live.

**Competitor benchmarking** — Search by keyword to see which apps rank for a term, then pull each one's reviews and metadata (developer, price, category) in the same run. Useful for understanding both what competitors ship and what their users complain about.

**Cross-platform app intelligence** — Pairs with the Google Play scrapers: the same app on both stores, with a comparable review schema, gives you a complete picture rather than the half your iOS or Android data alone provides.

### How to scrape Apple App Store reviews

1. Click **Try for free** and open the actor.
2. Enter one or more `app_ids` (numeric IDs or full `apps.apple.com` URLs) **or** `search_queries`.
3. Choose your `countries` (e.g. `us`, `gb`, `de`) — each adds its own distinct review set.
4. Optional: set `rating_filter`, `date_from`/`date_to`, or `max_apps_per_search` for search mode.
5. Click **Start** and watch results stream into the dataset.
6. Export as **JSON, CSV, or Excel**, or pull from the [Apify API](https://docs.apify.com/api/v2).

Scrape reviews for specific apps across multiple storefronts:

```json
{
  "app_ids": ["324684580"],
  "countries": ["us", "gb", "de"],
  "rating_filter": ["1", "2"]
}
```

Search by keyword, capped to the top 5 matches per query:

```json
{
  "search_queries": ["meditation app"],
  "max_apps_per_search": 5,
  "countries": ["us"]
}
```

### Apple App Store scraper input

| Field | Type | Default | Description |
|---|---|---|---|
| `app_ids` | string\[] | — | Numeric App Store IDs or full `apps.apple.com` URLs. At least one of `app_ids` or `search_queries` is required. |
| `search_queries` | string\[] | — | Keywords; the actor resolves matching apps first, then scrapes their reviews. |
| `countries` | string\[] | `["us"]` | Storefront codes. Each country returns its own distinct up-to-8-review set. |
| `max_apps_per_search` | int | `10` | Cap on how many apps to take from each search query's results (1–250). |
| `rating_filter` | enum\[] | — | Keep only reviews with these star ratings (1–5). Filters what's already returned; can't fetch beyond the App Store's fixed per-country set. |
| `date_from` | date | — | Keep only reviews on/after this date (`YYYY-MM-DD`). |
| `date_to` | date | — | Keep only reviews on/before this date (`YYYY-MM-DD`). |
| `transport` | enum | `auto` | HTTP engine: `auto` (curl\_cffi), `curl_cffi`, `httpx`, or `primp`. |
| `proxy` | object | — | Optional Apify Proxy configuration. Not required for correctness — see [Recommended proxies](#recommended-proxies-for-the-app-store). |

### Apple App Store data output

Each review is one dataset row. Sample from a live run:

```json
{
  "platform": "app_store",
  "review_id": "11994640656",
  "app_id": "324684580",
  "author_name": "l.lacx",
  "rating": 5,
  "title": "Favorite app ever",
  "text": "I personally love this app. I have had it for over 4 years, and it's been an app I use daily...",
  "review_date": "2024-11-26T17:10:59.000Z",
  "country": "us",
  "scraped_at": "2026-07-10T13:36:13.824529+00:00"
}
```

| Field | Description |
|---|---|
| `platform` | Always `"app_store"` — matches the discriminator on the Google Play actor for merged datasets. |
| `review_id`, `app_id` | Apple's review ID and the app's numeric App Store ID. |
| `author_name`, `rating`, `title`, `text` | Reviewer name, 1–5 star rating, and review title/body. |
| `review_date` | ISO 8601 timestamp as returned by Apple. |
| `country`, `scraped_at` | Storefront the review came from and capture timestamp. |

When using `search_queries`, matched apps are also pushed as rows:

```json
{
  "platform": "app_store",
  "app_id": "571800810",
  "title": "Calm",
  "developer": "Calm.com",
  "icon_url": "https://is1-ssl.mzstatic.com/image/thumb/.../512x512bb.jpg",
  "rating": 4.77337,
  "rating_count": 1964301,
  "is_free": true,
  "price": null,
  "currency": "USD",
  "category": "Health & Fitness",
  "url": "https://apps.apple.com/us/app/calm/id571800810?uo=4",
  "country": "us",
  "scraped_at": "2026-07-10T13:36:22.244929+00:00"
}
```

| Field | Description |
|---|---|
| `app_id`, `title`, `developer`, `url` | App identity and canonical App Store link. |
| `icon_url`, `category` | App icon and App Store category. |
| `rating`, `rating_count` | Aggregate app rating and total rating count (not per-review). |
| `is_free`, `price`, `currency` | Pricing; `price`/`currency` are `null` for free apps. |
| `country`, `scraped_at` | Storefront searched and capture timestamp. |

### How much it costs

This actor uses **pay-per-event** pricing — you pay for what you scrape, not for time.

| Event | USD |
|---|---|
| Actor start (per run) | $0.001 |
| App search result | $0.003 |
| Review scraped | $0.003 |

Reviews are priced above Google Play's per-review rate to reflect scarcity — the App Store's public surface caps at 8 reviews per country per app, so each one carries more marginal value.

| Typical run | Cost |
|---|---|
| 1 app, 1 country (≤8 reviews) | ~$0.03 |
| 10 apps, 3 countries (≤240 reviews) | ~$0.73 |
| Search query, 10 apps returned, 3 countries (≤240 reviews + 10 search results) | ~$0.76 |

### Recommended proxies for the App Store

**Proxy is optional.** The App Store's public search and review endpoints have no known anti-bot layer, so a proxy is not required for correctness — only useful for scale (avoiding shared-IP rate limits on very large runs) or to make sure a given country's storefront resolves consistently.

If you run your own scrapers (inside or outside Apify) and need reliable proxies for scale, we use **[DataImpulse](https://dataimpulse.com/?aff=404588\&utm_source=apify)** — pay-as-you-go IPs with per-country targeting and no monthly minimum:

👉 **[Get DataImpulse proxies](https://dataimpulse.com/?aff=404588\&utm_source=apify)** (referral link)

### Why this Apple App Store scraper

- **No anti-bot tax** — HTTP-only, no browser, no CAPTCHA solving; runs are fast and cheap because the App Store's public surface needs none of that.
- **Country fan-out that actually adds coverage** — verified live: zero review-ID overlap between US/GB/DE for the same app, so adding countries genuinely multiplies your review sample instead of returning duplicates.
- **Built for cross-platform ASO** — shares field names and a `platform` discriminator with our [Google Play App Search & Reviews Scraper](https://apify.com/herus13/google-play-reviews-scraper); merge both datasets with no remapping.
- **Validated output** — every row is Pydantic-validated before it's pushed; malformed entries are dropped, not shipped with garbage fields.
- **Open source** — the underlying `apple-app-store-scraper` Python package ships a Typer CLI and a FastAPI server; the Apify wrapper is a thin layer.

### FAQ

**Why do I only get 8 reviews per app per country?** That's Apple's own limit, not this scraper's. The App Store's public web surface (no login, no native app) exposes a fixed set of up to 8 reviews per country per product page — there is no bulk pagination endpoint available without Apple's private, device-authenticated mobile API. Add more `countries` to increase total coverage; each storefront's 8 are a genuinely distinct set.

**Do I need a proxy?** No. The App Store's search and review endpoints have no known anti-bot layer, so a proxy is optional. It only helps at scale or for consistent per-country resolution. For your own scrapers, we recommend [DataImpulse](https://dataimpulse.com/?aff=404588\&utm_source=apify).

**Can I scrape by URL instead of app ID?** Yes. Paste a full `apps.apple.com` URL into `app_ids` — the numeric ID is extracted automatically.

**What happens if I provide both `app_ids` and `search_queries`?** Both run: the actor scrapes reviews for the given IDs and also resolves and scrapes apps matching each search query.

**Why are `price` and `currency` null for some apps?** They're `null` for free apps; App Store metadata doesn't carry a price for `is_free: true` listings.

**Is scraping the Apple App Store legal?** This actor collects only publicly available app listing and review data. You are responsible for complying with Apple's terms and applicable laws. Do not collect personal data without a lawful basis.

### Rate this actor ⭐

If the Apple App Store App Search & Reviews Scraper saved you time, please **leave a review on its Apify Store page** — ratings help other people find it and tell us what to build next. Hit a bug or missing field? Open an issue or contact us through the actor's **Issues** tab and we'll fix it fast — recency and reliability are what keep this actor ranking.

### Related actors

Building a cross-platform ASO pipeline? Pair this actor with our other scrapers — same proxy config format, same Pydantic-validated output, all open source.

- **[Google Play App Search & Reviews Scraper](https://apify.com/herus13/google-play-reviews-scraper)** — the direct Android counterpart; matching field names and a shared `platform` column for merged datasets.
- **[Indeed Job Scraper](https://apify.com/herus13/indeed-scraper)** — track hiring signals for the same companies you're monitoring in the App Store.

# Actor input Schema

## `app_ids` (type: `array`):

<p>App Store numeric app IDs or full URLs.</p><p>Examples: <code>324684580</code>, <code>https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580</code></p>
## `search_queries` (type: `array`):

<p>Keywords to search the App Store; the scraper resolves each into apps, then scrapes their reviews.</p><p>Example: <code>meditation app</code></p>
## `countries` (type: `array`):

<p>App Store country/storefront codes. Drives both search results and review coverage — each country has a genuinely distinct set of up to 8 reviews per app, so adding more countries means more total reviews.</p><p>Example: <code>us</code>, <code>gb</code>, <code>de</code></p>
## `max_apps_per_search` (type: `integer`):

Cap on how many apps to take from each search query's results.

## `rating_filter` (type: `array`):

Only keep reviews with these star ratings (1-5). Leave empty for all ratings. Note: the App Store's public review surface returns a fixed set of up to 8 reviews per country per app, so this only filters what's already returned — it cannot fetch beyond that set.

## `date_from` (type: `string`):

Only keep reviews on/after this date (YYYY-MM-DD).

## `date_to` (type: `string`):

Only keep reviews on/before this date (YYYY-MM-DD).

## `transport` (type: `string`):

HTTP engine used to fetch pages. Auto uses curl\_cffi.

## `proxy` (type: `object`):

<p>Optional — the App Store's search and review endpoints have no known anti-bot layer, so a proxy is not required for correctness, only for scale/geo-accuracy.</p>

## Actor input object example

```json
{
  "app_ids": [
    "324684580"
  ],
  "countries": [
    "us"
  ],
  "max_apps_per_search": 10,
  "transport": "auto"
}
```

# Actor output Schema

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

App search results and reviews for each requested/discovered app

# 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 = {
    "app_ids": [
        "324684580"
    ],
    "countries": [
        "us"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("herus13/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 = {
    "app_ids": ["324684580"],
    "countries": ["us"],
}

# Run the Actor and wait for it to finish
run = client.actor("herus13/apple-app-store-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 '{
  "app_ids": [
    "324684580"
  ],
  "countries": [
    "us"
  ]
}' |
apify call herus13/apple-app-store-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/HuGwyus36vQinZ6zk/builds/hIm3texH4xiAqJTei/openapi.json