# Google Play Scraper - Rankings, Reviews & App Details (`haketa/google-play-scraper`) Actor

Google Play scraper & API: export top-chart rankings by category & country, app reviews & ratings, full app details and ASO keyword search. Android app market intelligence, review analysis and competitor tracking — fast, no login. Pairs with an Apple App Store scraper.

- **URL**: https://apify.com/haketa/google-play-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** SEO tools, Developer tools, Automation
- **Features:** Limited permissions
- **Stats:** 47 total users, 4 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Scraper 📱 — Rankings, Reviews, App Details & Keyword Search

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-00B4D8?style=for-the-badge\&logo=apify\&logoColor=white)](https://apify.com/haketa/google-play-scraper)
[![Google Play](https://img.shields.io/badge/Target-Google_Play_Store-414141?style=for-the-badge\&logo=google-play\&logoColor=white)](https://play.google.com/store)
[![Scale](https://img.shields.io/badge/Scale-1%2C000%2B_Apps_%26_Reviews-2EA44F?style=for-the-badge)]()
[![Markets](https://img.shields.io/badge/Markets-50%2B_Countries_%7C_30%2B_Languages-8A2BE2?style=for-the-badge)]()
[![Export](https://img.shields.io/badge/Export-JSON_%7C_CSV_%7C_Excel_%7C_API-FF9900?style=for-the-badge)]()

**Scrape [Google Play](https://play.google.com/store) data as clean, structured JSON — top-chart rankings by category and country, fully-paginated app reviews, complete app details, and keyword search.** This **Google Play scraper** turns the Play Store into a structured dataset: pull the Top Free / Top Paid / Top Grossing charts for any of 50+ markets, extract every public review for an app, grab full app metadata (installs, ratings, histogram, full description, pricing, developer contact) and run keyword searches for ASO — **no login, no coding, no headless browser.**

Export to **JSON, CSV, Excel, or API**.

> 🧭 Built for **ASO specialists, app marketers, product managers, competitive-intelligence analysts, investors, and data/AI teams** who need reliable, localized Google Play data at scale.

***

### ⚡ At a glance

| Feature | Details |
|---|---|
| **Target Website** | [Google Play Store](https://play.google.com/store) — Android apps, games, top charts & user reviews |
| **4 Extraction Modes** | `rankings` (Top Free/Paid/Grossing), `reviews` (cursor-paginated), `appDetails` (full metadata), `search` (ASO keywords) |
| **Core Data Extracted** | App ID, title, rank, installs, score, 1–5★ histogram, full description, developer email/website/address, IAP/price, reviews |
| **Pagination & Scale** | Multi-category chart & keyword expansion + deep review cursor pagination for **1,000+ unique records** |
| **Localization** | 50+ countries (`gl`) and 30+ languages (`hl`) built into dropdown selectors |
| **Export Formats** | JSON, CSV, Excel (XLSX), XML, HTML table, RSS, and direct Apify REST API / Webhooks |

***

### 📋 Table of contents

- [Why scrape Google Play?](#-why-scrape-google-play)
- [What this Google Play scraper does](#-what-this-google-play-scraper-does)
- [Use cases](#-use-cases)
- [Input](#-input)
- [Output](#-output)
- [Pagination & scale](#-pagination--scale)
- [How to use](#️-how-to-use)
- [Tips](#-tips)
- [FAQ](#-faq)
- [Related scrapers](#-related-scrapers)

***

### 🔎 Why scrape Google Play?

Google Play is the largest app marketplace on earth — millions of apps, billions of installs, and a live stream of reviews and ranking movements. That data is gold for **app store optimization (ASO)**, competitive research, and product decisions: which apps are climbing the charts, how a competitor is rated, what users complain about, how a title is positioned in its description, and how it all differs market by market.

The problem is that **Google Play has no public API** for most of this. The data lives in server-rendered JSON and an internal RPC, rankings are paginated and localized, and reviews sit behind a cursor-based endpoint that returns a few at a time. Collecting it by hand — opening pages, scrolling reviews, copying installs and ratings per country — is slow, error-prone, and impossible to keep fresh daily.

This **Google Play scraper** does it for you: it adds Apify proxy rotation and bounded concurrency on top of a battle-tested parsing core, and **fully paginates reviews with no artificial cap** — the single thing most Play scrapers get wrong. You get clean, typed records ready for a dashboard, a database, or an AI pipeline. A fresh benchmark run pulled the live **US Top Free** chart — **200 apps in ~141 seconds, 0 duplicates, 100% core-field coverage** — and a review run returned **400 de-duplicated reviews** for a single app across multiple cursor pages.

**Common reasons people scrape Google Play:**

- 📈 **Track top-chart rankings** daily per category and country (a low-cost Sensor Tower / data.ai alternative).
- 💬 **Analyze reviews at scale** for sentiment, bug reports, and feature requests — yours and your competitors'.
- 🔑 **Run ASO keyword research** — see which apps rank for a term and read their full descriptions and metadata.
- 🏢 **Benchmark competitors** on installs, ratings, monetization (IAP, price), and content rating.
- 💼 **Build market-intelligence feeds** for investment, M\&A, and category research.
- 🤖 **Create training datasets** for review-sentiment models and app-ranking analytics.
- 🌍 **Compare markets** — the same app's rank, price, and reviews across 50+ countries.

***

### ✨ What this Google Play scraper does

One actor, four modes — pick what you need and run:

- ✅ 🏆 **Rankings mode** — the **Top Free / Top Paid / Top Grossing** charts for any category and country, each app tagged with its **rank** position (up to ~200 apps per chart — Google Play's full server-side ceiling for a chart). A Sensor-Tower-style market-intelligence feed: any category × any country × any chart.
- ✅ 💬 **Reviews mode** — every public review for an app, **fully paginated** (sort by newest / rating / helpfulness), with rating, review text, date, thumbs-up count, app version, and the developer's reply.
- ✅ 📋 **App details mode** — complete app metadata: rating, ratings & reviews counts, the **1–5 star histogram**, installs, price and IAP, the **full app description**, developer name/email/website, category, content rating, version, release/update dates, screenshots and more.
- ✅ 🔎 **Search mode** — apps for a keyword (ideal for ASO and keyword-rank tracking), each enriched with full details.

Plus:

- ✅ **Automatic pagination** that collects large, **de-duplicated** result sets — hundreds of ranked apps, or thousands of reviews across multiple apps.
- ✅ **Rich captured fields** grouped by record type (named in the [Output](#-output) section): identity (`appId`, `title`, `url`), **marketing/ASO** (`summary`, `description`, `descriptionHTML`), **ratings** (`score`, `ratings`, `reviews`, `histogram`), **popularity** (`installs`, `minInstalls`, `maxInstalls`), **monetization** (`price`, `free`, `currency`, `offersIAP`, `IAPRange`, `adSupported`), **developer/contact** (`developer`, `developerId`, `developerEmail`, `developerWebsite`, `developerAddress`), and **classification** (`genre`, `categories`, `contentRating`, `version`, `released`, `updated`).
- ✅ **Localization** — every result respects **country (`gl`)** and **language (`hl`)**; 50+ countries and 30+ languages are pre-listed in the input.
- ✅ **Speed & reliability** — API-first (no browser), pooled keep-alive proxy connections with rotating exit IPs, bounded concurrency, per-item error isolation, and a time-budget guard that saves partial results instead of timing out.
- ✅ **Export** to **JSON, CSV, Excel, XML, or HTML**, or pull straight from the **Apify API**.

Only features the code actually implements are claimed above.

***

### 🎯 Use cases

- **📈 ASO & app marketing** — monitor chart rankings and keyword positions daily; mine full app descriptions and metadata to tune your own listing.
- **💬 Review mining / product teams** — pull the complete review stream for your app and rivals to surface bugs, feature requests, and sentiment trends.
- **🏢 Competitive intelligence** — compare installs, ratings, histograms, pricing, and IAP strategy across a category.
- **💼 Investment & M\&A research** — see who's climbing the Top Grossing charts in a market before anyone else.
- **🌍 Localization & market entry** — compare a title's rank, price, and reviews across 50+ countries to plan a launch.
- **🔌 Lead generation** — collect **developer email, website, and address** for apps in a niche or category.
- **🤖 Data & AI** — build app datasets and review-sentiment corpora for models and dashboards.
- **📊 Agencies & reporting** — schedule recurring runs and feed Google Sheets, BigQuery, or a BI tool via the API.

***

### 📥 Input

Configure everything from the Apify Console form — or pass a JSON input via the API. All fields are optional; an empty run returns a useful, diverse sample so you can see the shape instantly.

| Field | Type | Description |
|---|---|---|
| `mode` | string | What to scrape: `rankings`, `reviews`, `appDetails`, or `search`. Default `rankings`. |
| `collection` | string | Rankings chart: `TOP_FREE`, `TOP_PAID`, or `GROSSING`. Default `TOP_FREE`. |
| `category` | string | Rankings category, e.g. `APPLICATION` (all apps), `GAME` (all games), `SOCIAL`, `FINANCE`, `PHOTOGRAPHY`, `GAME_ACTION`. Default `APPLICATION`. |
| `searchTerms` | array | Keywords for **Keyword search** mode, e.g. `["photo editor", "budget"]`. |
| `appIds` | array | App package names (e.g. `com.whatsapp`) or full Play Store URLs — for **reviews** and **appDetails** modes. |
| `maxReviewsPerApp` | integer | Reviews to pull per app (fully paginated; Google serves up to ~4,500 per app). Default `200`. |
| `reviewsSort` | string | Review order: `NEWEST`, `RATING`, or `HELPFULNESS`. Default `NEWEST`. |
| `country` | string | Market / `gl` code — 50+ supported, e.g. `us`, `gb`, `de`, `tr`, `in`, `br`, `jp`. Default `us`. |
| `language` | string | Language / `hl` code for titles, descriptions, reviews — 30+ supported. Default `en`. |
| `fullDetail` | boolean | Enrich each ranked/found app with complete details (installs, histogram, full description, version…). Default `true`. Turn off for a faster, lighter rank-only list. |
| `maxItems` | integer | Cap total records (apps or reviews). `0` = no limit. Default `0`. |
| `proxyConfiguration` | object | Proxy settings. Default Apify Proxy is fine; `RESIDENTIAL` helps on very large review pulls. |
| `maxConcurrency` | integer | Max apps processed in parallel. Default `12` (max `20`). |

#### Input examples

**1) Top free apps in the US**

```json
{
  "mode": "rankings",
  "collection": "TOP_FREE",
  "category": "APPLICATION",
  "country": "us",
  "maxItems": 200
}
```

**2) Top grossing games in Germany**

```json
{
  "mode": "rankings",
  "collection": "GROSSING",
  "category": "GAME",
  "country": "de"
}
```

**3) All reviews for two apps, newest first**

```json
{
  "mode": "reviews",
  "appIds": ["com.whatsapp", "com.spotify.music"],
  "maxReviewsPerApp": 1000,
  "reviewsSort": "NEWEST",
  "country": "us"
}
```

**4) Full app details**

```json
{
  "mode": "appDetails",
  "appIds": ["com.instagram.android"]
}
```

**5) Keyword search (ASO)**

```json
{
  "mode": "search",
  "searchTerms": ["photo editor", "budget tracker"],
  "country": "us"
}
```

***

### 📤 Output

Every record is a flat JSON object. A `recordType` field tells you what it is: `rankedApp` (rankings mode), `app` (search / app-details), or `review` (reviews mode). Results stream to the dataset as they're scraped and can be exported to **JSON, CSV, Excel, XML, or HTML**, or read via the Apify API.

**App / ranked-app record** (full metadata when `fullDetail` is on):

```json
{
  "recordType": "rankedApp",
  "rank": 1,
  "collection": "TOP_FREE",
  "rankCategory": "APPLICATION",
  "country": "us",
  "appId": "com.facebook.aura",
  "title": "Muse from Meta",
  "url": "https://play.google.com/store/apps/details?id=com.facebook.aura&hl=en&gl=us",
  "summary": "Your personal AI agent",
  "description": "Muse is your personal AI agent that gets things done, always working on what matters to you. It manages email, ...",
  "descriptionHTML": "Muse is your personal AI agent that gets things done...",
  "developer": "Meta Platforms, Inc.",
  "developerId": "Meta+Platforms,+Inc.",
  "developerEmail": "facebook.android@fb.com",
  "developerWebsite": null,
  "score": 4.724825,
  "scoreText": "4.7",
  "ratings": 132512,
  "reviews": 20904,
  "histogram": { "1": 4459, "2": 1337, "3": 2820, "4": 8967, "5": 114924 },
  "installs": "5,000,000+",
  "minInstalls": 5000000,
  "maxInstalls": 7949137,
  "price": 0,
  "free": true,
  "currency": "USD",
  "priceText": "Free",
  "available": true,
  "offersIAP": true,
  "IAPRange": "$0.99 - $1,049.00 per item",
  "adSupported": false,
  "isAvailableInPlayPass": false,
  "genre": "Productivity",
  "genreId": "PRODUCTIVITY",
  "categories": [{ "name": "Productivity", "id": "PRODUCTIVITY" }],
  "contentRating": "Teen",
  "contentRatingDescription": "Diverse Content: Discretion Advised",
  "androidVersion": "10",
  "version": "14.0.0.4.149",
  "released": "Aug 31, 2026",
  "updated": 1793355852000,
  "icon": "https://play-lh.googleusercontent.com/qDQUfohqN-eZh_a_YuWYlTsBPwjg...",
  "screenshots": ["https://play-lh.googleusercontent.com/R7pQ9kQjhDBbsreE7p2M4D91...", "..."],
  "privacyPolicy": "https://muse.ai/privacy",
  "editorsChoice": null,
  "scrapedAt": "2026-11-01T23:34:59.730Z"
}
```

**Review record:**

```json
{
  "recordType": "review",
  "appId": "com.whatsapp",
  "reviewId": "1adf3890-82a9-49be-b281-87b496ad8ba3",
  "userName": "George Ibok",
  "userImage": "https://play-lh.googleusercontent.com/a/ACg8ocKYZDHGtgDQwH4lBq4Dh2BQ...",
  "score": 5,
  "title": null,
  "text": "very nice app",
  "date": "2026-10-31T23:37:30.820Z",
  "thumbsUp": 0,
  "version": "2.26.42.74",
  "replyText": null,
  "replyDate": null,
  "criterias": [],
  "url": "https://play.google.com/store/apps/details?id=com.whatsapp&reviewId=1adf3890-82a9-49be-b281-87b496ad8ba3",
  "country": "us",
  "scrapedAt": "2026-11-01T23:38:02.103Z"
}
```

#### Field reference

**App fields** (`recordType: "app"` / `"rankedApp"`):

| Category | Field | Coverage | Description |
|---|---|---|---|
| 🏷️ **Identity** | `recordType` | 🟢 High | `app` or `rankedApp`. |
| 🏆 **Ranking** | `rank` / `collection` / `rankCategory` | 🟢 High | Chart position and chart/category (rankings mode). |
| 🏷️ **Identity** | `appId` | 🟢 High | Play package name, e.g. `com.whatsapp`. |
| 🏷️ **Identity** | `title` / `url` / `icon` | 🟢 High | App name, Play Store URL, icon image. |
| 📝 **ASO & Copy** | `summary` | 🟢 High | Short tagline. |
| 📝 **ASO & Copy** | `description` / `descriptionHTML` | 🟢 High | **Full app description** text and HTML — present when `fullDetail` is on. |
| 🧑‍💻 **Developer & Lead Gen** | `developer` / `developerId` | 🟢 High | Developer name and Play Store developer ID. |
| 🧑‍💻 **Developer & Lead Gen** | `developerEmail` / `developerWebsite` / `developerAddress` | 🟡 Conditional | Developer contact details (email, website, physical address). |
| ⭐ **Ratings & Reviews** | `score` / `scoreText` / `ratings` / `reviews` | 🟢 High | Average rating, display string, total ratings count, total reviews count. |
| ⭐ **Ratings & Reviews** | `histogram` | 🟢 High | 1–5 star rating breakdown object. |
| 📈 **Install Volume** | `installs` / `minInstalls` / `maxInstalls` | 🟢 High | Install tier label and exact numeric bounds. |
| 💰 **Monetization** | `price` / `originalPrice` / `discountEndDate` / `free` / `currency` / `priceText` | 🟢 High | Pricing; `originalPrice`/`discountEndDate` present during active promotions. |
| 💰 **Monetization** | `available` / `offersIAP` / `IAPRange` / `isAvailableInPlayPass` / `adSupported` | 🟢 High | Availability, in-app purchase range, Play Pass status, ad support. |
| 🗂️ **Classification** | `genre` / `genreId` / `categories` | 🟢 High | Primary genre and category array. |
| 🗂️ **Classification** | `contentRating` / `contentRatingDescription` | 🟢 High | Age rating and content descriptors. |
| ⚙️ **Release & Tech** | `androidVersion` / `version` / `released` / `updated` / `recentChanges` | 🟢 High | Android OS requirement, current version, release/update dates, changelog. |
| 🖼️ **Media & Links** | `headerImage` / `screenshots` / `video` / `videoImage` | 🟡 Conditional | Store graphic assets and promo video URLs. |
| 🌐 **Metadata** | `privacyPolicy` / `editorsChoice` / `country` / `scrapedAt` | 🟢 High | Privacy policy URL, Editors' Choice badge, market code, scrape timestamp. |

**Review fields** (`recordType: "review"`):

| Category | Field | Coverage | Description |
|---|---|---|---|
| 🏷️ **Identity** | `appId` / `reviewId` | 🟢 High | App package and unique review ID. |
| 👤 **Reviewer** | `userName` / `userImage` | 🟢 High | Reviewer display name and avatar URL. |
| 💬 **Review Content** | `score` / `title` / `text` / `date` | 🟢 High | Star rating (1–5), optional title, review text, ISO timestamp. |
| 👍 **Engagement** | `thumbsUp` / `version` | 🟢 High | Helpful votes count and app version reviewed. |
| 🏢 **Developer Reply** | `replyText` / `replyDate` | 🟡 Conditional | Developer response text and date when answered. |
| 📊 **Metadata** | `criterias` / `url` / `country` / `scrapedAt` | 🟢 High | Feature sub-ratings, deep link, country code, scrape timestamp. |

> Fields marked "present when available / when `fullDetail` is on" populate only for records that carry them — e.g. `description`, `developerEmail`, and the histogram come from the full app-details fetch, while `originalPrice` appears only during a discount. This is normal Google Play data variability, not a gap.

***

### 🔁 Pagination & scale

- **Rankings** are fetched as a single localized list per chart/category and returned with their `rank` — up to ~200 apps per chart (Google Play's server-side ceiling for a chart; our fresh runs returned a full 200 for both the overall apps and games charts), each enriched in parallel.
- **Reviews** are **fully paginated**: the actor walks Google's cursor (`nextPaginationToken`) page by page per app, with **no artificial cap**, until it reaches your `maxReviewsPerApp` or Google's per-app ceiling (~4,500). Across several `appIds` this easily yields **thousands of de-duplicated reviews**.
- **Search** pulls results per keyword, then enriches each with full details.

You control scale with **`maxItems`** (total record cap; `0` = unlimited), **`maxReviewsPerApp`**, and **`maxConcurrency`**. A built-in time-budget guard stops gracefully just before the run would hit its timeout, so you always keep the records collected so far rather than losing them to a TIMED-OUT run.

***

### ⚙️ How to use

1. Open the actor on the **Apify Console** and click **Try for free / Start**.
2. Choose a **mode**:
   - **Rankings** → pick a **chart** (Top Free / Paid / Grossing), **category**, and **country**.
   - **Reviews / App details** → paste **App IDs** (e.g. `com.whatsapp`) or Play URLs.
   - **Search** → add **search terms**.
3. Set **country** and **language**, and optionally **Max items** / **Max reviews per app**.
4. Click **Save & Start**, then download results as **JSON, CSV, or Excel**.
5. Automate it: run on a **schedule** for daily rankings, call it from the **Apify API**, or wire the dataset into **Make, Zapier, Google Sheets, or a webhook**.

***

### 💡 Tips

- 🏆 **Schedule rankings daily** per category/country to track chart movement over time — the dated `scrapedAt` makes trend building easy.
- 🌍 **Iterate countries** (loop `country`) to build a global picture of a chart or an app's pricing.
- 💬 **Set `maxReviewsPerApp` high** for full review history; reviews are fully paginated to Google's ceiling.
- 📝 **Keep `fullDetail` on** when you need the **full description**, install counts, histogram, or developer contact; turn it **off** for a fast rank-only list.
- ⚡ **For very large review pulls**, keep `maxConcurrency` moderate and consider **RESIDENTIAL** proxy to reduce rate-limiting.
- 🔗 **Reviews accept Play URLs**, so you can paste links straight from the store instead of package names.

***

### ❓ FAQ

**Do I need a Google Play API key or login?**
No. There is no official public Google Play API for this data, and this actor needs **no key and no login** — it reads the same public data the Play website serves.

**How many results can I get, and how fast?**
Rankings return up to ~200 apps per individual category chart, and when you set `maxItems: 1000+` in rankings or search mode, the scraper automatically expands across Play Store categories/collections and discovery keywords to return **1,000+ de-duplicated apps**. Reviews are cursor-paginated up to ~4,500 per app and scale into the thousands across one or multiple apps. Thanks to pooled keep-alive proxy connections and bounded concurrency, 50 enriched apps finish in ~15 seconds and 200+ in ~2 minutes.

**Do I need proxies?**
Apify Proxy is enabled by default and is sufficient for most jobs. For very large review pulls, switching to **RESIDENTIAL** reduces rate-limiting. The actor rotates exit IPs across a pool automatically.

**What export formats are supported?**
**JSON, CSV, Excel, XML, and HTML table**, plus RSS — and you can pull results programmatically from the **Apify API** or push them to integrations.

**Is there an API?**
Yes — every Apify actor is callable via REST API. Start a run, poll it, and fetch the dataset as JSON/CSV. See the API tab on the actor page.

**How fresh is the data?**
It's scraped live on each run — rankings, reviews, and details reflect Google Play at run time. Each record includes a `scrapedAt` timestamp. Schedule the actor to keep a dataset continuously up to date.

**Can I filter by category and country?**
Yes. Rankings support a `category` (all apps/games or a specific niche, including game subcategories) and any of 50+ `country` markets, plus 30+ `language` options. Reviews, details, and prices are all localized.

**Can I get the full app description and the ratings histogram?**
Yes — with `fullDetail` on (the default), app records include the **full `description`/`descriptionHTML`** and the 1–5 star `histogram`, along with installs and developer contact.

**Why are some fields empty?**
Fields like `developerEmail`, `developerAddress`, `video`, `originalPrice`, or `criterias` only exist for apps/reviews that actually have them. Empty values reflect what Google Play exposes for that record, not a scraping error.

***

### 🔗 Related scrapers

- [App Store Scraper](https://apify.com/haketa/app-store-scraper) — the Apple App Store counterpart: rankings, reviews, and app details for iOS.
- [Bulk URL Checker](https://apify.com/haketa/bulk-url-checker) — validate and inspect large lists of URLs (status, redirects, metadata).
- [Bulk Metadata Extractor](https://apify.com/haketa/bulk-metadata-extractor) — pull titles, descriptions, and SEO/OpenGraph metadata from any list of pages.
- [Outseo Scraper](https://apify.com/haketa/outseo-scraper) — SEO data extraction for keyword and on-page research.
- [Google Trends Scraper](https://apify.com/haketa/google-trends-scraper) — interest-over-time and trending-query data from Google Trends.
- [Marktplaats Scraper](https://apify.com/haketa/marktplaats-scraper) — classifieds listings and prices from Marktplaats.

***

### 🏷️ Keywords

Google Play scraper, scrape Google Play, Google Play Store data extractor, Google Play reviews scraper, Google Play rankings API, Android app scraper, ASO keyword research tool, Play Store developer email lead generation, B2B mobile app intelligence, 1,000+ results pagination, bulk export JSON CSV Excel API.

***

### 📋 Changelog

| Version | Date | Highlights |
|---|---|---|
| **v1.2** | **2026-11** | Unlocked **1,000+ deep pagination** across rankings, search, and reviews modes by removing single-list 250/660 caps, adding automatic multi-category and multi-keyword expansion with global `appId`/`reviewId` deduplication, and setting fast 50-item prefill. |
| **v1.1** | **2026-11** | Added pooled keep-alive proxy connections and bounded parallel detail enrichment, cutting 200-app full-detail runs to ~140s with 0 duplicates. |
| **v1.0** | **2026-05** | Initial release — 4-mode Google Play extraction (Rankings, Reviews, App Details, Keyword Search) across 50+ countries and 30+ languages. |

***

▶️ **Ready to pull Google Play data?** Pick a mode, set your country, and click **Start** — structured rankings, reviews, and app details export to JSON, CSV, Excel, or API in minutes.

# Changelog

This Actor's version history is a separate document: https://apify.com/haketa/google-play-scraper/changelog.md

# Actor input Schema

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

Pick your data. Top-chart rankings, app reviews, full app details, or a keyword search — no setup needed, just choose and run.

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

Which top chart to pull when scraping rankings. Free, paid, or top-grossing apps.

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

Category for the ranking chart. Choose All apps or All games for the overall charts, or drill into a specific niche.

## `searchTerms` (type: `array`):

Keywords to find apps (used in Keyword search mode). Add one or more terms, e.g. photo editor, budget, meditation.

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

For App reviews and App details modes. Paste app package names (e.g. com.whatsapp) or full Play Store links — one per line.

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

How many reviews to pull per app in App reviews mode. Fully paginated — Google serves up to ~4500 per app.

## `reviewsSort` (type: `string`):

How to order reviews in App reviews mode.

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

Rankings, prices and reviews are localized per country. Pick your target market.

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

Language for titles, descriptions and reviews.

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

Enrich each ranked or found app with complete info — installs, ratings count, reviews count, histogram, version and more. ON by default (a rank list without install/rating counts is far less useful). Turn OFF for a faster, lighter rank-only list.

## `maxItems` (type: `integer`):

Cap the number of records (apps or reviews) returned. Use 0 for no limit.

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

Default Apify Proxy is fine. For very large review pulls, RESIDENTIAL reduces rate-limiting.

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

Maximum parallel apps processed. Higher is faster but heavier.

## Actor input object example

```json
{
  "mode": "rankings",
  "collection": "TOP_FREE",
  "category": "APPLICATION",
  "searchTerms": [
    "photo editor"
  ],
  "appIds": [
    "com.whatsapp"
  ],
  "maxReviewsPerApp": 200,
  "reviewsSort": "NEWEST",
  "country": "us",
  "language": "en",
  "fullDetail": true,
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxConcurrency": 12
}
```

# Actor output Schema

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

All records collected during the run.

## `runUrl` (type: `string`):

Open this run in the Apify Console.

# 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 = {
    "searchTerms": [
        "photo editor"
    ],
    "appIds": [
        "com.whatsapp"
    ],
    "maxReviewsPerApp": 200,
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/google-play-scraper").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 = {
    "searchTerms": ["photo editor"],
    "appIds": ["com.whatsapp"],
    "maxReviewsPerApp": 200,
    "maxItems": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/google-play-scraper").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 '{
  "searchTerms": [
    "photo editor"
  ],
  "appIds": [
    "com.whatsapp"
  ],
  "maxReviewsPerApp": 200,
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call haketa/google-play-scraper --silent --output-dataset

```

## MCP server setup

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

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/xHxfvjmSstGlmYUQT/builds/oG7qsskFCUMVB23Dj/openapi.json