# App Reviews Scraper — App Store & Google Play (`fabrikit/app-reviews-unified`) Actor

Scrape App Store and Google Play reviews in one run and one schema: rating, text, version, helpful votes and developer replies. US$0.50 per 1,000 reviews.

- **URL**: https://apify.com/fabrikit/app-reviews-unified.md
- **Developed by:** [Fabrikit](https://apify.com/fabrikit) (community)
- **Categories:** SEO tools, Automation, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 review results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## App Reviews Scraper — App Store & Google Play

Scrape **Google Play reviews and Apple App Store reviews in one run and one schema** — no more buying two scrapers and writing merge code for two different formats. Pass app IDs (or just an app name) and get back reviews from both stores normalized into the exact same fields: rating, title, text, author, date, app version, helpful votes and developer reply. Export to CSV, Excel, JSON or Google Sheets.

What you get from a single run:

- **iOS and Android reviews in identical rows** — pipe them straight into one spreadsheet, dashboard, sentiment model or LLM prompt with zero per-store branching.
- **The reviews that matter**: sort by `recent` to track what users say right now, or by `helpful` to surface the complaints other users vote to the top — including the **developer's reply** on Google Play.
- **Any country's storefront** (`us`, `gb`, `de`, `br`, `jp`, ...) — the same app reads completely differently per country, and this Actor lets you compare.

Example output item (Google Play):

```json
{
    "store": "google-play",
    "appId": "com.spotify.music",
    "appName": "Spotify: Music and Podcasts",
    "reviewId": "797cdc88-4cbc-46c2-b1de-5cf296de478b",
    "rating": 2,
    "title": null,
    "text": "Too many ads on the free tier lately, and shuffle keeps repeating songs.",
    "author": "Jane D",
    "date": "2026-08-19T23:43:02.874Z",
    "version": "9.0.62.500",
    "helpfulCount": 41,
    "replyText": "Thanks for the feedback! Please reach out at ...",
    "replyDate": "2026-08-20T09:11:00.000Z",
    "country": "us",
    "language": "en",
    "url": "https://play.google.com/store/apps/details?id=com.spotify.music&reviewId=...",
    "scrapedAt": "2026-08-20T23:46:09.316Z"
}
```

### How to scrape Google Play reviews (and App Store reviews) in one run

1. Add one entry per app to **apps**. Four formats work:
   - `android:<packageId>` — Google Play only (the `id=` in the Play URL, e.g. `android:com.whatsapp`).
   - `ios:<trackId>` — App Store only (the number in the App Store URL, e.g. `ios:310633997`).
   - `ios:<bundleId>` — App Store only, resolved automatically (e.g. `ios:net.whatsapp.WhatsApp`).
   - A bare name (e.g. `spotify`) — searched on **both** stores; the top match on each is used.
2. Pick a **country** storefront and press **Start**. Reviews land in the dataset within seconds, ready to download as CSV, Excel or JSON, or to sync to Google Sheets, webhooks, Zapier or Make.

#### Example input

```json
{
    "apps": [
        "android:com.whatsapp",
        "ios:310633997",
        "spotify"
    ],
    "country": "us",
    "language": "en",
    "maxReviewsPerApp": 50,
    "sort": "recent"
}
```

- **apps** *(required)* — one entry per app, in any of the four formats above.
- **country** — two-letter storefront code. Reviews are storefront-specific. Default `us`.
- **language** — two-letter language code for Google Play (Apple's feed is per-country only). Default `en`.
- **maxReviewsPerApp** — cap **per app per store**, `0` = unlimited. Apple's public feed serves at most **500 reviews per country**; Google Play has no such cap.
- **sort** — `recent` (newest first) or `helpful` (most helpful first).

#### Example: monitor a competitor weekly

```json
{
    "apps": ["android:com.competitor.app", "ios:123456789"],
    "country": "us",
    "maxReviewsPerApp": 200,
    "sort": "recent"
}
```

Schedule it weekly in Apify Console and connect the dataset to Google Sheets — a rolling review feed from both stores with zero code.

### App Store reviews API — without an API key

Apple's official App Store Connect API requires you to *own* the app. This Actor instead reads Apple's **public customer-reviews feed**, which works for **any app on the store** — competitors included — with no API key, no login and no App Store Connect account. Google Play reviews are fetched over plain HTTP with token-based pagination (tested into the thousands of reviews). No browser, no proxies: runs are fast, cheap and reliable.

### Export app reviews to CSV, Excel or Google Sheets

Every Apify dataset exports to CSV, Excel, JSON, XML or HTML with one click, or syncs to Google Sheets automatically. Because both stores share one schema here, the export is a single flat table — no post-processing needed before it lands in your BI tool, sentiment pipeline or LLM.

### Output fields

Every item has the same fields, regardless of the store:

| Field | Type | Description |
|---|---|---|
| `store` | string | `app-store` or `google-play` |
| `appId` | string | App Store track ID / Google Play package ID |
| `appName` | string | App display name |
| `reviewId` | string | Unique review ID in the source store |
| `rating` | number | 1–5 stars |
| `title` | string | null | Review title (App Store; Google Play reviews rarely have one) |
| `text` | string | null | Review body |
| `author` | string | null | Reviewer's display name |
| `date` | string | null | ISO 8601 review date |
| `version` | string | null | App version the review was written for |
| `helpfulCount` | number | null | Helpful votes (App Store vote sum / Google Play thumbs up) |
| `replyText` | string | null | Developer reply (Google Play; Apple's feed doesn't expose replies) |
| `replyDate` | string | null | ISO 8601 date of the developer reply |
| `country` | string | Storefront country the review came from |
| `language` | string | null | Requested language (Google Play) |
| `url` | string | null | Direct link to the review (Google Play) |
| `scrapedAt` | string | ISO 8601 timestamp of this run |

A per-app run summary (reviews found per store, errors) is stored in the run's key-value store under `SUMMARY`.

### What can you do with app reviews data?

- **ASO (App Store Optimization):** mine review text for the keywords real users use, spot the complaints that drag your rating down, and watch how each release's `version` field scores.
- **Competitor analysis:** pull a competitor's reviews from both stores in one run — where their users are unhappy is your roadmap.
- **Sentiment analysis:** feed the unified `text` + `rating` straight into an LLM or sentiment model — one schema, one prompt.
- **Product management:** track incoming reviews after each release (`sort: recent`) or triage the top pain points (`sort: helpful`).
- **Market research per country:** run one input per storefront and compare `us`, `br` and `jp`.

### Pricing — US$0.50 per 1,000 reviews

This Actor uses Apify's **pay-per-event** model and charges **per review delivered** (event `review-result`, **US$0.0005 per review = US$0.50 per 1,000 reviews**) on top of standard Apify platform usage. No subscription, no rental fee, no proxy costs. Scraping 10,000 Google Play reviews costs US$5 in events. You only pay for reviews actually pushed to your dataset.

### FAQ

**How do I scrape Google Play reviews?**
Paste the app's package ID (the `id=` in its Play URL, e.g. `com.whatsapp`) as `android:com.whatsapp`, choose a country and press Start. Google Play pagination is token-based and effectively unlimited — this Actor has been tested pulling thousands of reviews per app.

**How many App Store reviews can I get?**
Apple's public feed is capped at **500 reviews per country per sort order** — a limit of Apple's API, not of this Actor. Running the same app across several `country` storefronts multiplies iOS coverage.

**Do I need an API key or App Store Connect account?**
No. Apple's public reviews feed and Google Play both work without any key or login — that's what lets you scrape *competitors'* reviews, not just your own app's.

**Is it legal to scrape app reviews?**
The Actor only reads reviews that both stores publish publicly, through Apple's official public feed and Google Play's public pages. Standard practice for ASO and market-research tooling; how you use the data is up to your own compliance requirements.

**Can I export app reviews to CSV or Excel?**
Yes — one click in Apify Console, or automatically via the Google Sheets integration, webhooks, Zapier, Make or the Apify API.

**Does it get developer replies?**
Yes for Google Play (`replyText`, `replyDate`). Apple's public feed does not include developer replies, so those fields are `null` for App Store reviews.

**What's a track ID / package ID?**
Google Play: the `id=` parameter in the Play URL (`play.google.com/store/apps/details?id=com.whatsapp` → `com.whatsapp`). App Store: the number at the end of the app's URL (`apps.apple.com/us/app/whatsapp-messenger/id310633997` → `310633997`). Or skip the lookup entirely and pass the app's name.

**Why is a review missing that I can see in the store?**
Both stores serve a per-country selection. Make sure `country` matches the storefront you're looking at, and remember Apple only exposes the latest 500 per country.

**Does it use proxies or a browser?**
No. Apple's feed is an official public API; Google Play is plain HTTP. That keeps runs fast, cheap and reliable.

### More scrapers by Fabrikit

- **[ATS Jobs Scraper — Greenhouse, Lever, Ashby & SmartRecruiters](https://apify.com/fabrikit/ats-jobs-api)** — scrape job postings from any company on the four biggest ATS platforms into one normalized feed, with ATS auto-detection and a built-in remote filter.

### Technical details

- App Store: Apple's public customer-reviews feed (`itunes.apple.com/<country>/rss/customerreviews/...`), 10 pages × 50 reviews per country; bundle IDs and search terms resolved via the iTunes Lookup/Search API.
- Google Play: plain-HTTP scraping with token-based pagination (no browser, no proxies).
- Bare search terms are resolved to the top match on each store independently.
- Items are unique per `store:appId:reviewId` within a run.
- A per-app run summary is stored in the key-value store under `SUMMARY`.

# Actor input Schema

## `apps` (type: `array`):

One entry per app. Either `android:<packageId>` (e.g. `android:com.whatsapp`), `ios:<trackId>` (the number in the App Store URL, e.g. `ios:310633997`), `ios:<bundleId>` (e.g. `ios:net.whatsapp.WhatsApp`), or a bare search term (e.g. `spotify`) — a bare term is resolved to the top match on BOTH stores.

## `country` (type: `string`):

Two-letter store country code (e.g. `us`, `gb`, `de`, `br`, `jp`). Reviews are store-front specific: the same app has different reviews per country.

## `language` (type: `string`):

Two-letter language code for Google Play (e.g. `en`, `es`, `de`). The App Store feed is selected by country only, so this field affects Google Play results.

## `maxReviewsPerApp` (type: `integer`):

Stop after this many reviews per app per store. 0 = no limit. Note: Apple's public feed is capped at 500 reviews per country regardless of this setting; Google Play has no such cap.

## `sort` (type: `string`):

`recent` = newest first. `helpful` = most helpful first (Apple: most helpful votes; Google Play: helpfulness ranking).

## Actor input object example

```json
{
  "apps": [
    "android:com.whatsapp",
    "ios:310633997"
  ],
  "country": "us",
  "language": "en",
  "maxReviewsPerApp": 50,
  "sort": "recent"
}
```

# Actor output Schema

## `reviews` (type: `string`):

All normalized reviews collected during the run

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "apps": [
        "android:com.whatsapp",
        "ios:310633997"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fabrikit/app-reviews-unified").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "apps": [
        "android:com.whatsapp",
        "ios:310633997",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("fabrikit/app-reviews-unified").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "apps": [
    "android:com.whatsapp",
    "ios:310633997"
  ]
}' |
apify call fabrikit/app-reviews-unified --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,fabrikit/app-reviews-unified"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/2Z2zcqTyClfyb44wh/builds/Veq61fsyAPUK6Axpd/openapi.json