# Google Play Scraper - Apps, Ratings & Installs (No API Key) (`flash_scraper/google-play-scraper`) Actor

Scrape Google Play apps by keyword or package ID into clean rows: title, developer, category, rating, rating count, installs, price, content rating, version, last updated and icon. Keyless public store pages, no login. Export to CSV, JSON or Excel.

- **URL**: https://apify.com/flash\_scraper/google-play-scraper.md
- **Developed by:** [Flash Scrape](https://apify.com/flash_scraper) (community)
- **Categories:** E-commerce, Business, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 1,000 apps

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Scraper — Apps, Ratings & Installs (No API Key)

Turn the **Google Play Store** into a clean dataset. Search by keyword or pass package IDs /
store URLs, and get **one tidy row per app**: title, developer, category, rating, rating count,
install count, price, content rating, version, last-updated date, and icon.

**No API key, no login.** Data comes from each app page's own embedded data (schema.org JSON-LD
plus the store page markup).

Pairs with the **Apple App Store** actor for cross-platform coverage.

### What you can do with it

- 💡 **Find a profitable niche** — `discover: FINANCE` (or any category) returns what is currently ranking, with installs, ratings and prices, so you can see how crowded a niche is and what the leaders charge.
- 📊 **App market research** — pull a whole category or keyword and compare ratings and installs.
- 🔍 **ASO / competitor tracking** — watch a rival's rating, review count, version and update cadence.
- 💰 **Price monitoring** — track paid-app pricing per country.
- 🗂️ **Build app datasets** — export a niche to CSV/JSON/Excel.

### Input

| Field | Type | Description |
|---|---|---|
| `searchTerms` | array | Keywords to search Play, e.g. `meditation`, `budget tracker`. |
| `appIds` | array | Package names (`com.spotify.music`) or full store URLs. |
| `discover` | select | **Niche research:** `top` for the overall top-apps chart, or a category (`FINANCE`, `BUSINESS`, `HEALTH_AND_FITNESS`, `GAME`, …) to pull every app currently ranking in it. |
| `countryCode` | string | Region for pricing/availability (Play `gl`), e.g. `us`, `gb`, `ma`. Default `us`. |
| `language` | string | Content language (Play `hl`), e.g. `en`, `fr`, `ar`. Default `en`. |
| `maxItems` | integer | Max apps per run (1–300). |

#### Example

```json
{
  "searchTerms": ["meditation"],
  "appIds": ["com.spotify.music", "com.whatsapp"],
  "countryCode": "us",
  "maxItems": 50
}
```

Niche research — no keywords needed, just pick a category:

```json
{ "discover": "FINANCE", "countryCode": "us", "maxItems": 50 }
```

### Output (one row per app)

`app_id`, `title`, `url`, `developer`, `developer_url`, `category`, `description`, `rating`,
`rating_count`, `price`, `currency`, `is_free`, `content_rating`, `operating_system`,
`installs_text`, `installs`, `version`, `updated`, `icon`, `country`, `language`.

#### Sample row

```json
{
  "app_id": "com.spotify.music",
  "title": "Spotify: Music and Podcasts",
  "developer": "Spotify AB",
  "category": "MUSIC_AND_AUDIO",
  "rating": 4.34,
  "rating_count": 36020992,
  "installs_text": "1,000,000,000+",
  "installs": 1000000000,
  "price": 0.0,
  "currency": "USD",
  "is_free": true,
  "content_rating": "Teen",
  "version": "9.1.22.1630",
  "updated": "Jul 28, 2026"
}
```

### Honest notes

- **Chart sizes are what Google serves**: a category page returns roughly 25-40 apps and the
  overall `top` page around 80. Those are Google's own page sizes, not a cap this actor imposes.
  The legacy `topselling_free` / `topselling_paid` collection URLs now render empty and are
  deliberately not used.

- `installs`, `version` and `updated` are parsed from the **page markup** rather than JSON-LD
  (Google does not publish them as structured data), so they are best-effort and can come back
  `null` on some locales. Every other field comes from JSON-LD and is stable.

- `installs_text` keeps Google's own banding (`1,000,000,000+`) because that is all the store
  discloses; `installs` is that band converted to a number for sorting/filtering.

- Prices and availability are per `countryCode` — Google localizes both.

- Requests are paced and retried automatically. For large runs, enable **Apify Proxy**.

# Actor input Schema

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

Keywords to search the Play Store, e.g. 'meditation', 'budget tracker'. Each term returns its best-matching apps.

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

Exact package names or store URLs, e.g. com.spotify.music or https://play.google.com/store/apps/details?id=com.spotify.music

## `discover` (type: `string`):

Pull what is currently RANKING instead of apps you already know — 'top' for the overall top-apps chart, or a category to research that niche (installs, ratings and prices for every app in it).

## `countryCode` (type: `string`):

Two-letter country code for pricing and availability (Play 'gl' param), e.g. us, gb, de, ma, in.

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

Content language for titles and descriptions (Play 'hl' param), e.g. en, fr, es, ar.

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

Maximum number of apps to return across all inputs.

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

Optional. Route requests through Apify Proxy. Recommended for larger runs: this site throttles or blocks datacenter IPs, and residential proxies avoid that.

## Actor input object example

```json
{
  "searchTerms": [
    "meditation"
  ],
  "discover": "none",
  "countryCode": "us",
  "language": "en",
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchTerms": [
        "meditation"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("flash_scraper/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": ["meditation"] }

# Run the Actor and wait for it to finish
run = client.actor("flash_scraper/google-play-scraper").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 '{
  "searchTerms": [
    "meditation"
  ]
}' |
apify call flash_scraper/google-play-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/9lb6JthT2h6XbvpjI/builds/3qDstuGO8jp8aujz8/openapi.json