Pricing

from $0.25 / 1,000 review scrapeds

Try for free

Go to Apify Store

App Store & Google Play Reviews Scraper + App Details

Name: App Store & Google Play Reviews Scraper + App Details
Price: 0.25 USD

Try for free

Reviews and app details from Apple App Store and Google Play in one run. Paste app URLs, IDs or just app names. Multiple countries, star-rating and date filters, developer replies included. Clean output for sentiment analysis and ASO.

Pricing

from $0.25 / 1,000 review scrapeds

Rating

0.0

(0)

Developer

DataFetch Labs

Actor stats

Bookmarked

Total users

Monthly active users

13 hours ago

Last modified

.dockerignore

node_modules
storage
test

.gitignore

node_modules
storage
.DS_Store

Dockerfile

FROM apify/actor-node:22
COPY --chown=myuser package*.json ./
RUN npm --quiet set progress=false \
    && npm install --omit=dev --omit=optional \
    && rm -rf ~/.npm
COPY --chown=myuser . ./
CMD npm start --silent

package.json

{
  "name": "app-reviews-scraper",
  "version": "1.0.0",
  "description": "App Store and Google Play reviews and app details for any app, multiple countries, in one format.",
  "type": "module",
  "main": "src/main.js",
  "scripts": { "start": "node src/main.js" },
  "dependencies": { "apify": "^3.7.2", "google-play-scraper": "^10.1.3" },
  "license": "ISC"
}

.actor/actor.json

{
    "actorSpecification": 1,
    "name": "app-reviews-scraper",
    "title": "App Store & Google Play Reviews Scraper + App Details",
    "description": "Reviews and app details from Apple App Store and Google Play in one run. Paste app URLs, IDs or just app names. Multiple countries, star-rating and date filters, developer replies included. Clean output for sentiment analysis and ASO.",
    "version": "1.0",
    "buildTag": "latest",
    "input": "./input_schema.json",
    "output": "./output_schema.json",
    "storages": {
        "dataset": "./dataset_schema.json"
    },
    "dockerfile": "../Dockerfile",
    "readme": "../README.md",
    "minMemoryMbytes": 128,
    "maxMemoryMbytes": 4096,
    "defaultRunOptions": {
        "build": "latest",
        "memoryMbytes": 512,
        "timeoutSecs": 3600
    }
}

.actor/dataset_schema.json

{
    "actorSpecification": 1,
    "fields": {},
    "views": {
        "overview": {
            "title": "Reviews",
            "transformation": {
                "fields": [
                    "appTitle",
                    "store",
                    "country",
                    "rating",
                    "title",
                    "text",
                    "date",
                    "appVersion",
                    "thumbsUp",
                    "replyText"
                ]
            },
            "display": {
                "component": "table",
                "properties": {
                    "appTitle": {
                        "label": "App"
                    },
                    "store": {
                        "label": "Store"
                    },
                    "country": {
                        "label": "Country"
                    },
                    "rating": {
                        "label": "Stars",
                        "format": "number"
                    },
                    "title": {
                        "label": "Title"
                    },
                    "text": {
                        "label": "Review"
                    },
                    "date": {
                        "label": "Date",
                        "format": "date"
                    },
                    "appVersion": {
                        "label": "Version"
                    },
                    "thumbsUp": {
                        "label": "Helpful",
                        "format": "number"
                    },
                    "replyText": {
                        "label": "Developer reply"
                    }
                }
            }
        }
    }
}

.actor/input_schema.json

{
    "title": "App reviews",
    "type": "object",
    "schemaVersion": 1,
    "properties": {
        "apps": {
            "title": "Apps",
            "type": "array",
            "editor": "stringList",
            "description": "Google Play URLs or package names (com.spotify.music), App Store URLs or numeric IDs (324684580), or plain app names (\"Duolingo\"), which are searched in the stores. One per line.",
            "prefill": [
                "https://play.google.com/store/apps/details?id=com.spotify.music",
                "https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580"
            ]
        },
        "storeForNames": {
            "title": "Stores to search for app names",
            "type": "string",
            "editor": "select",
            "enum": [
                "both",
                "google",
                "apple"
            ],
            "enumTitles": [
                "Both stores",
                "Google Play only",
                "App Store only"
            ],
            "default": "both",
            "description": "Only used for plain app names."
        },
        "countries": {
            "title": "Countries",
            "type": "array",
            "editor": "stringList",
            "default": [
                "us"
            ],
            "prefill": [
                "us"
            ],
            "description": "Two-letter country codes (us, gb, de, fr, in, br...). Reviews are collected separately for each country."
        },
        "language": {
            "title": "Language (Google Play)",
            "type": "string",
            "editor": "textfield",
            "default": "en",
            "description": "Review language for Google Play, e.g. en, es, de. App Store reviews come in the country's languages."
        },
        "maxReviewsPerApp": {
            "title": "Max reviews per app and country",
            "type": "integer",
            "editor": "number",
            "minimum": 0,
            "default": 500,
            "prefill": 100,
            "description": "0 = as many as available. Apple's public feed provides up to ~500 recent reviews per country; Google Play has no practical limit."
        },
        "sort": {
            "title": "Sort reviews by",
            "type": "string",
            "editor": "select",
            "enum": [
                "newest",
                "relevant",
                "rating"
            ],
            "enumTitles": [
                "Newest",
                "Most helpful",
                "Rating (Google Play)"
            ],
            "default": "newest",
            "description": "Order in which reviews are collected."
        },
        "minRating": {
            "title": "Minimum stars",
            "type": "integer",
            "editor": "number",
            "minimum": 1,
            "maximum": 5,
            "default": 1,
            "description": "Keep reviews with at least this many stars."
        },
        "maxRating": {
            "title": "Maximum stars",
            "type": "integer",
            "editor": "number",
            "minimum": 1,
            "maximum": 5,
            "default": 5,
            "description": "Keep reviews with at most this many stars. Set to 2 to collect only complaints."
        },
        "reviewsSince": {
            "title": "Only reviews since",
            "type": "string",
            "editor": "datepicker",
            "description": "Keep only reviews written on or after this date."
        },
        "includeAppDetails": {
            "title": "Include app details",
            "type": "boolean",
            "editor": "checkbox",
            "default": true,
            "description": "Adds one item per app and country with rating, ratings count, installs, version, genre, price, developer and description (type = \"app\")."
        },
        "includeUserDetails": {
            "title": "Include reviewer names",
            "type": "boolean",
            "editor": "checkbox",
            "default": false,
            "description": "Adds reviewer display name and avatar. Off by default to minimize personal data."
        },
        "maxConcurrency": {
            "title": "Parallel apps",
            "type": "integer",
            "editor": "number",
            "minimum": 1,
            "maximum": 10,
            "default": 3,
            "description": "How many app/country combinations to process at once."
        }
    },
    "required": [
        "apps"
    ]
}

.actor/output_schema.json

{
    "actorOutputSchemaVersion": 1,
    "title": "Output schema",
    "properties": {
        "results": {
            "type": "string",
            "title": "Reviews and app details",
            "template": "{{links.apiDefaultDatasetUrl}}/items"
        },
        "report": {
            "type": "string",
            "title": "Per-app report",
            "template": "{{links.apiDefaultKeyValueStoreUrl}}/records/APPS_REPORT"
        }
    }
}

src/http.js

1const UA = 'Mozilla/5.0 (compatible; ats-jobs-scraper/1.0; +https://apify.com)';
2
3export class HttpError extends Error {
4    constructor(status, url) {
5        super(`HTTP ${status} for ${url}`);
6        this.status = status;
7    }
8}
9
10/**
11 * fetch() with timeout, retries on network errors / 429 / 5xx, and JSON or text parsing.
12 * 404 and other 4xx errors are thrown immediately as HttpError (not retried).
13 */
14export async function request(url, { method = 'GET', body, headers = {}, as = 'json', retries = 3, timeoutMs = 30000 } = {}) {
15    let lastErr;
16    for (let attempt = 0; attempt <= retries; attempt++) {
17        const ctrl = new AbortController();
18        const timer = setTimeout(() => ctrl.abort(), timeoutMs);
19        try {
20            const res = await fetch(url, {
21                method,
22                body: body === undefined ? undefined : (typeof body === 'string' ? body : JSON.stringify(body)),
23                headers: {
24                    'user-agent': UA,
25                    accept: as === 'json' ? 'application/json' : '*/*',
26                    ...(body !== undefined && typeof body !== 'string' ? { 'content-type': 'application/json' } : {}),
27                    ...headers,
28                },
29                signal: ctrl.signal,
30                redirect: 'follow',
31            });
32            if (res.status === 429 || res.status >= 500) {
33                lastErr = new HttpError(res.status, url);
34                const retryAfter = Number(res.headers.get('retry-after')) || 0;
35                await sleep(Math.max(retryAfter * 1000, 1000 * 2 ** attempt));
36                continue;
37            }
38            if (!res.ok) throw new HttpError(res.status, url);
39            if (as === 'json') return await res.json();
40            if (as === 'response') return res;
41            return await res.text();
42        } catch (err) {
43            if (err instanceof HttpError && err.status < 500 && err.status !== 429) throw err;
44            lastErr = err;
45            if (attempt < retries) await sleep(1000 * 2 ** attempt);
46        } finally {
47            clearTimeout(timer);
48        }
49    }
50    throw lastErr;
51}
52
53export const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
54
55/** Run `fn` over `items` with at most `limit` concurrent executions. Results keep input order. */
56export async function mapLimit(items, limit, fn) {
57    const results = new Array(items.length);
58    let next = 0;
59    const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
60        while (next < items.length) {
61            const i = next++;
62            results[i] = await fn(items[i], i);
63        }
64    });
65    await Promise.all(workers);
66    return results;
67}

src/main.js

1import { Actor, log } from 'apify';
2import { parseApp, googleApp, googleSearch, googleReviews, appleApp, appleSearch, appleReviews } from './stores.js';
3
4await Actor.init();
5
6const input = (await Actor.getInput()) ?? {};
7const {
8    apps = [],
9    storeForNames = 'both',
10    countries = ['us'],
11    language = 'en',
12    maxReviewsPerApp = 500,
13    sort = 'newest',
14    minRating = 1,
15    maxRating = 5,
16    reviewsSince = '',
17    includeAppDetails = true,
18    includeUserDetails = false,
19    maxConcurrency = 3,
20} = input;
21
22const ccs = (Array.isArray(countries) ? countries : String(countries).split(',')).map((c) => c.trim().toLowerCase()).filter(Boolean);
23if (!ccs.length) ccs.push('us');
24const since = reviewsSince ? new Date(reviewsSince).getTime() : null;
25const max = maxReviewsPerApp > 0 ? maxReviewsPerApp : 100000;
26const isPpe = Actor.getChargingManager().getPricingInfo().isPayPerEvent;
27
28// ---------------------------------------------------------------- resolve apps
29const targets = []; // { store, id, input }
30for (const raw of apps) {
31    const a = parseApp(typeof raw === 'string' ? raw : raw?.url ?? '');
32    if (a.id) { targets.push({ ...a, input: raw }); continue; }
33    if (!a.name) continue;
34    const opts = { country: ccs[0], lang: language };
35    if (storeForNames !== 'apple') {
36        const gid = await googleSearch(a.name, opts).catch(() => null);
37        if (gid) targets.push({ store: 'google', id: gid, input: raw });
38        else log.warning(`"${a.name}": not found on Google Play`);
39    }
40    if (storeForNames !== 'google') {
41        const aid = await appleSearch(a.name, opts).catch(() => null);
42        if (aid) targets.push({ store: 'apple', id: aid, input: raw });
43        else log.warning(`"${a.name}": not found on the App Store`);
44    }
45}
46if (!targets.length) await Actor.fail('No apps to scrape. Add Google Play / App Store URLs, app IDs, or app names.');
47log.info(`Scraping ${targets.length} app(s) in ${ccs.length} country(ies): ${targets.map((t) => `${t.store}:${t.id}`).join(', ')}`);
48
49// ---------------------------------------------------------------- scrape
50let stop = false;
51let reviewsSaved = 0;
52const appsReport = [];
53
54async function processTarget(t, country) {
55    if (stop) return;
56    const opts = { country, lang: language };
57    const rep = { store: t.store, appId: t.id, country, input: t.input, reviews: 0 };
58    appsReport.push(rep);
59    let app = null;
60    try {
61        app = t.store === 'google' ? await googleApp(t.id, opts) : await appleApp(t.id, opts);
62        rep.title = app.title;
63        if (includeAppDetails) {
64            const res = await Actor.pushData({ type: 'app', ...app, scrapedAt: new Date().toISOString() }, 'app-details');
65            if (isPpe && res.eventChargeLimitReached) stop = true;
66        }
67    } catch (err) {
68        rep.error = err.message;
69        log.warning(`${t.store}:${t.id} (${country}): ${err.message}`);
70        return;
71    }
72
73    const gen = t.store === 'google'
74        ? googleReviews(t.id, { ...opts, sort, max: since ? Math.max(max, 100000) : max })
75        : appleReviews(t.id, { country, sort, max: since ? Math.max(max, 100000) : max });
76
77    let batch = [];
78    let count = 0;
79    const flush = async () => {
80        if (!batch.length) return;
81        const res = await Actor.pushData(batch, 'review');
82        const n = isPpe ? res.chargedCount : batch.length;
83        count += n;
84        reviewsSaved += n;
85        if (res.eventChargeLimitReached || (isPpe && n < batch.length)) {
86            stop = true;
87            log.warning('The maximum cost per run you set was reached. Stopping.');
88        }
89        batch = [];
90    };
91    try {
92        for await (const r of gen) {
93            if (stop || count + batch.length >= max) break;
94            const ts = r.date ? new Date(r.date).getTime() : null;
95            if (since && ts && ts < since) {
96                if (sort === 'newest') break; // newest-first: everything after is older
97                continue;
98            }
99            if (r.rating < minRating || r.rating > maxRating) continue;
100            const item = { type: 'review', appId: app.appId, appTitle: app.title, ...r, scrapedAt: new Date().toISOString() };
101            if (!includeUserDetails) { delete item.userName; delete item.userImage; }
102            batch.push(item);
103            if (batch.length >= 100) await flush();
104        }
105        await flush();
106    } catch (err) {
107        await flush();
108        rep.error = err.message;
109        log.warning(`${t.store}:${t.id} (${country}) reviews: ${err.message}`);
110    }
111    rep.reviews = count;
112    log.info(`${app.title} [${t.store}, ${country.toUpperCase()}]: ${count} reviews`);
113}
114
115const jobs = targets.flatMap((t) => ccs.map((c) => [t, c]));
116let next = 0;
117await Promise.all(Array.from({ length: Math.max(1, Math.min(maxConcurrency, 10)) }, async () => {
118    while (next < jobs.length && !stop) {
119        const [t, c] = jobs[next++];
120        await processTarget(t, c);
121    }
122}));
123
124await Actor.setValue('APPS_REPORT', appsReport);
125log.info(`Done. ${reviewsSaved} reviews from ${appsReport.filter((r) => !r.error).length} app/country combinations.`);
126await Actor.setStatusMessage(`${reviewsSaved} reviews saved`, { isStatusMessageTerminal: true });
127await Actor.exit();

src/stores.js

1import gplay from 'google-play-scraper';
2import { request, sleep } from './http.js';
3
4// ---------------------------------------------------------------- input parsing
5
6/** Returns { store, id } for store URLs/ids, or { name } for a plain app name. */
7export function parseApp(raw) {
8    const s = String(raw).trim();
9    let m;
10    if ((m = s.match(/play\.google\.com\/store\/apps\/details\?(?:.*&)?id=([\w.]+)/))) return { store: 'google', id: m[1] };
11    if ((m = s.match(/apps\.apple\.com\/.*\/id(\d+)/)) || (m = s.match(/itunes\.apple\.com\/.*\/id(\d+)/))) return { store: 'apple', id: m[1] };
12    if ((m = s.match(/^(?:id)?(\d{6,12})$/))) return { store: 'apple', id: m[1] };
13    if (/^[a-zA-Z][\w]*(\.[\w]+){1,}$/.test(s)) return { store: 'google', id: s }; // com.spotify.music
14    return { name: s };
15}
16
17// ---------------------------------------------------------------- Google Play
18
19export async function googleApp(id, { country, lang }) {
20    const a = await gplay.app({ appId: id, country, lang });
21    return {
22        store: 'google',
23        appId: a.appId,
24        title: a.title,
25        developer: a.developer,
26        developerEmail: a.developerEmail ?? null,
27        developerWebsite: a.developerWebsite ?? null,
28        rating: a.score ?? null,
29        ratingsCount: a.ratings ?? null,
30        reviewsCount: a.reviews ?? null,
31        histogram: a.histogram ?? null,
32        installs: a.installs ?? null,
33        minInstalls: a.minInstalls ?? null,
34        price: a.price ?? 0,
35        free: a.free ?? null,
36        currency: a.currency ?? null,
37        genre: a.genre ?? null,
38        contentRating: a.contentRating ?? null,
39        version: a.version ?? null,
40        released: a.released ?? null,
41        updatedAt: a.updated ? new Date(a.updated).toISOString() : null,
42        summary: a.summary ?? null,
43        description: a.description ?? null,
44        icon: a.icon ?? null,
45        url: a.url ?? `https://play.google.com/store/apps/details?id=${id}`,
46        country,
47    };
48}
49
50export async function googleSearch(term, { country, lang }) {
51    const r = await gplay.search({ term, num: 5, country, lang });
52    return r[0]?.appId ?? null;
53}
54
55const G_SORT = { newest: gplay.sort.NEWEST, relevant: gplay.sort.HELPFULNESS, rating: gplay.sort.RATING };
56
57/** Async generator of normalized Google Play reviews, newest pages first. */
58export async function* googleReviews(id, { country, lang, sort, max }) {
59    let token = null;
60    let got = 0;
61    for (let page = 0; page < 1000 && got < max; page++) {
62        let r;
63        for (let attempt = 0; attempt < 3; attempt++) {
64            try {
65                r = await gplay.reviews({ appId: id, country, lang, sort: G_SORT[sort] ?? gplay.sort.NEWEST, num: 150, paginate: true, nextPaginationToken: token });
66                break;
67            } catch (err) {
68                if (attempt === 2) throw err;
69                await sleep(2000 * (attempt + 1));
70            }
71        }
72        const data = r?.data ?? [];
73        for (const x of data) {
74            yield {
75                store: 'google',
76                reviewId: x.id,
77                rating: x.score,
78                title: x.title ?? null,
79                text: x.text ?? null,
80                date: x.date ? new Date(x.date).toISOString() : null,
81                appVersion: x.version ?? null,
82                thumbsUp: x.thumbsUp ?? 0,
83                replyText: x.replyText ?? null,
84                replyDate: x.replyDate ? new Date(x.replyDate).toISOString() : null,
85                userName: x.userName ?? null,
86                userImage: x.userImage ?? null,
87                url: x.url ?? null,
88                country,
89                language: lang,
90            };
91            if (++got >= max) return;
92        }
93        token = r?.nextPaginationToken;
94        if (!token || !data.length) return;
95    }
96}
97
98// ---------------------------------------------------------------- Apple App Store
99
100export async function appleApp(id, { country }) {
101    const d = await request(`https://itunes.apple.com/lookup?id=${id}&country=${country}&entity=software`);
102    const a = d.results?.[0];
103    if (!a) throw new Error(`App ${id} not found in the ${country.toUpperCase()} App Store`);
104    return {
105        store: 'apple',
106        appId: String(a.trackId),
107        bundleId: a.bundleId ?? null,
108        title: a.trackName,
109        developer: a.artistName ?? a.sellerName ?? null,
110        developerWebsite: a.sellerUrl ?? null,
111        rating: a.averageUserRating ?? null,
112        ratingsCount: a.userRatingCount ?? null,
113        ratingCurrentVersion: a.averageUserRatingForCurrentVersion ?? null,
114        price: a.price ?? 0,
115        free: a.price === 0,
116        currency: a.currency ?? null,
117        genre: a.primaryGenreName ?? null,
118        genres: a.genres ?? [],
119        contentRating: a.contentAdvisoryRating ?? null,
120        version: a.version ?? null,
121        released: a.releaseDate ?? null,
122        updatedAt: a.currentVersionReleaseDate ?? null,
123        releaseNotes: a.releaseNotes ?? null,
124        description: a.description ?? null,
125        sizeBytes: a.fileSizeBytes ? Number(a.fileSizeBytes) : null,
126        minimumOsVersion: a.minimumOsVersion ?? null,
127        languages: a.languageCodesISO2A ?? [],
128        icon: a.artworkUrl512 ?? a.artworkUrl100 ?? null,
129        url: a.trackViewUrl,
130        country,
131    };
132}
133
134export async function appleSearch(term, { country }) {
135    const d = await request(`https://itunes.apple.com/search?term=${encodeURIComponent(term)}&entity=software&country=${country}&limit=5`);
136    return d.results?.[0]?.trackId ? String(d.results[0].trackId) : null;
137}
138
139/**
140 * Apple's public review feed: up to 10 pages x 50 reviews per country and sort order. Pages are served from a
141 * cache that occasionally returns an empty page, so each page is retried with alternate URL forms.
142 */
143export async function* appleReviews(id, { country, sort, max }) {
144    const sortBy = sort === 'relevant' ? 'mostHelpful' : 'mostRecent';
145    const variants = (p) => [
146        `https://itunes.apple.com/${country}/rss/customerreviews/page=${p}/id=${id}/sortBy=${sortBy}/json`,
147        `https://itunes.apple.com/${country}/rss/customerreviews/page=${p}/id=${id}/sortby=${sortBy.toLowerCase()}/json`,
148        `https://itunes.apple.com/${country}/rss/customerreviews/id=${id}/page=${p}/sortby=${sortBy.toLowerCase()}/json`,
149    ];
150    let got = 0;
151    let emptyStreak = 0;
152    const seen = new Set();
153    for (let p = 1; p <= 10 && got < max; p++) {
154        let entries = [];
155        for (const url of variants(p)) {
156            try {
157                const d = await request(url, { retries: 1 });
158                const e = d?.feed?.entry;
159                entries = Array.isArray(e) ? e : e ? [e] : [];
160                if (entries.length) break;
161            } catch { /* try next variant */ }
162        }
163        entries = entries.filter((e) => e['im:rating']); // first entry on page 1 can be the app itself
164        if (!entries.length) {
165            if (++emptyStreak >= 2) return;
166            continue;
167        }
168        emptyStreak = 0;
169        for (const e of entries) {
170            const rid = e.id?.label;
171            if (seen.has(rid)) continue;
172            seen.add(rid);
173            yield {
174                store: 'apple',
175                reviewId: rid,
176                rating: Number(e['im:rating']?.label),
177                title: e.title?.label ?? null,
178                text: e.content?.label ?? null,
179                date: e.updated?.label ? new Date(e.updated.label).toISOString() : null,
180                appVersion: e['im:version']?.label ?? null,
181                thumbsUp: Number(e['im:voteSum']?.label ?? 0),
182                replyText: null,
183                replyDate: null,
184                userName: e.author?.name?.label ?? null,
185                userImage: null,
186                url: `https://apps.apple.com/${country}/app/id${id}?see-all=reviews`,
187                country,
188                language: null,
189            };
190            if (++got >= max) return;
191        }
192    }
193}

App Store & Google Play Review Scraper

renzomacar/app-store-scraper

Scrape Apple App Store and Google Play in one run — app reviews, ratings, metadata, top charts, and keyword rankings, in any country, with no API key. Pay-per-result alternative to Sensor Tower & data.ai for ASO research, review monitoring, and sentiment analysis. Both stores. No login.

Renzo Madueno

App Store & Google Play Reviews Scraper: Ratings & Reviews API

f0rty7even/app-reviews-scraper

Scrape and aggregate app reviews and ratings from both the Apple App Store and Google Play into one unified dataset. Filter by star rating. Great for ASO, market research, and review monitoring.

Michael Yousrie

App Store & Google Play Reviews Scraper

rel8ble/app-reviews-scraper

Scrape app reviews from the Apple App Store and Google Play in one run: star rating, title, full text, date, app version, reviewer, helpful votes and the developer reply, with app metadata on every row. Any country, sort, star filter and date cutoff. HTTP-only, fast and cheap.

Giovanni Rich

App Store and Play Store Review Intelligence

scrapemint/app-review-intelligence

Pulls every review for any iOS App Store or Google Play app: rating, title, body, reviewer, date, app version, country, and developer replies. Track release sentiment, flag regressions per version, and benchmark competitors.

Ken M

5.0

(2)

📱 Google Play Store Scraper — App Reviews & Details

inexhaustible_glass/google-play-scraper

Scrape any Android app's reviews + metadata from Google Play. No login or API key. Author, rating, text, thumbs-up, date, app version, developer reply + app info (rating, installs, developer, genre). Auto-paginates to thousands. For app devs, ASO/marketers, competitor & sentiment analysis.

Hitman studio

App Store & Google Play Reviews — Dual ASO Export

noahadler/app-store-google-play-reviews

Scrape Apple App Store and Google Play reviews in one Actor: rating, title, text, author, date and version. Unified JSON for ASO, sentiment and competitor monitoring. App id or store URL input — cheaper than separate scrapers.

Noah Adler

App Store & Google Play Reviews Scraper API - iOS & Android

vonsensey/app-store-google-play-reviews-scraper

Used by mobile product teams and ASO analysts tracking release sentiment. App reviews scraper for Apple App Store and Google Play in one run and one shape: rating, text, date, app version, developer reply, storefront, language. Deep history past the 500-review feed. Pay per review.

Blackcube

Competitor App Reviews Analysis Scraper - Compare Apps

vonsensey/competitor-app-reviews-analysis-scraper

Put several competing apps side by side: reviews from both stores for every app on your list in one dataset with identical columns, plus one profile row per app with average rating, star histogram, installs and current version. Filter to 1-3 stars to read what users leave a rival over.

Blackcube