# App Review Scraper — Google Play & App Store Monitor (`dev-hoss/app-review-intelligence`) Actor

Scrape and monitor app reviews on Google Play and the App Store in one run: rating, text, author, app version, date. Optional monitor mode returns only reviews posted since the last run. No LLM, no logins. Pay per review fetched.

- **URL**: https://apify.com/dev-hoss/app-review-intelligence.md
- **Developed by:** [Hossam Mohamed](https://apify.com/dev-hoss) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 review fetcheds

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?

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

## App Review Scraper — Google Play & App Store Monitor

Scrape and monitor **app reviews on Google Play and the App Store in one run**: rating, text, author, app version, helpful votes and dates — in clean, schema-documented JSON. Optional **monitor mode** returns only reviews posted since your last run.

> No LLM, no logins. App Store reviews come from the official Apple RSS feed (up to 500 per app, newest first); Google Play reviews are parsed from the live store page.

**1 app = 1 watch.** Schedule it with `monitorMode: true` and every run is a fresh-review feed for your app — or your competitors' apps.

### AI agent quick start

**Actor tool ID:** `dev-hoss/app-review-intelligence`

- Send `apps` mixing stores freely: Google Play package names (`com.twitter.android`) and/or App Store ids (`333903271`).
- Read the `type` field: `review` (the data), `app-summary` (per-app coverage: count, avg rating, mode), `error`, `info`.
- Monitor mode: keep the same `stateKey` per watchlist; first run records a baseline (`firstRunReportsAll: true` seeds everything); subsequent runs emit only new reviews with `isNew: true`.
- Unavailable apps emit an `error` record — not a failed run.

### Quick start

```json
{
    "apps": ["com.twitter.android", "333903271"],
    "maxReviewsPerApp": 100,
    "minStars": 1
}
```

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `apps` | array (required) | — | 1–50 apps: Play package names, App Store ids, or full store URLs. |
| `maxReviewsPerApp` | integer | `100` | Cap per app. App Store: up to 500 (official RSS, 10 pages). Play: what the store page renders. |
| `minStars` | integer | `1` | Only reviews with at least this many stars. Use 2–3 to focus on critical feedback. |
| `country` | string | `us` | App Store storefront / Play locale (`us`, `gb`, `de`, `jp`…). |
| `monitorMode` | boolean | `false` | Emit only reviews new since the previous run. |
| `stateKey` | string | `default` | Separate watchlists in monitor mode. |
| `firstRunReportsAll` | boolean | `false` | Monitor mode: first run emits everything instead of a silent baseline. |
| `concurrency` | integer | `3` | Apps in parallel (both stores rate-limit; keep low). |

### Output

```json
{
    "type": "review",
    "store": "app-store",
    "appId": "333903271",
    "appName": "X",
    "country": "us",
    "author": "Bitetaeat lifestyle",
    "rating": 5,
    "title": null,
    "text": "Truly the most genuine social media platform there can be!",
    "reviewDate": "2026-09-10T18:22:04.000Z",
    "version": "11.13",
    "thumbsUp": null,
    "isNew": null,
    "checkedAt": "2026-09-12T14:00:00.000Z"
}
```

Plus `app-summary` per app (reviews fetched, new count, average rating, mode), `error` records for unavailable apps, and an `info` record when nothing matched your filters.

### Honest limitations

- **App Store**: official RSS, newest first — the best data source of the two.
- **Google Play**: reviews visible on the static store page (a handful per app, "most relevant" order). Pagination requires unofficial APIs that break often — not in this Actor's scope. If you need deep Play history, this Actor is the wrong tool.
- No sentiment scoring, no LLM — clean data out, you analyze it your way.

### Pricing

Pay per event: **$0.004 per review fetched** ($4 / 1,000) + $0.02 per app checked + $0.01 Actor Start. Platform usage included. A daily monitor over 10 apps ≈ 300 reviews/day ≈ $36/month at full depth — typically far less in monitor mode.

### Use with AI agents

```
POST https://api.apify.com/acts/dev-hoss~app-review-intelligence/run-sync-get-dataset-items?token=YOUR_API_TOKEN
Content-Type: application/json

{"apps": ["com.twitter.android", "333903271"], "maxReviewsPerApp": 50}
```

Also works with Apify's hosted MCP server (`mcp.apify.com`).

### Who is this for?

- **App developers & PMs** — monitor your own and competitors' reviews without another SaaS seat
- **ASO agencies** — client reporting across both stores with one tool
- **Product research** — version-pinned complaints and feature requests
- **AI agents** — reputation-monitoring feeds with structured, schema-documented output

# Actor input Schema

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

Apps to scrape, mixing stores freely. Google Play: package name (com.example.app) or play.google.com URL. App Store: numeric id (324684580) or apps.apple.com URL. Up to 50 apps per run.

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

Cap per app. App Store can return up to 500 per app (official RSS, newest first). Google Play returns the reviews visible on the store page (first page).

## `minStars` (type: `integer`):

Only return reviews with at least this many stars (1-5). Use 1 for all reviews, or 2-3 to focus on critical feedback.

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

Storefront for the App Store and locale for Google Play, e.g. us, gb, de, jp.

## `monitorMode` (type: `boolean`):

Remember seen reviews and emit only genuinely new ones on subsequent runs — schedule this Actor and get a fresh-review feed. First run records the baseline.

## `stateKey` (type: `string`):

Use different keys for separate watchlists in monitor mode.

## `firstRunReportsAll` (type: `boolean`):

Monitor mode only: the first run emits all fetched reviews instead of recording a silent baseline (useful to seed a review dump).

## `concurrency` (type: `integer`):

Apps processed in parallel. Keep low (1-3) — both stores rate-limit aggressively.

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

Optional proxy. Both stores are public; enable Apify proxy only if you hit rate limits at scale.

## Actor input object example

```json
{
  "apps": [
    "com.twitter.android",
    "333903271"
  ],
  "maxReviewsPerApp": 100,
  "minStars": 1,
  "country": "us",
  "monitorMode": false,
  "stateKey": "default",
  "firstRunReportsAll": false,
  "concurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

One record per review: store, app, author, rating, title, text, version, date, helpful votes. In monitor mode only new reviews are emitted with isNew=true.

# 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.twitter.android",
        "333903271"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("dev-hoss/app-review-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": [
        "com.twitter.android",
        "333903271",
    ],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("dev-hoss/app-review-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": [
    "com.twitter.android",
    "333903271"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call dev-hoss/app-review-intelligence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,dev-hoss/app-review-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/UbX5ROY5PchUaZRZc/builds/0ZiKewOESodkMeUi1/openapi.json