# App Store & Google Play Reviews Scraper API (`byteblisk/app-reviews-insights`) Actor

Google Play and App Store reviews in one format, with insights per app (complaint themes with exact quotes, bugs by version, feature requests), side-by-side comparisons, and monitoring that charges only new reviews and alerts on rating drops. API and MCP for AI agents.

- **URL**: https://apify.com/byteblisk/app-reviews-insights.md
- **Developed by:** [byteblisk](https://apify.com/byteblisk) (community)
- **Categories:** AI
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

### Turn thousands of app reviews into the three things your team should fix next

Every Google Play and App Store review in one clean dataset, plus the complaints, bugs and feature requests behind
your rating, each backed by real quotes. **$0.10 per 1,000 reviews.** No login and no app ownership needed, so it
works on competitors too.

**Try it free:** switch on *Demo* to see the exact output before you spend a cent.

#### What you get

- **Every review, both stores, one format.** Rating, text, app version, developer reply, date and country, ready for
  Google Sheets, your BI tool or your pipeline.
- **The "why" behind your rating.** Complaint and praise themes with counts and word-for-word quotes, and bugs tied
  to the release that introduced them.
- **Your app against the competition.** Ratings, share of 1-2 star reviews, reply speed and top complaints, side by side.
- **An early warning.** Schedule it weekly: you pay only for new reviews, and get a Slack or webhook alert when the
  rating drops or complaints spike.
- **No surprises on the bill.** Apps that fail to load are free, and every result shows how many reviews were read
  and why reading stopped.

#### Built for

- **Product managers** checking what broke after a release
- **ASO specialists and app marketers** taking apart a competitor's reviews
- **Support leads** finding the 1-star reviews nobody answered
- **AI agents and developers**, through the API or the MCP server

### What data can App Reviews & Insights extract?

| Field | Row type | Description |
|---|---|---|
| `store` | all | `google_play` or `app_store` |
| `app_id` | all | Play package name or App Store numeric id |
| `name`, `developer` | app | App and developer name |
| `rating`, `ratings_count` | app | Store rating and number of ratings |
| `installs` | app | Install range (Google Play only) |
| `version`, `updated_at` | app | Current version and its release date |
| `coverage` | app | Reviews requested, read, kept, and why reading stopped |
| `rating` | review | Stars, 1 to 5 |
| `title`, `text` | review | Review title (App Store) and text |
| `author` | review | The display name the reviewer chose |
| `app_version` | review | App version the review was written on (Google Play) |
| `thumbs_up` | review | Helpful votes (Google Play) |
| `reply`, `reply_at` | review | The developer's reply and when it was posted |
| `updated_at` | review | When the review was written or last edited |
| `stats`, `themes` | insights | Rating spread, by version and country, reply rate; complaint, praise, bug and request themes |

### How to scrape app reviews from Google Play and the App Store

1. Click **Try for free** and open the **Input** tab.
2. In **Apps**, paste Google Play package names or URLs (`com.spotify.music`) and App Store URLs or ids
   (`https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580`). You can mix both stores.
3. Choose **What to get**: app details, reviews, insights, comparison or monitor.
4. Set the **countries**, the **max reviews per app and country**, and any filters (stars, keywords, dates, app
   versions, answered or unanswered).
5. Click **Start**, then open the **Output** tab or download the dataset.

Not sure about the format? Tick **Demo** and run it: you get sample output for free, with no requests made.

### How much does it cost to scrape app reviews?

The actor uses **pay-per-event** pricing: you pay for what it delivers, and the platform usage is included. The
prices of each event are on the **Pricing** tab.

| Event | When it's charged |
|---|---|
| App details record | Once per app and country read |
| App reviews batch | Per started 100 reviews returned |
| App insights report | Once per insights report that analysed review text |
| Apps comparison | Once per comparison of an app set |
| Monitor check | Once per app checked in monitor mode (plus its new reviews) |

**Insights and comparisons run on your own Anthropic key** (field *Your Anthropic API key*): Claude's cost, about $0.01 per app on Claude Haiku, goes to your Anthropic account, and the key is used for that run only. Reviews, details and monitoring need no key.

Failed apps, empty results and reviews dropped by your filters are not charged. You can set a **maximum cost per
run** in the run options; the actor stops cleanly at that limit and keeps what it already read.

#### Cost examples

| Job | Cost |
|---|---|
| 1,000 reviews of one app | $0.10 + $0.002 for the app record |
| Insights report on 400 reviews | about $0.07 (+ about $0.01 of Claude on your key) |
| Your app vs 2 competitors, compared | about $0.31 |
| 10 apps monitored weekly | about $0.80 a month + new reviews |
| An app that fails to load | free |

### Input

See the **Input** tab for every option. The ones that need a word of explanation:

- **What to get:** `details` (app records only), `reviews` (app record + reviews), `insights` (one report per app),
  `compare` (two to five apps side by side), `monitor` (only new reviews since the last run, plus alerts).
- **Countries:** each app is read in each country. Reviews differ by country, especially on the App Store.
- **Filters** are applied after reading, so the app row's `coverage` shows both what was read and what was kept.
- **Monitor** remembers the last run in a named key-value store in your account. Schedule the same task daily or
  weekly. **Alert webhook** takes a Slack incoming-webhook URL or any HTTPS endpoint.

### Output

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel. Each row has a `type`: `app`,
`review`, `insights`, `comparison`, `alert`, `error` or `notice`.

```json
[
  {"type": "app", "store": "google_play", "app_id": "com.example.notes", "name": "Example Notes",
   "rating": 4.3, "ratings_count": 18240, "installs": "1,000,000+", "version": "5.2.0",
   "coverage": {"requested": 200, "read": 200, "kept_after_filters": 200, "stopped_because": "max_reviews"}},
  {"type": "review", "store": "google_play", "app_id": "com.example.notes", "rating": 2, "app_version": "5.2.0",
   "text": "Sync stopped working after the last update.", "reply": null, "updated_at": "2026-11-07T10:12:00Z"},
  {"type": "insights", "store": "google_play", "app_id": "com.example.notes", "name": "Example Notes",
   "stats": {"reviews": 400, "average_rating": 3.9, "low_share": 0.21, "reply_rate": 0.34, "median_reply_hours": 26.5},
   "themes": {"summary": "Users like the editor; the 5.2.0 sync bug drives the low ratings.",
              "complaints": [{"theme": "sync failures", "count": 61,
                              "quotes": ["Sync stopped working after the last update."]}],
              "bugs": [{"issue": "sync fails", "count": 54, "versions": ["5.2.0"]}],
              "feature_requests": [{"theme": "dark mode for widgets", "count": 17}]}}
]
```

### Use it as an API or from an AI agent

- **API:** start runs and read results through the Apify API; see the **API** tab for ready-made code in Python,
  JavaScript and cURL.
- **MCP:** the actor also runs in Standby mode as an MCP server, with the tools `app_details`, `app_reviews`,
  `app_insights`, `compare_apps`, `monitor_apps` and `usage`. Each tool returns a compact result and states its cost,
  so an agent doesn't pull thousands of rows by accident.

### Tips

- Start with **Demo** to see the format, then with a small **Max reviews** (for example 50) for one app.
- For a release check, use **App versions** or **Only the last N days** instead of reading the full history.
- **Insights** reads the newest reviews of each app (up to about 400 per report), which keeps reports fast and
  focused on what users say now.

### FAQ

#### Which App Store reviews can it read?

Reviews come newest first, per country, from the same source the App Store website shows. App Store reviews carry no
app version or helpful-vote count; those two fields are Google Play only.

#### Why did an app return fewer reviews than I asked for?

The app row's `coverage.stopped_because` says why: the store had no more (`store_end`), your dates ended the read
(`date_range`), or the store slowed requests down (`rate_limited`). What was read up to that point is kept.

#### Is it legal to scrape app reviews?

Our Actors are ethical and do not extract any private user data, such as email addresses, gender, or location. They
only extract what the user has chosen to share publicly. We therefore believe that our Actors, when used for ethical
purposes by Apify users, are safe. However, you should be aware that your results could contain personal data.
Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should
not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is
legitimate, consult your lawyers.

#### Something isn't working. Where do I report it?

Open the **Issues** tab and describe the app, the input and what you expected. We read every issue.

### byteblisk actors

Built and supported by **byteblisk**. Same record conventions, API style and MCP design across all three, so an AI
agent can use them together:

- 📄 **[SiteReader](https://apify.com/byteblisk/sitereader)**: any website to clean Markdown or JSON for AI, with AI fields, site maps and watches.
- ⭐ **[App Reviews & Insights](https://apify.com/byteblisk/app-reviews-insights)**: Google Play and App Store reviews in one format, with AI insights and alerts.
- 🔎 **[Google Play & Search Toolkit](https://apify.com/byteblisk/google-play-search-toolkit)**: Play apps, reviews and search, top-100 search rank, and exports to
  your warehouse, in one actor.

Something missing or broken? Open an issue in the **Issues** tab: we answer every one.

# Actor input Schema

## `mode` (type: `string`):

Monitor remembers the last run: schedule it daily or weekly and it returns only new reviews.

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

Google Play package names or URLs, and App Store URLs or numeric ids. Mix both stores freely.

## `store` (type: `string`):

Detect picks the App Store for apps.apple.com URLs and numeric ids, Google Play for everything else.

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

Two-letter store countries; each app is read in each country.

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

Two-letter language for Google Play pages and reviews.

## `maxReviews` (type: `integer`):

Reviews are read newest first; reading stops here for each app and country.

## `anthropicApiKey` (type: `string`):

Insights and comparisons are written by Claude on your own Anthropic account (console.anthropic.com), about $0.01 per app on Claude Haiku. Used for this run only, never stored. Reviews, details and monitoring don't need it.

## `minRating` (type: `integer`):

Keep reviews with at least this many stars.

## `maxRating` (type: `integer`):

Keep reviews with at most this many stars.

## `keywords` (type: `array`):

Keep reviews containing any of these.

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

Keep reviews written on or after this day.

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

Keep reviews written on or before this day.

## `versions` (type: `array`):

Keep reviews written on these app versions.

## `hasReply` (type: `boolean`):

Checked: only answered reviews. Unchecked: only unanswered. Leave empty for all.

## `recentDays` (type: `integer`):

Keep reviews written in the last N days.

## `webhookUrl` (type: `string`):

Slack incoming-webhook URL or any HTTPS endpoint; gets new-version, rating-drop and complaint-spike alerts.

## `ratingDrop` (type: `number`):

Alert when the store rating falls by this much since the last run.

## `spikeRatio` (type: `number`):

Alert when the 1-2 star share of new reviews is this many times the usual share (and at least 30%).

## `minNewReviews` (type: `integer`):

A complaint spike needs at least this many new reviews.

## `demo` (type: `boolean`):

Returns sample output so you can see the format. No requests, no charge.

## Actor input object example

```json
{
  "mode": "reviews",
  "apps": [
    "com.spotify.music",
    "https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580"
  ],
  "store": "auto",
  "countries": [
    "us"
  ],
  "language": "en",
  "maxReviews": 200,
  "ratingDrop": 0.1,
  "spikeRatio": 2,
  "minNewReviews": 10,
  "demo": false
}
```

# Actor output Schema

## `results` (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": [
        "com.spotify.music",
        "https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("byteblisk/app-reviews-insights").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": [
        "com.spotify.music",
        "https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("byteblisk/app-reviews-insights").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": [
    "com.spotify.music",
    "https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580"
  ]
}' |
apify call byteblisk/app-reviews-insights --silent --output-dataset

```

## MCP server setup

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

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/htK6wd36ep8pODV8j/builds/QRrXujmK7oNiBtw7p/openapi.json