# Google Play Scraper — Apps, Ratings & Installs (`hipersoft/google-play-scraper`) Actor

Search Google Play and scrape app details: title, developer, rating, rating count, installs, price, category, content rating, description and icon. No login or API key. For app market research and ASO.

- **URL**: https://apify.com/hipersoft/google-play-scraper.md
- **Developed by:** [hiper soft](https://apify.com/hipersoft) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.002 / app scraped

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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Scraper — Apps, Ratings & Installs, No API Key, Clean JSON

Search Google Play by keyword or look up exact apps, and get back clean, structured JSON — title, developer, rating, rating count, install count, price, currency, category, content rating, description and icon. It reads Google Play's own public search results and app pages over fast, plain HTTP. No account, no API key. Built for app market research and ASO teams who need reliable store data without a headless browser.

### Features
- 🔎 **Keyword search or direct lookup** — pass `searches` like `"weather"`, or exact `appIds` like `com.spotify.music` (package names or Play URLs).
- ⭐ **Ratings that matter** — `rating` and `ratingCount` come straight from the app's structured data.
- 📥 **Install counts** — the `installs` field captures Google's downloads figure (e.g. `"1,000,000+"`).
- 💵 **Price + free flag** — `price`, `currency` and a `free` boolean, parsed from the store offer.
- 🌍 **Country & language control** — set `country` and `language` to see localized rankings and metadata.
- ⚡ **Fast, browser-free HTTP** — no headless Chrome, no login, with built-in retry on rate limits.
- 🏷️ **Rich metadata** — `category`, `contentRating`, `operatingSystem`, full `description` and `icon` URL.

### What you get
Every app becomes one clean JSON record:

```json
{
  "appId": "com.spotify.music",
  "title": "Spotify: Music and Podcasts",
  "developer": "Spotify AB",
  "rating": 4.3,
  "ratingCount": 32000000,
  "price": 0,
  "currency": "USD",
  "free": true,
  "category": "MUSIC_AND_AUDIO",
  "contentRating": "Teen",
  "operatingSystem": "ANDROID",
  "installs": "1,000,000,000+",
  "description": "With Spotify, you can listen to music and play millions of songs and podcasts...",
  "icon": "https://play-lh.googleusercontent.com/icon.png",
  "url": "https://play.google.com/store/apps/details?id=com.spotify.music"
}
````

### Input

```json
{
  "searches": ["weather", "budget"],
  "appIds": ["com.spotify.music"],
  "maxAppsPerSearch": 30,
  "country": "us",
  "language": "en",
  "proxyConfiguration": { "useApifyProxy": false }
}
```

| Field | Description |
| --- | --- |
| `searches` | Keywords to search on Google Play, one per line. |
| `appIds` | Specific package names or Play URLs (e.g. `com.spotify.music`), one per line. |
| `maxAppsPerSearch` | Apps to fetch per search term (~30 max results). |
| `country` | Store country code (e.g. `us`, `gb`, `de`). |
| `language` | Language code (e.g. `en`, `es`). |
| `proxyConfiguration` | Optional. Google Play works without a proxy. |

### Use cases

- Run app market research on a keyword and rank competitors by rating and installs.
- Monitor your own app's rating, install count and store metadata over time.
- Build an ASO dataset of titles, categories and descriptions in a target country.
- Enrich a catalog of package names with live pricing and rating data.

### Pricing

Pay-per-event: you're billed a small amount per run and per item scraped — you only pay for what you get. See the **Pricing** tab for current rates.

### FAQ

**Do I need a Google account or API key?**
No. The Actor reads [Google Play](https://play.google.com)'s public search results and app detail pages over plain HTTP — no login, no API key and no headless browser, with built-in retry on rate limits.

**How many apps can I get per run?**
Google Play returns roughly 30 results per search term; use `maxAppsPerSearch` to control that. You can also look up an unlimited list of exact apps by passing package names or Play URLs in `appIds`.

**Is scraping Google Play legal?**
Only public store data that Google Play shows to any visitor is read. This is an independent tool, not affiliated with Google; "Google Play" is a trademark of Google LLC. Review Google's Terms of Service and applicable regulations for your use case.

**What's the output format?**
Clean JSON — one record per app with `appId`, `title`, `developer`, `rating`, `ratingCount`, `installs`, `price`, `currency`, `free`, `category`, `contentRating`, `description`, `icon` and store `url`. Export as JSON, CSV or Excel.

**Can I target a specific country or language?**
Yes. Set `country` (e.g. `us`, `gb`, `de`) and `language` (e.g. `en`, `es`) to get localized rankings, pricing and metadata.

### Related Actors

Extend your app-market and ASO research with related scrapers:

- [Google Play Reviews Scraper](https://apify.com/hipersoft/google-play-reviews-scraper) — user reviews and ratings for any Android app.
- [App Store Reviews Scraper](https://apify.com/hipersoft/appstore-reviews-scraper) — reviews and ratings from Apple's App Store.

### Notes

This Actor reads Google Play's public search results and app detail pages. It is an independent tool and is not affiliated with, endorsed by, or sponsored by Google; "Google Play" is a trademark of Google LLC.

# Actor input Schema

## `searches` (type: `array`):

Keywords to search on Google Play (e.g. "weather", "budget"), one per line.

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

Specific package names or Play URLs (e.g. com.spotify.music). One per line.

## `maxAppsPerSearch` (type: `integer`):

Apps to fetch per search term (~30 max results).

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

Store country code (e.g. us, gb, de).

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

Language code (e.g. en, es).

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

Optional. Google Play works without a proxy.

## Actor input object example

```json
{
  "searches": [
    "weather"
  ],
  "appIds": [],
  "maxAppsPerSearch": 30,
  "country": "us",
  "language": "en",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "searches": [
        "weather"
    ],
    "appIds": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("hipersoft/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 = {
    "searches": ["weather"],
    "appIds": [],
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Play Scraper — Apps, Ratings & Installs",
        "description": "Search Google Play and scrape app details: title, developer, rating, rating count, installs, price, category, content rating, description and icon. No login or API key. For app market research and ASO.",
        "version": "1.0",
        "x-build-id": "pjv2y83roUxGSrut2"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/hipersoft~google-play-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-hipersoft-google-play-scraper",
                "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/hipersoft~google-play-scraper/runs": {
            "post": {
                "operationId": "runs-sync-hipersoft-google-play-scraper",
                "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/hipersoft~google-play-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-hipersoft-google-play-scraper",
                "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",
                "properties": {
                    "searches": {
                        "title": "Searches",
                        "type": "array",
                        "description": "Keywords to search on Google Play (e.g. \"weather\", \"budget\"), one per line.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "appIds": {
                        "title": "App IDs / URLs (optional)",
                        "type": "array",
                        "description": "Specific package names or Play URLs (e.g. com.spotify.music). One per line.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxAppsPerSearch": {
                        "title": "Max apps per search",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Apps to fetch per search term (~30 max results).",
                        "default": 30
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Store country code (e.g. us, gb, de).",
                        "default": "us"
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Language code (e.g. en, es).",
                        "default": "en"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy (optional)",
                        "type": "object",
                        "description": "Optional. Google Play works without a proxy.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
