# Google Play Review & Competitor Intelligence (`datahunter_labs/google-play-review-competitor-intelligence`) Actor

Analyze public Google Play reviews for sentiment, complaints, feature requests, switching signals, competitor mentions, app-version trends, and monitoring changes.

- **URL**: https://apify.com/datahunter\_labs/google-play-review-competitor-intelligence.md
- **Developed by:** [DataHunter Labs](https://apify.com/datahunter_labs) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 analyzed 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

## Google Play Review & Competitor Intelligence

Turn public Google Play reviews into structured product intelligence: sentiment, complaint categories, feature requests, questions, purchase intent, competitor mentions, switching signals, app-version trends, app metadata, and change monitoring.

### Why this Actor

Raw Google Play review scrapers are common. This Actor is designed for product, growth, support, and competitive-intelligence workflows that need normalized signals rather than only review text.

### Source and stability

The default source is the public Google Play web review corpus through the pinned `app-reviews==0.6.0` package. No Google account, customer API key, login, or browser is required. Google Play's public web endpoint is undocumented and rate-limited, so it can change without notice. The Actor therefore uses bounded request budgets, retries/backoff, direct-first networking, optional proxy/session rotation, cycle-safe pagination, diagnostics, and a circuit breaker. It never attempts to solve CAPTCHA or bypass authentication.

Google Play reviews are a **global corpus** in this source; a country selector would imply precision the source does not provide, so the current version intentionally does not expose one. It also uses newest-first collection only to keep monitoring semantics stable.

### Input

- `apps`: package names or Play Store URLs.
- `maxReviewsPerApp`: hard per-app result cap.
- `ratings`: optional 1-5 star filter.
- `competitorNames`: names used for mention/switching analysis.
- `includeReviewerName`: off by default to minimize unnecessary personal data.
- `includeAppMetadata`: fetch app/developer/category/version/rating/price metadata.
- `monitorChanges`: actor-scoped baseline/change tracking.
- `onlyNewReviews`: after a baseline exists, emit only new/changed reviews.
- `cacheTtlMinutes`, `forceRefresh`: non-monitoring cache controls.
- bounded concurrency/request/retry/timeout/proxy controls.

### Output

Each `review` row includes the normalized review plus:

- `sentiment`
- `complaintCategories` and `complaintScore`
- `featureRequest`
- `questionSignal`
- `purchaseIntent`
- `competitorsMentioned`
- `switchingSignal`, `switchingScore`, `switchingPhrases`
- `audienceIntent`
- baseline-safe monitoring flags

Each app also gets an `app_summary` with rating distribution, average rating in the run, sentiment counts, top complaint categories, competitor mentions, app-version counts, and monitoring counts.

The built-in semantic heuristics are strongest for English-language review text. Raw review/rating extraction is not language-restricted.

### Monitoring behavior

The first monitoring run establishes a baseline; reviews are not falsely labeled new. Later runs compare the same scoped configuration. Cache/state keys include inputs that materially affect results so changing limits, ratings, metadata inclusion, or competitor names does not silently reuse an incompatible cache/state scope.

### Pricing

This Actor uses Pay Per Event pricing with the primary event `review-returned` at **$0.0005 per useful chargeable review** (**$0.50 per 1,000 reviews**).

Summaries, diagnostics, retries, proxy rotations, cached rows, duplicates, and unchanged monitoring rows are not charged as review events.

### Limits

- Public Google Play web scraping is unofficial and may change or rate-limit.
- Reviewer country is not inferred.
- Reviewer display names are optional and disabled by default.
- Developer replies / thumbs-up are not currently exposed because the normalized dependency API does not guarantee those fields.
- CAPTCHA is never solved.

# Changelog

This Actor's version history is a separate document: https://apify.com/datahunter\_labs/google-play-review-competitor-intelligence/changelog.md

# Actor input Schema

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

Google Play package names or public Play Store app URLs. Google Play reviews are a global corpus, so no country selector is exposed.

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

Hard cap on normalized review rows collected for each app after rating filtering.

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

Optional star-rating filter. Leave empty to keep ratings 1 through 5.

## `competitorNames` (type: `array`):

Optional product or competitor names used to detect mentions and switching intent in review text.

## `includeReviewerName` (type: `boolean`):

Include the public reviewer display name when the source reports it. Disabled by default to minimize unnecessary personal data.

## `includeAppMetadata` (type: `boolean`):

Fetch public app name, developer, category, current version, store rating, rating count, price, icon URL, and release dates when available.

## `monitorChanges` (type: `boolean`):

Persist actor-scoped state to identify new or changed reviews on later runs with the same relevant inputs. The first run is a baseline and is not falsely marked new.

## `onlyNewReviews` (type: `boolean`):

When monitoring is enabled and a baseline exists, emit only reviews that are new or changed. Summaries remain free output.

## `cacheTtlMinutes` (type: `integer`):

Actor-scoped cache lifetime used only when monitoring is disabled.

## `forceRefresh` (type: `boolean`):

Ignore a valid non-monitoring cache entry and fetch fresh public Google Play data.

## `maxConcurrency` (type: `integer`):

Bounded number of apps processed concurrently to reduce load and blocking risk.

## `maxRequestsPerRun` (type: `integer`):

Hard cap on source requests including retries. Prevents runaway pagination and unexpected cost.

## `timeoutSeconds` (type: `integer`):

Per-request timeout before a bounded retry or diagnostic failure is recorded.

## `maxRetries` (type: `integer`):

Bounded retries for rate limits, blocking responses, timeouts, transport errors, and transient server errors.

## `retryBackoffSeconds` (type: `integer`):

Base exponential backoff between bounded retries.

## `directFirst` (type: `boolean`):

Use the public Google Play web source directly first and fall back to proxy rotation only after blocking or transient failures.

## `maxProxyRotations` (type: `integer`):

Hard cap on proxy/session rotations after blocking or transient failures.

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

Optional Apify or custom proxy used only when needed. Direct requests are preferred by default.

## Actor input object example

```json
{
  "apps": [
    "com.spotify.music"
  ],
  "maxReviewsPerApp": 100,
  "ratings": [],
  "competitorNames": [],
  "includeReviewerName": false,
  "includeAppMetadata": true,
  "monitorChanges": true,
  "onlyNewReviews": false,
  "cacheTtlMinutes": 60,
  "forceRefresh": false,
  "maxConcurrency": 2,
  "maxRequestsPerRun": 100,
  "timeoutSeconds": 20,
  "maxRetries": 2,
  "retryBackoffSeconds": 1,
  "directFirst": true,
  "maxProxyRotations": 2,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Normalized review intelligence, app-summary, and diagnostic rows.

## `summary` (type: `string`):

Run status, app success counts, request usage, proxy rotations, cache hits, circuit state, and billing-limit state.

# 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"
    ],
    "directFirst": true,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("datahunter_labs/google-play-review-competitor-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.spotify.music"],
    "directFirst": True,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("datahunter_labs/google-play-review-competitor-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.spotify.music"
  ],
  "directFirst": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call datahunter_labs/google-play-review-competitor-intelligence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,datahunter_labs/google-play-review-competitor-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/7yo7463HExXEwH1T1/builds/klazviE6EjWLag5NL/openapi.json