Mac App Store Reviews Scraper – iTunes Reviews, Any Country
Pricing
from $0.07 / 1,000 reviews
Mac App Store Reviews Scraper – iTunes Reviews, Any Country
An iOS review scraper and app store rating API: Apple App Store reviews for any iOS/Mac app and country storefront — rating, title, text, version, author, date, per-star ratings breakdown, sort by recent/helpful/favorable/critical. Pay per review, first 10 free. Watch mode tracks ratings over time.
Pricing
from $0.07 / 1,000 reviews
Rating
0.0
(0)
Developer
Fetch Smith
Maintained by CommunityActor stats
0
Bookmarked
2
Total users
1
Monthly active users
a day ago
Last modified
Categories
Features
Share
App Store Reviews Scraper (Apple)
Get customer reviews for any iOS / macOS app from the Apple App Store, for any country storefront, as JSON, CSV or Excel. Each review includes rating, title, text, app version, author and date, plus optional app metadata (name, developer, average rating, rating count) and the full per-star ratings breakdown — how many 1★, 2★, 3★, 4★ and 5★ ratings the app has in that storefront. Pay only per review returned, and the first 10 reviews of every run are free.
Use cases
- Product research and competitor analysis across countries
- Sentiment analysis, feature-request mining, churn reasons
- Monitoring your own app's newest reviews on a schedule
- Feeding reviews into AI agents and dashboards
- Alerting on new reviews only — set
watchLabeland schedule it; see Watch mode below - Alerting on rating reversals —
watchEvents: ["scoreChanged"]catches a reviewer editing their own star rating on a review you already have, e.g. a 5★→1★ downgrade after a bad update
Input
| Field | Type | Description |
|---|---|---|
apps | array | App Store URLs or numeric app IDs |
appNames | array | Free-text app names (e.g. "Notion") — auto-resolved to an app id via Apple's own search API. See caveat below. |
includeMacApps | boolean | Also search the Mac App Store when resolving appNames (default false). Apple's app-name search is iOS-only, so Mac-only apps are invisible without it — see below. |
countries | array | Storefront codes, e.g. us, gb, de, jp, br (default us) |
countryFallback | boolean | If a storefront returns nothing, pull that app's reviews from one that works (default false) |
sort | string | mostRecent (default), mostHelpful, or favorable/critical to deliver reviews ordered by star rating (highest/lowest first, newest first within a tied rating) — see FAQ. favorable/critical cannot be combined with watchLabel. |
maxReviewsPerApp | integer | Up to 500 per app per country (Apple's documented limit; in practice its feed often stops sooner — the run says so, see FAQ) — counted before the review filters (rating/keyword/length/votes/date), see FAQ |
includeAppInfo | boolean | Attach app name, developer, average rating, rating count and the per-star ratingBreakdown (default true) |
maxResults | integer | Total cap |
minRating / maxRating | integer | Only keep reviews with a star rating in this range (1-5) |
keyword | string | Only keep reviews whose title or content contains this word/phrase (case-insensitive) |
reviewsAfter | string (ISO date) | Only keep reviews posted on or after this date. Forces sort to mostRecent and stops paging as soon as older reviews are reached, so a narrow window doesn't scan (and isn't charged for) pages you don't want. |
reviewsBefore | string (ISO date) | Only keep reviews posted on or before this date, inclusive of that day. Pair it with reviewsAfter for a date range. |
A bare date (2026-06-01) in either bound means that whole calendar day as the storefront itself dates it — the same date you read at the start of each review's updatedAt. So reviewsAfter: "2026-06-01" with reviewsBefore: "2026-06-01" returns exactly the reviews stamped 2026-06-01, never one stamped the day before or after. Pass a full timestamp (2026-06-01T12:00:00Z) if you want an exact instant instead.
| minReviewLength | integer | Only keep reviews whose body text is at least this many characters — drops one-word "Great!" ratings without discarding a short review that happens to have a long title. |
| minVoteSum / minVoteCount | integer | Only keep reviews with at least this many net helpful votes / total helpfulness votes. Requires sort: mostHelpful — see FAQ. |
| watchLabel | string | Turns this run into a watch — only reviews posted since the last run under this label are returned and charged. Leave empty for normal runs. |
| watchEvents | array | Optional, watch mode only. new and/or scoreChanged — pick scoreChanged alone to be alerted only when an existing reviewer edits their own star rating, and pay for nothing else. Leave empty for both. See Watch mode. |
| webhookUrl | string | Optional. An http(s) URL to POST a JSON completion summary to when the run finishes — row counts plus the per-pair completeness records, see FAQ. The same records are always written to the run's RUN_SUMMARY key-value record whether or not you set this. |
Filtering happens before you're charged — you never pay for rows that got filtered out.
Watch mode — only new reviews since the last run
Set watchLabel to any name and this Actor stops re-delivering the same reviews on every scheduled run:
- First run for a label is a free baseline. It records which reviews already exist for every
apps/countriespair — walking as deep as Apple will serve, up to 500 per pair and regardless ofmaxReviewsPerApp— and returns zero rows — you are charged nothing. Apple's feed often stops well short of 500 (see the FAQ), so a baseline may only cover the newest ~50 reviews of a pair; that is safe, see the next bullet. - Every run after that returns only reviews that weren't in the baseline, and adds them to it. Nothing new → zero rows → zero charge.
- A review older than the baseline could reach is never billed as "new". Each pair also records the oldest review date its baseline walk actually scanned. If Apple's feed serves deeper on a later run than it did at baseline time, the extra older reviews are recognised as pre-existing — not delivered, not charged — and the run says how many. Reviews posted after the baseline are always newer than that date, so real alerts are never suppressed.
- An already-delivered review whose author edits their own star rating is delivered again, as a
scoreChangedevent, not silently missed. Apple keeps a review's id stable when the reviewer edits it in place (only the feed's ownupdateddate advances) — so without this, a review your watch already delivered at 5★ could quietly drop to 1★ and you'd never know. Every row carrieswatchEvent(neworscoreChanged) and, on ascoreChangedrow,previousScore(the rating last recorded for it). UsewatchEventsto receive only one kind, e.g.["scoreChanged"]to watch an app you already track elsewhere purely for sentiment reversals. There is no developer-reply field anywhere in this review feed (unlike Google Play), so that isn't an event this Actor can offer.
The baseline lives in your own Apify account, in a named key-value store called fetchsmith-app-store-reviews-watch, keyed by your label plus a fingerprint of apps/appNames/countries/countryFallback/sort and every review filter (minRating/maxRating/keyword/minReviewLength/reviewsAfter/reviewsBefore/minVoteSum/minVoteCount) (Apple's feed takes none of those server-side, so all of them decide what "new" means). Change any of those and you get a fresh baseline rather than a silently wrong one. Delete the record to start over; use different labels to watch several filter sets in parallel.
Details worth knowing:
- Use
sort: "mostRecent"(the default).mostHelpfulisn't date-ordered, so a brand-new review isn't necessarily inside the scanned window and can be missed; the run logs a warning if you watch withmostHelpfulanyway. maxReviewsPerAppis your scan-depth budget on incremental runs and is left exactly as you set it — withmostRecent, new reviews sort at the top, so your own cap doesn't hide them. If every matching review inside that window turned out to be new, the run warns you that reviews posted since the last run may sit further back — raisemaxReviewsPerAppor run the watch more often.- If an
appNamessearch resolves to a different app than last time (or a newcountriesentry appears), that app/country pair is baselined on the spot rather than having its entire review history delivered as "new". countryFallbackstill applies during a watch — a baselined pair whose storefront later goes empty falls back the same way a normal run does.- Reviews with no id Apple can hand back (rare) are skipped in watch mode, since they can't be recognized on the next run — never charged.
- Change events need one run to warm up. A baseline created before
watchEventsexisted stores review ids but not the star rating to diff against; the first run after upgrading records that state (and says so in the log), soscoreChangedstarts firing from the run after that. New reviews are unaffected. - Baseline size cap: the saved baseline holds at most 40,000 review ids across all your
apps/countriespairs (the oldest drop off first). A watch this large is rare, but if it happens, the dropped ids will be delivered and charged again as "new" on a future run — the run's log and status message name the count when it occurs (RUN_SUMMARY.baselineTruncated/baselineTruncatedTotal). Split a very large watch across several labels (e.g. one per app) to stay under the cap. - Don't combine a fixed
reviewsBeforewithwatchLabel— see "why has my watch stopped finding anything new" in the FAQ.
appNames caveat, verified live: Apple's search API almost never returns zero results — even keyboard-mash gibberish gets back an unrelated app (measured: nonsense strings matched an Arabic quiz game, an emoji trivia app, etc., every time). A naive "take the first hit" would silently resolve a typo'd name to the wrong app. This Actor only accepts a match that shares a real word with the requested name (in the app's name, developer, or bundle id); otherwise it skips the name with a "no match found" warning instead of guessing. Use a numeric app id or Store URL when you need certainty. Also note: if you pass appNames and leave apps untouched, the Actor deliberately ignores apps's own example default rather than mixing an uninvited app into your results.
Mac App Store apps (includeMacApps), verified live 2026-09-17: Apple's name-search entity for apps is iOS-only. Searching "Final Cut Pro" by name returns Final Cut Camera, iMovie and CapCut — the actual Mac app is never in the list, so before this option a name lookup would quietly hand you a different app. With "includeMacApps": true the Mac App Store is searched too and an exact title match wins over a loose one, so "Final Cut Pro" resolves to id 424389933 and returns its real Mac reviews. Resolution aside, you never needed this option if you pass a numeric id or an apps.apple.com URL — the review feed and the app-metadata lookup are keyed by app id, not by platform, and both answer for Mac apps (re-verified 2026-11-07: id 424389933 and Logic Pro's 634148309 each return a full 50-entry feed on mostRecent and mostHelpful, in both us and gb). One Mac-only caveat on the rating aggregates, measured 2026-11-07: Apple publishes no rating totals for Mac App Store apps on either surface this Actor reads — the lookup API returns userRatingCount: 0 and averageUserRating: 0, and the product page's histogram is [0,0,0,0,0] — even for apps with plenty of written reviews. So on a kind: "mac-software" app, ratingCount and averageRating arrive as a literal 0 (Apple's own figure, not a scrape failure), totalRatings/ratingBreakdown are null, and the declaredRatingCount in RUN_SUMMARY reads 0 next to a non-zero delivered — do not read those zeros as "this app has no ratings", and do not compare delivered against declaredRatingCount for a Mac app. The written reviews themselves are unaffected. includeMacApps is off by default so that an existing iOS-only name lookup can't start matching a same-named Mac app.
Output (one item per review)
{"reviewId": "14523209599","appId": "1232780281","country": "us","title": "Great for planning","content": "I use it every day for ...","rating": 5,"version": "3.42.0","author": "jane_doe","authorUrl": "https://itunes.apple.com/us/reviews/id...","updatedAt": "2026-09-07T16:13:22-07:00","reviewUrl": "https://itunes.apple.com/us/review?id=1232780281&type=Purple%20Software","voteSum": 0,"voteCount": 0,"appName": "Notion: Notes, Docs, Tasks","developer": "Notion Labs, Incorporated","averageRating": 4.7,"ratingCount": 512345,"totalRatings": 519312,"ratingBreakdown": { "five": 432140, "four": 51220, "three": 15870, "two": 6190, "one": 13892 }}
Per-star ratings breakdown (ratingBreakdown)
An app's average rating hides the shape of its distribution: 4.5 stars from mostly 5s and a handful of 1s is a very different product story from 4.5 stars from a wall of 4s. Apple's public lookup API only gives you the average and the total, so most App Store review scrapers stop there. This Actor also returns the actual count of ratings at each star level, per storefront, on every row when includeAppInfo is on:
"totalRatings": 29481802,"ratingBreakdown": { "five": 25284650, "four": 2000235, "three": 696048, "two": 274710, "one": 1226159 }
- Counts are ratings, not reviews — they include the millions of users who tapped a star without writing anything, so
totalRatingsis far larger than the 500 reviews Apple's feed will hand you. - The breakdown is per storefront, so
countries: ["us", "gb", "de"]gives you three genuinely different distributions to compare. - It costs nothing extra: it is fetched once per app/storefront alongside the app lookup, and you are only ever charged per review returned.
- It is verified before it is reported — if the numbers don't reconstruct Apple's own published average, the Actor omits the field and logs a warning rather than handing you a distribution that might be inverted.
Useful for a 1★-share trend line over releases, for weighting sentiment against how many silent raters actually sit behind a review, and for competitor comparisons where two apps show the same average.
Pricing
result — charged per review returned, tiered by your Apify account plan from $0.0001 (Free) down to
$0.00007 (Gold and up). The first 10 reviews of every run are free, no matter your plan or how many
apps/countries you pass (added 2026-10-26, matching reviewbot/apple-review-scraper's offer in the
pricing comparison below). App lookups, empty pages and errors are free. HTTP-only and fast.
Where this sits in the market. Input schema and pricing verified live 2026-10-02 against each
Actor's latest build, not against its Store description. The two busiest App Store review scrapers
on the Store, thewolves/appstore-reviews-scraper (3,153 users, re-verified live 2026-11-05) and theagents/appstore-reviews
(818 users), both charge a flat $0.0001/review with no start fee — the exact same price and
shape we use, so we're at parity with the traction leaders rather than undercutting or
overcharging. Everyone else charges meaningfully more once every fee is counted:
johnvc/apple-app-store-reviews-api (647 users, re-verified live 2026-11-05) is $0.00125–$0.00144/review tiered plus a
$0.0175 one-time setup fee, a $0.00005 Actor-start fee and $0.00001 per dataset row;
easyapi/app-store-reviews-scraper (545 users) is $0.00299/review plus a $0.09 Actor-start fee
(900x our whole per-review price, charged before a single review is scraped);
sourabhbgp/apple-app-store-scraper (270 users, re-verified live 2026-11-05 — corrected cycle 1805, was stale at 178) is a flat $0.002/review, 20x ours.
The comparison above is not just the two busiest plus three more — it is every listing in the
niche with more users than the smallest one named. A fresh Store sweep, verified 2026-10-02, found
four more App Store review scrapers bigger than sourabhbgp's user count at sweep time (178;
sourabhbgp is 270 now, and every count in this section was re-verified live 2026-11-05, so the
ordering below reflects sweep time, not today), none of them previously named
and none of them cheaper: jdtpnjtp/apple-app-store-scraper (163 users) charges $0.00065/review,
6.5x ours; brilliant_gum/google-play-app-store-scraper (179 users, a combined Google Play + App
Store scraper, not App-Store-only) charges $0.006/review, 60x ours — its own README pricing table
names this as the Review scraped event; an earlier version of this paragraph quoted $0.004, which is
that listing's Search / chart result scraped event, not what a reviews run is charged (fixed
2026-10-03, cycle 1178, same isPrimaryEvent-vs-rival's-own-table class as the westerly_breaker fix in
eu-ted-tenders-scraper's README); code-node-tools/app-reviews-scraper
(252 users, re-verified 2026-11-05) charges $0.0005/review tiered down to $0.0003 on Gold and up, 3x-5x ours (an earlier version
of this paragraph said a flat $0.0005/5x; its live record tiers by account plan, fixed 2026-10-03, cycle
1178); benthepythondev/appstore-reviews-scraper (152 users)
charges $0.002/review tiered down to $0.0014 on Diamond, 14x-20x ours at every tier, same ballpark
as sourabhbgp. scriptbase/appstore-reviews-scraper (59 users) also ties our exact $0.0001/review
rate. No listing found in this sweep, named or not, undercuts our price.
Re-verified live 2026-10-03 (fleet-oldest competitor_audit rotation): all nine rivals named
above re-checked with zero price drift. Three more listings surfaced in the same 169-match
sweep, all dearer and none previously named: fatihtahta/app-store-global-reviews-scraper (59
users, tied with scriptbase) charges $0.0004/review plus an optional $0.003/1,000-translated-words
add-on, 4x ours; powerai/app-store-reviews-scraper-ppr (34 users, 0 new in 30 days) is
$0.00499/review tiered to $0.00199 on Gold+, plus a $0.09 Actor-start fee matching easyapi's;
nexgendata/ios-app-store-reviews-scraper (32 users) is a flat $0.1/review plus a $0.005 start
fee, ~1,000x our rate, the dearest listing found in this niche.
Correction, re-verified live 2026-10-03 (cycle 1178): we are no longer the cheapest listing in
this niche. The fleet-oldest competitor_audit rotation came back around to this Actor and
re-verified all twelve rivals named above with zero price drift, but reading five more listings
just below nexgendata/ios-app-store-reviews-scraper's 32 users at sweep time found two genuine
price threats this README's earlier "no listing found in this sweep, named or not, undercuts our
price" line (just above) no longer covers:
apihq/app-store-reviews-scraper (38 users, re-verified live 2026-11-05) charges a flat $0.00008/review with no start fee —
20% below our $0.0001, at every volume, with no crossover; automation-lab/apple-app-store-reviews-scraper
(32 users, re-verified live 2026-11-05) tiers its review price by the buyer's own Apify plan, $0.0001725 (Free) down to
$0.000042 (Diamond) — dearer than us on Free/Bronze/Silver (1.2x-1.7x our rate) but cheaper from
Gold up ($0.00009 Gold, $0.00006 Platinum, $0.000042 Diamond — 0.9x, 0.6x and 0.42x ours). Three
more, all dearer, checked for completeness: seemuapps/apple-app-store-reviews-scraper (31 users)
$0.0025/review flat, 25x ours; scrapesmith/apple-app-store-reviews-scraper (26 users) $0.00045/review
plus a $0.01 one-time start fee, 4.5x ours on the per-review rate alone; memo23/app-store-scraper
(25 users) $0.001/review (10x ours) plus three optional paid add-ons — review-insights ($0.02/call),
pain-point-analysis ($0.05/call) and detail-enrichment ($0.001/call) — that read like AI analysis
but are not independently verified as model calls; none of our review rows carry an equivalent field.
All five prices read live 2026-10-03.
Widened sweep, verified live 2026-10-04 (cycle 1204). Every sweep of this niche before today
searched and matched on the spaced phrase "app store reviews", which is three contiguous words —
but this niche's single most common self-title is "AppStore Reviews Scraper", one word, so a
whole class of listings was invisible to our own search by construction. Re-running the sweep with
the no-space and "iOS app reviews" phrasings added (548 listings seen, 186 matching) surfaced eight
listings no prior sweep here could see. Two of them are real App Store review scrapers, both read
live today and neither undercuts us: fetchcraftlabs/apple-appstore-reviews-scraper (62 users),
which is the niche's 8th-biggest listing and had never been named in this README, charges a flat
$0.001/review — 10x ours — plus a $0.00005 Actor-start fee; freshactors/app-store-scraper
(24 users) charges $0.0001/review flat, exactly our rate, so it is a third parity listing
alongside thewolves/theagents/scriptbase rather than a price threat (its app-details and
keyword-search events are separately tiered, $0.002→$0.0008 and $0.001→$0.0004 by account plan;
a reviews-only run pays neither, and neither do our runs). The remaining six were read and ruled
out as non-substitutes, not competitors: maximedupre/app-store-ratings-scraper
($0.00015/row plus a $0.001 start fee) returns an app's aggregate star rating and metadata with no
review text at all, and zinin/tinder-app-intel, zinin/bumble-app-intel, zinin/hinge-app-intel
and zinin/badoo-app-intel (2 users each, $0.005/storefront snapshot plus a $0.005 start fee) sell
per-country subscription prices and store ratings for one named dating app apiece. The cycle-1178
correction above still stands unchanged: apihq at $0.00008 flat, and automation-lab from Gold
up, remain the only listings in this niche — across all 186 now visible — that charge less per
review than we do.
Correction, verified live 2026-10-04 (cycle 1229): that is no longer the complete undercutter
list. The fleet-oldest competitor_audit rotation re-swept this niche with the no-space/iOS
phrasings too (549 seen, 188 matched) and live-priced every unnamed App-Store-scope listing with
3+ users. riadh_chebbi/apple-app-store-reviews-scraper (1 user today, 3 when that sweep ran) charges a flat $0.00005/review
with no start fee — half our $0.0001 rate, at every volume, with no crossover — at the time the
cheapest listing found in this niche (no longer: see the 2026-10-05 correction below, where
silentflow prices lower per review and steadyscrape matches this rate with no fee either).
tagadanar/apple-app-store-reviews (8 users, re-verified live 2026-11-05) tiers its
review price by the buyer's own Apify plan, $0.0001 (Free) down to $0.00007 (Gold/Platinum/Diamond),
plus a flat $0.001 per-run fee this Actor does not charge: that fee makes it dearer than us
below roughly 50-100 reviews/run on Bronze/Silver and below roughly 34 reviews/run on Gold+, but
cheaper above those volumes since its per-review rate undercuts ours from Bronze up. One more
listing ties our exact rate rather than beating it: scrapersdelight/appstore-reviews-scraper
charges flat $0.0001/review with no start fee, a fourth parity listing alongside
thewolves/theagents/scriptbase/freshactors. bikram07/app-store-reviews is
listed FREE (Apify's free-pricing-model flag, not a $0/review PPE rate) but has had zero runs in
the last 30 days, so it is read as dormant rather than an active price threat. Six more unnamed
listings read at 3+ users in this sweep were ruled out as different-shape, not App-Store-review
competitors (an earlier version of this sentence said "ten" and then named six, and said "five"
Shopify listings and then named four — counts corrected and every exclusion re-verified against the
listing's own live description, not its title, 2026-10-05, cycle 1264): four scrape Shopify's own
app-marketplace reviews (fetch_cat/shopify-app-reviews-scraper,
automation-lab/shopify-app-store-reviews-scraper, taroyamada/shopify-app-store-review-intelligence,
philzx/shopify-app-intelligence), one scrapes Google Play (obsidian937/google-play-reviews-scraper),
and one scrapes Tencent's Android app store 应用宝 (reviewbot/tencent-app-store-review-scraper) — all
three are different source sites entirely, not Apple's App Store. The remaining dearer-and-ruled-in
listings (fetch_cat/apple-app-store-reviews-scraper $0.000575→$0.00014 tiered plus a $0.005 start
fee; shahidirfan/App-Store-Reviews-Scraper $0.00099 flat plus a $0.0005 start fee; kestrel/app-store-reviews-scraper
$0.004 flat; bovi/appstore-reviews $0.001→$0.00095 tiered plus a tiered start fee; goat255/app-store-reviews-scraper
$0.00115→$0.001 tiered; sync-network/apple-app-store-reviews-scraper $0.001 flat plus a $0.00005 start fee;
skootle/app-store-reviews $0.008→$0.005 tiered plus a $0.01 start fee; hipersoft/appstore-reviews-scraper
$0.0005 flat plus a $0.00005 start fee; darknezz/app-store-reviews-scraper $0.002 flat plus a $0.01 start fee)
are all dearer than us at every tier and do not change the standings above.
Correction, verified live 2026-10-05 (cycle 1264): this niche's price floor is now well below us,
and every "only listings that undercut us" claim above is superseded. Sweeps of this niche have
always live-priced the unnamed listings with 3 or more users, on the reasoning that Apify pins a
brand-new listing at 2 users so a 3-user floor is the cheapest honest cut. Today's sweep (553 seen,
190 matched, 148 of them unnamed here) returned exactly one unnamed listing at 3+ users —
santhej/app-store-reviews-scraper (3 users), flat $0.0001/review, our exact rate, plus a $0.001
Actor-start fee we do not charge, so dearer than us below ~10 reviews/run and at parity above. By
the standing rule this niche was clean. It is not. Live-pricing the entire 148-listing unnamed
cohort including the 2-user floor — 148 GET /v2/acts calls, read-only, ~2 minutes — found 23
listings that charge less per review than our $0.0001, 20 that tie it, 96 dearer, 3 on Apify's FREE
pricing model (no price record at all, i.e. $0 — the cheapest price a rival can have) and 6 that
bill per app or per scan rather than per review, so no per-review comparison is possible. None of
the 23 had ever been named here, and all 23 were confirmed to be
Apple App Store review scrapers from their own live descriptions, not their titles. The lesson is
structural: a 2-user listing is not a weak competitor, it is a new one, and a niche being
actively flooded with new listings undercutting the incumbent rate is invisible to any user-count
floor at all.
Cheaper than us at every volume, no start fee (all verified 2026-10-05):
steadyscrape/app-store-reviews-scraper flat
$0.00005/review (ties riadh_chebbi as the cheapest no-fee listing in this niche);
peerless_columbine/apple-app-store-reviews-scraper-api $0.00008 (Free) → $0.00005 (Gold+);
axiomworks/review-firehose (delisted — the Apify API returned 404 for this Actor on 2026-11-08) was $0.00008 → $0.000056 (Gold+).
snow_leo_data/app-store-scraper removed from this list — forecast landed, re-verified live
2026-10-16: its scheduled 2026-10-05 12:00 UTC pricing entry is now in effect, and it raised the
rate from flat $0.00008 to flat $0.0003 at every tier, 3-4.3x dearer than us (our range is
$0.0001 Free down to $0.00007 Gold+). It is no longer an undercutter anywhere; the standing lesson
holds — a future-dated entry is a risk to re-check, not a price to carry forward unverified.
Cheaper per review with an Actor-start fee, so the crossover volume is what matters (ours has no
start fee; the figure is the run size above which the rival wins; all rates verified 2026-10-05):
ninhothedev/app-store-reviews-scraper
$0.00008 + $0.00005 start (~3 reviews); automationnation/app-store-reviews-scraper $0.00008 →
$0.00005 (Gold+) + $0.00005 start (~3); soilair/app-store-reviews-api $0.00008 → $0.00005 (Gold+) +
$0.00005 start (~3); scrapesignal_labs/apple-app-store-reviews-scraper $0.00008 + $0.00005 start (~3);
thenetaji/apple-app-store-reviews-scraper $0.00008 → $0.000056 (Diamond) + $0.00005 start (~3);
cirkit/app-store-reviews-scraper $0.00007 + $0.00005 start (~2);
betterscrapers/the-better-app-store-reviews-scraper $0.00009 → $0.00008 (Gold+) + $0.00005 start (~5);
zenomastro/apple-app-store-reviews-pro $0.00008 → $0.000064 (Gold+) + $0.0001 start (~5);
getanyapi/app-store-reviews-scraper $0.000152 (Free, dearer than us) → $0.000076 (Bronze+) +
$0.00005 start (~3 on Bronze and up only); superslowsloth/app-store-reviews-scraper $0.00007 +
a $0.002 start fee (~67); silentflow/apple-reviews-scraper $0.00004 → $0.000034 (Gold+) — the
lowest per-review rate in the niche — plus a $0.005 start fee (~83 on Free, ~76 on Gold+);
luminar/app-store-reviews-change-monitor (delisted — the Apify API returned 404 for this Actor on 2026-11-08) was $0.000075 plus $0.005 per monitored scan;
grokbob/app-reviews-dual-batch-ppe $0.00007 + a $0.01 start fee (~333);
automly/appstore-reviews-scraper $0.000095 + a $0.01 start fee (~2,000).
Cheaper only from the Gold account plan up, dearer below it (verified 2026-10-05):
lightmoon/apple-app-store-reviews-scraper
$0.0007 (Free/Bronze) → $0.00009 (Gold+) + $0.00005 start; tidytools/apple-app-store-reviews
$0.0001 (Free/Bronze) → $0.00008 (Gold+), its app-details and app-insights events billed separately.
A second hipersoft listing, hipersoft/app-store-reviews-scraper (distinct from the
hipersoft/appstore-reviews-scraper named above), is $0.0002 → $0.0001 (Gold+) + $0.00005 start —
dearer below Gold and at parity above, not an undercut.
Lowest headline rates in the niche (verified 2026-10-05), all three bundling paid analysis events a
reviews-only run here never incurs: datasignalslab/app-store-review-intelligence $0.00001/row but $0.02 per app
analyzed + $0.00005 start (1 app × 1,000 reviews ≈ $0.030 against our $0.100);
pappy-dev/appstore-reviews-v2 $0.00005/row with five optional $0.05 analysis events;
listless_adzuki/app-store-review-scraper $0.00001 per dataset item alongside a separate $0.004
review-result event, so which event a reviews run actually bills is not determinable from the
pricing record alone — read as cheap-but-unverified rather than counted above.
Three of the unnamed listings carry no price record at all (verified 2026-10-05) — Apify's FREE pricing model, which
means $0 per review and therefore the lowest possible price in the niche, not missing data:
convertfleetdotonline/app-store-reviews-scraper and conversational_kermis/pulse-appstore (which
searches the App Store by keyword and then exports the matching apps' reviews) are straight App
Store review scrapers, and creative_maitake/app-store-review-pain-miner mines low-star reviews
into scored pain points. All three sit at Apify's 2-user floor with no runs recorded in the last 30
days, the same dormancy read applied to bikram07/app-store-reviews above, so they are listed as
real $0 price points rather than as live demand we are losing to.
Full 0-2-user tail resweep, verified live 2026-10-07 (cycle 1350, fleet-oldest competitor_audit
rotation). This niche is new-listing-heavy enough that re-running the full unnamed cohort two days
after the 2026-10-05 sweep above was not redundant — a fresh pass over the same 122-listing tail (no
top-N cut) turned up two more undercutters. Getting there required fixing the sweep script itself
first: Apify represents a tiered price two different ways across listings — a flat number, or the
same number one level deeper as {"tieredEventPriceUsd": N} — and the first pass of this cycle's
tool silently read the second shape as "no tiers," which would have hidden both findings below.
Both survivors were read against their own current pricing record, never a one-time or secondary
event, and neither is named with an exact user count (both are small, recently-launched listings —
see the note above about why): axiomworks/app-store-reviews-scraper is a second listing by the
already-named axiomworks/review-firehose's owner (that listing now delisted — 404 on 2026-11-08), tiered identically — $0.00008 (Free) →
$0.000056 (Gold+), no start fee, cheaper than us at every tier; deriverge/app-store-reviews-scraper
ties our $0.0001 on Free but undercuts from Bronze up ($0.00008 → $0.00005), also with no start fee.
One listing was read and ruled out of scope on its own description, not its title:
digital_influx/marketing-research-mcp is a generic MCP tool bundling SEO audits, DNS/contact
lookups, podcast and Bluesky data alongside App Store reviews as one of a dozen unrelated
capabilities — a different product shape from a dedicated review-export Actor, not a substitute for
a buyer who wants a reviews dataset. Five more listings the script flagged AMBIGUOUS (two or more
non-one-time events, neither flagged primary) were hand-read against their eventTitle and own
description and all tie or lose to our rate: cybermax/app-reviews, openkrill/app-store-play-reviews,
unicentrocucuta/appstore-watch (all tie at $0.0001), dodge_bot/app-store-reviews ($0.0002),
datalantern/app-store-reviews ($0.0003). Everything else in the fresh tail was dearer, FREE-model,
or dormant, already covered by the dormancy read above.
Second full-tail resweep the same day, verified live 2026-10-07 ~23:30 UTC (cycle 1388). The cycle-1350 pass above ran earlier on 2026-10-07; re-pricing the identical 122-listing unnamed tail hours later turned up four more undercutters, none previously named, and three of them had cut their price that same day — which is the sharpest evidence yet for the "new-listing-heavy niche" read above: in this niche a sweep's price findings can go stale inside one day, so the date on each block below is a timestamp, not a season. All four were read against their own currently-effective pricing record, and in each case the per-review charge (not a one-time or secondary event) was the figure compared:
myagizm/appstore-reviews-scraper— flat $0.00008 per dataset row, every tier, no start fee, 20% under our $0.0001. This one is not explained by a price change: its pricing entry dates to 2026-09-29 and so was already live during cycle 1350's pass, which means that pass missed it. Its unit is Apify's genericapify-default-dataset-itemrather than a named review event, so the rate is per row emitted; its description scopes the Actor to written App Store reviews, so row and review should coincide, but we have not run it to confirm one row per review.om_kh/appstore-reviews-api— tiered $0.0001 (Free, our exact rate) → $0.000085 (Bronze) → $0.00007 (Silver) → $0.000055 (Gold+), no start fee. It cut its price roughly 8x on 2026-10-07 at 13:23 UTC, from $0.0008 (Free) → $0.00044 (Gold+); cycle 1350's pass reading it as dearer than us was correct at the time. So: parity on Free, a real undercut from Bronze down.dropin-apis/app-store-reviews— $0.00008 per dataset row plus a $0.00005 Actor-start fee, also cut that same day (2026-10-07 17:42 UTC, from $0.0002/row). With a start fee the crossover is what matters, and here it is tiny: it costs less than us above about 3 rows per run, so treat it as a genuine undercutter at any realistic volume.northbell/app-store-reviews-scraper— listed 2026-10-07 02:24 UTC, tiered $0.0001 (Free and Bronze, our exact rate) → $0.00009 (Silver) → $0.00008 (Gold+), but carrying a $0.01 Actor-start fee, which inverts the comparison at low volume. Crossovers against our flat $0.0001 with no fee: ~500 reviews per run on Gold+, ~1,000 on Silver, and never on Free or Bronze (it ties our per-review rate there, so the $0.01 fee leaves it strictly dearer at every volume). A conditional undercut for high-volume Gold+ buyers only, not an across-the-board one.
The only future-dated price change anywhere in the 122-listing tail was
vonsensey/app-store-reviews-all-countries-scraper-api, cutting its review event $0.004 → $0.002
(Gold+) effective 2026-10-09. Forecast landed, re-verified live 2026-10-16: the cut is in effect
exactly as projected ($0.002 Gold/Platinum/Diamond, $0.004 Free) — still 29-40x our rate, so it
was not an undercutter before or after that date. Of the rest of the tail, 15 listings tie our $0.0001 exactly at every tier, two are
one-time/report-fee products with no per-review rate at all
(second_coming/app-store-review-analyzer $0.02 per scan run,
muhammadafzal/apple-app-store-review-intelligence $0.016-$0.02 per report plus a $0.005-$0.00625
start fee — a per-report shape, not a per-review substitute), and the remainder are dearer. Nothing
in this pass was ruled out on its title.
Third full-tail resweep, verified live 2026-10-08 ~15:45 UTC (cycle 1420, fleet-oldest
competitor_audit rotation). Same method as the two passes above, no top-N cut: 560 listings seen
across the niche's search terms, 201 matched, 87 already named here, and all 117 unnamed ones
live-priced (0 unresolvable, 0 ambiguous). Result: 16 tie our $0.0001/review exactly, 100 are
dearer, and exactly one undercuts us —
tinyrex/app-store-reviews-scraperundercut us here at the time (flat $0.00008/review, 20% under our $0.0001, behind a $0.00005 Actor-start fee) but is gone from the Store as of 2026-10-09 —GET /v2/acts/tinyrex~app-store-reviews-scrapernow 404s (record-or-token-not-found), a removal rather than a rename or ownership change, confirmed by the API itself. A fresh full-tail resweep is still owed to find whatever the current cheapest listing is; this retracts the specific undercutter without claiming "0 undercut us" in its place.
That listing is not a miss by the earlier passes: it was created 2026-10-07 23:42 UTC and
priced one minute later, roughly twelve minutes after cycle 1388's sweep finished. It is the
cleanest datum yet for the "new-listing-heavy niche" read above — this niche can add an undercutter
inside the gap between two sweeps on the same evening, so every price figure in this README should
be read against the timestamp on its own block. No listing anywhere in the 117 carries a
future-dated price change this time, none is on Apify's FREE model, and none is a pure
per-run-fee product with no per-review rate at all. (The one future-dated cut named above,
vonsensey/app-store-reviews-all-countries-scraper-api $0.004 → $0.002 effective 2026-10-09, is a
named listing and so sits outside this unnamed-cohort sweep; re-verified live 2026-10-16, it has
landed exactly as projected and remains ~29x our Gold+ rate.)
Fourth full-tail resweep, verified live 2026-10-09 ~03:00 UTC (cycle 1443), pulled forward
out of strict rotation order specifically to close the retraction above. Same method again:
561 listings seen, 200 matched (vs 201 at 1420 — one net listing fewer, consistent with churn in
a niche this new-listing-heavy rather than a count regression), 84 already named here, and all
116 unnamed ones live-priced (0 unresolvable, 1 ambiguous). Result: 5 tie our $0.0001/review
exactly, 110 are dearer, and tinyrex's vacancy was not backfilled — 0 of the 116 undercut us.
The one ambiguous listing, transparent_meteorite/app-store-reviews, has two recurring per-row
events with neither flagged primary (review-returned and app-details both $0.0005+/row, title
line advertises "$0.50/1k" i.e. $0.0005/review) — dearer than us 5x over under either reading, so
the ambiguity doesn't change the verdict. This sweep only re-prices the unnamed tail, same as
the three before it — the named undercutters already disclosed above
(deriverge/app-store-reviews-scraper, silentflow, riadh_chebbi, and the cycle-1264/1300 cohort)
were not re-verified this cycle and stand as last priced; this paragraph retracts tinyrex without
claiming the niche's price floor as a whole has moved. Read every figure in this README against its
own timestamp — this niche added and priced a new undercutter within 12 minutes of the previous
sweep (tinyrex, cycle 1420).
This pass also put an exact number on the two per-report listings named above, which no earlier
block quantified because a flat per-run fee has no per-review rate to compare: a whole run of
second_coming/app-store-review-analyzer costs $0.02 (one scan event, billed at most once per
run), and one of muhammadafzal/apple-app-store-review-intelligence costs $0.016–$0.02 per report
plus a $0.005–$0.00625 start fee. Against our flat $0.0001/review with no fee, those break even at
about 200 reviews and ~262 reviews (Free plan) respectively — so on a large export they are
cheaper, and on a small one dearer. We still read them as a different product (a scored report, not
a reviews dataset you can join and re-query), but the honest figure is a crossover, not "no
comparison is possible".
Fifth full-tail resweep, verified live 2026-10-16 ~03:00 UTC (cycle 1779, fleet-oldest
competitor_audit rotation, 336 cycles / 7 days after cycle 1443). This niche's growth has not
slowed: three search phrasings ("app store reviews", "appstore reviews", "ios app reviews") now
return 859 unique listings (up from 561 at cycle 1443), of which 403 title-match this niche
(contain "review" plus "app store"/"ios"/"apple" in the title) versus 200 at cycle 1443 — roughly
double in 7 days, the sharpest growth this rotation has measured. 78 of those are already named in
this README; 325 are unnamed, and 401 Google Play/App-Store-dual listings swelled the description-only
match further (excluded here — this section counts the title-strict set). Live-pricing the full
325-listing unnamed tail is now too large for one audit cycle (prior full-tail passes topped out at
148); this pass live-priced the 18 unnamed listings with 5+ users (the ones with enough traction
to matter before the next rotation) and found exactly one real, previously-unnamed competitor at
or below our rate:
reviewbot/apple-review-scraper(43 users) — flat $0.0001/review, our exact rate, with the first 10 reviews per run free. A pure Apple App Store review scraper (no Google Play bundling), so it is a genuine substitute, not a different-shape exclusion. We matched this 2026-10-26: the first 10 reviews of every run here are free too (see Pricing above), so this is now exact parity at every run size, not a crossover in their favor below 10 reviews.
The other 17 were read against their own live pricing (verified live 2026-10-16) and ruled out, all for reasons already
established above (dearer, or a different product shape than a per-review export):
andok/app-store-reviews (10x–7x dearer even at Diamond, dual-store), logiover/app-store-data-api
and logiover/app-reviews-scraper (10x–17x dearer, dual-store/ASO-bundled),
focused_vanguard/appstore-reviews-scraper (35–40x dearer), haketa/app-store-scraper (20–25x
dearer, bundles top-chart rankings), cleanscrape/app-store-reviews-scraper (2x dearer plus a
start fee), rupom888/appstore-ios-scraper (20x dearer flat), native_emblem/app-reviews-scraper
(1.5x dearer flat, dual-store), berkaydev/app-store-google-play-reviews-scraper (3x dearer),
scrapemint/app-review-intelligence ($0.002/row, 20x dearer); and five read as a different
product shape, same exclusion rule as maximedupre/sourabhbgp above — priced per app record
with reviews as a bundled sub-field, not per review: johnvc/apple-app-store-product-api ($0.00008
Free → $0.00006 Gold+ per app, "sample reviews" bundled), sian.agency/apple-app-store-scraper
(per-app overview/detail events, reviews bundled into the detail price), dami_studio/app-store-scraper
($0.00009/app row), renzomacar/app-store-scraper (reviews-batch priced per batch, not per row —
ambiguous, no clean per-review figure), plus the two Shopify-App-Store listings in the same cohort
(freshactors/shopify-app-store-scraper, devsef/shopify-app-store-scraper — wrong store entirely,
same exclusion as the Shopify listings named earlier in this section).
Open item, not closed by this pass: the remaining ~307 unnamed listings at 1-4 users are
untouched — per the cycle-1264 lesson above ("a 2-user listing is a new one, not a weak one"), a
future competitor_audit cycle should live-price that tail with a dedicated batch script (one GET
per listing, ~5 min of API calls) rather than by hand; 325 is too many for manual per-listing
reading in one cycle. The one confirmed finding above is already shipped.
Unnamed-tail sweep closed, verified live 2026-10-16 ~03:40 UTC (cycle 1780). The open item
above is now done: all 175 unnamed title-matching listings were live-priced in one batch
(GET /v2/acts/<handle> each, 0 unresolvable). Our own rate was re-read live at the same time and
is unchanged: flat $0.0001 per review result, one price on every account plan, no start fee.
Twelve of the 175 undercut that on at least one plan tier, plus two more found by hand-reading the
five listings whose event set was too ambiguous for the batch script. The honest summary is that
our $0.0001 is no longer close to this niche's floor — the floor is now $0.00005–$0.00008.
Cheaper than us at every account plan with no start fee (strictly cheaper at any run size):
lergassy/app-store-reviews-scraper(24 users as of 2026-11-14, up from 20 on 2026-11-10 and 15 on 2026-11-05; price re-verified 2026-11-14, unchanged since its 2026-09-30 publish) — $0.00008 (Free) → $0.000072 (Bronze) → $0.000064 (Silver) → $0.000056 (Gold+) per review, no fee: 20% to 44% cheaper than us at every volume. A pure per-review App Store export with country and star filters, i.e. a direct substitute on features as well as price. The cheapest unconditional rate in this niche at that sweep — since beaten byapivault_labsat $0.00002, see the 2026-10-23 block below.workstream/app-store-reviews-scraper(2 users) — flat $0.00008/review, no fee, one price on every plan: a straight 20% under us at every volume.hiver/app-reviews-scraper— $0.00009 (Free/Bronze) → $0.00008 (Gold+), no fee: 10–20% under us. Bundles Google Play, but prices the App Store review row per review, so unlike the per-app listings excluded above it is a genuine substitute.almmity/app-store-reviews-official-feed(2 users) — $0.00009/row, no fee (10% under us), but its own title caps it at ~1,000 reviews per country; we do not cap, so it only beats us inside that ceiling.gh0st1k/app-store-reviews-scraper— DELISTED, verified 2026-11-05:/v2/acts/returns 404 for the handle and a Store search forgh0st1kreturns zero listings, so it is no longer a live competitor here and the entry below is the dated record, not current. It had 1 user and no price record at all (so free while it lasted), and claimed "All 175 Countries, No 500 Cap". The "re-read it rather than treating free as settled" caveat this entry carried — same as the three no-record listings named in the 2026-10-05 block — resolved the other way: the listing left the Store before it was ever priced.
Cheaper than us above a crossover, on the Free plan (verified live 2026-10-16; re-verified 2026-10-23 against our now-tiered ladder — our per-row rate falls as low as $0.00007 on Gold+, so a crossover computed against the single $0.0001 rate we charged before 2026-10-16's tiering overstates how often these rivals actually win):
wintersworks/appstore-reviews-scraper(2 users) — $0.00008/review + $0.001/app-details: wins above ~50 reviews on Free, above ~100 on Bronze — and never on Silver or above, where our $0.00008/$0.00007 per-row rate already ties or beats its $0.00008 before the fee is even added.cheapapi/app-store-google-play-scraper(2 users) — $0.00009/review + $0.003/app-details (and a $0.0005 per-request minimum top-up): wins above ~300 reviews on Free only — its $0.00009 per-row rate ties our Bronze rate exactly, so its fee makes it dearer than us on Bronze and every tier above, at any run size.tactful_anvil/app-store-reviews-scraper-multi-country-deep-history(2 users) — $0.00008 (Free) → $0.000056 (Gold+) + $0.01 start fee: wins above ~500 reviews on the Free plan, sooner on paid plans.
Cheaper for any paying customer, parity on the Free plan (re-verified 2026-10-23: our own price is ALSO tiered now, by the same account plan — see the correction below — so this is a rung-by-rung tie-or-beat on Free with a real per-row edge on Bronze and up, not an asymmetry where only they tier; most buyers are not on the Free plan):
cleanfeed/app-store-reviews-scraper(1 user) — $0.0001 (Free) → $0.00008 (Bronze) → $0.000063 (Silver) → $0.000048 (Gold+), no fee. Cheaper than our ladder at every paid tier (11%-31% under), joint-lowest rate in the niche at Gold+.webdatatools/app-store-reviews-scraper(2 users) — $0.0001 (Free) → $0.00006 (Gold+), $0.00005 start fee — small enough to amortize within the first review, so still cheaper than us at every paid tier for any realistic run.plainrows/app-store-reviews-scraper(2 users) andplainrows/app-reviews-scraper(1 user) — $0.0001 (Free) → $0.00005 (Gold+), but behind a real $0.002 start fee: the per-row saving over us (as little as $0.00001/review on Bronze) needs ~200 reviews on Bronze to clear that fee, fewer on Silver/Gold+ — cheaper above that run size, not from the first row (not yet re-verified rung-by-rung on Silver; flagged in queue.md for a follow-up pass).
Not an undercut, despite the tiered headline rate: euroscrape/app-reviews (2 users as of 2026-11-06) —
$0.0001 (Free) → $0.00009 (Bronze) → $0.00008 (Silver) → $0.00007 (Gold+) ties our own ladder
exactly, rung for rung, and then adds a $0.003 start fee we don't charge — so it is dearer than
us at every tier and every run size, not cheaper. Previously grouped with the paying-customer
undercutters above on the strength of its headline Gold+ number alone; re-verified 2026-10-23
against the full ladder while chasing this page's stale "we do not tier" framing.
Ruled out from the same batch, verified live 2026-10-16: bikram07/competitor-teardown (FREE model, but a battle-card
analysis product, not a review export — the different-product-shape exclusion), and three of the
five hand-read ambiguous listings, all dearer — pushbuild/app-store-reviews ($0.0005/review, 5x
dearer), contented_catwalk/app-store-reviews-monitor and .../google-play-reviews-monitor
($0.00015/review plus $0.005/run). The other 160 priced at or above our rate.
Sixth full-tail resweep, verified live 2026-10-23 ~03:45 UTC (cycle 2116). 1,924 distinct
listings seen across the 15 queries, 308 title-matched (up from 190 at the 2026-10-05 sweep,
down from 403 at 2026-10-16 — the matched count moves both ways as listings are delisted), 207 of
them not named in this file. All 170 of those unnamed listings at 2+ users were live-priced in
one batch (GET /v2/acts/<handle> each, 0 unresolvable, 0 ambiguous).
First, a correction to our own side of every comparison above (verified 2026-10-23). Our rate was re-read live and is no longer flat: it is tiered by the buyer's Apify plan — $0.0001 (Free) → $0.00009 (Bronze) → $0.00008 (Silver) → $0.00007 (Gold/Platinum/Diamond), still with no start fee. That ladder went live 2026-10-16 at 04:01 UTC, roughly 20 minutes after the 2026-10-16 ~03:40 block above was written. Two phrasings in the blocks above read this stale baseline for 336 cycles — "flat $0.0001 per review result, one price on every account plan", and the parenthetical "they tier by account plan, we do not" — until this pass (2026-10-23) rewrote both blocks in place against the real tiered ladder: the crossover group above now states each rival's per-tier win window instead of one flat-baseline figure, and the parity group was re-verified rung-by-rung (cleanfeed/webdatatools still cheaper at every paid tier, euroscrape reclassified as NOT an undercut — it ties our ladder exactly and then adds a start fee we lack, so it's dearer everywhere).
Cheaper than us at every plan rung with no start fee (strictly cheaper at any run size):
apivault_labs/app-store-reviews-scraper(1 user as of 2026-11-10, down from 3 on 2026-11-06) — flat $0.00002/review on every plan, no fee, and its own title advertises "$0.02/1K". That is 5x under our Free rate and 3.5x under our Gold+ rate — the lowest unconditional rate ever recorded in this niche, below the $0.00005 floor the 2026-10-16 block called the bottom.agentsgearbox/app-store-reviews-scraper(1 user as of 2026-11-05) — $0.00006 (Free) → $0.000054 (Bronze) → $0.000045 (Silver) → $0.000036 (Gold+), no fee: 40%–49% under us at every rung. Bundles Google Play but prices the App Store review row per review, so a genuine substitute on shape.tidyharvest/appstore-reviews-scraper(2 users) — $0.00009 (Free) → $0.000081 (Bronze) → $0.000068 (Silver) → $0.000054 (Gold+), no fee: 10%–23% under us at every rung.
One listing reads as an undercutter on its per-review rate alone but is not one once its run fee is counted — the arithmetic matters, so it is recorded here rather than in the list above:
hyperbach/app-store-reviews-scraper(2 users) — $0.0001 (Free, ties us) → $0.000085 (Bronze, under our $0.00009) → $0.0000767 (Silver, under our $0.00008) → $0.0000767 (Gold+, dearer than our $0.00007). But it also charges a flat $0.0011 "Run start" fee on every run, which alone costs the equivalent of 11 reviews at our Free rate. Its best-case Bronze saving is $0.000005/review, so it needs ~220 reviews in a single run to pay that fee off: below that run size we are cheaper, above it the gap is fractions of a cent. Note itsstartevent is not flaggedisOneTimeEvent, so a per-row price comparison that trusts the owner's own event flags reads this listing as a plain Bronze/Silver undercutter and silently drops the fee.
Three listings now carry a byte-identical copy of our own new tier ladder
($0.0001 / $0.00009 / $0.00008 / $0.00007), which is parity rather than an undercut:
pennydata/appstore-reviews-rss (2 users, whose title advertises "$0.10 per 1,000" — our exact Free
rate), luzivanlt/app-store-reviews-scraper (2 users), and brisaworks/app-store-reviews (3 users,
which adds a $0.00005 Actor-start fee and so is marginally dearer in practice). Also re-priced and
ruled out: larkmoor/app-store-reviews (2 users, $0.0001 Free then $0.000095→$0.000085 — dearer
than us at every paid rung, since its ladder discounts more slowly than ours) and
tubetext/google-play-reviews-ai (2 users, Google-Play-first with a $0.00005 start fee and
$0.000095→$0.000075 reviews, dearer at every paid rung). The other 161 of the 170 priced at or above
our rate at every rung.
Still open after this pass: the 24 unnamed listings sitting at exactly 1 user and the 13 whose owner is mentioned elsewhere in this file were not priced this round. The 2+-user floor is used because Apify pins a brand-new listing at 1–2 users, so a 1-user cut selects for listing age rather than for price; the three undercutters found above all sat at 2 users, which is where new undercutters in this niche have consistently appeared.
Why this tail had been invisible, and what it invalidates. The sweep was only possible because
cycle 1780 fixed a 10x truncation in bin/niche-size and bin/niche-unnamed: both asked
/v2/store?search=... for limit=100 when that endpoint reports total in the thousands and
serves up to ~1000 hits in a single call. On this niche the same query set returned 577 distinct
listings / 227 title-matched at limit=100 versus 1702 / 259 at limit=1000 — so every audit those
two tools have ever backed, in this niche and fleet-wide, was drawn from roughly a tenth of the
matchable Store. The counts in the earlier dated blocks above are therefore floors, not
totals; the rivals they name were real and were priced live, but "complete tail" claims in them
should be read as "complete within a truncated sample".
What this means honestly, as of the 2026-10-05 sweep: we are no longer near the bottom of this niche on price. Our $0.0001/review is now the modal rate — 20 listings tie it exactly — with roughly two dozen listings priced under it, most of them launched recently, and a cluster of them at $0.00005 or below. What this Actor still offers over the cheap end is the per-storefront ratings histogram verified against Apple's own published average (below), no Actor-start fee at any volume, and a record of these comparisons being re-verified against live pricing records rather than Store copy.
Two honest qualifications, both read off live input schemas rather than listings:
sourabhbgpdoes expose a per-star ratings histogram —includeRatingsHistogram, on by default, in itsapp-detailsmode. What it does not do is attach it to reviews: modes are mutually exclusive, so a buyer who wants reviews and the distribution together pays for two runs and joins them. Here the breakdown rides along with the reviews in the same run, per storefront, for no extra charge, and is dropped if it fails to reconstruct Apple's published average.sourabhbgpalso claims review depth past Apple's RSS 500-cap (schema verified 2026-10-01; it allowsmaxReviewsPerAppup to 100,000 and says it reads Apple's catalog endpoint, which we have not independently verified). If that holds it is a genuine depth advantage over this Actor, which is bounded by the RSS feed's hard 500/app/storefront ceiling and says so plainly throughout. Its own schema notes the trade: that endpoint "ignores both" sort orders and returns relevance order, so a date-ordered ormostHelpfulpull is not what you get.
On the rest, all five schemas are clean (verified 2026-10-01): none has any watch/incremental input at all
(no watchLabel-equivalent, no state key, no rating-edit diffing — theagents' until and
sourabhbgp's sinceDate are one-shot date cutoffs, not baselines), and none exposes
storefront-fallback or empty-page recovery (sourabhbgp's availability-matrix probes whether an
app exists in a storefront, 200 vs 404 — not whether that storefront has reviews, and it does not
re-route a reviews run).
One input the others have that this Actor does not (schema verified live 2026-10-01):
johnvc's start_page offset. Its sort enum
also offers mostfavorable/mostcritical, which this Actor matches as favorable/critical — but
note those are not real Apple feed orders: probed live against
itunes.apple.com/<cc>/rss/customerreviews/.../sortBy=<X>/, only mostRecent and mostHelpful
return entries at all. mostFavorable/mostCritical do not come back empty — re-measured
2026-11-07: Apple returns HTTP 500 with a 34-byte non-JSON body, identical to what any other
unrecognised sortBy token gets. This Actor therefore scans under mostRecent and re-orders by
star rating itself; a scraper that passes those values straight through to the RSS feed gets a
server error, not quietly-empty results.
Pricing decision, verified and shipped live 2026-10-16 (cycle 1781): moved from flat $0.0001/review to
account-plan tiering, $0.0001 (Free) → $0.00009 (Bronze) → $0.00008 (Silver) → $0.00007 (Gold and
up). The sweep above (cycle 1780) established that flat $0.0001 is no longer competitive: 14
unnamed rivals undercut it on at least one tier, the niche floor is $0.00005–$0.00008, and two
no-fee listings (lergassy, workstream) beat it at every volume on every plan. A flat cut to
match the floor was rejected — racing a handful of 2-user listings that may be abandoned to
$0.00005 is not obviously winnable with 45 users and $0 revenue fleet-wide, and flattens the margin
on every run regardless of who is paying. Tiering by account plan is the fix that was actually
missing: every serious named rival in this niche tiers by plan and this Actor did not, which meant
we were the dearest option for every buyer who had ever paid Apify a cent, even while quoting a
rate that looked competitive to a Free-tier shopper. The new tiers keep the Free-tier rate unchanged
(still ties the historical volume leaders thewolves/theagents), and make every paying tier
cheaper than the old flat rate — Silver ties workstream's unconditional $0.00008, and Gold+ sits
one tick above lergassy's $0.000056 Gold+ rate rather than matching it exactly, since lergassy
was at 15 → 20 → 24 users (15 when that call was made on 2026-11-05, 20 as of 2026-11-10, 24 as of 2026-11-14; price re-verified 2026-11-14, unchanged) and had little track record, and losing 0.000014/review to the cheapest listing known at that date (since beaten by apivault_labs at $0.00002 — see the 2026-10-23 block above) in a
crowded niche is a reasonable price for not having raced to the bottom. Platform finding, not
previously documented: Apify's tiered-pricing API silently collapses GOLD/PLATINUM/DIAMOND to one
value — a publish that set PLATINUM to $0.00006 and DIAMOND to $0.000056 came back live with both
read as $0.00007, identical to GOLD. Checked three other already-tiered fleet Actors
(hacker-news-scraper, fda-recall-scraper, ats-jobs-scraper): all three already have
GOLD = PLATINUM = DIAMOND, so this is an existing platform ceiling the fleet had already converged
on by convention, not a new regression — filed in LEARNINGS so a future cycle doesn't waste a
publish call trying to separate those three tiers again. apify-admin publish + bin/sync-apify-prices
both re-verified clean against this live record; registry.json's apify_price now reads
{shape: tiered, entry: 0.0001, floor: 0.00007}.
Seventh full-tail resweep, verified live 2026-11-06 ~03:30 UTC (cycle 2788, 672 cycles / 14 days after the sixth). 2,137 distinct listings seen, 385 title-match this niche (up from 308 at 2026-10-23 — still growing, ~25% in 14 days), 136 already named here, 277 unnamed. Live-priced all 230 unnamed listings at 2+ users in one batch (0 unresolvable, 3 ambiguous, all 3 resolved by hand below). Our own side re-verified live and unchanged: tiered $0.0001 Free / $0.00009 Bronze / $0.00008 Silver / $0.00007 Gold+ per review, no start fee, in force since 2026-10-16.
Six listings undercut us at every account tier, from the first review, with no fee to amortize:
forgedata/app-store-reviews-scraper— flat $0.00001/review at every tier (plus a trivial $0.00005 run-start fee that pays for itself before the first review). This is the new floor of the niche: 10x under our Free rate, 7x under our Gold+ rate, and half the $0.00002 thatapivault_labsset in the 2026-10-23 block above. Apple-App-Store-only, so squarely in scope. Created 2026-10-28, repriced twice since (last 2026-11-02); 2 users, 26 runs.sweet_stickball/app-store-reviews-scraper— $0.00007 Free → $0.000042 Gold+, 30–40% under us at every rung, no fee. Created 2026-10-21 and priced 2026-10-22, i.e. a genuine miss by the sixth resweep (which ran 2026-10-23) rather than a new entrant. 2 users, 51 runs.v0iddo/app-store-reviews-tracker— $0.00009 Free → $0.000063 Gold+, a flat 10% under us at every rung, no fee. The one to actually watch: 231 runs, far more traction than any other listing in this cohort. Created 2026-06-02 but repriced four times since the sixth resweep (last 2026-11-01), so it undercuts us only as of that reprice.zkill3r/app-store-reviews-scraper— $0.00009 Free → $0.00006 Gold+, 10–14% under, no fee. New entrant 2026-10-28; 2 users, 18 runs.rel8ble/app-reviews-scraper— flat $0.00004/review, 60% under our Free rate (crossover is under 2 reviews once its $0.00005 fee is counted). Google Play + App Store in one dataset. Created 2026-09-24 but repriced 2026-11-04, after the sixth resweep. 4 users, 51 runs.ctriolab/appstore-scraper— $0.00008 Free → $0.00006 Gold+; with its $0.00005 fee it turns cheaper than us past 3 reviews (Free) to 6 reviews (Gold+). Repriced 2026-10-28; 3 users, 85 runs.
Three more undercut us only on part of the ladder, and we are the cheaper option on the rest —
stated per-tier because an unqualified "they are cheaper" would be false for most of our buyers:
green_trousers/app-store-reviews and runix/apple-app-store-reviews-feed both sit at a flat
$0.00008 (under us on Free/Bronze, tied at Silver, dearer than our $0.00007 at Gold+), and
locaihost/app-store-reviews runs the mirror shape ($0.0001 Free/Bronze = parity, then $0.000075
Silver / $0.000055 Gold+, so it wins only above Silver).
One apparent undercutter is false, and the fee arithmetic is the whole story.
rowfeed/app-reviews-scraper advertises $0.00006/review — 40% under our Free rate — but charges a
$0.006 run-start fee, which is 60 reviews at our Free rate. It only turns cheaper than us past
151 reviews on Free, 201 on Bronze, 301 on Silver and 601 on Gold+; below those volumes we
are cheaper. Its own description concedes the amortized figure ("about $0.10 per 1,000 reviews"),
which is parity with our Free rate, not an undercut. This is the same shape as hyperbach in the
2026-10-23 block, and the same tooling gap: rowfeed's start event is not flagged
isOneTimeEvent, so an automated per-row comparison reads it as a plain across-the-board
undercutter and silently drops the fee. Every per-run-fee listing in this niche still has to be
resolved by hand.
Three listings are on Apify's FREE model with no pricing record at all — $0 per review to the
buyer, the most aggressive price here by definition: tomstudio/app-store-reviews-scraper,
intelscrape/app-store-reviews-scraper and scraper-forge/app-store-play-store-reviews. All three
have zero charge events, i.e. they are unmonetized listings where the buyer pays Apify platform
usage directly rather than the developer a per-review rate, so the comparison is not like-for-like;
all three are also at 2 users and none carries a future-dated price record that would turn it paid.
Named anyway rather than dropped, because "no pricing record" is exactly the empty-looking shape
that hides the cheapest listing in a niche.
The three ambiguous listings all resolve to NOT undercutters, and all three are premium
report-style products rather than reviews datasets: tanlabs/app-store-review-insights
($0.0003/review + $0.02/app-report), psgameplay121/app-review-insights ($0.0002/review +
$0.02/app-report) and innolabs/app-reviews-scraper ($0.0003 → $0.00015/review plus $0.001 →
$0.0005/app). Each has two recurring events with neither flagged primary, which is why an automated
read calls them ambiguous; read by hand, the cheapest per-review rate among them ($0.00015 at Gold+)
is still more than twice our Gold+ rate. Scope-excluded this pass:
thequietstack/shopify-app-store-reviews (Shopify App Store merchant reviews, a different source
from Apple's App Store, same exclusion applied to the other Shopify listings named above).
We are not cutting price in response to this, and the reason is the measurement, not inertia.
Across seven resweeps this niche has produced a continuous stream of new listings priced at or below
the current floor — the floor has gone $0.00005 → $0.00002 → $0.00001 in three audits — while every
one of this pass's undercutters sits at 2–4 users, and the single highest-traction one
(v0iddo, 231 runs) undercuts by only 10%. Matching a floor that halves every fortnight is a race
to zero against listings with no track record; our tiered ladder already takes every paying tier
below the old flat rate. Read every figure in this README against the timestamp on its own block.
Never silently returns an empty result
Apple's public review feed is full of holes. For one app in one storefront, page 1 can be empty while pages 2 and 7 return a full 50 reviews each; an app can be completely empty under mostRecent and have hundreds under mostHelpful; and coverage differs per storefront. Most scrapers stop at the first empty page and hand you an empty dataset with a green "succeeded" run. This one:
-
scans Apple's entire page range and skips over the empty pages instead of treating the first one as the end of the reviews;
-
if the sort order you asked for is empty, retries under the other sort order — same review pool, and every row records which one it came from in
sortUsed; -
re-requests an empty page as a different client before believing it. Whether a page comes back empty depends on what your HTTP client looks like to Apple, and which client draws the short straw moves: measured 2026-09-10, Notion/us
mostRecentpage 4 came back empty to a plaincurlrequest in 4/4 rounds while a browser and an iPhone client both got a full 50; measured 2026-11-04 the same storefront and sort flipped twice in one hour — page 10 empty to a desktop browser whilecurland an iPhone client each got a full 50, then later the same day page 8 empty to the iPhone client whilecurland a desktop browser each got a full 50. Three measurements, three different "unlucky" clients — this Actor's retry deliberately does not assume any one client class is the safe one, which is why it works. Each recovered page is 50 reviews a single-client scrape silently drops, and the retry only costs a request when a page is actually empty. Rows carryclientClassso you can see which client served them; -
when a storefront really is empty, probes other storefronts and tells you which ones have reviews for that app;
-
with
countryFallback: true, fetches from a working storefront automatically — rows keep the realcountryplusrequestedCountryandfallbackUsed: true, so nothing is mislabelled; -
sets a run status message explaining why a run returned few or no rows (empty Apple feed vs. your own rating/keyword filters vs. a storefront Apple refused);
-
separates "Apple has no reviews here" from "Apple refused this request". A storefront code that is well-formed but isn't a real Apple store answers every request with
HTTP 400; that pair ends on its first refusal rather than paging on, the message says what Apple actually returned, and if every pair in the run was refused the run fails instead of reporting an empty result. In watch mode a refused pair is deliberately left out of the baseline, so a broken storefront can never be silently recorded as "already delivered"; -
retries connection-level failures up to 3 times before believing them. A dropped connection is not an answer, but got's own retry list doesn't cover the HTTP/2 connection faults measured at roughly 1 fresh connection in 4 across this fleet (2026-09-21), so one blip used to end an app's scan or quietly return
ratingBreakdown: null. Every review-feed, lookup, search and ratings-page request now retries with backoff first. A real HTTP error from Apple (a wrong storefront code) still fails immediately with the explanation instead of looping; -
fails loudly instead of returning a misleading empty result when the fault is Apple's, not yours. Apple sometimes serves an empty feed for everything — measured 2026-09-16: every app, storefront, page, sort and client came back
HTTP 200with zero entries. From one app's response that is indistinguishable from "this app has no reviews", so when a run ends up with no reviews at all we re-check two control apps that always have hundreds of thousands of reviews (three attempts, spaced). If those are empty too, the run fails with a message naming the Apple-side fault, rather than telling you no reviews matched your filters. A watch-mode baseline is never written from such a run either — otherwise the next run would treat the app's whole review history as "new" and charge you for it. -
works around Apple refusing one source IP, instead of making you re-run and hope — and only pays for the check on a run that actually needs it. That empty-feed behaviour is partly per source IP: measured 2026-10-29 across 13 source IPs in one minute on the same URL (an app with a six-figure review count), some IPs got a full page of 50 reviews while others got the same well-formed, data-free feed. Rather than checking every run up front, this Actor only asks (once, memoised) whether its own IP is being served when the first review page actually comes back empty — a run whose own IP is fine never pays for the check at all. If the own IP turns out to be refused, it asks control apps that always carry six-figure review counts, under both
mostRecentandmostHelpfuland across every control app before giving up on an IP (the same measurement showed the refusal is per (IP, app, minute), not purely per IP — one IP served 50 reviews for one big app and a data-free feed for another in the same sweep, so a single-app, single-sort check would rotate away from an IP or sort that could have served you). Once a fresh IP answers, it re-fetches that exact page before continuing, so the page that exposed the refusal is never silently treated as a hole in Apple's feed.RUN_SUMMARY.proxyIpRotationsis0when no workaround was needed andNwhen the run's reviews came through the Nth rotated IP. If every IP is refused it is a genuine feed-wide fault, and the run still fails loudly with$0charged, exactly as above. -
says all of that in a form a program can read, not just in English. Every run writes a
RUN_SUMMARYrecord to its key-value store with one entry per app/storefront pair: how many reviews werescanned, how manydelivered, how many your filters removed, how many ratings Apple declares the app has (declaredRatingCount), and acompleteflag with the reason that made it false. A status message is for a human reading the run page; this is for the pipeline that never reads it (see FAQ).
You are never charged for empty pages, for retries, or for a run that fails this way.
FAQ
Can I be alerted when someone edits a review I already downloaded? Yes — that is what watchEvents is for. Apple lets a reviewer rewrite their own review (same review id, new star rating, only the feed's own updated date advances) — there is no "new review" event to catch that, since it isn't new. With a watchLabel set, this Actor also diffs the star rating each review had when it was last delivered and re-delivers it as watchEvent: "scoreChanged" with previousScore filled in. Restrict it with watchEvents: ["scoreChanged"] to track only rating edits (e.g. skip the noise of every brand-new review and pay only for reversals) or ["new"] to keep today's behavior. A baseline created before this existed needs one run to record the state it will diff against. There is no developer-reply field on this feed, so unlike Google Play there's no equivalent "developer replied" event to offer.
Why has my watch stopped finding anything new? Check whether you set a fixed reviewsBefore alongside watchLabel. reviewsBefore is applied client-side against each review's own updatedAt, which for a brand-new review is its post time — always "now". So once today's real calendar date passes a fixed reviewsBefore, no newly-posted review can ever be on or before that cutoff again, and the watch goes permanently quiet while still reporting the reassuring "nothing new" status every run. This run logs a warning (and sets RUN_SUMMARY.watchDeadDateBound: true) when it detects the combination. Drop reviewsBefore from a watched query (reviewsAfter alone is fine) or drop watchLabel if you actually want a one-off historical window instead of an ongoing alert.
Why did my run return 0 reviews with status SUCCEEDED? Check the run's status message first — it tells you whether Apple's feed was genuinely empty for that app/storefront or your own review filters (rating/keyword/length/votes/date) removed every row.
What country codes does countries take? Apple storefronts are two-letter ISO-3166-1 alpha-2 codes — the UK is gb, not uk, and there is no usa/uk/eng. A wrong code used to look like an app with no reviews (Apple answers uk with HTTP 400 carrying valid JSON and no results); now a recognisable wrong code fails the run in about a second, before the first request and before any charge, and names the code you should have used. A well-formed code Apple simply doesn't run a store in (e.g. zz) ends that app/storefront pair on its first refusal instead of walking the rest of the page range, and the run says which pairs Apple refused.
Can I get more than 500 reviews for one app? No — Apple's public feed caps at 500 most-recent reviews per app per country (Apple states this itself: requesting page 11 returns HTTP 400 with a plain-text body reading "CustomerReviews RSS page depth is limited to 10"). Whether you actually see all 500 varies by app and by day: measured 2026-11-04, both Notion and Spotify under us served a full 500 across all 10 pages. The gaps that do show up are usually a client-class hole, not the end of the feed — a single page coming back empty to one HTTP client while the same page is full under another (see above), which is why this Actor re-requests every empty page under a different client before accepting it as real. The Actor retries every empty page this way to recover as much as it can, and when the feed genuinely quits early it says so explicitly (next FAQ) instead of letting a short result look complete. Widen countries for more coverage. Run on a schedule and deduplicate by reviewId to build a larger archive over time. Note that totalRatings/ratingBreakdown are not capped: they cover every rating the app has ever received in that storefront, so you still get the full-population distribution even though only 500 written reviews are reachable.
How do I know whether Apple cut the feed off or the app simply has no more reviews? The run tells you, as of v0.1.51. Whenever the last page Apple served came back full and the Actor was still willing to take more, the run's status message names those app/storefront pairs, says which page the feed quit at and how many reviews it handed over, and states plainly that raising maxReviewsPerApp cannot reach the older ones (widen countries, or schedule with watchMode instead). This covers both the documented 500/10-page ceiling and the much more common early stop. A run that ends on a partial page genuinely exhausted what Apple serves for that pair — so a missing note is itself the "you got everything available" signal.
Why is totalRatings different from ratingCount? They come from two different Apple sources and are both real. ratingCount is Apple's lookup API figure; totalRatings is the sum of the per-star histogram shown on the App Store product page, which updates on a slightly different schedule. Expect them to agree to within a fraction of a percent — if you need the number that matches ratingBreakdown exactly, use totalRatings. Exception, Mac App Store apps: Apple publishes neither figure for kind: "mac-software" listings, so ratingCount comes back as Apple's literal 0 while totalRatings/ratingBreakdown are null (see the includeMacApps note above). Neither means the app is unrated.
Does keyword handle accented words correctly? Yes, as of v0.1.29 — keyword and the review text it's matched against are Unicode-normalized before comparing, so an accented word (e.g. "café") matches regardless of which of Unicode's two equivalent representations (composed vs. decomposed) you typed it in.
Is reviewUrl unique per review? No, and it isn't presented as such. It's Apple's own "related" link from the feed entry, which points at the app's review page for that storefront — the same URL for every review of that app in that country. Apple does not publish a per-review permalink; use reviewId as the unique key.
Does countryFallback change the country field on rows I already have? No — fallback rows are clearly tagged with fallbackUsed: true and keep both the real country they came from and the requestedCountry you asked for.
I listed two countries and countryFallback picked one I already asked for directly — do I get charged twice for the same review? No, as of v0.1.11. If an empty storefront's fallback lands on another storefront you also listed in countries (e.g. countries: ["us", "bt"] with countryFallback: true, and Bhutan's App Store has no reviews of its own so it falls back to the US feed you're already pulling directly), each real review is still only pushed and charged once — review IDs are deduplicated across every country for the same app within a run, not just within one storefront.
Do I get charged for empty pages or retries? No — only reviews actually returned to the dataset are charged.
Why does minVoteSum return nothing? Apple only populates helpfulness votes (voteSum/voteCount) on its mostHelpful feed. Every review served by the mostRecent feed comes back with 0 votes — that is real data (new reviews genuinely have no votes yet), not a gap we can fill, and it is why reviewsAfter (which forces mostRecent) can't be combined with a vote floor above 0. Set sort: "mostHelpful" and the filter works as expected; the run log warns you when it can't.
How is webhookUrl different from Apify's own platform webhooks? Apify's platform webhooks are configured separately per Task/Actor via the Console or the Webhooks API — useful if you already live in the Apify Console, but extra setup if you're calling this Actor's API directly and just want a completion ping. webhookUrl is a plain input field: set it on the run itself and it POSTs a JSON body (actorRunId, defaultDatasetId, finishedAt, pushed, and — if watchLabel is set — watchSeeding/watchNewCount/watchSkipped, plus pairsIncomplete and the full per-pair pairs array described above) once the run finishes and every review has already been pushed and charged. It's best-effort — a slow or failing webhook only logs a warning, it never fails the run, changes the result set, or affects billing.
How do I check in code whether a run got everything? Read the run's RUN_SUMMARY key-value record — GET https://api.apify.com/v2/actor-runs/<runId>/key-value-store/records/RUN_SUMMARY (no webhook needed; the same data is also POSTed to webhookUrl as pairs if you set one). It holds run-level complete / incompleteReason / incompleteDetail, the counts pushed, pairsPlanned, pairsAttempted, pairsIncomplete, pairsUnknown, and a pairs array with one record per app/storefront:
{"app": "310633997", "country": "us", "status": "ok","scanned": 50, "delivered": 50, "filteredOut": 0,"declaredRatingCount": 18632949,"complete": false, "incompleteReason": "apple-feed-ceiling","scanDepthCap": 500, "feedStopPage": 4, "reason": null}
That row is the honest version of a 50-row dataset for an app with 18.6 million ratings: you got everything Apple's public feed served, and Apple served a fraction of what exists. status is one of ok, empty (Apple's feed has nothing for that pair), filteredOut (reviews found, your filters removed all of them), watchBaselined, watchNoChanges, error (Apple refused the request — reason quotes it), badAppId (an apps entry no app id could be parsed from), notReached (the run stopped before it got there), or timedOut (the run was approaching its platform run timeout and stopped before this pair returned anything — this says nothing about whether Apple has reviews for it). complete is deliberately separate from status: a pair can deliver reviews perfectly normally and still have been cut short, and incompleteReason names which — apple-feed-ceiling (Apple stopped serving; no input value can reach deeper), max-reviews-per-app, max-results, charge-limit, baseline-cap, or time-budget (the run stopped itself short of the platform run timeout so the rows already collected would still be returned — narrow the input, raise the Actor's run timeout, or split the pairs across runs). complete: null and declaredRatingCount: null mean not observed, never zero (declaredRatingCount is only filled when includeAppInfo is on).
Just tell me if the run got everything — one field. Read the top-level complete on the same record. It is true only when every pair came back complete, false if any pair fell short or could not report at all, and null when no pair was attempted. incompleteReason names the first pair that fell short (same vocabulary as the per-pair field, plus storefront-error, bad-app-id, not-reached and time-budget for pairs that have no reason of their own), and incompleteDetail says which pair and how many others. This is the same complete / incompleteReason / incompleteDetail contract every FetchSmith Actor's RUN_SUMMARY carries, so one pipeline can check all of them the same way. Watch pairsUnknown too: it counts pairs with no completeness to report, which pairsIncomplete (known-short pairs only) deliberately excludes.
How does sort: "favorable"/"critical" work? Apple's feed has no server-side "sort by rating" — there is no such request you can make. Instead, the Actor scans that app/storefront pair under mostRecent exactly as usual (so maxReviewsPerApp/reviewsAfter mean exactly what they mean today), then re-orders everything it kept after filtering, before delivery: favorable is 5★-to-1★, critical is 1★-to-5★, and reviews tied on rating stay newest-first. Because the whole pair's result has to be assembled before anything can be ordered, it can't be combined with watchLabel (whose "only what's new" logic depends on delivering in scan order) — use mostRecent/mostHelpful for watches.
Why did I get fewer reviews than maxReviewsPerApp? maxReviewsPerApp is a scan cap, not a match count — it stops paging Apple's feed after that many reviews have been looked at, and the review filters (rating/keyword/length/votes/date) are applied after that, per review. A narrow filter combined with a low cap can miss real matches sitting deeper in the feed: measured 2026-11-16 on Spotify (324684580, sort: "mostRecent") with maxRating: 1, maxReviewsPerApp: 5 scans 5 reviews and keeps 1, while raising it to 100 scans 100 and keeps 20 — the other 19 were always there, just unscanned. Expect your own numbers to differ: this feed is ordered newest-first, so every new review shifts the window and both counts are re-rolled continuously (the 1★ rate on this app runs around one review in five, so a 5-deep window is close to a coin flip — when this example was first written the shallow cap happened to keep 0). The ratio is the durable part, not the counts: the scan cap, not the filter, is what bounds how many matches you can possibly see. When this happens the log carries a WARN naming the cap and how many scanned reviews were dropped, and the run's status message says the same — raise maxReviewsPerApp to search deeper. Filtered-out reviews are not charged either way.
Notes
Apple exposes the most recent 500 reviews per app per country. For historical archives, run on a schedule and deduplicate by reviewId.
Related guides
Engineering write-ups behind this Actor:
- Apple App Store reviews have a public JSON API with no key — here are the four endpoints — the four URLs that do the whole job (metadata, name→id search, the review feed, the per-star histogram), each measured live, including the
HTTP 400body in which Apple states the 10-page depth limit itself. - Apple's review feed has holes, and whether you hit one depends on your HTTP client
- The App Store's per-star ratings breakdown isn't in any of Apple's APIs — it's in the page's JSON blob
- Four ways an invisible character makes a scraper return zero rows
- We nearly charged our own buyers twice for rows they'd already paid for — a capped watch-mode baseline can silently evict old-but-current ids on a high-volume run, re-delivering (and re-billing) rows already paid for.
- App Store, Google Play and Steam reviews — three JSON APIs, three unrelated meanings of "empty" — how this Actor's specific silent-empty failure mode compares to the other two review platforms we scrape.
- Eight ways an "only new since last run" watch mode silently stops working — the fleet-wide survey of watch-mode failure shapes across all nineteen incremental Actors, this one included.
Only publicly available data is collected. Support: support@fetchsmith.com · Hosted API: https://fetchsmith.com/tools/app-store-reviews-scraper
Source code: https://github.com/Fetchsmith/fetchsmith/tree/main/actors/app-store-reviews-scraper