Apple App Store Reviews API

Extract public App Store reviews from any iOS app as structured JSON.

Fast batch extraction — 1,000+ App Store reviews in seconds in typical workloads.

✓ Ratings, titles, and review text
✓ Authors, helpful votes, and optional reviewed-version enrichment
✓ Multiple countries and multiple apps per run
✓ Rating and date filters
✓ API & MCP-friendly input/output
✓ No Apple login or proxy required
✓ Pay only for delivered reviews

Each review is a separate Dataset item, ready for JSON, CSV, Excel, XML, automations, and data pipelines.

Production verification on 128 MB runs delivered 1,200 reviews in 3.2–13.5 seconds. Actual runtime varies with Apple endpoint latency, storefront availability, filters, and optional version enrichment.

This is an independent, unofficial tool. It is not affiliated with, endorsed by, or sponsored by Apple Inc.

Quick example

Input in Apify Console:

{
  "apps": ["284882215"],
  "countries": ["us"],
  "maxReviews": 1000
}

Output item:

{
  "reviewId": "1234567890",
  "appId": "284882215",
  "appName": "Facebook",
  "appUrl": "https://apps.apple.com/us/app/facebook/id284882215",
  "country": "us",
  "rating": 2,
  "title": "Needs improvement",
  "text": "The latest update keeps crashing...",
  "author": {
    "name": "John Doe",
    "id": "85038071"
  },
  "reviewedVersion": null,
  "date": "2026-08-31T17:22:00.000Z",
  "helpfulness": {
    "helpful": 5,
    "total": 7
  },
  "source": {
    "platform": "apple_app_store",
    "page": 1,
    "sort": "mostRecent"
  },
  "fetchedAt": "2026-09-04T07:15:32.000Z"
}

Unavailable optional Apple fields are returned as null; values are never invented.

Input

Provide apps, appNames, or both. The two lists are combined and deduplicated.

The Console opens with Facebook (284882215), the US storefront, and 1,000 reviews per app–country pair prefilled. Replace or remove the sample App ID before running your own lookup; remove us if you want storefronts to be inferred from App Store URLs.

Field	Type	Default	Description
apps	string[]	—	Up to 20 numeric IDs, id123 values, or full App Store URLs
appNames	string[]	—	App names to resolve through Apple Search; each selected result is logged
countries	string[]	["us"]	Up to 20 two-letter storefront codes; explicit values override URL storefronts
maxReviews	integer	1000	1–10,000 reviews after filtering, per app × country
sort	string	mostRecent	mostRecent or mostHelpful
ratings	string[]	all	Any combination of "1"–"5"
since	string	—	ISO 8601 date or timestamp; older reviews are excluded
maxConcurrency	integer	5	1–20 concurrent app × country tasks
includeReviewedVersion	boolean	false	Enrich matching JSON reviews from RSS; increases Apple requests

For example, two apps, three countries, and maxReviews: 1000 can return up to 6,000 items. With ratings: ["1"], the Actor keeps paging until it finds 1,000 one-star reviews per combination or reaches the end of Apple's feed.

The efficient default path uses Apple's JSON response only. Set includeReviewedVersion: true when the reviewed app version is important: the Actor then reads RSS lazily and joins versions by stable review ID. RSS enrichment is best-effort and never prevents an otherwise valid JSON review from being delivered.

IDs and URLs in apps are merged with Apple Search results from appNames, then deduplicated. A maximum of 20 app entries is accepted across both fields. Explicit countries always wins over storefronts inferred from URLs. Without explicit countries, all unique URL storefronts become the country set for the deduplicated apps; this is a cross-product, consistent with the app × country processing model.

When appNames is used, every resolution is explicit in the run log:

Resolved appNames query -> "Spotify: Music and Podcasts" (324684580)

JavaScript API example

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('<username>/apple-app-store-reviews-api').call({
    apps: ['284882215', '324684580'],
    countries: ['us', 'gb', 'de'],
    ratings: ['1', '2'],
    maxReviews: 1000,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Python API example

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("<username>/apple-app-store-reviews-api").call(run_input={
    "appNames": ["Spotify", "Netflix"],
    "countries": ["us", "gb"],
    "maxReviews": 1000,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

curl / REST API example

Start a run and wait for it to finish:

curl -X POST \
  "https://api.apify.com/v2/acts/<username>~apple-app-store-reviews-api/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"apps":["284882215"],"countries":["us","gb"],"maxReviews":1000}'

Dataset exports use Apify's native API. Add format=csv, format=xlsx, or format=xml to the Dataset items endpoint instead of maintaining a separate exporter.

MCP and agent workflows

The descriptive input and output schemas make the Actor discoverable through Apify's MCP tooling. Agents can call it with direct fields such as apps, countries, ratings, and since; no opaque scraper-specific configuration is required. This is a normal finite Actor run, not a Standby MCP server.

Pricing

The Actor uses Apify Pay Per Event with an Actor Start event and a review event.

1 successfully delivered unique review = 1 billable event.

The base pricing reference is $0.00005 per Actor start and $1.00 per 1,000 reviews ($0.001 per review). Paid-plan tier discounts may reduce the review price; the Pricing tab on the published Actor remains authoritative. .actor/pay_per_event.json mirrors the base Store configuration so repository readers do not mistake stale development pricing for production pricing. Failed requests, invalid apps, filtered reviews, duplicates, and apps with no reviews are not charged. A run-level maximum charge is respected; when it is reached, no additional item is written or billed.

Publication safety: configure the custom review event and remove/disable Apify's synthetic apify-default-dataset-item event. Enabling both would charge two events for the same Dataset item, so the Actor fails fast on Apify if it detects that configuration instead of processing reviews under ambiguous billing.

Run summary

The OUTPUT record in the default Key-Value Store contains:

{
  "appsRequested": 2,
  "countriesRequested": 3,
  "combinationsProcessed": 6,
  "reviewsFetched": 325,
  "reviewsOutput": 280,
  "duplicatesSkipped": 5,
  "filteredOut": 40,
  "noReviewCombinations": 0,
  "suspiciousEmptyFeeds": 0,
  "failedCombinations": 0,
  "durationMs": 2840,
  "chargeLimitReached": false
}

reviewsFetched counts parsed source reviews actually inspected before maxReviews or the charge limit stopped processing. Filtered and duplicate records are counted separately, and HTTP retries do not increment review counters.

Use cases

• Feed public app feedback into product research, ASO, or competitor intelligence.
• Export recent low-rating reviews for manual triage.
• Prepare normalized review text for your own sentiment or RAG pipeline.
• Compare storefront feedback across countries.
• Use since in scheduled runs to limit work to a recent time window.

Ready-made workflow catalog

The Actor includes 50 public Task configurations built around distinct user goals rather than aliases for individual input fields. Every Task has its own title, description, SEO metadata, editable input, example application, and overview Dataset view.

The public catalog covers exports, API access, rating filters, product research, monitoring, competitor analysis, country-specific extraction, sentiment analysis, RAG, and bulk datasets.

Export, API, and bulk extraction

1. Export App Store Reviews to CSV
2. Export App Store Reviews to Excel
3. Get App Store Reviews as JSON
4. Get App Store Reviews via API
5. Scrape App Store Reviews by App URL
6. Scrape App Store Reviews by App ID
7. Download Latest App Store Reviews
8. Bulk Extract App Store Reviews

CSV and Excel Tasks use Apify's native Dataset exports. They do not maintain a separate converter inside the Actor.

Rating, complaints, and product research

9. Get 1-Star App Store Reviews
10. Get 2-Star App Store Reviews
11. Get Negative App Store Reviews (1–2 Stars)
12. Get 5-Star App Store Reviews
13. Get Positive App Store Reviews (4–5 Stars)
14. Get Most Helpful App Store Reviews
15. Find Customer Complaints in App Store Reviews
16. Collect App Reviews for Bug Analysis
17. Collect App Reviews for Feature Request Analysis
18. Collect App Reviews for Product Feedback Research

Research Tasks collect structured source data. They do not classify complaints, bugs, feature requests, or sentiment themselves.

Monitoring and incremental collection

19. Get Recent App Store Reviews Since a Date
20. Monitor New App Store Reviews
21. Track App Store Reviews After an App Update
22. Collect Reviews After a New App Release
23. Daily App Store Review Monitoring
24. Weekly App Store Review Monitoring
25. Build an Incremental App Store Review Feed
26. Sync Only New App Store Reviews

For incremental operation, the caller stores the last successful timestamp and passes it back as since on the next run. Scheduling and checkpoint persistence remain explicit external workflow concerns.

Competitor intelligence

27. Monitor Competitor App Store Reviews
28. Track Competitor 1-Star Reviews
29. Compare Reviews from Multiple iOS Apps
30. Bulk Scrape Competitor App Reviews
31. Build a Competitor App Review Dataset
32. Research Competitor Customer Complaints
33. Compare Customer Feedback Across Competing Apps

Country and localization

34. Get App Store Reviews by Country
35. Compare App Store Reviews Across Countries
36. Get US App Store Reviews
37. Get UK App Store Reviews
38. Get German App Store Reviews
39. Get French App Store Reviews
40. Get Japanese App Store Reviews
41. Get Canadian App Store Reviews
42. Get Australian App Store Reviews
43. Get Indian App Store Reviews
44. Get Brazilian App Store Reviews
45. Get Spanish App Store Reviews
46. Get Italian App Store Reviews
47. Get Ukrainian App Store Reviews

Apple reviews are storefront-specific, so the country Tasks return genuinely different source datasets for the same application.

AI and data workflows

48. Get App Store Reviews for Sentiment Analysis
49. Get App Store Reviews for RAG and LLM Analysis
50. Build an App Store Reviews Dataset for AI

AI Tasks extract normalized text, ratings, dates, versions, and country metadata for downstream models. The Actor does not perform sentiment analysis, embeddings, RAG, or other AI processing.

Limitations

• Apple does not offer an authenticated public reviews API for arbitrary third-party apps. The Actor uses Apple's iTunes WebObjects JSON response as its primary source and Customer Reviews RSS only as fallback or optional version enrichment. Neither reviews endpoint has a formal compatibility or availability guarantee.
• If both sources return zero items for an app whose storefront metadata reports many ratings, the combination is marked as a suspicious empty feed and failed instead of being reported as a trustworthy zero. It is counted in OUTPUT.suspiciousEmptyFeeds and is never charged.
• The primary JSON response does not expose the reviewed app version, so reviewedVersion is normally null. Enable includeReviewedVersion to populate it where RSS contains a matching review.
• Storefronts are independent. An app or its reviews may be available in one country and absent in another.
• Apple controls feed depth and page size; maxReviews is a ceiling, not a guarantee.
• Pagination has a hard safety cap of 100 JSON pages per app × country (up to 100 source reviews per page); RSS fallback has a 50-page cap. Rare rating filters can therefore return fewer selected reviews than maxReviews even when Apple has deeper history.
• Empty title or review-body strings returned by Apple are preserved as real empty strings. An unrecoverable malformed review is skipped when other valid reviews remain on the page; a page containing no valid review records is retried and then fails that combination.
• Rating filtering is local. mostHelpful follows Apple's feed order; no global mostCritical or mostFavorable order is claimed.
• since stops pagination early only with mostRecent; with mostHelpful, all available pages must be inspected.
• This MVP does not perform translation, sentiment analysis, summaries, alerts, monitoring state, or Google Play extraction.

FAQ

Do I need an Apple developer account or App Store Connect token?

No. The Actor reads public storefront data and never accepts Apple credentials.

Do I need a proxy?

No. Requests go directly to Apple's public endpoints by default.

Does version enrichment triple the request count?

Only when you opt into it. The default path makes no RSS or App Store HTML requests: it uses one cached storefront lookup per country, application metadata lookup, and JSON pages of up to 100 reviews. With includeReviewedVersion: true, RSS adds up to roughly two 50-review requests for each full 100-review JSON page. Use enrichment only when per-review app versions are worth that extra traffic.

How are duplicates handled?

Within a run, country + appId + reviewId is unique. Duplicate feed entries are neither saved nor charged. A page containing only already-seen IDs terminates that pagination path.

What happens when one app or country fails?

Other app × country tasks continue. The failed combination is logged and counted in OUTPUT.failedCombinations.

Why did I receive fewer reviews than requested?

The storefront may have fewer exposed reviews, filters may exclude items, since may stop at the requested boundary, or the run charge limit may have been reached.

Can an empty Apple feed be mistaken for an app with no reviews?

The Actor does not trust a single empty response. It retries suspiciously empty JSON responses three times with backoff and then checks the independent RSS source. If both sources are still empty while metadata shows at least 10 ratings, the combination is reported as inconclusive in the run log and summary rather than silently returned as “no reviews.” Apps with fewer than 10 ratings can legitimately have no written reviews and are counted in noReviewCombinations when both sources are empty.

Are dates normalized?

Yes. Parseable Apple timestamps become ISO 8601 UTC strings. An unavailable or unparseable optional timestamp is null.

Local development

Requires Node.js 22.12 or newer.

npm install
npm run typecheck
npm run lint
npm test
npm run build

Run locally with Apify CLI:

$npx apify-cli run --input-file examples/input.json

Run live endpoint tests and the network benchmark explicitly:

npm run test:integration
npm run benchmark -- 100

Before publishing, choose Pay per event in Actor monetization settings, remove the automatically offered apify-default-dataset-item event, and configure Actor Start plus the custom review event from .actor/pay_per_event.json. This companion file mirrors the intended base prices, but the published Store pricing (including tier discounts) is configured in Apify Console and is authoritative. After every Store price change, update this file and its metadata test in the same change. Then deploy with npx apify-cli push.

Data source and operational notes

Application metadata and name resolution use Apple's documented iTunes Search/Lookup API. Reviews use the iTunes WebObjects JSON response first because live checks show that Customer Reviews RSS can return an empty feed for storefronts that still have reviews; numeric storefront IDs are resolved dynamically and cached once per country. RSS is called after empty/failed JSON or when includeReviewedVersion explicitly enables best-effort enrichment. Both review endpoints are undocumented and may change. For an unfiltered request smaller than 100 reviews, the JSON page size is reduced to avoid downloading unused items. Filtered reviews are delivered to the Dataset and charged in page-sized batches rather than one SDK request per item; the global billing queue and SDK prefix trimming preserve run charge limits across concurrent app/storefront tasks. HTTP requests have a 15-second timeout, three attempts for transient failures (429, 5xx, timeouts, connection errors, and malformed HTTP 200 payloads), exponential backoff with jitter, and no browser dependency. Response bodies are capped at 1 MiB for Search/storefront metadata, 5 MiB for RSS, and 10 MiB for review JSON; oversized responses fail without retry.