AI disclosure: This article was written with AI assistance (Claude). The code is condensed from a scraper I maintain, and every number in the output sections came from actually running the scripts below on 2026-11-20/22.
If you want to know what users think of an iOS app (yours or a competitor's), the App Store review pages are the obvious source. Scraping the HTML is painful, though: it's rendered client-side, it changes often, and it only shows a handful of reviews.
There's a much simpler route that most people don't know about. Apple still serves two plain JSON endpoints that need no API key, no login, no headless browser and, at small volumes, no proxies:
- The customer-reviews RSS feed, which returns the most recent (or most helpful) reviews for an app, per country storefront.
- The iTunes Lookup API, which returns app metadata, including the lifetime average rating and rating count.
In this tutorial we'll use both with plain Node.js fetch to:
- pull recent reviews for one app from four countries,
- turn them into a labelled JSONL dataset (
positive/neutral/negative), - find which words show up far more in negative reviews than in positive ones.
The example app is Duolingo (ID 570060128), because it has lots of reviews in many countries. Any app ID works.
The two endpoints
The reviews feed URL looks like this:
https://itunes.apple.com/{country}/rss/customerreviews/page={1-10}/id={appId}/sortby={mostrecent|mosthelpful}/json -
countryis a 2-letter storefront code (us,gb,de,br, ...). Each storefront has its own reviews. A US review never shows up in the German feed. - Each page has up to 50 entries, and there are at most 10 pages. That makes 500 reviews per app per country the hard ceiling.
- Drop
/jsonand you get XML instead.
The Lookup API is even simpler:
https://itunes.apple.com/lookup?id=570060128&country=us It returns trackName, averageUserRating, userRatingCount, version, releaseNotes, genres, price and more. If you only have an app name, https://itunes.apple.com/search?term=duolingo&entity=software&country=us gives you the ID.
To get the app ID from a store URL like https://apps.apple.com/us/app/duolingo-language-lessons/id570060128, a regex is enough:
const m = s.match(/id(\d{6,})/) || s.match(/^(\d{6,})$/); Quirks in the feed you need to handle
The feed is old (it dates from the iTunes era) and has a few traps. I learned these the hard way:
-
feed.entryis not always an array. If a page has exactly one review, you get an object. Always normalise it. - Some entries aren't reviews. Depending on the response, the first entry can describe the app itself. Real reviews are the ones with an
im:ratingfield, so filter on that. - Every value is wrapped in
{ label: ... }. The rating ise['im:rating'].label, a string. - An empty or missing page means you're done. Past the last page you get no
entryat all (or a 400/404), not an error you need to retry. - Rate limits are real but generous. At a few requests per second you're fine. If you go faster you'll see
429and5xxresponses, so back off and retry.
Step 1: fetch reviews and build the dataset
Here is the whole script. It has no dependencies and needs Node 18+ for the global fetch.
// reviews.mjs - App Store reviews for one app across countries -> sentiment JSONL import { writeFileSync } from 'node:fs'; const APP_ID = process.argv[2] ?? '570060128'; // Duolingo const COUNTRIES = (process.argv[3] ?? 'us,gb,de,br').split(','); const sleep = (ms) => new Promise((r) => setTimeout(r, ms)); async function getJson(url) { for (let attempt = 0; attempt < 3; attempt++) { const res = await fetch(url); if (res.status === 429 || res.status >= 500) { await sleep(1000 * 2 ** attempt); continue; } if (!res.ok) return null; // 400/404: no more pages return res.json(); } return null; } async function reviewsFor(appId, country, maxPages = 2) { const out = []; for (let page = 1; page <= maxPages; page++) { const url = `https://itunes.apple.com/${country}/rss/customerreviews/page=${page}/id=${appId}/sortby=mostrecent/json`; const data = await getJson(url); let entries = data?.feed?.entry; if (!entries) break; if (!Array.isArray(entries)) entries = [entries]; // a single review is not wrapped in an array const reviews = entries.filter((e) => e['im:rating']); // skip the app-metadata entry for (const e of reviews) { out.push({ country, id: e.id.label, rating: Number(e['im:rating'].label), title: e.title?.label ?? '', text: e.content?.label ?? '', version: e['im:version']?.label ?? null, date: e.updated?.label ?? null, }); } if (entries.length < 50) break; // last page await sleep(400); } return out; } const label = (stars) => (stars <= 2 ? 'negative' : stars === 3 ? 'neutral' : 'positive'); const lookup = await getJson(`https://itunes.apple.com/lookup?id=${APP_ID}&country=${COUNTRIES[0]}`); const app = lookup.results[0]; console.log(`${app.trackName} | lifetime avg ${app.averageUserRating.toFixed(2)} from ${app.userRatingCount} ratings | v${app.version}`); const rows = []; for (const c of COUNTRIES) { const rs = await reviewsFor(APP_ID, c); const avg = rs.reduce((s, r) => s + r.rating, 0) / rs.length; const neg = rs.filter((r) => r.rating <= 2).length; console.log(`${c}: ${rs.length} reviews, avg ${avg.toFixed(2)}, negative ${Math.round((100 * neg) / rs.length)}%`); for (const r of rs) rows.push({ ...r, label: label(r.rating), app: app.trackName }); } writeFileSync('reviews.jsonl', rows.map((r) => JSON.stringify(r)).join('\n') + '\n'); console.log(`wrote ${rows.length} rows to reviews.jsonl`); maxPages = 2 keeps the demo at 100 reviews per country. Set it to 10 for the full 500.
The labels come straight from the stars: 1-2 is negative, 3 is neutral, 4-5 is positive. That's a deliberately simple choice. Star ratings are a free, human-provided label, which makes this a reasonable weakly-labelled dataset for training or evaluating a sentiment classifier, with no annotation budget.
Real output
$ time node reviews.mjs Duolingo: Learn Languages | lifetime avg 4.72 from 5612297 ratings | v7.149.1 us: 100 reviews, avg 3.84, negative 23% gb: 100 reviews, avg 3.91, negative 23% de: 100 reviews, avg 3.60, negative 29% br: 100 reviews, avg 4.32, negative 14% wrote 400 rows to reviews.jsonl real 0m8.135s One row of reviews.jsonl:
{"country":"us","id":"14813626408","rating":5,"title":"This game is amazing","text":"Once I tried chest, the game got really fun now I can’t stop playing","version":"7.149.1","date":"2026-11-20T11:09:07-07:00","label":"positive","app":"Duolingo: Learn Languages"} That's 400 reviews from four countries in 8 seconds, from a residential connection, with no proxy.
Two things already stand out:
- The lifetime average (4.72) is much higher than the average of recent written reviews (3.60-4.32). The Lookup number includes star-only ratings, which mostly come from in-app rating prompts. People who bother to write text are more often unhappy. Keep this in mind before you call an app "loved" or "hated" based on either number alone.
- Countries differ a lot. Germany has twice the share of negative reviews that Brazil has, for the same app version (7.149.1 was the version on 77-99% of these reviews). This is exactly why the per-country feed matters: if you only scrape
us, you miss it.
Step 2: what are the unhappy users talking about?
A full sentiment model is overkill for a first look. A simple and surprisingly useful trick is to compare how often each word appears in negative vs positive reviews, using document frequency with add-one smoothing so rare words don't explode:
// themes.mjs - which words show up far more in negative than positive reviews? import { readFileSync } from 'node:fs'; const rows = readFileSync('reviews.jsonl', 'utf8').trim().split('\n').map(JSON.parse) .filter((r) => ['us', 'gb'].includes(r.country)); // English-language stores only const STOP = new Set('the a an and or but to of in on for is it i my me this that with was are be have has not you so at as just can its im dont app duolingo their see into they get all from what'.split(' ')); const words = (s) => s.toLowerCase().replace(/[^a-z' ]/g, ' ').split(/\s+/) .map((w) => w.replace(/'/g, '')).filter((w) => w.length > 2 && !STOP.has(w)); function counts(label) { const c = new Map(); for (const r of rows.filter((r) => r.label === label)) for (const w of new Set(words(`${r.title} ${r.text}`))) c.set(w, (c.get(w) ?? 0) + 1); // doc frequency return c; } const neg = counts('negative'), pos = counts('positive'); const nNeg = rows.filter((r) => r.label === 'negative').length; const nPos = rows.filter((r) => r.label === 'positive').length; const scored = [...neg].filter(([, n]) => n >= 4).map(([w, n]) => { const pNeg = (n + 1) / (nNeg + 2), pPos = ((pos.get(w) ?? 0) + 1) / (nPos + 2); return { w, inNeg: n, inPos: pos.get(w) ?? 0, ratio: +(pNeg / pPos).toFixed(1) }; }).sort((a, b) => b.ratio - a.ratio).slice(0, 10); console.log(`negative reviews: ${nNeg}, positive: ${nPos}`); for (const s of scored) console.log(`${s.w.padEnd(14)} neg ${s.inNeg} pos ${s.inPos} x${s.ratio}`); Real output
$ node themes.mjs negative reviews: 46, positive: 144 paid neg 5 pos 0 x18.3 enough neg 5 pos 0 x18.3 spend neg 5 pos 0 x18.3 duplicates neg 4 pos 0 x15.2 luck neg 4 pos 0 x15.2 subscription neg 4 pos 0 x15.2 gems neg 5 pos 1 x9.1 had neg 9 pos 3 x7.6 collect neg 4 pos 1 x7.6 either neg 4 pos 1 x7.6 Reading the reviews behind duplicates, luck, gems and collect tells a clear story: a limited-time event where users collect puzzle pieces, keep getting duplicates, and feel pushed to buy gems with real money to finish the set. subscription and paid point at a second, older complaint about trials and billing. That's two concrete product issues, found from 200 English reviews in under a minute of compute.
With a sample this small, treat the list as "where to start reading", not as statistics. Words like had and either are noise that a bigger sample or bigrams would wash out.
Where to take the dataset next
- Better labels. Run a multilingual sentiment model (for example, an XLM-R based model from Hugging Face) on
title + textand compare it with the star label. The reviews where they disagree ("5 stars, but the new update is awful") are often the most interesting ones. - Version tracking. Every row has
version. Group the negative share by version and you get a cheap regression detector for releases. - Competitor comparison. Run the same script for 3-5 apps in a category and compare complaint themes side by side.
- Most helpful vs most recent.
sortby=mosthelpfulgives you the reviews other users upvoted, which skews towards long, detailed reviews. It's a different sample, so don't mix the two without a column that says which one it came from.
The limits (read this before you build on it)
- 500 reviews per app per country, recent only. The feed is a window, not an archive. For a popular app, 500 reviews might cover only a couple of days. If you need history, run it on a schedule and store everything with
idas the dedupe key. - Star-only ratings are invisible. You only get reviews with text. The rating distribution in the feed is not the app's real rating distribution, as the 4.72 vs 3.84 gap shows.
- No developer replies. The feed doesn't include the developer's response to a review.
- Country is not language. The US feed in my run contained a review in Russian. Filter by detected language if your NLP step assumes English.
- It's a legacy endpoint. Apple doesn't promote this feed and could change or remove it. Build your pipeline so a missing
feed.entryfails loudly instead of silently writing zero rows. - Be polite. Apple's Search/Lookup docs suggest staying around 20 calls per minute. The reviews feed tolerated more in my tests, but pace your requests and back off on
429. - Personal data. The feed includes reviewer nicknames under
author.name. I leave them out by default. If you keep them, you're storing personal data, so think about GDPR and your use case. - iOS only. Google Play reviews need a completely different approach.
If you'd rather not maintain this yourself
Running the script once is easy. Running it every day across 20 countries and 50 apps, with retries, dedupe, scheduling and exports, is where it turns into a small maintenance job.
I packaged the same approach as an Apify actor. Full disclosure: it's ours, and it's paid per use through Apify's pay-per-event pricing: it's free to use until December 6, 2026, and from then it costs about $0.40 per 1,000 reviews plus $0.002 per app details record. It adds app search by keyword, star filters, up to 500 reviews per country, an app-details record from the Lookup API, scheduling and CSV/Excel/JSON export. Reviewer names are off unless you turn them on. In a local test run it pulled the same 400 Duolingo reviews from four countries with zero failed requests.
If you also want to feed an app's website, docs or changelog into the same LLM pipeline next to the reviews, our Website to Markdown actor converts pages into clean Markdown. It's built the same way: plain HTTP and no browser.
The review scraper is here: Apple App Store Reviews Scraper (Multi-Country, No Proxy).
But honestly, the two scripts above are about 100 lines. If you only need a one-off dataset, copy them and go.
