# Google Play App Scraper (`jdtpnjtp/google-play-apps-scraper`) Actor

Scrape Google Play apps - search, top charts, similar apps, developer portfolios and app detail. Get title, developer, rating, installs, price, IAPs, category, version and screenshots. Pay per result.

- **URL**: https://apify.com/jdtpnjtp/google-play-apps-scraper.md
- **Developed by:** [Data Forge](https://apify.com/jdtpnjtp) (community)
- **Categories:** SEO tools, Developer tools, Integrations
- **Features:** Limited permissions
- **Stats:** 5 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.28 / 1,000 app 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 App Scraper

Scrape Google Play apps at scale. **Apps from $0.25 / 1,000 results** - pull 20,000+ app rows in one run. Search keywords, country-localized top charts, similar apps, developer portfolios and detailed app pages come back as clean structured rows, with no subscription. No setup, no browser, no infrastructure to run - pick a mode and press Start.

### Why this Actor?

Most Google Play libraries wrap a single storefront call and hand back whatever the US store returns. This Actor covers 5 data surfaces from one input form and keeps rankings honest per country.

| Capability | This Actor (Data Forge) | Typical scraper library |
|---|---|---|
| Data surfaces in one Actor | **5: search, top charts, similar apps, developer portfolio, app detail** | 1 - 2 |
| Top-chart accuracy by country | **Localized titles + local install formats per market (verified Brazil pt-BR)** | Same US chart returned whatever country code you pass |
| Chart collections | **3: top free, top paid, top grossing** | 1 (top free only) |
| Chart slicing | **By category and by device (phone, tablet, watch, TV, car, more)** | Phone-only, or none |
| App-detail depth | **60+ fields per app** | 10 - 20 fields |
| Failed or not-found inputs | **Free error rows, never charged** | Charged, or silently dropped |
| Pricing | **Pay per result, from $0.25 / 1,000** | Monthly subscription |

### What does the Google Play App Scraper do?

The Google Play App Scraper turns the Play Store into a structured dataset. Feed it search keywords, app IDs, developer IDs or chart selectors, pick your modes, and it returns app title, developer, rating, installs, price, category, version, screenshots and more as flat rows you can sort, filter and export to CSV, Excel or JSON.

5 modes run from one input form:

| Mode | What you get | Needs |
|---|---|---|
| `search` | Keyword search results from Google Play | Search queries |
| `topcharts` | Country-localized top free, paid or grossing charts | Country + collection |
| `similar` | Apps similar to a given app | App names, IDs or URLs |
| `developer` | A developer's app portfolio | Developer IDs |
| `app` | Detailed app page (60+ fields) | App names, IDs or URLs |

Flip on **Fan out listings to full app detail** and each listing row is enriched with a detailed app page, so a single search returns ranking plus deep metadata in one pass.

### What data can you get from a Google Play app?

Each app row carries the buyer-facing columns plus a `data` payload with 60+ raw fields:

- **Identity** - app title, package ID (com.whatsapp), Play Store URL, icon
- **Developer** - developer name, developer ID, portfolio link
- **Ratings** - average score (1.0 to 5.0), rating count, review count
- **Reach** - install-count buckets (e.g. 10,000,000,000+)
- **Pricing** - price, free flag, currency, in-app purchase ranges (IAPs)
- **Classification** - category / genre, content rating
- **Release** - release date, last update, current version
- **Media** - icon, screenshots, header image, description and short summary

Listing rows return the lightweight fields; app-detail rows carry the deep metadata for market and competitor work.

### How to scrape Google Play apps

1. Open the Google Play App Scraper and click **Try it** - the input form is prefilled with a `puzzle games` search, so you get real data on the first click.
2. Replace it with your own **search queries**, **app IDs / URLs**, **developer IDs** or **similar-to app IDs**.
3. Pick your **data types** (search, top charts, similar, developer, app detail).
4. Set **country** and **language** for localized rankings, and a **max results per type** cap.
5. (Optional) Turn on **Fan out listings to full app detail** to enrich each result with deep metadata.
6. Click **Save & Start**, then export the dataset to CSV, Excel or JSON, or pull it through the API.

### Input modes

Seven ready-to-run recipes, one per job. Each maps 1:1 to a published example task on the Actor page - paste any block into the input editor (JSON view) and press Start.

#### 1. Search a niche for market sizing

Founder or ASO manager sizing a keyword: pull the ranked search results for one term.

```json
{ "searchQueries": ["fitness"], "dataTypes": ["search"], "maxResults": 100 }
```

#### 2. US top free chart

Trend analyst grabbing today's top free apps on the US storefront.

```json
{ "dataTypes": ["topcharts"], "chartCollection": "topselling_free", "maxResults": 100 }
```

#### 3. Top grossing games

Game studio benchmarking revenue leaders, ranked by earnings rather than downloads.

```json
{ "dataTypes": ["topcharts"], "chartCollection": "topgrossing", "chartCategory": "GAME", "maxResults": 100 }
```

#### 4. Localized charts (Brazil, pt-BR)

Growth team entering Brazil: get the real Brazilian top free chart with localized titles and local install formats, not the US list.

```json
{ "dataTypes": ["topcharts"], "chartCollection": "topselling_free", "country": "br", "lang": "pt", "maxResults": 100 }
```

#### 5. Developer portfolio

Competitive-intel analyst mapping a publisher's catalog by developer name or ID.

```json
{ "developerIds": ["Spotify AB"], "dataTypes": ["developer"], "maxResults": 100 }
```

#### 6. Competitor set via similar apps

Product manager building a competitor list from one seed app using the Play similar-apps graph.

```json
{ "similarToAppIds": ["com.spotify.music"], "dataTypes": ["similar"], "maxResults": 100 }
```

#### 7. Full app detail (60+ fields)

Investor or researcher pulling one deep app page: ratings histogram, screenshots, IAP ranges and version.

```json
{ "appIds": ["com.spotify.music"], "dataTypes": ["app"] }
```

### Output

Rows are flat and typed. The `row_type` field tells you which surface produced each row:

| `row_type` | Produced by | Shape |
|---|---|---|
| `search_result` | Search mode | Listing row (title, developer, score, installs, price) |
| `chart` | Top charts mode | Listing row in chart ranking order |
| `similar` | Similar-apps mode | Listing row for each related app |
| `developer_app` | Developer mode | Listing row for each app in the portfolio |
| `app_detail` | App-detail mode or fan-out | Deep row, 60+ fields |

#### Output example

A search-result row:

```json
{
  "query": "puzzle games",
  "row_type": "search_result",
  "app_id": "com.king.candycrushsaga",
  "title": "Candy Crush Saga",
  "developer": "King",
  "score": 4.6,
  "price": 0.0,
  "free": true,
  "installs": "1,000,000,000+",
  "icon": "https://play-lh.googleusercontent.com/...",
  "description_short": "Match candies in this tasty puzzle adventure.",
  "data": { "...": "full raw app object (60+ fields)" }
}
```

An app-detail row:

```json
{
  "query": "com.spotify.music",
  "row_type": "app_detail",
  "app_id": "com.spotify.music",
  "title": "Spotify: Music and Podcasts",
  "developer": "Spotify AB",
  "developer_id": "Spotify+AB",
  "category": "Music & Audio",
  "score": 4.3,
  "ratings": 31280544,
  "reviews": 5128342,
  "installs": "1,000,000,000+",
  "price": 0.0,
  "free": true,
  "content_rating": "Teen",
  "released": "Oct 7, 2008",
  "version": "8.9.42.575",
  "icon": "https://play-lh.googleusercontent.com/...",
  "url": "https://play.google.com/store/apps/details?id=com.spotify.music",
  "data": { "...": "full raw app object: screenshots, IAPs, rating histogram, description" }
}
```

The dataset ships with **Overview** and **Apps** table tabs, so each view reads as a clean spreadsheet. Error rows carry an `error_code` and are free.

### How much does it cost to scrape Google Play apps?

Pay per result, no subscription:

- **app-result** (search, top charts, similar, developer rows) - **$0.25 / 1,000** ($0.00025 each)
- **app-detail** (detailed app page, 60+ fields) - **$3.90 / 1,000** ($0.0039 each)

Worked math: Apify's **$5 free monthly credits** cover about **20,000 app listing rows** ($5 / $0.00025) before you spend a cent of your own. Need deep metadata? Detailed app pages run **$3.90 / 1,000**, so 1,000 complete app profiles cost under four dollars. Error rows are never charged, so you pay only for real data.

### What can you use Google Play app data for?

- **App Store Optimization (ASO)** - track titles, ratings, install buckets and category rankings to refine keywords and listings.
- **Market intelligence** - size a category by pulling top free, paid and grossing charts per country.
- **Competitor tracking** - monitor a rival app's score, version cadence, install growth and pricing over time.
- **Developer mapping** - pull a developer's portfolio to map a publisher's catalog and reach.
- **Lead generation** - build lists of developers and apps in a niche for outreach.
- **Discovery and recommendations** - use similar-app graphs to surface adjacent apps and substitutes.
- **Pricing and monetization research** - compare price, free flags and in-app purchase ranges across a segment.
- **Trend monitoring** - watch country-localized charts to catch rising apps early.
- **Investment and due diligence** - benchmark traction signals (installs, ratings, review velocity) across a portfolio.

### Is it legal to scrape Google Play?

Scraping publicly available data is generally legal, and this actor collects only public Google Play listing pages that any visitor can view without logging in. Court rulings such as hiQ v. LinkedIn have supported the collection of public data. You stay responsible for how you use the output: respect copyright, trademarks, privacy laws (GDPR / CCPA) and Google's terms where they apply, and avoid republishing personal data. Consult a lawyer if you need certainty for a commercial deployment.

### Related actors

Part of the **Data Forge** Google Play fleet:

- **[Google Play Reviews Scraper](https://apify.com/jdtpnjtp/google-play-reviews-scraper)** - pull user reviews (user, score, text, date, thumbs-up, developer reply) at scale.
- **[Google Play Scraper](https://apify.com/jdtpnjtp/google-play-scraper)** - the umbrella actor that covers apps and reviews in one place.

### FAQ

**Is it legal to scrape Google Play app data?**
Public listing data is generally legal to collect, and this Actor reads only public Google Play pages any visitor can view. Rulings such as hiQ v. LinkedIn support gathering public data. You stay responsible for downstream use: respect copyright, trademarks and privacy laws (GDPR / CCPA), and avoid republishing personal data. Ask a lawyer for a commercial deployment.

**How fresh is the data?**
Each row is fetched live from Google Play on the run, not served from a stale warehouse. Schedule a daily or weekly run to track ranking, rating and version movement over time.

**Why do other chart datasets show US apps no matter which country I ask for?**
Many libraries default to the US storefront and ignore the country parameter, so a Brazil request quietly returns the US chart. This Actor passes both country and language to the store, so you get the real localized titles and local install formats per market (verified on Brazil pt-BR).

**Can I run this on a schedule?**
Yes. Use the Apify Scheduler (cron) or webhooks to run any recipe on an interval and append fresh rows to your dataset - handy for daily chart snapshots or weekly competitor sweeps.

**Can I scrape top charts for a specific country?**
Yes. Set `country` to a 2-letter code (us, jp, de) and pick a `chartCollection` (top free, top paid or top grossing). Charts localize to that country and language.

**How do I get deep app metadata, not just listing columns?**
Use the `app` data type with app IDs or URLs, or turn on **Fan out listings to full app detail** to enrich each listing with a 60+ field app page.

**Can I run this from the API or an integration?**
Yes. Start runs and fetch the dataset through the Apify API, the JavaScript / Python clients, webhooks and the scheduler, or the Apify MCP server so AI agents can call the actor as a tool.

**What export formats are supported?**
CSV, Excel, JSON, JSONL, XML or RSS, through the Console or API.

**What happens to failed inputs?**
Failed or not-found inputs come back as error rows with an `error_code` and are free, so you pay only for real results.

**Do I need internal IDs?**
No. Search by keyword like a human, paste app IDs or Play URLs, or enter a developer name, and the actor normalizes the input for you.

### Support

Built and maintained by **Data Forge**. Need custom fields, higher volume or a quick answer? Reach out on any channel for help, enterprise plans or custom scraping.

[![Telegram](https://img.shields.io/badge/Telegram-2CA5E0?style=for-the-badge\&logo=telegram\&logoColor=white)](https://t.me/j4dtpnj2tp)
[![WhatsApp](https://img.shields.io/badge/WhatsApp-25D366?style=for-the-badge\&logo=whatsapp\&logoColor=white)](https://wa.me/380686031542)
[![Email](https://img.shields.io/badge/Email-D14836?style=for-the-badge\&logo=gmail\&logoColor=white)](mailto:jdtpnjtp@gmail.com)

# Actor input Schema

## `dataTypes` (type: `array`):

Which verticals to pull. Search needs queries, App needs IDs, Similar needs app IDs, Developer needs developer IDs. Top charts runs only when explicitly selected.

## `searchQueries` (type: `array`):

Keyword searches (e.g. `puzzle games`).

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

Apps by package name (com.whatsapp), Play URL, or just the app name (WhatsApp) - the top search match is used. Each is pulled as full app detail.

## `developerIds` (type: `array`):

Developer names/IDs (e.g. `Google LLC`) - returns each developer's apps.

## `similarToAppIds` (type: `array`):

Apps (package name, Play URL or app name) - returns apps similar to each.

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

2-letter country code (us, jp, de ...). Top charts and rankings are localized to this country.

## `lang` (type: `string`):

2-letter language code (en, ja, de ...).

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

Upper bound per vertical / input item (1-500). Store-side caps: search returns up to 250, developer portfolios up to 200.

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

When on, every listing row is enriched with a full app-detail call (60+ fields). Adds an app-detail charge per result.

## `chartCollection` (type: `string`):

Which top-chart collection to pull (free, paid or grossing).

## `chartCategory` (type: `string`):

Category slug for charts (APPLICATION, GAME, ...).

## `chartDevice` (type: `string`):

Optional device/form-factor for the chart (phone, tablet, watch, tv, car, chromebook, xr). Leave blank for default phone charts.

## Actor input object example

```json
{
  "dataTypes": [
    "search"
  ],
  "searchQueries": [
    "puzzle games"
  ],
  "appIds": [],
  "developerIds": [],
  "similarToAppIds": [],
  "country": "us",
  "lang": "en",
  "maxResults": 20,
  "includeAppDetails": false,
  "chartCollection": "topselling_free",
  "chartCategory": "APPLICATION",
  "chartDevice": ""
}
```

# Actor output Schema

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

Default dataset; row_type discriminates search_result / chart / similar / developer_app / app_detail. Full payload under data.

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

OUTPUT key: app_results, app_details, errors, total_rows, estimated_cost_usd, limit_reached, actor_version.

# 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 = {
    "dataTypes": [
        "search"
    ],
    "searchQueries": [
        "puzzle games"
    ],
    "appIds": [],
    "developerIds": [],
    "similarToAppIds": [],
    "country": "us",
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("jdtpnjtp/google-play-apps-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 = {
    "dataTypes": ["search"],
    "searchQueries": ["puzzle games"],
    "appIds": [],
    "developerIds": [],
    "similarToAppIds": [],
    "country": "us",
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("jdtpnjtp/google-play-apps-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 '{
  "dataTypes": [
    "search"
  ],
  "searchQueries": [
    "puzzle games"
  ],
  "appIds": [],
  "developerIds": [],
  "similarToAppIds": [],
  "country": "us",
  "maxResults": 20
}' |
apify call jdtpnjtp/google-play-apps-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,jdtpnjtp/google-play-apps-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/4gTbuXuGeRgi4a5eJ/builds/ziaNHIkqpIzjD3apg/openapi.json