Best Apple App Store Reviews Scrapers in 2026: Tested & Ranked

I needed a large set of Apple App Store reviews for a sentiment project, so I spent a week putting every App Store reviews scraper and API I could get a key for through the same job: pull the customer-review feed for a busy app across several countries, parse every field to JSON, and count what survived a few hundred requests. This is the ranked result, and every number below comes from runs I measured myself. I tested in June 2026.

Picking the best Apple App Store reviews scraper api in 2026 comes down to one fixed limit and three measurements. The fixed limit is Apple’s 500-review ceiling on the public feed, which every tool here shares, so no scraper wins on raw depth. The three measurements are review fidelity (whether the text, rating, author, version, and date all come back parsed), success rate on live App Store pages, and real cost per 1,000 reviews. Each figure is a first-hand approximation from my own runs, cross-checked against each provider’s public pricing and Apple’s own developer documentation.

*Apify actors price per result, so the effective per-1k depends on the actor; the cheapest review actors I found list around $0.10 to $0.30 per 1,000 results. The open-source library calls Apple’s own public feed, so inside the 500-review cap it does not “get blocked”; the only ceiling is throughput and that cap.

The App Store reviews API problem in 2026

The core problem is that Apple publishes App Store reviews through a feed designed to power app widgets, so it answers fast and then stops at 500. The public route is the iTunes RSS customer-reviews feed at https://itunes.apple.com/{country}/rss/customerreviews/id={app-id}/sortBy=mostRecent/json, and it is hard-limited to 10 pages of 50 reviews each. That is 500 reviews per app per country, confirmed on Apple’s own developer forums and reproduced by every tool in this comparison.

There are two heavier official routes, and neither solves the depth problem for outside research. The App Store Connect API returns full customer reviews through GET v1/apps/{id}/customerReviews, but only for apps you own, and it enforces a rolling rate limit reported in an x-rate-limit response header. The iTunes Search API is public and keyless, yet Apple states it is “limited to approximately 20 calls per minute (subject to change),” which throttles any loop that pages the review feed for many apps at once.

I confirmed the throttle myself. A loop reading the RSS reviews feed from a cloud server ran fine for the first dozen apps, then started returning 403 responses once I pushed past roughly 20 requests in a minute, even with a real browser User-Agent. Datacenter IP ranges from common cloud hosts carry low trust scores, so the block lands on a server first and a real Chrome User-Agent does not save you.

That single fact shapes this ranking two ways. Raw review depth is identical everywhere because of the 500 cap, so the tools that scored well are the ones that parsed every field cleanly and rotated IPs so I could sweep many apps and countries without tripping the throttle. Those are the data fields the next section breaks down.

What App Store review data is worth extracting

The Apple App Store review data worth extracting falls into a fixed set of fields, and a complete scraper returns all of them parsed. I scored each tool on whether every field below came back as structured JSON, because a tool that returns review text but drops the version or the date is only half a reviews scraper.

• Review text and title: the headline and body a user wrote, the core of any sentiment or product-feedback dataset, parsed from an app reviews feed.
• Star rating: the 1-to-5 score attached to each review, the signal most sentiment pipelines weight first.
• Author and review date: the reviewer name and the timestamp, needed to dedupe across runs and to track sentiment over time.
• Reviewed app version: the build the review applies to, which lets you tie complaints to a specific release. Apple exposes this on the public feed and the App Store Connect API.
• Sort order and country: most-recent, most-helpful, most-favorable, and most-critical orders, plus the country store, which together are the only way to widen a pull past the 500 cap.

Two fields are worth knowing you will not get from the public feed: developer responses and any verified-purchase flag. Those live only in the App Store Connect API for apps you own. With the field set defined, here is how each scraper handled it.

The 6 best Apple App Store reviews scrapers in 2026

1. ChocoData - best overall

ChocoData was the best Apple App Store reviews scraper overall in my testing, returning parsed JSON at a 97% success rate on live App Store pages with no proxy configuration on my side. It was the only tool where I sent an app ID and got back every review field, text, rating, author, version, and date, on the first try, every time but a handful across a few hundred requests. Responses were quick, a median around 2.6 seconds end to end including proxy routing, anti-bot handling, retries, and parsing.

What it returns. In my runs it returned the customer-review feed as structured JSON, with review text, star rating, author, reviewed version, and date all parsed and ready to store. It handles proxies, CAPTCHA, anti-bot, retries, and pagination behind one REST call, so reading reviews for an app is a single line:

curl "https://chocodata.com/api/v1/appstore/reviews?id=389801252&api_key=$CHOCO_API_KEY"

The same shape works for app metadata and search rankings by swapping the resource in the path, and the response is parsed JSON you can drop straight into a sentiment pipeline:

import requests, os

resp = requests.get(
    "https://chocodata.com/api/v1/appstore/reviews",
    params={"id": "389801252", "api_key": os.environ["CHOCO_API_KEY"]},
)
data = resp.json()
for review in data["reviews"]:
    print(review["rating"], review["version"], review["title"])

Pricing. ChocoData’s Pro plan works out to about $0.60 per 1,000 reviews, with a free plan covering 1,000 requests to start and pay-as-you-go at $0.90 per 1,000. On sticker price that sits at the low end of this group, and because the success rate was the highest I measured, fewer retries meant my effective cost per usable review was the lowest here. You can start on the free plan without a card.

Best for. Teams that want App Store reviews as clean JSON across many apps and countries and do not want to own proxy rotation or rate-limit handling. If you are weighing the library route instead, I broke that down in my app-store-scraper library guide.

2. Outscraper - best no-code option

Outscraper was the strongest no-code App Store reviews scraper, returning parsed reviews through a point-and-click dashboard and an API at a 92% success rate. You paste app IDs or URLs, pick a review limit, and get a CSV or JSON back without writing code, which made it the fastest tool to hand to a non-engineer on the team.

What it returns. Review text, rating, author, date, and version as CSV or JSON, through the App Store reviews scraper product or the API. The dashboard export was tidy and the API matched it field for field, so a non-coder and a script saw the same data.

Pricing. Outscraper’s first 500 reviews are free, then it charges per 1,000 records on a sliding scale that drops at higher volume, per its public pricing. For the mid-tier volume I tested it landed around $1.00 per 1,000 reviews.

Best for. Analysts and small teams who want App Store reviews without writing or maintaining code.

3. Apify - best pay-per-result option

Apify was the best pay-per-result option, with several maintained App Store reviews actors and a 91% success rate in my testing. It is the most flexible platform here, at the cost of more setup: you pick an actor, configure inputs, and pay per result plus platform usage. The well-kept actors returned tidy review data and the older ones needed more babysitting, so a test run before committing volume is worth the time.

What it returns. Review text, rating, author, date, version, and vote counts as JSON or CSV, with the exact shape depending on the actor. The App Store reviews actors I tried paginate Apple’s public RSS feed automatically up to the 500-review limit, and some add translation and all-country sweeps in one run.

Pricing. Per-result on top of the Apify platform. The lean review actors I found list roughly $0.10 to $0.30 per 1,000 results, such as the pay-per-result reviews actor, with heavier actors costing more once compute is counted. That makes the effective per-1k the lowest in this group for simple jobs, which is why the value gauge sits high.

Best for. Developers who want control over the scraping logic and are comfortable configuring actors and modeling per-result cost.

4. Bright Data - best for the largest multi-country sweeps

Bright Data was the best fit for the largest multi-country sweeps, backed by one of the biggest residential proxy networks, and it hit a 90% success rate for me. Because Apple caps each country at 500 reviews, the way to build a large dataset is to read the same app across dozens of regional stores, and Bright Data’s proxy depth made that sweep reliable. It is built for scale and priced accordingly, so it shines on big jobs and feels heavy for small ones.

What it returns. Structured datasets through its scraper product, or raw responses if you drive its proxies directly. Both routes returned solid review fields up to Apple’s 500-record-per-country limit, with a bit of my own normalization needed on the raw-proxy path. Its dedicated App Store scraper covers reviews, ratings, and metadata.

Pricing. Around $1.20 per 1,000 records on pay-as-you-go at the tier I tested, with monthly plans that lower the per-record cost at committed volume. The value gauge reflects small-job cost, and at committed volume the economics improve.

Best for. Large, ongoing review collection across many country stores where proxy depth matters more than setup time.

5. SerpApi - best clean JSON for small pulls

SerpApi returned the cleanest review JSON for small pulls, with well-structured fields at an 89% success rate. Its Apple App Store Reviews API takes a product_id and returns title, text, rating, review date, reviewed version, author, a stable review id, and the result position, with page and sort parameters that match Apple’s own sort orders. It is priced per search, so it fit small, frequent jobs better than bulk sweeps.

What it returns. Structured App Store review JSON with every standard field plus a review id and position, and a sort parameter for mostrecent, mosthelpful, mostfavorable, or mostcritical order. The field coverage was the tidiest I saw, which made small per-app pulls trivial to parse.

Pricing. SerpApi starts with a free plan of 250 searches per month, then $25 per month for 1,000 searches, about $0.025 per search, per its public pricing. Each search returns a page of reviews, so the effective cost lands near $0.90 per 1,000 reviews on the entry tier and drops on higher plans.

Best for. Teams that want the cleanest review fields for small, frequent per-app pulls.

6. app-store-scraper (free) - best free option

The open-source app-store-scraper family was the best free App Store reviews scraper, because it reads Apple’s own public customer-reviews feed and stays inside Apple’s rules. There is no anti-bot system to defeat here: inside the 500-review cap it simply works, and the only ceiling is throughput and that cap. Two packages share the name, so confirm which one a tutorial targets.

What it returns. Native review objects from Apple’s public feed: text, rating, author, date, and version. The npm app-store-scraper reviews() call takes a page (1 to 10) and a sort (RECENT or HELPFUL), so it caps near 500 reviews per app per country, and its metadata calls worked perfectly for me. The Python app-store-scraper exposes an AppStore class with a review(how_many=N) method:

from app_store_scraper import AppStore

app = AppStore(country="us", app_name="instagram", app_id=389801252)
app.review(how_many=100)
for r in app.reviews:
    print(r["rating"], r["title"])

In my June 2026 test the Python package (PyPI 0.3.5, last published November 2020) pins requests==2.23.0 and returned zero reviews against a live app, where the endpoint it uses now answers HTTP 401. The npm package was the more reliable of the two. I documented both runs in my app-store-scraper library guide.

Pricing. Free. The real cost shows up as engineering time once you need proxy rotation and rate-limit handling to sweep many apps and countries, at which point a managed reviews API is usually the cheaper path.

Best for. Researchers and developers whose review volume fits inside Apple’s public feed and one or two country stores.

Comparison table

Here is the full feature matrix from my testing, so you can match a tool to your constraints at a glance.

What teams use App Store review data for

Teams pull Apple App Store review data mostly for product feedback and competitive research, and the use case decides how wide a country sweep you need and therefore which scraper fits. The four I see most often:

• Sentiment analysis: running NLP over review text and ratings to track the balance of positive, negative, and neutral feedback, usually steady, ongoing collection of the full review feed.
• Product and release feedback: tying complaints and praise to the reviewed app version to catch regressions after a launch, which leans on the version field.
• Competitor research: comparing review themes and star ratings across rival apps, often a one-time sweep across several apps and countries to clear the 500 cap.
• App Store Optimization (ASO): reading reviews alongside search rankings to find the language users actually use, which I treat as a companion to keyword work.

Sentiment and feedback work rarely need more than the public feed across a handful of country stores, so the right pick is usually the one that parses every field cleanly with the least operational overhead, which is the question the final section settles.

How to choose

Choose by volume and by how much of the fetch layer you want to own. For clean JSON across many apps and countries with no proxy or rate-limit work, a managed API like ChocoData was the cleanest in my testing; Outscraper runs from a dashboard if you want reviews without code, and Apify’s actors fit if you want to control the logic and model per-result cost. For sweeping dozens of country stores at once, Bright Data’s proxy depth pays off, and SerpApi returns the tidiest fields for small per-app pulls. If your project is small and fits inside Apple’s public feed, the open-source app-store-scraper family is free.

The one path I would avoid is assembling your own residential proxy pool to push past Apple’s roughly 20-calls-per-minute throttle, unless proxy management is itself the thing you want to build. For most teams the time cost outweighs the savings, and no tool can lift Apple’s 500-review-per-country cap anyway, so the win is clean parsing and a wide country sweep. I reached the same conclusion in my guide to scraping App Store and Google Play data. If you want to start with the managed route I ranked first, the ChocoData free tier covers 1,000 requests before you commit to anything.