# Google Play Data API Scraper (`logiover/google-play-data-api`) Actor

Unofficial REST-style API for Google Play Store. Search apps, get full details,
extract reviews, list category top charts, fetch developer profiles, get app
permissions. Built for developers, ASO tools, and app analytics platforms.

- **URL**: https://apify.com/logiover/google-play-data-api.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Developer tools, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## 📱 Google Play Data API — Unofficial REST-style Scraper for Google Play Store

> **One actor. Ten endpoints. Sub-3-second cold start.** The fastest, most complete unofficial Google Play API on Apify — built for developers, ASO platforms, market researchers, AI agents, and anyone who needs structured data from the Play Store without the hassle of a Google Developer Console account.

Search apps by keyword, pull full app details, scrape reviews with automatic pagination, get top charts by category, find similar apps, list a developer's portfolio, mine autocomplete suggestions for ASO keyword research, audit permissions and data-safety info — all from a single Apify actor.

No headless browser. No proxy required. No login. Pure HTTP. Just JSON.

---

### 🎯 What you can do with this Google Play scraper

| You want to… | Use mode | Typical input |
|---|---|---|
| Find apps matching a keyword | `search` | `"query": "meditation"` |
| Get every detail about a specific app | `app` | `"appId": "com.spotify.music"` |
| Pull thousands of user reviews | `reviews` | `"appId": "...", "maxResults": 5000` |
| See top free / paid / grossing apps | `list` | `"collection": "TOP_FREE"` |
| Find competitors and similar apps | `similar` | `"appId": "..."` |
| List every app by a publisher | `developer` | `"devId": "Spotify AB"` |
| Get ASO autocomplete keywords | `suggest` | `"query": "fit"` |
| Audit Android permissions | `permissions` | `"appId": "..."` |
| Check Google Play data-safety info | `datasafety` | `"appId": "..."` |
| List all Google Play categories | `categories` | — |

Every result is tagged with a `_mode` field so you can run multiple modes back-to-back and slice the dataset afterwards.

---

### 🚀 Why developers, ASO teams, and analysts pick this actor

#### Compared with other Google Play scrapers on Apify

| | Most others | **This actor** |
|---|---|---|
| Endpoints | 1–3 (reviews only, or details only) | **10 endpoints in one** |
| Cold start | 8–15 seconds (headless browser) | **~3 seconds (pure HTTP)** |
| Reviews pagination | Manual / capped at 200 | **Automatic, up to 100,000+ per app** |
| Batch app lookups | Sequential | **5× concurrent** |
| Output schema | Sparse / undocumented | **70 fields, all documented with examples** |
| Dataset views | None | **4 pre-built views (Overview, Apps, Reviews, App details)** |
| Maintenance | Often abandoned | **Built on actively-maintained npm package** |

#### Compared with Google's official Play Developer API

| | Official Google API | **This actor** |
|---|---|---|
| Access scope | Your own apps only | **Any public app on Google Play** |
| Reviews API | OAuth + Play Console required | **Just call it** |
| Search / discovery | Not available | **Yes** |
| Top charts | Not available | **Yes** |
| Competitor analysis | Not possible | **Yes (search, similar, developer modes)** |
| Setup time | Hours (OAuth, scopes, verification) | **Seconds** |

---

### ⚡ Quick start — three runs in 30 seconds

#### Run 1 — Search apps by keyword

```json
{
  "mode": "search",
  "query": "meditation",
  "country": "us",
  "language": "en",
  "maxResults": 50
}
````

**Returns:** 50 apps matching "meditation" with title, icon, developer, rating, install count, price, summary, and direct Play Store URL.

#### Run 2 — Get full details for one app

```json
{
  "mode": "app",
  "appId": "com.spotify.music",
  "country": "us",
  "language": "en"
}
```

**Returns:** every public field — full description (text + HTML), 30+ screenshots, install bands, exact rating histogram (1-star to 5-star counts), version, last updated, content rating, ads/IAP flags, developer name/email/website/legal address, privacy policy URL, genre, and more.

#### Run 3 — Pull 1,000 newest reviews

```json
{
  "mode": "reviews",
  "appId": "com.spotify.music",
  "country": "us",
  "language": "en",
  "maxResults": 1000,
  "reviewSort": "NEWEST"
}
```

**Returns:** 1,000 reviews with user name, avatar, star rating, full review text, date, app version, helpful-votes count, developer reply text and date, and per-criterion sub-ratings (when available).

***

### 📖 All 10 endpoints in depth

#### 1. `mode: "search"` — Keyword search

Find apps that match a search term — the same results a user sees when they type into Google Play's search bar.

```json
{
  "mode": "search",
  "query": "spotify",
  "country": "us",
  "language": "en",
  "maxResults": 50,
  "fullDetail": false
}
```

**Set `fullDetail: true`** to enrich each hit with the full 50+ field app record (slower, but no separate `app` calls needed).

**Use cases:** keyword tracking for ASO, finding competitors, niche discovery, building app directories.

***

#### 2. `mode: "app"` — Full app details

Pull every public field for one app — or many apps in parallel (5× concurrency).

```json
{
  "mode": "app",
  "appIds": ["com.spotify.music", "com.zhiliaoapp.musically", "com.instagram.android"],
  "country": "us",
  "language": "en"
}
```

**Returns 50+ fields including:**

- Identity: appId, title, summary, description, descriptionHTML
- Ratings: score (float), scoreText (display), ratings count, reviews count, full histogram (1–5 star breakdown)
- Reach: installs (display band), minInstalls, maxInstalls, realInstalls
- Pricing: price, currency, free, priceText, offersIAP, IAPRange
- Visual assets: icon, headerImage, screenshots\[], video, videoImage
- Metadata: version, recentChanges, released, updated (epoch ms), androidVersion, contentRating, genre, genreId, categories
- Developer: developer, developerId, developerEmail, developerWebsite, developerAddress, developerLegalName, developerLegalEmail
- Compliance: privacyPolicy, adSupported, isAvailableInPlayPass
- Availability: preregister, earlyAccessEnabled, available

**Use cases:** app intelligence dashboards, competitor pricing analysis, version monitoring, content rating compliance audits.

***

#### 3. `mode: "reviews"` — User reviews with automatic pagination

Pull anywhere from 1 to 100,000+ reviews per app. Pagination is fully automatic — just set `maxResults` and the actor handles continuation tokens.

```json
{
  "mode": "reviews",
  "appId": "com.spotify.music",
  "country": "us",
  "language": "en",
  "maxResults": 5000,
  "reviewSort": "NEWEST",
  "reviewScore": null
}
```

**Sort options:** `NEWEST` (default), `RATING` (highest first), `HELPFULNESS`.

**Filter by star rating:** set `reviewScore: 1` to pull only 1-star reviews — handy for negative-sentiment monitoring.

**Use cases:** review sentiment analysis, NPS-style monitoring, support-load forecasting, version-bug tracking (filter reviews by `version` field after export), competitor weakness research.

***

#### 4. `mode: "list"` — Top charts

Pull top-100 charts (or any size up to 200) for any collection × category combination Google Play exposes.

```json
{
  "mode": "list",
  "collection": "TOP_FREE",
  "category": "GAME_PUZZLE",
  "maxResults": 100,
  "country": "us",
  "language": "en",
  "fullDetail": false
}
```

**Collections:** `TOP_FREE`, `TOP_PAID`, `TOP_GROSSING`, `NEW_FREE`, `NEW_PAID`, `TRENDING`.

**Common category codes:** `GAME`, `BUSINESS`, `EDUCATION`, `FINANCE`, `SOCIAL`, `MUSIC_AND_AUDIO`, `PHOTOGRAPHY`, `PRODUCTIVITY`, `SHOPPING`, `TOOLS`, `TRAVEL_AND_LOCAL`, `HEALTH_AND_FITNESS`, `LIFESTYLE`, `ENTERTAINMENT`, `COMMUNICATION`, `NEWS_AND_MAGAZINES`, `MAPS_AND_NAVIGATION`, `FOOD_AND_DRINK`, `WEATHER`, `BOOKS_AND_REFERENCE`, `DATING`, `MEDICAL`, `PARENTING`, `BEAUTY`, `SPORTS`, `AUTO_AND_VEHICLES`, `HOUSE_AND_HOME`, `ART_AND_DESIGN`, `VIDEO_PLAYERS`, `PERSONALIZATION`, `COMICS`, `EVENTS`, `LIBRARIES_AND_DEMO`. Game subcategories: `GAME_ACTION`, `GAME_ADVENTURE`, `GAME_ARCADE`, `GAME_BOARD`, `GAME_CARD`, `GAME_CASINO`, `GAME_CASUAL`, `GAME_EDUCATIONAL`, `GAME_MUSIC`, `GAME_PUZZLE`, `GAME_RACING`, `GAME_ROLE_PLAYING`, `GAME_SIMULATION`, `GAME_SPORTS`, `GAME_STRATEGY`, `GAME_TRIVIA`, `GAME_WORD`.

**Use cases:** chart-position tracking, category benchmarking, market trend analysis, country-by-country expansion research.

***

#### 5. `mode: "similar"` — Apps similar to a given app

Get the "Similar apps" list that Google Play shows on every app page.

```json
{
  "mode": "similar",
  "appId": "com.spotify.music",
  "country": "us",
  "language": "en",
  "maxResults": 30,
  "fullDetail": true
}
```

**Use cases:** competitor mapping, market sizing for a niche, finding adjacent categories, ad-targeting lookalike audiences.

***

#### 6. `mode: "developer"` — All apps by a publisher

List every app a developer has published on Google Play.

```json
{
  "mode": "developer",
  "devId": "Spotify AB",
  "country": "us",
  "language": "en",
  "maxResults": 100,
  "fullDetail": false
}
```

The `devId` is the developer's URL-encoded name (you'll find it in any of their app records as `developerId`).

**Use cases:** publisher portfolio analysis, M\&A research, identifying "studio" releases, agency competitive monitoring.

***

#### 7. `mode: "suggest"` — Autocomplete suggestions for ASO

Get the autocomplete suggestions Google Play shows as you type — gold for ASO keyword research because they reflect actual search behavior.

```json
{
  "mode": "suggest",
  "query": "fit",
  "country": "us",
  "language": "en"
}
```

**Returns:** ranked list of suggested search terms (e.g. `fitness apps`, `fitness tracker`, `fitness band`).

**Use cases:** ASO keyword discovery, long-tail keyword mining, title and short-description optimization, paid UAC campaign keyword seeding.

***

#### 8. `mode: "permissions"` — Android permissions

List every Android permission an app declares.

```json
{
  "mode": "permissions",
  "appId": "com.spotify.music",
  "country": "us",
  "language": "en",
  "shortPermissions": false
}
```

Set `shortPermissions: true` for compact string output instead of full permission objects.

**Use cases:** privacy audits, MDM (Mobile Device Management) policy compliance, security research, "what does this app access?" UX displays.

***

#### 9. `mode: "datasafety"` — Google Play data-safety info

Pull the "Data safety" section that Google requires every developer to fill in — what data the app collects, whether it's shared, and security practices.

```json
{
  "mode": "datasafety",
  "appIds": ["com.spotify.music", "com.zhiliaoapp.musically"],
  "country": "us",
  "language": "en"
}
```

**Use cases:** GDPR/CCPA compliance research, vendor security reviews, consumer privacy tools, building "privacy nutrition label" UIs.

***

#### 10. `mode: "categories"` — All Play Store categories

Get the full list of Google Play category codes — useful for populating filter UIs or for use in `list` mode.

```json
{
  "mode": "categories"
}
```

No other inputs needed.

> ⚠️ **Known limitation:** Google Play occasionally changes how it exposes its category list. When that happens, this endpoint may return a reduced list until the upstream library is updated. Common stable category codes are documented above under endpoint 4.

***

### 💡 Real-world use cases

#### ASO platforms and app store optimization tools

- **Keyword tracking** — run `search` mode daily across your tracked keywords, compute rank changes
- **Suggest mining** — feed `suggest` mode 1,000 seed terms, harvest tens of thousands of long-tail keywords
- **Competitor monitoring** — run `app` mode on competitors weekly, alert on title / description / screenshot changes
- **Top-chart tracking** — `list` mode by country + category for market-share dashboards

#### App intelligence and analytics platforms

- **Bulk metadata ingestion** — `app` mode in batch (pass hundreds of `appIds`)
- **Review streaming** — `reviews` mode in a scheduled Apify task, deduplicate by review `id` server-side
- **Install-band estimation** — `minInstalls` / `maxInstalls` fields give you Google's official bands per country
- **Pricing intelligence** — `price`, `free`, `IAPRange`, `offersIAP` fields for monetization research

#### AI agents and LLM-powered tools

- **ChatGPT / Claude plugins** — wrap this actor as a tool so users can ask "what are the top 10 mindfulness apps in Germany?"
- **RAG pipelines** — pull full app `description` + recent `reviews` for context-rich embeddings
- **Customer-support bots** — given an app ID, fetch latest reviews + version + recent changes to answer "what's broken in the new version?"

#### Market research and consultancies

- **Category benchmarking** — top-100 free + grossing charts by country, joined to install bands
- **Genre trend analysis** — track which categories are growing by sampling top charts over time
- **Publisher M\&A research** — `developer` mode to map a target's portfolio and revenue indicators

#### Privacy, compliance, and security teams

- **Permission audits** — `permissions` mode across hundreds of corporate-approved apps
- **Data-safety reviews** — `datasafety` mode for GDPR / app procurement workflows
- **Privacy "nutrition label" UIs** — surface what an app collects in a user-friendly format

#### Internal alerting and product monitoring

- **Your own app's reviews** — schedule `reviews` mode hourly, alert on sudden 1-star spikes
- **Version drift** — compare `version` field run-over-run, alert when a new release hits Play Store
- **Competitor releases** — `app` mode on competitor IDs daily, alert on `updated` timestamp change

***

### 🔌 Integration — call this actor from your stack

#### REST API (curl)

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/YOUR-USERNAME~google-play-data-api/run-sync-get-dataset-items?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "mode": "search",
    "query": "meditation",
    "maxResults": 50
  }'
```

#### JavaScript / Node.js

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const { defaultDatasetId } = await client
    .actor('YOUR-USERNAME/google-play-data-api')
    .call({
        mode: 'reviews',
        appId: 'com.spotify.music',
        maxResults: 1000,
        reviewSort: 'NEWEST',
    });

const { items } = await client.dataset(defaultDatasetId).listItems();

for (const review of items) {
    console.log(`${review.score}★  ${review.userName}: ${review.text}`);
}
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("YOUR-USERNAME/google-play-data-api").call(
    run_input={
        "mode": "app",
        "appIds": ["com.spotify.music", "com.instagram.android"],
        "country": "us",
        "language": "en",
    }
)

for app in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{app['title']:40s} ⭐ {app['score']:.1f}  📥 {app['installs']}")
```

#### No-code automation (n8n, Make, Zapier)

This actor works out-of-the-box with any tool that supports Apify's HTTP API. Trigger it on a schedule, push results to Google Sheets, Airtable, Notion, Slack, your warehouse — whatever you already use.

***

### 📊 Output format

#### Universal fields (on every item, every mode)

| Field | Type | Description |
|---|---|---|
| `_mode` | string | Which endpoint produced this item — use it to filter when you mix modes |
| `scrapedAt` | string (ISO 8601) | UTC timestamp of when this item was scraped |

#### Pre-built dataset views

Switch between these in the Apify dataset UI without any post-processing:

- **Overview** — universal columns across all modes (`_mode`, `appId`, `title`, `developer`, `score`, `installs`, `price`, `url`)
- **App catalog** — best for `search`, `list`, `similar`, `developer` modes (icon, title, developer, rating, install band, price)
- **Reviews** — best for `reviews` mode (user, rating, text, date, version, developer reply)
- **App details** — wide view for `app` mode (50+ fields including ratings, pricing, monetization, content rating, developer contact)

#### Export formats

The Apify dataset exposes the data as JSON, CSV, XLSX (multi-sheet workbook), HTML, RSS (great for review monitoring), and JSONLines (for streaming pipelines).

***

### ⚡ Performance benchmarks

Measured on Apify default resources, `us` locale:

| Operation | Time |
|---|---|
| Cold start (container spin-up to first result) | ~3 seconds |
| `search` — 50 results | 2–4 seconds |
| `app` — single app full details | 1–2 seconds |
| `app` — batch of 100 apps (5× concurrency) | 20–30 seconds |
| `reviews` — 1,000 reviews (auto-paginated) | 10–15 seconds |
| `reviews` — 10,000 reviews | 90–120 seconds |
| `list` — top 100 from a chart | 2–4 seconds |
| `similar` — 30 results | 2–4 seconds |
| `developer` — 50 apps by publisher | 2–4 seconds |
| `suggest` — autocomplete | <1 second |
| `permissions` / `datasafety` — single app | 1–2 seconds |
| `categories` | <1 second |

Non-US locales may be slightly slower due to localization. Reviews retrieval scales linearly with `maxResults`.

***

### 🌍 Country and language support

Pass any combination of `country` (ISO 3166-1 alpha-2, e.g. `us`, `gb`, `de`, `tr`, `jp`, `br`, `in`, `mx`) and `language` (BCP 47, e.g. `en`, `tr`, `de`, `fr`, `pt`, `ja`, `ar`, `hi`).

The same app can have **different titles, descriptions, ratings, screenshots, and even availability** per locale. For accurate localized data, always pair `country` with the matching `language`.

Tested heavily in: `us/en`, `gb/en`, `de/de`, `fr/fr`, `es/es`, `it/it`, `tr/tr`, `jp/ja`, `kr/ko`, `br/pt`, `mx/es`, `in/en`, `in/hi`.

***

### ❓ FAQ

#### Is this an official Google API?

No — this is an unofficial scraper. It accesses only data that is publicly visible on the Google Play website, the same way a browser would. No authentication, no Play Console account, no OAuth.

#### Do I need a Google account or API key?

No. You only need an Apify account (free tier works for testing).

#### Is this legal?

This actor scrapes publicly available data from `play.google.com`. As with any scraper, use it responsibly: respect rate limits, follow Google's terms of service, and use the data for legitimate research, analytics, or product purposes. Bulk redistribution of Google's data or commercial resale may require additional consideration — consult your legal counsel.

#### How accurate is the rating data?

`score` is the floating-point average rating Google Play exposes (e.g. `4.3372774`), and `scoreText` is the rounded display version (`"4.3"`). The `histogram` field gives you the exact 1-star to 5-star vote counts. `ratings` is the total rating count (including no-comment ratings) and `reviews` is the count of reviews that include text.

#### Can I scrape paid app prices and in-app purchases?

Yes — for paid apps `price` returns the numeric price in the requested country's `currency`. For apps with IAPs, `offersIAP` is `true` and `IAPRange` returns Google's price-range string (e.g. `"$0.99 – $99.99 per item"`).

#### What about app screenshots and icons?

`app` mode returns the `icon` URL and a `screenshots` array with every screenshot (often 20–40 images). Each is a direct CDN URL — no auth required to fetch.

#### How do I get historical reviews (older than the last few months)?

Use `reviewSort: "NEWEST"` and crank `maxResults` up. The reviews endpoint will paginate backwards in time as long as Google Play exposes the reviews. In practice, you can pull tens of thousands of reviews from popular apps.

#### Why does the `categories` endpoint sometimes return only one item?

Google Play occasionally changes its HTML structure, which can break the upstream parser. The actor returns whatever the library finds. Common category codes are documented in the `list` endpoint section above — use those directly until the parser is updated upstream.

#### Can I run multiple modes in one actor run?

Each actor run executes one mode. To combine modes (e.g. `search` then `reviews` on every result), call the actor multiple times via the API and join the datasets on `appId`. Each result includes `_mode` so you can keep everything in a single combined dataset.

#### What's the difference between `price=null` and `price=0`?

This actor normalizes both to `price: 0, free: true` for consistency. If you want to distinguish "explicitly priced at 0" from "unpriced", look at `priceText` — free apps return `"Free"`, while paid apps return the localized currency string.

#### How do I monitor my own app's reviews?

Set up a scheduled Apify task with this config:

```json
{
  "mode": "reviews",
  "appId": "YOUR.APP.ID",
  "reviewSort": "NEWEST",
  "maxResults": 100
}
```

Schedule it hourly. Use the Apify dataset's RSS export to feed into Slack, email, or a webhook. Each review has a unique `id` so you can deduplicate.

#### Can I use this for App Store / iOS data too?

This actor covers **Google Play (Android) only**. For App Store (iOS) data, use a separate scraper.

#### Does this support proxy rotation?

The actor uses pure HTTP and works fine from Apify's default infrastructure without proxies. If your use case requires custom proxy routing for high-volume runs, you can configure proxy settings in the Apify run options.

***

### 🛠 Built on open source

This actor is built on top of [`google-play-scraper`](https://github.com/facundoolano/google-play-scraper) — the de-facto unofficial Google Play library (84,000+ weekly npm downloads, MIT-licensed, actively maintained since 2017). The actor wraps the library with:

- A unified mode-based interface so all 10 methods are accessible from one input form
- Automatic pagination for reviews
- Concurrent batch processing (5× workers) for app detail lookups
- Retry logic with exponential backoff for transient errors (429s, 5xx, network blips)
- Output normalization (consistent URL format, price/free reconciliation)
- A complete dataset schema with 70 fields and 4 pre-built views
- Production logging with per-mode and per-app progress

***

### 🆘 Support

Have an issue, a feature request, or a use case you'd like supported?

- **Bug reports & feature requests:** open an Issue on this actor's page
- **Response time:** typically within 24 hours
- **Custom modifications:** available on request — contact via Apify Console

***

#### Keywords

google play scraper · google play api · unofficial google play api · play store api · google play store scraper · google play reviews scraper · android app data api · google play search api · google play top charts · google play developer api · play store data extraction · app store data · android app reviews · aso keyword research · app intelligence platform · play store autocomplete · google play permissions · google play data safety · android app analytics · play store metadata · google play category scraper · google play similar apps · play store competitor analysis

# Actor input Schema

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

Which Google Play endpoint to call.

• **search** — keyword search (most common)
• **app** — full details for one or more app IDs
• **reviews** — user reviews with pagination
• **list** — top charts (free/paid/grossing) by category
• **similar** — apps similar to a given app
• **developer** — all apps by a developer
• **suggest** — autocomplete suggestions (great for ASO keyword research)
• **permissions** — Android permissions list (privacy/security audits)
• **datasafety** — Google Play data safety section
• **categories** — full list of Google Play category codes

## `appId` (type: `string`):

Single Google Play app ID — the value after `id=` in the Play Store URL. E.g. `com.spotify.music`. Used by **app**, **reviews**, **similar**, **permissions**, **datasafety** modes.

## `appIds` (type: `array`):

Array of app IDs for batch operations. Used by **app**, **reviews**, **permissions**, **datasafety** modes when you want multiple apps in one run. Adds to (or replaces) the single App ID field above.

## `query` (type: `string`):

Keyword to search for in **search** mode, or partial term for **suggest** mode autocomplete.

## `devId` (type: `string`):

Developer name as it appears on Google Play (URL-encoded). E.g. `Spotify+AB` or `Google+LLC`. Used by **developer** mode.

## `collection` (type: `string`):

Which top chart to fetch in **list** mode.

## `category` (type: `string`):

Optional category filter for **list** mode. Use the category code (e.g. `GAME`, `BUSINESS`, `EDUCATION`, `FINANCE`, `SOCIAL`). Run mode=categories first to see all available codes.

## `age` (type: `string`):

Age-band filter for game categories in **list** mode.

## `reviewSort` (type: `string`):

How reviews are ordered when fetched from Google Play.

## `reviewScore` (type: `integer`):

Optional: return only reviews with this exact star rating (1–5). Leave blank for all ratings.

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

Two-letter country code. Affects localized title, description, ratings, and which apps are returned. E.g. `us`, `gb`, `de`, `tr`, `jp`, `br`.

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

Two-letter language code. E.g. `en`, `tr`, `de`, `fr`, `pt`, `ja`.

## `maxResults` (type: `integer`):

Maximum results to return. For **reviews** mode, this is per-app. For **list/search/similar/developer** modes, this is overall. Note: some modes have hard caps from Google Play (typically 250).

## `fullDetail` (type: `boolean`):

For **search**, **list**, **similar**, **developer** modes: if enabled, each result is enriched with the full 47+ field app detail (slower, more expensive). Disable for quick lookups.

## `shortPermissions` (type: `boolean`):

For **permissions** mode: if enabled, returns a compact list of permission strings instead of the full permission objects.

## Actor input object example

```json
{
  "mode": "search",
  "appId": "com.spotify.music",
  "appIds": [],
  "query": "spotify",
  "devId": "Spotify AB",
  "collection": "TOP_FREE",
  "category": "GAME",
  "reviewSort": "NEWEST",
  "country": "us",
  "language": "en",
  "fullDetail": false,
  "shortPermissions": false
}
```

# Actor output Schema

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

Full results dataset. Switch between Overview, App catalog, Reviews, and App details views depending on which mode you ran.

# 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("logiover/google-play-data-api").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("logiover/google-play-data-api").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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 logiover/google-play-data-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=logiover/google-play-data-api",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Play Data API Scraper",
        "description": "Unofficial REST-style API for Google Play Store. Search apps, get full details, \nextract reviews, list category top charts, fetch developer profiles, get app \npermissions. Built for developers, ASO tools, and app analytics platforms.",
        "version": "1.0",
        "x-build-id": "mFfkcxG3BcbDuBBTd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~google-play-data-api/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-google-play-data-api",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/logiover~google-play-data-api/runs": {
            "post": {
                "operationId": "runs-sync-logiover-google-play-data-api",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/logiover~google-play-data-api/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-google-play-data-api",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "app",
                            "reviews",
                            "list",
                            "similar",
                            "developer",
                            "suggest",
                            "permissions",
                            "datasafety",
                            "categories"
                        ],
                        "type": "string",
                        "description": "Which Google Play endpoint to call.\n\n• **search** — keyword search (most common)\n• **app** — full details for one or more app IDs\n• **reviews** — user reviews with pagination\n• **list** — top charts (free/paid/grossing) by category\n• **similar** — apps similar to a given app\n• **developer** — all apps by a developer\n• **suggest** — autocomplete suggestions (great for ASO keyword research)\n• **permissions** — Android permissions list (privacy/security audits)\n• **datasafety** — Google Play data safety section\n• **categories** — full list of Google Play category codes",
                        "default": "search"
                    },
                    "appId": {
                        "title": "App ID",
                        "type": "string",
                        "description": "Single Google Play app ID — the value after `id=` in the Play Store URL. E.g. `com.spotify.music`. Used by **app**, **reviews**, **similar**, **permissions**, **datasafety** modes."
                    },
                    "appIds": {
                        "title": "App IDs (batch)",
                        "type": "array",
                        "description": "Array of app IDs for batch operations. Used by **app**, **reviews**, **permissions**, **datasafety** modes when you want multiple apps in one run. Adds to (or replaces) the single App ID field above.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "query": {
                        "title": "Search query / keyword",
                        "type": "string",
                        "description": "Keyword to search for in **search** mode, or partial term for **suggest** mode autocomplete."
                    },
                    "devId": {
                        "title": "Developer ID",
                        "type": "string",
                        "description": "Developer name as it appears on Google Play (URL-encoded). E.g. `Spotify+AB` or `Google+LLC`. Used by **developer** mode."
                    },
                    "collection": {
                        "title": "Top-chart collection",
                        "enum": [
                            "TOP_FREE",
                            "TOP_PAID",
                            "TOP_GROSSING",
                            "NEW_FREE",
                            "NEW_PAID",
                            "TRENDING"
                        ],
                        "type": "string",
                        "description": "Which top chart to fetch in **list** mode.",
                        "default": "TOP_FREE"
                    },
                    "category": {
                        "title": "Category filter",
                        "type": "string",
                        "description": "Optional category filter for **list** mode. Use the category code (e.g. `GAME`, `BUSINESS`, `EDUCATION`, `FINANCE`, `SOCIAL`). Run mode=categories first to see all available codes."
                    },
                    "age": {
                        "title": "Age filter (games only)",
                        "enum": [
                            "FIVE_UNDER",
                            "SIX_EIGHT",
                            "NINE_UP"
                        ],
                        "type": "string",
                        "description": "Age-band filter for game categories in **list** mode."
                    },
                    "reviewSort": {
                        "title": "Review sort order",
                        "enum": [
                            "NEWEST",
                            "RATING",
                            "HELPFULNESS"
                        ],
                        "type": "string",
                        "description": "How reviews are ordered when fetched from Google Play.",
                        "default": "NEWEST"
                    },
                    "reviewScore": {
                        "title": "Filter by star rating",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Optional: return only reviews with this exact star rating (1–5). Leave blank for all ratings."
                    },
                    "country": {
                        "title": "Country (ISO 3166-1 alpha-2)",
                        "type": "string",
                        "description": "Two-letter country code. Affects localized title, description, ratings, and which apps are returned. E.g. `us`, `gb`, `de`, `tr`, `jp`, `br`.",
                        "default": "us"
                    },
                    "language": {
                        "title": "Language (BCP 47)",
                        "type": "string",
                        "description": "Two-letter language code. E.g. `en`, `tr`, `de`, `fr`, `pt`, `ja`.",
                        "default": "en"
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum results to return. For **reviews** mode, this is per-app. For **list/search/similar/developer** modes, this is overall. Note: some modes have hard caps from Google Play (typically 250)."
                    },
                    "fullDetail": {
                        "title": "Enrich results with full app details",
                        "type": "boolean",
                        "description": "For **search**, **list**, **similar**, **developer** modes: if enabled, each result is enriched with the full 47+ field app detail (slower, more expensive). Disable for quick lookups.",
                        "default": false
                    },
                    "shortPermissions": {
                        "title": "Short permissions output",
                        "type": "boolean",
                        "description": "For **permissions** mode: if enabled, returns a compact list of permission strings instead of the full permission objects.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```