# App Reviews Intelligence: App Store & Google Play (`kupilux/app-reviews-intelligence`) Actor

Scrape App Store and Google Play reviews into one dataset and get an AI insight report: sentiment, themes, bugs, feature requests, and competitor or peer comparison. Shareable HTML, Markdown, and JSON.

- **URL**: https://apify.com/kupilux/app-reviews-intelligence.md
- **Developed by:** [Kupilux](https://apify.com/kupilux) (community)
- **Categories:** AI, Developer tools
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.20 / 1,000 review saveds

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## App Reviews Intelligence

**App Reviews Intelligence** scrapes **App Store reviews** and **Google Play reviews** into one dataset and builds a ready-to-share **AI insight report**: sentiment, themes, bugs, feature requests, and **competitor analysis** or a neutral peer comparison (for example Duolingo vs Babbel).

Use it to see what users praise or complain about, compare apps, and watch ratings over time — without extra accounts or API keys. The AI report is included in the price.

### Use cases

- **Voice of the customer** — collect App Store and Google Play reviews for your app and see the main themes.
- **Competitor analysis** — put your app next to rivals, or compare two peers side by side.
- **Bug and request mining** — surface crashes, login issues, and the features people ask for most.
- **Sentiment and ratings** — track star mix, positive / neutral / negative split, and health-style scores.
- **Ongoing monitoring** — schedule **only new reviews** runs so you pay only for fresh feedback.

The input form is prefilled with a **Duolingo vs Babbel** peer comparison (both stores, a modest review cap) so you can start a sample run immediately. Replace those apps with yours.

***

### What you get

- **Both stores in one dataset** — the same fields for iOS and Android reviews.
- **AI insight reports** — themes, sentiment, bugs, feature requests, and suggested actions, with charts and statistics.
- **Comparison modes** — **your apps vs competitors**, or **peer** comparison (App A vs App B) with neutral labeling.
- **Shareable outputs** — the report as HTML (printable), Markdown, and JSON, plus the review dataset for spreadsheets and other tools.
- **Monitoring** — an **only new reviews** mode for scheduled runs, and memory across runs so trends get richer over time.

On **Google Play**, very large runs can hit store rate limits; in that case the run shows a warning and may return partial data. Using [Apify Proxy](https://docs.apify.com/platform/proxy) helps for heavy use.

***

### What the report contains

A typical AI insight report (`report.html`, `report.md`, and `report.json`) includes:

- **Summary** — how many reviews were saved, how many were already seen, and how many apps were analyzed.
- **Ratings and sentiment** — review count, average stars, and positive / neutral / negative split for each app and store.
- **Metrics** — a health score, 7-day and 30-day rating trends when earlier runs exist, the share of 1–2★ reviews, theme share, and on Google Play developer-reply coverage and timing when replies exist.
- **Comparison** — owner vs competitor, or peer: who leads on ratings and sentiment, shared complaints, and divergent themes (owner mode also notes capability gaps).
- **Insights** — prioritized themes (impact, suggested action, and sample quotes), feature requests, bugs and reliability issues, and recommended actions.

***

### What data can it extract?

Each **dataset item** is one review. Typical fields:

| Field | Description |
|--------|-------------|
| `store` | `apple` or `google` |
| `appId` | Store-specific id or package name |
| `appName` | Resolved app title |
| `country` | ISO country code |
| `rating` | Star rating (1–5) |
| `title` | Review title (common on Apple; often null on Play) |
| `text` | Review body |
| `date` | ISO 8601 timestamp |
| `version` | App version when available |
| `thumbsUp` | Helpful votes (Google Play) |
| `developerReply` | Developer response text |
| `replyDate` | Developer reply timestamp |
| `reviewUrl` | Public review or app URL |
| `reviewId` | Stable review identifier |
| `appRole` | `primary`, `competitor`, or `peer` |

Example row:

```json
{
  "store": "google",
  "appId": "com.duolingo",
  "appName": "Duolingo",
  "country": "us",
  "rating": 5,
  "title": null,
  "text": "Great daily practice.",
  "date": "2026-10-01T12:00:00.000Z",
  "version": "6.0.0",
  "thumbsUp": 12,
  "developerReply": null,
  "replyDate": null,
  "reviewUrl": "https://play.google.com/store/apps/details?id=com.duolingo",
  "reviewId": "gp-review-id"
}
```

***

### How to use it

1. Open the **Input** tab (or call the Actor via API or MCP with the same fields).
2. Set **`apps`** — App Store numeric IDs, Google Play package names, or store listing URLs (up to 10). For **peer comparison**, use **`compareApps`** with **two or more** ids (this overrides `apps` / `competitorApps`).
3. Choose **`stores`**: Apple only, Google only, or **both** (default). Set **`countries`**; **only the first country in the list is used per run**.
4. Set **`maxReviewsPerApp`** (default 80, max 2000).
5. Set a **date window**: **`dateFrom`** / **`dateTo`** (inclusive UTC calendar days, `YYYY-MM-DD`), or if both are empty use **`sinceDays`** (last *N* UTC days). If you set either boundary date, the absolute range wins over `sinceDays`.
6. Optional: add **`competitorApps`** (up to 5) for **owner vs competitor**, or use **`comparisonMode`** / **`compareApps`** for **peer** mode.
7. For recurring monitoring, turn on **`onlyNew`** and run the Actor on a schedule: reviews already collected are skipped.
8. Start the run.

***

### How much will it cost?

This Actor uses **pay-per-event (PPE)** pricing on Apify:

| Event | Price | Notes |
|--------|--------|--------|
| `review` | **$0.0002** each ($0.20 / 1k) | One charge per **unique review saved** to the dataset |
| `ai_report` | **$0.15** | Once per run, only when the **AI insight report** is generated |
| Actor start | **$0.00005** | Once per run |

No API keys or extra accounts needed: the AI report is included in the price.

Example: the prefilled Duolingo vs Babbel run (two apps, both stores, 80 reviews each) can collect up to 320 reviews — about **$0.064** plus **$0.15** if the AI report is on.

***

### Input (summary)

| Field | Role |
|--------|------|
| `apps` | Apps to scrape (App Store ids, Play packages, or URLs; max 10) |
| `stores` | `apple`, `google`, or `both` |
| `countries` | ISO codes (first country used per run) |
| `maxReviewsPerApp` | Cap per app per store (1–2000, default 80) |
| `sinceDays` | Relative filter: last *N* **UTC calendar days** (ignored if `dateFrom` or `dateTo` is set) |
| `dateFrom` / `dateTo` | Optional inclusive **UTC day** bounds (`YYYY-MM-DD`); either side can be omitted |
| `onlyNew` | Skip reviews already seen in earlier runs (for recurring monitors) |
| `compareApps` | **2+** app ids → **peer** mode (overrides `apps` / `competitorApps`) |
| `competitorApps` | Up to 5 competitors (with `apps` in **owner vs competitor** mode) |
| `comparisonMode` | Owner vs competitor (default) or **peer** |
| `includeAiReport` | Generate the AI insight report |
| `useMemory` | Remember stats across runs for trend metrics (default on) |
| `memoryStoreName` | Name of that memory (default `app-reviews-memory`) |

**Date filter order** (each review’s date is treated as a **UTC calendar day**):

1. If **either** `dateFrom` **or** `dateTo` is set → use that range (missing side is open; inclusive on UTC days).
2. Else if `sinceDays` is set → **relative** cutoff.
3. Else → **no** date filter.

If the dates are invalid, the run stops with a clear error message.

***

### Output

| Output | Description |
|--------|-------------|
| **Dataset** | One row per review (see above). |
| **Report** | `report.html`, `report.md`, and `report.json` in the run output, when the AI report is on. |
| **`memory-summary.json`** | Summary of trends across runs, when memory is on. |

***

### Tips

- **`onlyNew`:** on scheduled runs you pay only for new reviews; a run with nothing new adds no rows.
- **Memory:** keep the same `memoryStoreName` across runs so trends use more history.

***

### Use with AI agents (MCP)

You can run this Actor from Claude, Cursor, ChatGPT, and other assistants that support [Model Context Protocol](https://modelcontextprotocol.io/), through [Apify’s MCP server](https://docs.apify.com/mcp).

1. Add **`https://mcp.apify.com`** as an MCP server in your client. Sign in with Apify when asked (or authorize with your Apify token).
2. To load only this Actor, use **`https://mcp.apify.com?tools=kupilux/app-reviews-intelligence`**.
3. Ask the assistant to run **`kupilux/app-reviews-intelligence`**. With the default Apify tools, that is the **`call-actor`** tool and the Actor name `kupilux/app-reviews-intelligence`. If you pinned this Actor in the server URL, it also appears as a dedicated tool named like `kupilux--app-reviews-intelligence` (the same `username--actor-name` pattern as other pinned Actors).
4. After the run finishes, read the review dataset and the report files (`report.html`, `report.md`, `report.json`).

Minimal example input:

```json
{
  "apps": ["570060128", "com.duolingo"],
  "compareApps": ["570060128", "com.duolingo", "829587759", "com.babbel.mobile.android.en"],
  "stores": "both",
  "countries": ["us"],
  "maxReviewsPerApp": 80,
  "includeAiReport": true
}
```

Pricing is the same as a run started from the Store page.

***

### FAQ & disclaimer

**Is scraping app reviews allowed?** Reviews are **public** on store listings. You are responsible for compliance with **Apple and Google** terms, **privacy law**, and your use case. This is not legal advice.

**Where do I report issues?** Use the **Issues** tab on the Actor page.

# Actor input Schema

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

Apps to analyze (max 10). Each item can be an App Store numeric ID (for example 570060128), a Google Play package name (for example com.duolingo), or a full App Store or Google Play listing URL. For a side-by-side peer comparison of two or more apps, use Compare apps instead.

## `stores` (type: `string`):

Which stores to collect reviews from: apple (App Store), google (Google Play), or both. Default: both. Numeric App Store IDs are used only on Apple; Play package names are used only on Google Play.

## `countries` (type: `array`):

ISO 3166-1 alpha-2 country codes for the storefront (for example us, gb, de). Only the first country in the list is used per run.

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

Maximum number of reviews to collect for each app on each selected store (1–2000). Default: 80. Lower values finish faster and cost less.

## `sinceDays` (type: `integer`):

Keep only reviews from the last N UTC calendar days. Ignored when Date from or Date to is set.

## `dateFrom` (type: `string`):

Optional start of the review date range as a UTC calendar day (YYYY-MM-DD, inclusive). If this or Date to is set, that absolute range is used and Since (days) is ignored. Leave empty for no start bound.

## `dateTo` (type: `string`):

Optional end of the review date range as a UTC calendar day (YYYY-MM-DD, inclusive). If both bounds are set, Date from must be on or before Date to.

## `onlyNew` (type: `boolean`):

If enabled, skip reviews already collected in earlier runs. Turn this on for scheduled monitoring so you pay only for new reviews.

## `languages` (type: `array`):

Optional Google Play language filter using ISO 639-1 codes (for example en, es, de). Ignored for App Store reviews.

## `includeAiReport` (type: `boolean`):

If enabled (default), generate the AI insight report as HTML, Markdown, and JSON: themes, sentiment, comparisons, and recommended actions.

## `competitorApps` (type: `array`):

Up to 5 competitor apps (App Store IDs, Play package names, or listing URLs). Used with Apps for owner-versus-competitor mode. Ignored when Compare apps has two or more entries.

## `compareApps` (type: `array`):

Two or more apps for a neutral peer comparison (App A vs App B). Each item can be an App Store ID, Play package name, or listing URL. When this list has two or more entries, it replaces Apps and Competitor apps. The prefilled example compares Duolingo and Babbel on both stores.

## `comparisonMode` (type: `string`):

owner_vs_competitor compares your Apps against Competitor apps. peer uses neutral labels for a balanced comparison. Peer is also used automatically when Compare apps has two or more entries.

## `useMemory` (type: `boolean`):

If enabled (default), remember summary statistics across runs (not review text) so rating trends get richer on scheduled runs.

## `memoryStoreName` (type: `string`):

Name of the memory used across runs (max 63 characters). Default: app-reviews-memory. Reuse the same name on recurring schedules.

## `memoryKeyValueStoreId` (type: `string`):

Optional. Choose an existing memory store instead of creating one from the name above. Most users can leave this empty.

## Actor input object example

```json
{
  "apps": [
    "570060128",
    "com.duolingo"
  ],
  "stores": "both",
  "countries": [
    "us"
  ],
  "maxReviewsPerApp": 80,
  "onlyNew": false,
  "includeAiReport": true,
  "compareApps": [
    "570060128",
    "com.duolingo",
    "829587759",
    "com.babbel.mobile.android.en"
  ],
  "comparisonMode": "peer",
  "useMemory": true,
  "memoryStoreName": "app-reviews-memory"
}
```

# Actor output Schema

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

No description

## `reportJson` (type: `string`):

No description

## `reportMd` (type: `string`):

No description

## `reportHtml` (type: `string`):

No description

# 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": [
        "570060128",
        "com.duolingo"
    ],
    "countries": [
        "us"
    ],
    "compareApps": [
        "570060128",
        "com.duolingo",
        "829587759",
        "com.babbel.mobile.android.en"
    ],
    "comparisonMode": "peer"
};

// Run the Actor and wait for it to finish
const run = await client.actor("kupilux/app-reviews-intelligence").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": [
        "570060128",
        "com.duolingo",
    ],
    "countries": ["us"],
    "compareApps": [
        "570060128",
        "com.duolingo",
        "829587759",
        "com.babbel.mobile.android.en",
    ],
    "comparisonMode": "peer",
}

# Run the Actor and wait for it to finish
run = client.actor("kupilux/app-reviews-intelligence").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": [
    "570060128",
    "com.duolingo"
  ],
  "countries": [
    "us"
  ],
  "compareApps": [
    "570060128",
    "com.duolingo",
    "829587759",
    "com.babbel.mobile.android.en"
  ],
  "comparisonMode": "peer"
}' |
apify call kupilux/app-reviews-intelligence --silent --output-dataset

```

## MCP server setup

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

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/b0RjEEA9i6mxBH7Wg/builds/Z5nkSCQEH6FaAZPeD/openapi.json