# App Store & Google Play Reviews Scraper & Monitor (`quillstone-labs/app-store-google-play-reviews-scraper`) Actor

Scrape and monitor App Store and Google Play reviews by app link or name, in one run. Filter by stars, date or keyword, get new reviews on a schedule, complaint topics (crashes, ads, pricing, login), rating trends by week and version, and an Excel report.

- **URL**: https://apify.com/quillstone-labs/app-store-google-play-reviews-scraper.md
- **Developed by:** [Quillstone Labs](https://apify.com/quillstone-labs) (community)
- **Categories:** Developer tools, E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.30 / 1,000 reviews

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Store & Google Play Reviews Scraper

Scrape App Store reviews and Google Play reviews in one run, for iOS and Android apps. Paste in app links, store IDs or just app names, and get every review as a row: stars, title, text, date, version, helpful votes and the developer's reply. Each app also gets a one-line summary with its store rating, how the collected reviews split by stars, and the words that come up most in 1- and 2-star reviews.

Run it once to research an app, or put it on a schedule and it'll only send you reviews you haven't seen yet. You don't need a developer account, an API key or a login.

### What you get

| | |
|---|---|
| Both stores at once | Type "Duolingo" and get its App Store and Google Play reviews side by side |
| Any country | Each country's store has its own reviews. Ask for `us`, `gb`, `de`, or as many as you like |
| Filters | Only 1-2 star reviews, only reviews since a date, or only ones mentioning words like "crash" or "refund" |
| Watch mode | Each run returns only new reviews, so a daily schedule becomes a review feed |
| App summaries | Store rating and its star split, % negative, developer reply rate, top complaint words |
| Trends | Average rating and share of 1-2 star reviews by week and by app version, so you can see whether an update made things better or worse |
| Excel report | Apps, Trends and Reviews sheets, colour-coded by stars, ready to filter |
| Complaint topics | Each review tagged with what it's about (crashes and bugs, ads, price and subscription, login, support, after an update and more), and each app's share of 1-2 star reviews per topic: *crashes & bugs 17%, price & subscription 17%* |
| Summaries only | Switch it on to get one line per app instead of every review: the quick answer to "what do users think of this app?" for dashboards and automated tools |

### Example inputs

What users think of an app, one line per store:

```json
{ "apps": ["Spotify"], "maxReviewsPerApp": 300, "summaryOnly": true }
```

Recent complaints about a specific app, in the US and UK:

```json
{ "apps": ["https://apps.apple.com/us/app/notion-notes-tasks-ai/id1232780281"], "ratings": ["1", "2"], "countries": ["us", "gb"], "maxReviewsPerApp": 200 }
```

1- and 2-star reviews from the last 30 days, with what they complain about:

```json
{ "apps": ["com.duolingo"], "ratings": ["1", "2"], "sinceDate": "30 days", "maxReviewsPerApp": 500 }
```

Reviews that mention crashes or refunds, Google Play only:

```json
{ "apps": ["com.duolingo"], "keywords": ["crash", "refund"], "maxReviewsPerApp": 500 }
```

New reviews since the last run (put it on a daily schedule):

```json
{ "mode": "watch", "apps": ["Spotify", "com.spotify.music"], "watchName": "spotify" }
```

Each app summary includes an `explanation`, one plain sentence like *Duolingo: Learn Languages on Google Play (US): rated 4.75 from 51,197,568 ratings. Of 200 reviews read, averaging 1.32 stars, 100% are 1-2 stars, mostly mentioning language, learning, streak, lessons; the most common complaints are crashes & bugs (17%), price & subscription (17%), after an update (7%).*

Calls written for other review Actors also work: `appIds`, `appUrls`, `startUrls` and `urls` are read as well as `apps`.

### Ready-made examples

Open one, type your app's name, and click **Start**:

- [App Store & Google Play complaints (1–2 stars)](https://apify.com/quillstone-labs/app-store-google-play-reviews-scraper/examples/app-complaints-1-2-star): the latest negative reviews and what they're about
- [App rating summary and trends](https://apify.com/quillstone-labs/app-store-google-play-reviews-scraper/examples/app-rating-summary): one line per store, with the rating split and top complaints
- [Monitor new app reviews](https://apify.com/quillstone-labs/app-store-google-play-reviews-scraper/examples/new-app-reviews-monitor): put it on a schedule and get only reviews you haven't seen

### Who uses it

- **App developers and product teams** reading what users complain about after each release.
- **App-marketing (ASO) agencies** tracking ratings and reviews for clients and their competitors.
- **Support teams** finding reviews that need a reply.
- **Researchers and investors** comparing how users feel about competing apps.

### How to use it

#### Read the complaints about an app

1. On the **Input** tab, add the app under **Apps**. A name like `Spotify` works, or paste its App Store or Google Play link.
2. Under **Only these star ratings**, pick *1 star* and *2 stars*.
3. Set **Reviews per app** to how many you want, for example 500.
4. Click **Start**.
5. Open the **Output** tab. **Reviews** has every review. **App summaries** shows the top complaint words for each store, which is the quickest way to see what's going wrong. **Excel report** downloads both as a spreadsheet.

#### Get new reviews every day

1. Add your apps, set the mode to *Watch for new reviews*, and give it a **Watch name** like `my-app`.
2. Click **Save as a new task** (top right).
3. Go to **Schedules** in the left menu, create a daily schedule, and add your task.
4. Open the task's **Integrations** tab and add an email, Slack or webhook notification.

The first run looks back seven days. After that, each run only returns reviews the last one didn't see, and a run with nothing new costs nothing.

**Tip:** set **Only these star ratings** to 1 and 2 stars as well, and the daily alert becomes a list of new complaints only.

#### See whether an update helped

Collect a few hundred recent reviews, then open the **Trends** sheet in the Excel report. It shows the average rating and the share of 1-2 star reviews week by week, and for each Google Play app version. A drop right after a release usually shows up there before it moves the store rating.

### Getting your results into Excel, Google Sheets or Word

- **Excel report:** every run saves `reviews-report.xlsx`, linked as **Excel report** on the Output tab, with Apps, Trends and Reviews sheets. It opens in Excel, Google Sheets, LibreOffice and Numbers. Runs of more than 20,000 reviews put the first 20,000 in the file; the full set is always in the dataset.
- **Other formats:** the **Export** button on the Output tab downloads the reviews as CSV, JSON, XML or HTML.
- **Google Sheets automatically:** add Apify's Google Sheets integration to a saved task and every run lands in a sheet.
- **Word or Google Docs:** open the Excel report, copy the Apps sheet and paste it in. It keeps the table.

### Using it from your own code

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('quillstone-labs/app-store-google-play-reviews-scraper').call({
    apps: ['com.spotify.music', 'https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580'],
    ratings: ['1', '2'],
    maxReviewsPerApp: 500,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
const summaries = await client.keyValueStore(run.defaultKeyValueStoreId).getRecord('app-summaries');
```

### Use it from an AI assistant

Claude, Cursor, VS Code and other assistants that support MCP can run this Actor for you. Add this server to your assistant's MCP settings:

```
https://mcp.apify.com?tools=quillstone-labs/app-store-google-play-reviews-scraper
```

The first time it connects, a browser window opens so you can sign in to Apify. Then just ask, for example *"What are people complaining about in Duolingo's recent reviews?"* Each app summary includes a plain-English `explanation` the assistant can pass straight on, and **Summaries only** keeps the answer short, and every output field is described, so it knows what each one means. To set up several Actors at once, use Apify's [MCP configurator](https://mcp.apify.com/).

### What a result looks like

Each review is one row:

```json
{
    "input": "Spotify",
    "store": "Google Play",
    "appId": "com.spotify.music",
    "appName": "Spotify: Music and Podcasts",
    "country": "us",
    "reviewId": "0cb487e6-9323-47bb-927f-175977278824",
    "rating": 1,
    "title": null,
    "text": "I got 4 minutes of ads in a row...",
    "userName": "OLC",
    "date": "2026-10-20T05:45:51.000Z",
    "appVersion": "9.1.92.3058",
    "thumbsUp": 0,
    "developerReply": "Hi. Thanks for reporting this to us...",
    "developerReplyDate": "2026-10-20T09:12:03.000Z",
    "reviewUrl": "https://play.google.com/store/apps/details?id=com.spotify.music&reviewId=0cb487e6-...",
    "topics": ["ads"]
}
```

And each app, store and country gets a summary, saved as `app-summaries` and shown on the Output tab:

```json
{
    "appName": "Spotify: Music and Podcasts",
    "store": "Google Play",
    "country": "us",
    "storeRating": 4.35,
    "storeRatingCount": 36515514,
    "reviewsCollected": 150,
    "averageRating": 1.23,
    "stars": { "5": 0, "4": 0, "3": 0, "2": 35, "1": 115 },
    "negativePercent": 100,
    "replyPercent": 31,
    "topComplaints": "premium (38), music (33), songs (32), ads (22), play (22), listen (16), free (15), fix (14)",
    "complaintTopics": [
        { "topic": "ads", "label": "Ads", "negativeReviews": 41, "percentOfNegative": 27, "percentOfAll": 27 },
        { "topic": "price", "label": "Price & subscription", "negativeReviews": 38, "percentOfNegative": 25, "percentOfAll": 25 }
    ],
    "mostReviewedVersion": "9.1.92.3058",
    "byWeek": [{ "period": "2026-10-19", "reviews": 150, "averageRating": 1.23, "negativePercent": 100 }],
    "byVersion": [{ "period": "9.1.92.3058", "reviews": 97, "averageRating": 1.2, "negativePercent": 100 }]
}
```

### How much does it cost?

You pay per review returned, not for run time, and Apify's platform costs are included. App summaries and the Excel report are free. Exact prices are on the **Pricing** tab, and they're lower on Apify's paid plans. To cap what a run can cost, set **Max total charge** in the run options before you start.

### FAQ

**How many reviews can I get?**
Up to 50,000 per app, store and country in one run, as far back as the store goes. Google Play and the App Store both go back years for popular apps. Set **Reviews per app** to what you need; the run stops there.

**Why is there no developer reply or version on App Store reviews?**
Apple doesn't include them in the review data it serves outside its own apps. Google Play reviews have both.

**Why did a name come back as not found?**
Store search always returns something, even for a typo. If the top result doesn't share a word with what you typed, the Actor skips it rather than give you reviews for the wrong app. Paste the store link to be exact.

**Which countries work?**
Over a hundred. Use two-letter codes like `us`, `gb`, `de`, `jp` or `br`. Each country is a separate store with its own reviews and rating.

**What language are Google Play reviews in?**
Google Play returns reviews written in the language you set under **Google Play language** (English by default). The App Store returns all reviews posted in that country's store.

**What are the top complaint words?**
The words used most often across the 1- and 2-star reviews you collected, counted once per review, with common words and the app's own name left out. It's a quick way to spot "crash", "login" or "ads" before reading everything.

**What are complaint topics?**
Each review is tagged with what it talks about, from its words: crashes and bugs, slow or laggy, ads, price and subscription, login and account, customer support, after an update, hard to use, notifications and spam, lost data, privacy. The app summary gives the share of 1-2 star reviews mentioning each, so "what are users angry about?" has a one-line answer. Tagging works on English reviews.

**Can I ask for the last 30 days instead of a date?**
Yes. **Only reviews since** takes a date like `2026-10-01` or a span like `30 days`, `2 weeks` or `3 months`.

### More from Quillstone Labs

- **[USPTO Trademark Search & Monitor](https://apify.com/quillstone-labs/uspto-trademark-search)**: is a brand name or slogan already taken in the US, sound-alikes included, plus what a company owns, renewal dates and new filings.
- **[TikTok Transcript Scraper](https://apify.com/quillstone-labs/tiktok-transcript-scraper)**: TikTok video to text: transcripts, subtitles with timestamps and English translations, from video links.
- **[YouTube Transcript Scraper](https://apify.com/quillstone-labs/youtube-transcript-scraper)**: YouTube videos, Shorts, playlists and channels to text, with SRT subtitles.
- **[Used Car Search](https://apify.com/quillstone-labs/used-car-search)**: ten used-car sites searched at once, duplicates merged, with a price check.

### Support

Found a bug, or need a field that isn't there? Open an issue on the **Issues** tab and include the input you used. For anything else, like a custom version or a bulk data job, email QuillStoneLabs@yahoo.com.

### Data and fair use

Reviews are public posts from the App Store and Google Play. They include the reviewer's display name, so treat the output as personal data where your local law does, and don't use it to contact reviewers with marketing. This Actor is an independent tool and isn't affiliated with, endorsed by or sponsored by Apple or Google. App Store is a trademark of Apple Inc. and Google Play is a trademark of Google LLC.

# Actor input Schema

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

One app per line. Paste a store link, an app ID (like <code>com.duolingo</code> or <code>570060128</code>), or just the app's name and it's looked up in both stores. Calls written for other review Actors also work: <code>appIds</code>, <code>appUrls</code>, <code>startUrls</code> and <code>urls</code> are read too.

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

<strong>Get reviews:</strong> collect reviews now.<br><strong>Watch for new reviews:</strong> only return reviews the last run didn't see. Put it on a schedule to get new reviews daily or weekly.

## `summaryOnly` (type: `boolean`):

Return one line per app (store rating, star split, % negative, top complaint words, weekly and per-version trends) instead of every review. The reviews are still read to build it and charged as usual.

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

The most reviews to collect for each app, store and country.

## `stores` (type: `array`):

Which stores an app name is looked up in. Links and IDs always go to their own store.

## `ratings` (type: `array`):

Leave empty for all. Pick 1 and 2 to read only complaints.

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

Keep reviews that contain any of these words, like <code>crash</code>, <code>login</code> or <code>refund</code>. Leave empty for all.

## `sinceDate` (type: `string`):

Skip reviews older than this: a date, or a span back from today like <code>30 days</code> or <code>2 weeks</code>.

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

Newest first, or the reviews the store ranks most helpful.

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

Two-letter country codes, like <code>us</code>, <code>gb</code> or <code>de</code>. Each country's store has its own reviews.

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

Google Play returns reviews written in this language, as a two-letter code like <code>en</code> or <code>es</code>.

## `watchName` (type: `string`):

Give each watch its own name, like <code>my-app</code>. Runs with the same name remember what they've already shown you.

## `lookbackDays` (type: `integer`):

How far back the first run of a watch goes. Later runs only return new reviews.

## `proxyConfiguration` (type: `object`):

The stores limit how many requests come from one address. Apify Proxy keeps big runs going.

## Actor input object example

```json
{
  "apps": [
    "Duolingo",
    "https://apps.apple.com/us/app/notion-notes-tasks-ai/id1232780281"
  ],
  "mode": "reviews",
  "summaryOnly": false,
  "maxReviewsPerApp": 100,
  "stores": [
    "apple",
    "google"
  ],
  "sort": "newest",
  "countries": [
    "us"
  ],
  "language": "en",
  "watchName": "default",
  "lookbackDays": 7,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `summaries` (type: `string`):

No description

## `report` (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": [
        "Duolingo",
        "https://apps.apple.com/us/app/notion-notes-tasks-ai/id1232780281"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("quillstone-labs/app-store-google-play-reviews-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 = {
    "apps": [
        "Duolingo",
        "https://apps.apple.com/us/app/notion-notes-tasks-ai/id1232780281",
    ],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("quillstone-labs/app-store-google-play-reviews-scraper").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": [
    "Duolingo",
    "https://apps.apple.com/us/app/notion-notes-tasks-ai/id1232780281"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call quillstone-labs/app-store-google-play-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,quillstone-labs/app-store-google-play-reviews-scraper"
        }
    }
}
```

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/jgOZCFcmr506GZhxv/builds/IQpURswtz5WbvgItg/openapi.json