iOS App Store Reviews Scraper (Apify Actor)

Download Apple App Store reviews and ratings for any iOS app by app ID, bundle ID or URL, per country, as JSON/CSV/Excel. Also returns app details (developer, price, rating count, version). $0.10 per 1,000 reviews. No API key. Runs as an Apify Actor, callable from MCP clients via the Apify MCP server (https://mcp.apify.com/?actors=pennydata/appstore-reviews-rss).

View on apify.com

Hosted MCP Server

npx add-mcp 'https://mcp.apify.com/?actors=pennydata/appstore-reviews-rss'

Installs into Claude Code, Codex, Cursor and more

Documentation

App Store Reviews Scraper: Ratings, Text & Versions, $0.10/1k (`pennydata/appstore-reviews-rss`) Actor

App Store reviews scraper: paste app IDs, bundle IDs or URLs and get rating, title, text, version, author and date for each review, per country, as JSON/CSV/Excel. $0.10 per 1,000 reviews, first 3 per run free, no API key. Built with AI assistance.

URL: https://apify.com/pennydata/appstore-reviews-rss.md
Developed by: Penny Data (community)
Categories: Developer tools, Lead generation, Automation
Stats: 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
User rating: No ratings yet

Pricing

from $0.07 / 1,000 review returneds

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 section below.

Each client library has reference documentation the quickstart does not restate: JavaScript/TypeScript (npm install apify-client) and Python (pip install apify-client).

README

Paste iOS app IDs, bundle IDs or App Store URLs, get each app's public App Store reviews: rating, title, text, version, author, date. $0.10 per 1,000 reviews ($0.0001 each), first 3 reviews per run free. Apps or countries with no reviews cost $0, every app and country gets a free summary row, and the run stops at your max cost. Click Start: the prefilled input (WhatsApp and Instagram, US, 5 reviews each) runs as is and costs at most $0.0007.

Real output, 5 reviews (local run of this build, 2026-10-24, WhatsApp, US, newest first):

rating	title	text	version	date
1	Meta group	This group has been interfering in democratic elections arou...	26.41.75	2026-10-23
1	Terrible company	A Meta está sob suspeita de favorecer Flávio Bolsonaro na co...	26.41.75	2026-10-23
4	⭐️⭐️⭐️⭐️	I like how I can communicate and call but it logs me of when...	26.41.75	2026-10-23
1	Why my account is blocked ?	My account was under review many times with no specific reas...	26.41.75	2026-10-23
5	Ninja WhatsApp	It’s good tuff and tuff recommend for sure	26.41.75	2026-10-23

Each row also has reviewId, appId, country and reviewUrl. Text is cut for this table only.

Try it free: set sampleOnly to get the first 10 reviews at no charge.

iOS App Reviews Scraper - App Store Reviews by App ID or Bundle ID, $0.10 per 1,000

Price: $0.10 per 1,000 reviews ($0.0001 each, pay per event). Apps or countries with no reviews are free.

Try it free: set sampleOnly to get the first 10 reviews at no charge.

Up to 500 newest reviews per app per country, not 10. App Store reviews scraper for Apple apps: give app IDs, bundle IDs (e.g. com.spotify.client) or App Store URLs and countries, and get rating, title, text, version, author and date for each review from Apple's public customer-reviews RSS feed. No login, no browser, no proxies. Pay $0.0001 per review; apps or countries with no reviews cost nothing.

Coming from another App Store reviews Actor?

Public issues on other Apify App Store review Actors show these questions. What this Actor does, checked against src/main.js (commit shipped with this build):

"Returns only 10 results even when 3000 selected" / "Stops after 10 reviews, doesn't say why" - issue 1, issue 2. Apple's public RSS feed exposes at most 10 pages of 50 reviews, so 500 per app per country is the ceiling for any tool reading it. Here maxPages is clamped to 1-10 and defaults to 2, and pages are requested in a loop until empty. Every app and country also gets one free summary row (recordType: "summary") saying how many reviews Apple exposed, how many were returned or filtered out, and why the run stopped. For more reviews, list more countries.
"Missing Country Store" - issue. countries accepts any two-letter storefront code, not a fixed list.
"Support of package name" (bundle id) - issue. Supported: put com.burbn.instagram in bundleIds (or apps); it is resolved through Apple's lookup API.
Filter by date / rating - issue. Supported: dateFrom and minRating. Filtered-out reviews are not billed.

We have not run the other Actors; their behaviour may have changed since those issues were opened. Not affiliated with them.

Switching from another iOS reviews scraper

Drop-in replacement for the input of the most-used iOS App Store reviews scrapers: paste your existing input JSON (appIds, startUrls, country, maxItems) and change only the Actor ID.

Other App Store review scrapers on Apify use appId, appIds, startUrls and country. This Actor accepts those names as aliases, so you can change only the Actor ID in a saved task or integration and keep the rest of your input:

Field in the other scraper	Same thing here	Notes
`appId` (string or list)	`apps`	numeric ID, App Store URL or bundle ID
`appIds` (list)	`apps`	same
`startUrls` (`[{"url": "https://apps.apple.com/us/app/.../id310633997"}]` or plain strings)	`apps`	the country in the URL is used for that app
`country` (string or list)	`countries`	used when `countries` is not set
`maxItems` (integer)	`maxReviewsPerAppCountry`	applied per app and country; wins over `maxReviewsPerAppCountry` when both are sent

If you set both an alias and the canonical field, the app lists are merged and countries wins over country. Fields this Actor does not have (for example customMapFunction, outputConnector, deliver*) are ignored. Output field names are this Actor's own. Max reviews, date and rating filters are named maxReviewsPerAppCountry, dateFrom and minRating here. Not affiliated with the other Actors.

App details mode (`mode: "appInfo"`)

Set mode to appInfo to get App Store app details instead of reviews: name, developer, bundle ID, genre, price, average rating, rating count, current version and release notes, description, languages, file size, icon and screenshots. Give app IDs, App Store URLs or bundle IDs in apps / bundleIds, and/or keywords in searchTerms (e.g. habit tracker, up to maxSearchResults apps per term and country, max 200). Data comes from Apple's public iTunes lookup/search API; no login. One row per app and country (recordType: "app"), billed with the same pay-per-event price as a review ($0.0001, first 3 per run free). Apps that are not found return a free error row.

{ "mode": "appInfo", "searchTerms": ["habit tracker"], "maxSearchResults": 25, "countries": ["us", "de"] }

Input

apps: numeric app IDs, App Store URLs (the country in the URL, e.g. /gb/, is used for that app), or bundle IDs / package names.
sort: mostRecent (default) or mostHelpful.
bundleIds: optional list of bundle IDs (package names) such as com.burbn.instagram, resolved via Apple's lookup API.
dateFrom: only reviews on or after this date (e.g. 2026-09-01).
minRating: only reviews with at least this many stars (1-5).
includeSummary: one free summary row per app and country (default on).
countries: two-letter storefront codes (default us).
maxPages: pages per app and country, 50 reviews each, max 10, default 2.
maxReviewsPerAppCountry: default 50, 0 = no cap.

Output (one item per review, plus one free summary row per app and country)

reviewId, appId, country, rating, title, text, version, author (display name exactly as given in the feed), date, reviewUrl, helpfulCount, voteCount. Set sort to mostHelpful to get the most-voted-helpful reviews first (default mostRecent).

Row	`recordType`	`status`	Billed
Review	none	`ok`	yes (first 3 per run free)
Per app and country summary	`summary`	`ok`, or `skipped` if no review returned	no
Unparseable app entry or unknown bundle ID	`error`	`error`	no
Final run record (counts: `rows`, `reviews`, `ok`, `error`, `skipped`)	`SUMMARY`	`ok`, `partial` or `error`	no

Sample output: 10 reviews, real local run (2026-10-20)

Input: app 310633997 (WhatsApp Messenger), country us, maxPages 1, maxReviewsPerAppCountry 10. Review text and author names are written by the public, so the table shows only structural fields; every row also has reviewId, appId, country, title, text, author and reviewUrl.

rating	date	app version	title length	review length
5	2026-10-19T04:20:42-07:00	26.40.77	13 chars	11 chars
5	2026-10-19T04:12:09-07:00	26.40.77	4 chars	6 chars
4	2026-10-19T01:32:36-07:00	26.40.77	20 chars	331 chars
4	2026-10-19T00:29:14-07:00	26.40.77	25 chars	86 chars
1	2026-10-18T23:18:04-07:00	26.40.77	1 chars	185 chars
5	2026-10-18T23:09:09-07:00	26.40.77	4 chars	4 chars
1	2026-10-18T22:29:23-07:00	26.40.77	21 chars	84 chars
2	2026-10-18T21:04:41-07:00	26.40.77	9 chars	94 chars
1	2026-10-18T20:38:36-07:00	26.40.77	73 chars	32 chars
5	2026-10-18T19:59:55-07:00	26.40.77	11 chars	11 chars

Example input

{
  "apps": ["310633997"],
  "countries": ["us"],
  "maxPages": 1
}

The default input runs as-is, so you can click Start without editing anything.

Example output

Field values below are illustrative of the shape, not a real review.

{
  "reviewId": "1234567890",
  "appId": "310633997",
  "country": "us",
  "rating": 4,
  "title": "Works well",
  "text": "Example review text.",
  "version": "1.2.3",
  "author": "ExampleUser",
  "date": "2026-10-01T12:00:00-07:00",
  "reviewUrl": "https://itunes.apple.com/us/review?id=310633997&type=Purple%20Software"
}

Pricing (pay per event)

Event review-result: one review item pushed to the dataset. Price: review-result $0.0001 per review ($0.10 per 1,000), matching .actor/pay_per_event.json. Empty apps/countries are free; set Max total charge to cap spend. A run that returns no reviews fails and is not billed.

FAQ

Can I use the bundle ID instead of the app ID?

Yes. Put com.burbn.instagram in bundleIds (or in apps); it is resolved to the App Store app through itunes.apple.com/lookup?bundleId= (in the first country you list, default us). iOS bundle IDs only: Android package names belong to Google Play, which this Actor does not read. An ID that is not found in that storefront gets one dataset row (recordType: "error", with the bundle ID and reason) and is not billed.

How to scrape App Store reviews?

Give apps (numeric IDs or App Store URLs) and countries, then click Start. The actor reads Apple's public customer-reviews RSS feed and returns one row per review. No login, browser or proxy.

Why do other scrapers return only 10 reviews?

Some tools stop at one page. This Actor pages through Apple's feed (10 pages of 50), so one app and country returns up to 500 newest reviews; set maxPages to 10 (default is 2).

How many App Store reviews can I get per app?

Up to the 500 most recent reviews per app per country (10 pages of 50), which is all that feed exposes. Older reviews are not available from this source; list several countries to cover more storefronts.

Can I get reviews from several countries in one run?

Yes. List storefront codes in countries (for example us, gb, de, ro); every app is fetched once per country, each with up to 500 reviews and its own free summary row, and each review row has a country field. Combine with dateFrom to keep only recent reviews.

Is the output format the same on every run?

Yes. Every review row is a flat object with the same fields (reviewId, appId, country, rating, title, text, version, author, date, reviewUrl), built in src/parse.js; there are no nested objects. date is always present as a key and holds Apple's updated timestamp; it is an empty string if Apple omits it for a review. Summary rows have recordType: "summary" and different fields.

What is the difference between id and appId?

The numeric App Store id (the number after id in the app URL, e.g. 324684580) is the same value as the appId column in the output. The bundle ID (package name, e.g. com.spotify.client) is a different string; give either one and the actor resolves bundle IDs to the numeric id before fetching.

Can I filter App Store reviews by date or rating?

Yes. dateFrom keeps reviews on or after a date (feed is newest first, so paging stops once older reviews are reached) and minRating keeps reviews with at least that many stars. Filtered-out reviews are not billed.

Why only N reviews? Why did the run stop?

Apple's RSS feed exposes at most 500 recent reviews per app and country, and your own maxPages, maxReviewsPerAppCountry or dateFrom can stop it sooner. The free summary row (recordType: "summary", fields reviewsExposedByApple, reviewsReturned, reviewsFilteredOut, duplicatesDropped, stoppedBecause) tells you exactly which one applied.

How to find an App Store app ID?

It is the number after id in the App Store URL, e.g. https://apps.apple.com/us/app/whatsapp-messenger/id310633997. URLs are also accepted directly.

How much does it cost to scrape App Store reviews?

$0.0001 per review, $0.10 per 1,000, so 500 reviews cost $0.05. Empty apps or countries are free, and a run that returns no reviews fails and is not billed. Max total charge caps spend.

Can I export App Store reviews to CSV or Excel?

Yes. The dataset exports as JSON, CSV or Excel from Apify Console or the API.

Is this affiliated with Apple?

No. It reads Apple's public RSS feed and is not affiliated with or endorsed by Apple Inc.

Honest limits

Apple's feed returns at most the 500 most recent reviews per app per country (10 pages x 50). Older reviews are not available from this source. Reviews are de-duplicated by reviewId per app and country, so you never pay for the same review twice when Apple's feed shifts between pages.
Reviews are per storefront; to cover several markets list several countries.
Summary rows are free and are not reviews; filter on recordType.
Every row has a status (ok, error or skipped). The last row of every run is a free recordType: "SUMMARY" record with rows, reviews, ok, error, skipped, appsRequested and appsResolved; rows equals the number of dataset rows before it, so one bad app ID shows up as a status: "error" row and error: 1 instead of a silent gap.
Only reviews with text and rating as published by Apple; no developer replies, no Google Play, no app metadata.
Apple may change or throttle the feed; failed pages are retried 3 times, then skipped.
Review text and author names are public data supplied by Apple; handle them according to the privacy law that applies to you.

Related actors

Website Tech Stack Detector: after pulling an app's reviews, check what technology the publisher's website runs on.
Website Contact Extractor: find public contact details on the publisher's website.
RSS/Atom Feed Reader (bulk): another feed-based source, for blogs and news about the same apps.

Use from Claude Desktop / Cursor (Apify MCP)

AI agents can call this Actor as a tool through the Apify MCP server (https://mcp.apify.com, authenticated with your Apify API token). Ask your agent to find pennydata/appstore-reviews-rss in Apify Store and run it, or preload it by adding the Actor to the server URL as described in the Apify MCP docs (for example https://mcp.apify.com/?tools=pennydata/appstore-reviews-rss). Typical agent task: "fetch iOS App Store reviews for an app ID". The agent passes the same input JSON as in the example below and reads the dataset rows back. Billing is the usual per-event pay-per-event pricing; set a maximum cost per run in the run options to cap what an agent can spend.

Ready-made URL: https://mcp.apify.com/?tools=pennydata/appstore-reviews-rss

Client config for Claude Desktop or Cursor (mcpServers format; sign in with OAuth when the client asks):

{"mcpServers": {"apify": {
  "url": "https://mcp.apify.com/?tools=pennydata/appstore-reviews-rss"
}}}

Call it with curl

curl -X POST "https://api.apify.com/v2/acts/pennydata~appstore-reviews-rss/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"apps":["310633997"],"countries":["us"],"maxPages":1}'

Call it from Python

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("pennydata/appstore-reviews-rss").call(run_input={"apps": ["310633997"], "countries": ["us"], "maxPages": 1})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

Schedules and integrations

Run it on a schedule from Apify Console (Schedules), or trigger it from your own pipeline through the API above. Finished runs can notify a webhook, and the dataset exports as JSON, CSV or Excel. Apify also offers integrations with Make, Zapier, n8n and Google Sheets that can start this Actor with the same input.

AI disclosure

This actor was written with the assistance of an AI model (Claude, by Anthropic) and tested locally on live Apple feeds.

Other languages

Español: Reseñas de la App Store en JSON

Descarga las reseñas de cualquier app de la App Store (iPhone e iPad) en JSON: texto, valoración, versión, fecha y país. Indica el ID de la app o su bundle ID y los países que quieras; sin cuenta de desarrollador ni clave de API. Precio: 0,0001 USD por reseña devuelta (0,10 USD por 1.000); si no hay reseñas, no se cobra.

Ejemplo de entrada:

{"apps":["310633997"],"countries":["us","es","mx"],"maxReviewsPerAppCountry":50}

Português: Avaliações da App Store em JSON

Baixe as avaliações de qualquer app da App Store (iPhone e iPad) em JSON: texto, nota, versão, data e país. Informe o ID do app ou o bundle ID e os países desejados; sem conta de desenvolvedor e sem chave de API. Preço: US$ 0,0001 por avaliação retornada (US$ 0,10 por 1.000); sem avaliações, sem cobrança.

Exemplo de entrada:

{"apps":["310633997"],"countries":["us","br","pt"],"maxReviewsPerAppCountry":50}

Deutsch: App-Store-Bewertungen als JSON

Lädt die Bewertungen jeder App aus dem App Store (iPhone und iPad) als JSON: Text, Sterne, Version, Datum und Land. App-ID oder Bundle-ID und gewünschte Länder angeben; kein Entwicklerkonto und kein API-Schlüssel nötig. Preis: 0,0001 USD pro zurückgegebener Bewertung (0,10 USD pro 1.000); ohne Bewertungen fallen keine Kosten an.

Beispieleingabe:

{"apps":["310633997"],"countries":["de","at","ch"],"maxReviewsPerAppCountry":50}

I built this and earn from its runs. Written with AI assistance (Claude).

Actor input Schema

`mode` (type: `string`):

reviews (default) returns customer reviews. appInfo returns App Store app details (name, developer, price, rating, rating count, version, release notes, genres, screenshots) for the listed apps or for apps found by search terms.

`apps` (type: `array`):

Numeric App Store app IDs (e.g. 389801252), App Store URLs (e.g. https://apps.apple.com/gb/app/spotify/id324684580; the country in the URL is used), or bundle IDs / package names (e.g. com.burbn.instagram). One entry per app.

`bundleIds` (type: `array`):

iOS bundle IDs such as com.burbn.instagram, resolved to the App Store app via Apple's lookup API. Use instead of, or together with, Apps.

`countries` (type: `array`):

Two-letter App Store country codes (e.g. us, gb, de). Reviews are stored per storefront, so each country is fetched separately.

`maxPages` (type: `integer`):

Pages of reviews to fetch per app and country (50 reviews per page). Apple exposes at most 10 pages, i.e. 500 most recent reviews.

`maxReviewsPerAppCountry` (type: `integer`):

Optional hard cap on reviews returned (and charged) for each app and country combination. Default 50; set 0 for no extra cap beyond max pages.

`dateFrom` (type: `string`):

Keep only reviews on or after this date (e.g. 2026-09-01). Reviews are read newest first, so paging stops once older reviews are reached. Filtered-out reviews are not billed.

`minRating` (type: `integer`):

Keep only reviews with at least this many stars (1-5). 0 keeps all. Filtered-out reviews are not billed.

`sort` (type: `string`):

mostRecent (default) returns newest reviews first; mostHelpful returns the reviews other users voted most helpful first. Each review row carries helpfulCount.

`sampleOnly` (type: `boolean`):

When on, at most 10 reviews are returned in total and no pay-per-event charge is made. Use it to try the output format at no cost.

`includeSummary` (type: `boolean`):

Adds one free summary row per app and country (recordType: summary) saying how many reviews Apple exposes (500 per country cap) and why the run stopped. Not billed.

`searchTerms` (type: `array`):

appInfo mode only: keywords to search the App Store for apps (e.g. 'habit tracker'). Each term and country returns up to Max search results apps.

`maxSearchResults` (type: `integer`):

appInfo mode only: apps returned per search term and country (1-200).

Actor input object example

{
  "mode": "reviews",
  "apps": [
    "310633997",
    "389801252"
  ],
  "countries": [
    "us"
  ],
  "maxPages": 1,
  "maxReviewsPerAppCountry": 5,
  "minRating": 0,
  "sort": "mostRecent",
  "sampleOnly": false,
  "includeSummary": true,
  "maxSearchResults": 25
}

Actor output Schema

`reviews` (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

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 = {
    "apps": [
        "310633997",
        "389801252"
    ],
    "countries": [
        "us"
    ],
    "maxPages": 1,
    "maxReviewsPerAppCountry": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("pennydata/appstore-reviews-rss").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

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 = {
    "apps": [
        "310633997",
        "389801252",
    ],
    "countries": ["us"],
    "maxPages": 1,
    "maxReviewsPerAppCountry": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("pennydata/appstore-reviews-rss").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

echo '{
  "apps": [
    "310633997",
    "389801252"
  ],
  "countries": [
    "us"
  ],
  "maxPages": 1,
  "maxReviewsPerAppCountry": 5
}' |
apify call pennydata/appstore-reviews-rss --silent --output-dataset

MCP server setup

{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,pennydata/appstore-reviews-rss"
        }
    }
}

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/nhjknbuPgcGc2X0Jx/builds/kmFht7DEaHP7h16J5/openapi.json