# App Store & Google Play Reviews Scraper + Insights Report (`berkaydev/app-review-insights-scraper`) Actor

Scrape Google Play AND Apple App Store reviews, then get a built-in insights report — rating trends by version, complaint/praise keywords, feature-request signals, suspicious spike detection, and cross-app comparison. No API key needed. Pure HTTP, free-plan compatible. Pay per review scraped.

- **URL**: https://apify.com/berkaydev/app-review-insights-scraper.md
- **Developed by:** [Gezgin Data](https://apify.com/berkaydev) (community)
- **Categories:** Developer tools, AI
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.30 / 1,000 review scrapeds

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

**The only Google Play review scraper and Apple App Store review scraper that also delivers a built-in insights report** — no extra cost, no LLM, no API key required. Runs on the free Apify plan.

Competitors return raw review rows. This actor gives you raw reviews **plus** analytics: rating trends by app version, top complaint/praise keywords, feature-request signals, suspicious spike detection, and cross-app comparison.

### App review insights report: complaint analysis, version trends, and cross-app comparison

The built-in insights report turns raw reviews into answers: a complaint and praise keyword analysis, rating trends by app version, feature-request signals, suspicious-spike detection, and a side-by-side cross-app comparison when you scrape more than one app.

### What it does

1. **Scrapes reviews** from Google Play and/or the Apple App Store (pure HTTP — no browser, free-plan compatible).
2. **Normalises** both sources into a unified schema (same fields for both stores).
3. **Computes insights** (pure Python analytics):
   - Rating distribution (1–5 stars)
   - Rating trend by month
   - **Rating by app version** — the killer developer insight: which release tanked or improved the score
   - Top complaint keywords from 1–2★ reviews
   - Top praise keywords from 4–5★ reviews
   - Feature-request signal detection ("please add", "wish", "would be great", "fehlt", etc.)
   - Suspicious spike months (possible fake/incentivised burst of reviews)
   - Cross-app comparison table (when scraping multiple apps)
4. **Writes** the insights as JSON (`INSIGHTS` KVS key) and as a clean HTML report (`REPORT` KVS key).

### Use cases

- **ASO (App Store Optimisation)**: understand what users love and hate to improve your store listing.
- **Competitive analysis**: compare your app's sentiment against competitors across both stores.
- **Release quality monitoring**: see exactly which version caused a rating drop.
- **Feature roadmap**: surface the most-requested features from user reviews.
- **Review moderation / support**: identify complaint clusters to address in the next release.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `googlePlayAppIds` | string\[] | `["com.whatsapp"]` | Package names or Play Store URLs |
| `appleAppIds` | string\[] | `[]` | Numeric Apple IDs or App Store URLs |
| `country` | string | `"us"` | Store country code (ISO 3166-1 alpha-2) |
| `language` | string | `"en"` | Language code (ISO 639-1) |
| `maxReviewsPerApp` | integer | `200` | Max reviews per app (Apple caps at ~500 via RSS) |
| `generateInsights` | boolean | `true` | Generate the insights report |
| `maxRunTimeSecs` | integer | `3000` | Internal run deadline |

At least one of `googlePlayAppIds` or `appleAppIds` must be non-empty.

#### Example input (JSON)

```json
{
  "googlePlayAppIds": ["com.whatsapp", "com.spotify.music"],
  "appleAppIds": ["310633997"],
  "country": "us",
  "language": "en",
  "maxReviewsPerApp": 200,
  "generateInsights": true
}
```

### Output

#### Dataset — unified review records

Each record has the same fields regardless of the source store:

```json
{
  "source": "googlePlay",
  "appId": "com.whatsapp",
  "appName": "WhatsApp Messenger",
  "reviewId": "gp:AbcDef123...",
  "userName": "JohnDoe",
  "rating": 5,
  "title": null,
  "text": "Works perfectly, love the encryption.",
  "appVersion": "2.24.10.73",
  "thumbsUp": 12,
  "date": "2024-05-03T14:22:00+00:00",
  "replyContent": null,
  "replyDate": null,
  "country": "us",
  "language": "en"
}
```

> **Note:** `title` is null for Google Play (no review titles). `thumbsUp` is null for Apple App Store. `replyContent`/`replyDate` are null for Apple (not available in the public RSS feed).

#### KVS: INSIGHTS (JSON)

```json
{
  "apps": {
    "googlePlay:com.whatsapp": {
      "appName": "WhatsApp Messenger",
      "averageRating": 4.21,
      "storeAverageRating": 4.4,
      "storeRatingCount": 185000000,
      "ratingDistribution": { "5": {"count": 31, "pct": 62.0}, ... },
      "ratingByVersion": {
        "2.24.10.73": {"reviewCount": 18, "avgRating": 4.50},
        "2.24.9.81":  {"reviewCount": 12, "avgRating": 3.25}
      },
      "topComplaintTerms": [{"term": "crashes", "count": 8}, ...],
      "topPraiseTerms": [{"term": "easy use", "count": 14}, ...],
      "featureRequestSignals": {"count": 6, "snippets": ["please add voice messages..."]},
      "suspiciousSpikeMonths": [],
      ...
    }
  },
  "comparison": [
    {"appName": "WhatsApp Messenger", "store": "googlePlay", "averageRating": 4.21, ...}
  ]
}
```

#### KVS: REPORT (HTML)

A standalone HTML page with colour-coded rating cards, star distribution bars, version rating table, keyword pills, feature request snippets, trend table, and comparison table. Open directly in a browser or embed in a dashboard.

### Google Play field mapping

| google-play-scraper field | Actor field |
|---|---|
| `title` (app metadata) | `appName` |
| `score` (app metadata) | `storeAverageRating` |
| `ratings` | `storeRatingCount` |
| `version` | `currentVersion` (metadata) |
| `reviewId` | `reviewId` |
| `userName` | `userName` |
| `content` | `text` |
| `score` (review) | `rating` |
| `thumbsUpCount` | `thumbsUp` |
| `reviewCreatedVersion` | `appVersion` |
| `at` (datetime) | `date` (ISO 8601) |
| `replyContent` | `replyContent` |
| `repliedAt` | `replyDate` (ISO 8601) |

### Apple App Store field mapping

| iTunes endpoint / field | Actor field |
|---|---|
| Lookup `trackName` | `appName` |
| Lookup `averageUserRating` | `storeAverageRating` |
| Lookup `userRatingCount` | `storeRatingCount` |
| Lookup `version` | `currentVersion` (metadata) |
| RSS `id.label` | `reviewId` |
| RSS `author.name.label` | `userName` |
| RSS `title.label` | `title` |
| RSS `content.label` | `text` |
| RSS `im:rating.label` | `rating` |
| RSS `im:version.label` | `appVersion` |
| RSS `updated.label` | `date` |
| n/a | `thumbsUp` = null |
| n/a | `replyContent` = null |

### Pricing

Pay per review scraped (**$0.0003/review = $0.30 per 1,000**), no per-run start fee. The insights report is always included free. Cheaper than most App Store review scrapers — and the only one that also returns a built-in analysis report.
A run with 200 Google Play reviews + 200 Apple reviews = $0.12 total.

### Limitations

- Apple App Store RSS caps at ~500 reviews per app (10 pages × 50).
- Apple RSS does not provide developer replies or thumbs-up counts.
- Reviews are fetched in "most recent" order; historical bulk export is not supported by the public endpoints.
- Language/country filter on Apple applies to the store region; Apple RSS returns mixed languages.

### Technical notes

- Pure HTTP — no browser, no Playwright. Runs on Apify free plan (512 MB memory is sufficient).
- `google-play-scraper` PyPI package handles Google Play pagination and anti-bot headers.
- Apple App Store uses the public iTunes RSS feed + lookup API (no authentication).
- Insights computed in pure Python (no LLM, no paid API).

***

### More data tools by Gezgin Data

- [Google Maps Email Scraper — Business Leads](https://apify.com/berkaydev/google-maps-email-scraper-business-leads)
- [G2 Reviews Scraper + Insights Report](https://apify.com/berkaydev/g2-reviews-insights-scraper)
- [Trustpilot Reviews Scraper + Insights Report](https://apify.com/berkaydev/trustpilot-insights-scraper)
- [SEO & Technical Site Audit](https://apify.com/berkaydev/seo-audit-tool)

# Actor input Schema

## `googlePlayAppIds` (type: `array`):

Package names or full Google Play URLs to scrape. Examples: 'com.whatsapp', 'https://play.google.com/store/apps/details?id=com.spotify.music'. One per line.

## `appleAppIds` (type: `array`):

Numeric Apple app IDs or full App Store URLs to scrape. Examples: '310633997', 'https://apps.apple.com/us/app/whatsapp-messenger/id310633997'. One per line.

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

Two-letter ISO 3166-1 alpha-2 country code for the store region (e.g. 'us', 'de', 'gb').

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

Two-letter ISO 639-1 language code for the review language (e.g. 'en', 'de'). Used for Google Play; Apple RSS returns mixed languages.

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

Maximum number of reviews to scrape per app. Google Play supports up to several thousand; Apple App Store RSS caps at ~500 (10 pages x 50).

## `generateInsights` (type: `boolean`):

Compute an analytics/insights report after scraping: rating trends by version, top complaint/praise keywords, feature-request signals, suspicious spikes, and cross-app comparison. Written to key-value store as JSON (INSIGHTS) and HTML (REPORT).

## `maxRunTimeSecs` (type: `integer`):

Internal run deadline. The actor will flush collected data and exit cleanly before this limit.

## Actor input object example

```json
{
  "googlePlayAppIds": [
    "com.whatsapp"
  ],
  "appleAppIds": [],
  "country": "us",
  "language": "en",
  "maxReviewsPerApp": 50,
  "generateInsights": true,
  "maxRunTimeSecs": 3000
}
```

# Actor output Schema

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

One row per app review from Google Play and the iOS App Store: rating, title, text, author, version, and date.

## `report` (type: `string`):

Ready-to-read report: rating trends, complaint and praise keywords, version sentiment, and suspicious spike detection.

## `insights` (type: `string`):

The full analytics object behind the report, machine-readable for your own pipelines.

# 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 = {
    "googlePlayAppIds": [
        "com.whatsapp"
    ],
    "country": "us",
    "language": "en",
    "maxReviewsPerApp": 50,
    "generateInsights": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("berkaydev/app-review-insights-scraper").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 = {
    "googlePlayAppIds": ["com.whatsapp"],
    "country": "us",
    "language": "en",
    "maxReviewsPerApp": 50,
    "generateInsights": True,
}

# Run the Actor and wait for it to finish
run = client.actor("berkaydev/app-review-insights-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "googlePlayAppIds": [
    "com.whatsapp"
  ],
  "country": "us",
  "language": "en",
  "maxReviewsPerApp": 50,
  "generateInsights": true
}' |
apify call berkaydev/app-review-insights-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=berkaydev/app-review-insights-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/ZcNpt2BPulHvsuQPm/builds/gmzsNlThegZzkLBJ1/openapi.json