# Google Play Scraper & SERP Rank Checker (`byteblisk/google-play-search-toolkit`) Actor

Everything in one actor: Google Play app details, reviews and search, top-100 rank on Google, Bing and Yandex results pages or search APIs, AI answer citations from official APIs, and export to files or your storage. Batch, REST API and MCP.

- **URL**: https://apify.com/byteblisk/google-play-search-toolkit.md
- **Developed by:** [byteblisk](https://apify.com/byteblisk) (community)
- **Categories:** SEO tools, Developer tools
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 data and search rankings, without stitching five tools together

App details, reviews and keyword search from Google Play, plus where any domain ranks in the top 100 on Google, Bing
and Yandex, all in one actor and delivered where your data lives. **$0.10 per 1,000 reviews, $0.03 per rank check.**

#### What you get

- **Complete Google Play data.** App details, reviews with every filter that matters, and keyword search results.
- **Search rank you can trust.** Your best position and every matching position in the top 100. Add your own free
  Brave Search API key for reliable checks, since search engines often block cloud servers.
- **Delivery built in.** JSON, CSV, Excel or Parquet, pushed straight to Snowflake, Pub/Sub, Alibaba OSS or email.
- **You pay for what arrives.** An app that fails to load is a free error row.
- **Ready for agents.** HTTP API and 9 MCP tools.

#### Built for

- **ASO teams** tracking apps and competitors on Google Play
- **SEO agencies** running quick rank checks without a monthly tool
- **Data teams** loading app and search data into their warehouse

### What data can Google Play & Search Toolkit extract?

| Field | Row type | Description |
|---|---|---|
| `app_id`, `name`, `developer` | app | Google Play package ID, app title and developer name |
| `rating`, `ratings_count`, `installs` | app | Store rating, total ratings count and install bracket |
| `price`, `currency`, `category` | app | Price, currency code and Play Store category |
| `version`, `updated_at` | app | Current version (including split-APK fallback) and release date |
| `rating`, `text`, `author` | review | 1–5 star score, review body and reviewer display name |
| `app_version`, `thumbs_up` | review | App version the review was written on and helpful vote count |
| `reply`, `reply_at` | review | Developer reply text and timestamp |
| `best_rank`, `matching_positions` | rank | Highest Top-100 position and all matching positions for `target` |
| `visibility_score`, `results` | rank | Weighted SERP visibility score and ranked result rows |
| `answer_text`, `citations` | answer | Full AI answer and extracted cited URLs (`source_domains`) |
| `brand_insights` | answer | Per-brand mention count, prominence score and sentiment |

### How to use Google Play & Search Toolkit

1. Click **Try for free** and open the **Input** tab.
2. Select **Mode**:
   - `app` or `reviews`: enter Google Play package IDs or URLs in **Apps** (`com.spotify.music`).
   - `search`: enter a **Search Keyword** and set **Max Search Apps**.
   - `rank`: enter a **Search Keyword**, **Target Domain or URL** (`spotify.com`), and **Rank source** (`google`, `bing`, `yandex` or `api`).
   - `answers`: enter an **AI Answer Engine Prompt**, choose `perplexity`, `openai` or `gemini`, and list **Tracked Brands**.
3. Optionally choose an **Export Format** (`json`, `ndjson`, `csv`, `xlsx`, `parquet`), a **Delivery Sink** (`snowflake`, `pubsub`, `alibaba_oss`, `email`), or a custom **Proxy URL**.
4. Click **Start**, then view or download your results from the **Output** tab.

### How much does it cost?

The actor uses **pay-per-event** pricing: you pay only for the records delivered, and platform compute is included. See the **Pricing** tab for current per-event rates.

| Event | When it's charged |
|---|---|
| `app` | Once per Google Play app metadata record returned |
| `reviews-100` | Per started batch of 100 Google Play reviews returned |
| `answer` | Once per AI answer & citation report returned |
| `rank-check` | Once per Top-100 domain rank check completed |
| `dataset_fields`, `dataset_search`, `export`, `usage` | Free (0 units) |

#### Cost examples

| Job | Cost |
|---|---|
| 1,000 Google Play reviews | $0.10 + $0.002 per app |
| 100 app records | $0.20 |
| 20 keywords' top-100 rank, weekly | about $2.40 a month |
| An app that fails to load | free |

### Input

See the **Input** tab for every field. Key options unique to this toolkit:

- **Mode:** `app` (metadata), `reviews` (metadata + paginated reviews), `search` (Play Store keyword search + app records), `rank` (Top-100 web search rank check), `answers` (AI citation & brand analysis), or `server` (Standby HTTP API + MCP).
- **Review filters:** `sort` (`newest`, `most_relevant`, `rating`), `stars` (`1`–`5`), `startDate` and `endDate` (`YYYY-MM-DD`).
- **Rank source:** `google`, `bing`, `yandex` results pages, or `api` (`braveApiKey` / `searxngUrl`). When a search results page is blocked, the actor automatically falls back to the search API if configured.
- **Delivery Sink & Export Format:** set `exportFormat` (`xlsx`, `parquet`, `csv`, `ndjson`, `json`) for file sinks (`local`, `alibaba_oss`, `email`), or set `deliveryDestination` to `snowflake` (SQL row insert) or `pubsub` (JSON messages) with `deliveryConfig` credentials.
- **Proxy URL & Pacing:** pass `proxyUrl` for your own upstream HTTP/HTTPS proxy and `requestsPerSecond` (`1`–`10`) to control request rate.

### Output

You can download the dataset in JSON, HTML, CSV, or Excel (or export to Parquet and XLSX via `exportFormat`). Each row carries a `type` (`app`, `review`, `rank`, `answer`):

```json
[
  {"type": "app", "app_id": "com.spotify.music", "name": "Spotify: Music and Podcasts",
   "developer": "Spotify AB", "rating": 4.43, "ratings_count": 31000000, "installs": "1,000,000,000+",
   "version": "8.9.82.612", "category": "Music & Audio", "country": "us", "language": "en"},
  {"type": "review", "app_id": "com.spotify.music", "review_id": "gp:AOqpTOF...",
   "author": "Alice", "rating": 5, "text": "Great sound quality!", "app_version": "8.9.82.612",
   "thumbs_up": 19, "reply": null, "updated_at": "2026-11-07T10:12:00+00:00"},
  {"type": "rank", "query": "music streaming", "target": "spotify.com", "engine": "google",
   "is_ranked_top100": true, "best_rank": 2, "matching_positions": [2], "visibility_score": 99.0},
  {"type": "answer", "provider": "perplexity", "prompt": "What is the best music app?",
   "citation_count": 2, "source_domains": ["open.spotify.com", "techcrunch.com"],
   "brand_insights": [{"brand": "Spotify", "mentioned": true, "mention_count": 1, "sentiment": "positive"}]}
]
```

### Use it as an API or from an AI agent

- **Standby HTTP API (`/v1/*`):** `GET /health`, `POST /v1/apps`, `POST /v1/reviews`, `POST /v1/search`, `POST /v1/answers`, `POST /v1/rank`, `POST /v1/datasets/fields`, `POST /v1/datasets/search`, `POST /v1/export`, and `GET /v1/usage`. Every response returns `{"ok": true, ..., "cost": {"units": n}}` or `{"ok": false, "error": "..."}`.
- **MCP (`/mcp`):** connect any MCP client to `/mcp` to use all 9 tools (`play_app`, `play_reviews`, `play_search`, `answers`, `rank`, `dataset_fields`, `dataset_search`, `export`, `usage`).

### Tips

- Use `search` mode with a small `maxApps` (for example `5`–`10`) to discover Google Play apps for a keyword and extract their full metadata records; pass those `app_id`s to `reviews` mode when you want their user reviews.
- Use `/v1/datasets/search` and `/v1/export` in Standby mode when an AI agent needs to filter collected reviews in memory before exporting a clean `.xlsx` or `.parquet` file.
- In `rank` mode, supplying a `braveApiKey` or `searxngUrl` gives automatic API fallback if a search engine challenges the request.

### FAQ

#### Which Google Play endpoints does each mode read?

`app` mode reads `/store/apps/details?id=...`. `reviews` mode calls `/_/PlayStoreUi/data/batchexecute`, and `search` mode reads `/store/search`; both are controlled by explicit input flags (`includeReviews` and `enableSearch`).

#### How are requests paced and protected against blocks?

Every outgoing request goes through a central request gate (`gate.py`) that validates public addresses (`netguard.py`), paces outgoing requests with jitter, sends Chrome Client Hints, and escalates through session/proxy rotation on rate limits before stopping cleanly if a block persists.

#### Is it legal to scrape Google Play data?

Our Actors are ethical and do not extract any private user data, such as email addresses, reviewer avatar photos, gender, or location. They only extract what the user has chosen to share publicly. However, you should be aware that your results could contain personal data protected by GDPR and other regulations, and you should not scrape personal data without a legitimate reason. "Google Play" is a trademark of Google LLC; this product is independent and is not affiliated with or endorsed by Google LLC.

#### Something isn't working. Where do I report it?

Open the **Issues** tab and describe the input and what you expected. We read every issue.

### byteblisk actors

Built and supported by **byteblisk**. Same record conventions, API style and MCP design across all three, so an AI
agent can use them together:

- 📄 **[SiteReader](https://apify.com/byteblisk/sitereader)**: any website to clean Markdown or JSON for AI, with AI fields, site maps and watches.
- ⭐ **[App Reviews & Insights](https://apify.com/byteblisk/app-reviews-insights)**: Google Play and App Store reviews in one format, with AI insights and alerts.
- 🔎 **[Google Play & Search Toolkit](https://apify.com/byteblisk/google-play-search-toolkit)**: Play apps, reviews and search, top-100 search rank, and exports to
  your warehouse, in one actor.

Something missing or broken? Open an issue in the **Issues** tab: we answer every one.

# Actor input Schema

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

Select 'app', 'reviews', 'search', 'answers', 'rank', or 'server' (Standby HTTP API + MCP).

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

Android package IDs (e.g. 'com.spotify.music') or full Google Play URLs.

## `includeReviews` (type: `boolean`):

Explicitly enable reading user reviews via the Play Store batch endpoint.

## `enableSearch` (type: `boolean`):

Explicitly enable searching package IDs via '/store/search' when mode is 'search'.

## `keyword` (type: `string`):

Keyword for Play Store search ('search' mode) or rank check ('rank' mode).

## `target` (type: `string`):

Domain or URL to locate in the Top-100 search results.

## `engine` (type: `string`):

Where rank mode reads results. A blocked results page falls back to the search API when a Brave key or SearXNG URL is set.

## `prompt` (type: `string`):

Prompt sent to the official Perplexity, OpenAI, or Gemini API when mode is 'answers'.

## `provider` (type: `string`):

Official AI API provider to query.

## `trackedBrands` (type: `array`):

Brands or products to track for mention count, prominence, and sentiment.

## `apiKey` (type: `string`):

Official API key for Perplexity, OpenAI, or Google Gemini.

## `braveApiKey` (type: `string`):

Needed for reliable rank checks: search engines often block results pages from cloud servers. Brave includes free monthly credit (api-dashboard.search.brave.com). Used for this run only.

## `searxngUrl` (type: `string`):

Optional public or self-hosted SearXNG base URL returning JSON results.

## `maxApps` (type: `integer`):

Maximum number of apps to return in 'search' mode.

## `maxReviews` (type: `integer`):

Maximum number of reviews to read per app.

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

Sort order for reviews.

## `stars` (type: `integer`):

Optional filter for a specific star rating (1 to 5).

## `startDate` (type: `string`):

Read only reviews posted on or after this ISO date.

## `endDate` (type: `string`):

Read only reviews posted on or before this ISO date.

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

Two-letter ISO 3166-1 alpha-2 country code (e.g. 'us', 'gb', 'de').

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

Two-letter ISO 639-1 language code (e.g. 'en', 'de', 'fr').

## `exportFormat` (type: `string`):

Optional export file format when delivering to a destination sink.

## `deliveryDestination` (type: `string`):

Optional external sink to deliver exported records.

## `deliveryConfig` (type: `object`):

Connection settings for the selected deliveryDestination.

## `requestsPerSecond` (type: `integer`):

Maximum outgoing request rate per second.

## `proxyUrl` (type: `string`):

Optional HTTP/HTTPS proxy URL.

## Actor input object example

```json
{
  "mode": "app",
  "apps": [
    "com.spotify.music"
  ],
  "includeReviews": true,
  "enableSearch": true,
  "engine": "google",
  "provider": "perplexity",
  "maxApps": 5,
  "maxReviews": 100,
  "sort": "newest",
  "country": "us",
  "language": "en",
  "exportFormat": "json",
  "requestsPerSecond": 1
}
```

# Actor output Schema

## `apps` (type: `string`):

No description

## `reviews` (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("byteblisk/google-play-search-toolkit").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("byteblisk/google-play-search-toolkit").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 byteblisk/google-play-search-toolkit --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,byteblisk/google-play-search-toolkit"
        }
    }
}
```

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/E81APPP5kAStSZAgp/builds/CRtANDO46tfzkuR8p/openapi.json