# Google Play Reviews Scraper & App Intelligence (`azzarilabs/google-play-reviews-app-intelligence`) Actor

Turn public Android reviews into structured feedback, app-health, version, and developer-response evidence.

- **URL**: https://apify.com/azzarilabs/google-play-reviews-app-intelligence.md
- **Developed by:** [Azzari Labs](https://apify.com/azzarilabs) (community)
- **Categories:** Marketing, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.20 / 1,000 review results

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

## Google Play Reviews Scraper & App Intelligence

Turn public Google Play reviews into structured product-feedback evidence. Instead of manually reading Store pages, provide Android package IDs or public app URLs and receive review rows, app summaries, OUTPUT, and REPORT.html for product, QA, ASO, and reputation-review decisions.

### What problem it solves

Ratings alone do not explain what users are reporting, whether feedback clusters around a version, or how often developers answer. This Actor collects the public evidence and summarizes the observed sample with transparent, deterministic calculations. It does not estimate downloads, revenue, conversion, sentiment, or future ratings.

### Input → result → decision

1. **Input:** one or more Android package IDs or Google Play URLs, plus country, language, ordering, star filters, and a bounded review limit.
2. **Result:** deduplicated public review rows, one non-billable app summary per app, aggregate OUTPUT, and a self-contained HTML report.
3. **Decision:** identify feedback that merits manual investigation, compare observed app-health signals, or prioritize QA and response workflows.

### Three concrete use cases

- **Product feedback review:** surface recurring and complaint terms in the collected sample before reading individual reviews.
- **QA and release monitoring:** inspect version issue signals and recent-versus-previous rating movement as descriptive evidence, never as causation.
- **Reputation response planning:** review public developer-reply coverage and filter low-star feedback for a response queue.

### Quick Start

Run a small, bounded collection first:

```json
{
  "apps": ["com.spotify.music"],
  "maxReviewsPerApp": 25,
  "sortBy": "newest",
  "language": "en",
  "country": "us",
  "includeDeveloperReplies": true,
  "includeAppDetails": true
}
```

Then inspect the `reviews` and `app_summaries` Dataset views. Use OUTPUT for aggregate counts and billing metadata, or REPORT.html for a readable evidence review. A reusable input is available at `examples/STORE_DEMO_INPUT.json`.

### Sanitized output example

```json
{
  "record_type": "review",
  "app_id": "com.example.app",
  "review_id": "fixture-review-001",
  "rating": 2,
  "review_text": "slow login after update",
  "app_version": "9.1.0",
  "developer_reply": "Thanks for reporting",
  "source": "sanitized deterministic fixture"
}
```

The complete local example is `examples/STORE_DEMO_OUTPUT.json`. It was derived from deterministic test-fixture shapes and anonymized; it is not a live Cloud run, external production result, reliability claim, or proof of future availability.

### Main fields

Review rows include:

- `app_id`, `app_url`, and `app_title`
- `review_id`, `rating`, `review_text`, and `review_created_at`
- `thumbs_up_count`, `app_version`, and public developer-reply fields
- `language`, `country`, `source`, and `retrieved_at`

Non-billable app summaries can include:

- observed rating distribution and positive/negative share
- recent and previous observed averages plus descriptive trend
- developer-response coverage
- recurring terms, complaint terms, and version issue signals
- explainable App Health and Product Feedback Opportunity scores with confidence and reasons

Unknown or unexposed values remain `null` rather than being invented.

### Clear pricing

The active Cloud event is `review-result` at **USD 0.0002 per valid unique review delivered**.

| Delivered reviews | Event cost |
|---:|---:|
| 100 | USD 0.02 |
| 1,000 | USD 0.20 |
| 10,000 | USD 2.00 |

App summaries, duplicates, invalid or empty review rows, warnings, OUTPUT, and REPORT.html are non-billable. Platform compute or storage charges, when applicable to the account, are separate from these event-cost examples.

### Verifiable proof points

- Billing eligibility requires a non-empty valid review row and is evaluated after Dataset delivery.
- Review delivery is deduplicated by `review_id`, with a documented content fallback when the public identifier is absent.
- Store rating and the rating observed in the collected review sample remain separate fields.
- Scores expose their component evidence and do not use generative sentiment or synthetic values.
- Dataset, OUTPUT, and REPORT.html preserve provenance, warnings, and null handling.

### Source and method

The Actor uses anonymous HTTPS requests to the public Google Play web surface: the app details page and the web client's `UsvDTd` batchexecute review RPC. It does not require a Google API key, Play Console login, browser automation, or synthetic data.

App Health is a 0–100 explainable score based on observed rating quality, negative share, recent trend, developer-response coverage, and evidence coverage. Levels are HIGH (75+), MEDIUM (50–74.9), and LOW (<50). Confidence reflects observed sample size. These are descriptive summaries of collected public evidence, not predictions.

### Honest limitations

- Google Play's public HTML and undocumented web RPC can change, throttle, or omit fields.
- Review availability and ordering vary by country, language, time, and Google's public response.
- A bounded sample is not the complete review population and must not be treated as market share or a reliability metric.
- Trend and version signals are correlations in observed rows; they do not establish causation.
- Term frequency is deterministic text counting, not semantic sentiment analysis.
- Public reviewer names are kept only when exposed and are not used for profiling.

### Next step

Start with one app and 25 reviews, inspect the evidence quality and warnings, then increase the bound only if the returned sample supports the decision you need to make.

### Related App Intelligence Actors

- [Google Play Apps Scraper & ASO Market Intelligence](https://apify.com/azzarilabs/google-play-apps-aso-intelligence)
- [Apple App Store Reviews Scraper & Rating Intelligence](https://apify.com/azzarilabs/apple-app-store-reviews-intelligence)

# Actor input Schema

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

Add an Android package ID such as com.spotify.music or a Google Play app URL.

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

Set a small first-run cap; you pay only for valid delivered review rows.

## `sortBy` (type: `string`):

Newest reveals recent feedback; Most relevant shows Google's relevance order.

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

Two-letter Google Play country code, for example us or gb.

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

Two-letter language hint, such as en or es.

## `starRatings` (type: `array`):

Optional values 1–5; leave empty for all ratings.

## `includeDeveloperReplies` (type: `boolean`):

Include public replies when Google Play exposes them.

## `includeAppDetails` (type: `boolean`):

Add public app metadata when available.

## Actor input object example

```json
{
  "apps": [
    "com.spotify.music"
  ],
  "maxReviewsPerApp": 50,
  "sortBy": "newest",
  "country": "us",
  "language": "en",
  "includeDeveloperReplies": true,
  "includeAppDetails": true
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `output` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("azzarilabs/google-play-reviews-app-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("azzarilabs/google-play-reviews-app-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 '{}' |
apify call azzarilabs/google-play-reviews-app-intelligence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,azzarilabs/google-play-reviews-app-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/IpEjqJSH4OQQyULx6/builds/bIvW054f9wBHNO2Kn/openapi.json