# App Store & Google Play Reviews with AI Triage Tags (`pixel-minions/app-review-tagger`) Actor

Scrapes App Store and Google Play reviews and tags every review with topic, severity, churn risk, actionability, competitor mentions, and your own yes/no labels.

- **URL**: https://apify.com/pixel-minions/app-review-tagger.md
- **Developed by:** [Pixel Minions](https://apify.com/pixel-minions) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 tagged reviews

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 Store & Google Play Reviews Scraper with AI Triage Tags

Scrape app reviews from the **Apple App Store** and **Google Play**, and get every review back already triaged: **topic, severity, churn risk, actionability, competitor mentions**, plus **your own yes/no labels**. No API keys, no prompts to write, no second tool to run the reviews through.

Most review scrapers hand you thousands of raw rows and leave the reading to you. This one answers the questions a product team actually asks: *what is broken, how bad is it, who is about to leave, and what can we act on?*

### What you get for every review

| Field | Meaning |
|---|---|
| `topic` | One of `bug`, `performance`, `account`, `pricing`, `ads`, `design`, `feature_request`, `content`, `support`, `praise`, `other` |
| `topicConfidence` | 0–1, how clearly the review belongs to that topic |
| `severity` | 0–3: 0 no problem, 1 minor annoyance, 2 significant problem, 3 blocking / lost money or data / already quit |
| `churnRisk` | 0–1 probability the reviewer has stopped or is about to stop using or paying |
| `actionable` | 0–1 probability the review contains something specific a team can act on |
| `mentionsCompetitor` | 0–1 probability a competing app or service is named |
| `labels` | Your custom yes/no questions, each answered with a 0–1 probability |
| plus | `store`, `appId`, `country`, `date`, `rating`, `version`, `title`, `text`, `reviewId` |

Scores are **probabilities, not labels**: filter `churnRisk > 0.7` or sort by `severity` and pick your own cut-off. Non-English reviews are tagged too (English is the most accurate).

### Example output

```json
{
  "store": "appstore",
  "appId": "324684580",
  "country": "us",
  "reviewId": "appstore:14560912345",
  "date": "2026-09-17T16:18:01+00:00",
  "rating": 1,
  "version": "9.1.82",
  "title": "Unfortunately",
  "text": "I have over 2,000 songs downloaded. The playlist lags nonstop and plays the same songs...",
  "topic": "bug",
  "topicConfidence": 0.81,
  "severity": 2.5,
  "churnRisk": 0.93,
  "actionable": 0.88,
  "mentionsCompetitor": 0.04,
  "labels": { "mentionsOffline": 0.91 }
}
```

### Custom labels

Ask anything that has a yes/no answer, in plain English:

```json
"customLabels": [
  { "name": "mentionsDarkMode", "question": "Does the review mention dark mode or the color theme?" },
  { "name": "afterUpdate", "question": "Does the reviewer say the problem started after a recent update?" },
  { "name": "refundRequest", "question": "Is the reviewer asking for a refund?" }
]
```

Each label comes back as a probability under `labels`. Up to 20 labels per run.

### Input

- **Apps** – App Store ids or URLs (`324684580`, `https://apps.apple.com/us/app/spotify/id324684580`) and Google Play package names or URLs (`com.spotify.music`). Mix both stores in one run.
- **Max reviews per app** – newest first. Apple's public feed serves at most 500 reviews per country; Google Play serves more.
- **Countries** – two-letter codes; each country has its own reviews.
- **Only reviews since** – skip older reviews. Combine with an Apify schedule for daily or weekly monitoring that only pays for new reviews.
- **Custom yes/no labels** – see above.

### Pricing

Pay per result, nothing else:

- **$1.50 per 1,000 tagged reviews** (all built-in tags included)
- **$0.20 per 1,000 reviews for each custom label**

Reviews that could not be tagged are dropped and never billed. The run stops cleanly when it reaches the maximum charge you set.

### What people use it for

- **Product managers** – a weekly digest of the highest-severity, most actionable reviews instead of reading everything.
- **ASO and app marketing agencies** – topic breakdowns per client app and per competitor, per country.
- **Support and CX teams** – route `account`, `pricing` and refund reviews to the right queue; reply first where `churnRisk` is high.
- **Competitive research** – run it on a competitor's app and see what their users complain about and which rivals they mention.
- **AI agents and dashboards** – typed, numeric fields that drop straight into a sheet, a BI tool, or an agent's context without another LLM pass.

### FAQ

**Do I need an App Store Connect or Google Play Console account?** No. Only public reviews are read; it works for any app, including competitors'.

**Are reviewer names included?** No. Only the review content, rating, version and date are returned.

**How fresh is the data?** Reviews come straight from the stores at run time, newest first.

**Something looks mis-tagged.** Open an issue with the `reviewId`. Tag definitions are tuned continuously.

# Actor input Schema

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

App Store ids or URLs (e.g. 324684580 or https://apps.apple.com/us/app/spotify/id324684580) and Google Play package names or URLs (e.g. com.spotify.music). You can mix both stores.

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

Newest reviews first. Apple's public feed allows at most 500 per country; Google Play allows more.

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

Two-letter store country codes. Each country has its own set of reviews.

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

Two-letter language code for Google Play reviews. Ignored for the App Store.

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

Skip reviews older than this date (YYYY-MM-DD). Use it with a schedule to tag only new reviews and keep runs cheap.

## `customLabels` (type: `array`):

Your own questions, answered for every review with a probability from 0 to 1. Example: {"name": "mentionsDarkMode", "question": "Does the review mention dark mode or the app's color theme?"}. Each label is billed per review.

## Actor input object example

```json
{
  "apps": [
    "324684580",
    "com.spotify.music"
  ],
  "maxReviewsPerApp": 100,
  "countries": [
    "us"
  ],
  "language": "en",
  "customLabels": []
}
```

# Actor output Schema

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

Every scraped review with its topic, severity, churn risk, actionability, competitor mention and custom labels.

# 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": [
        "324684580",
        "com.spotify.music"
    ],
    "customLabels": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("pixel-minions/app-review-tagger").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": [
        "324684580",
        "com.spotify.music",
    ],
    "customLabels": [],
}

# Run the Actor and wait for it to finish
run = client.actor("pixel-minions/app-review-tagger").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": [
    "324684580",
    "com.spotify.music"
  ],
  "customLabels": []
}' |
apify call pixel-minions/app-review-tagger --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,pixel-minions/app-review-tagger"
        }
    }
}
```

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/guC8xlVvBZK2Pc7Ib/builds/jOPIeQkV8Vxih5Mx0/openapi.json