# Google Play Apps Scraper — App Details, Ratings & Installs (`fabrikit/google-play-apps-scraper`) Actor

Scrape Google Play app listings by package ID, URL or developer: name, developer, category, rating and review counts, installs, price, in-app purchases, version, last update, permissions, data safety and description. Any country and language, no API key. From US$1.60 per 1,000 apps.

- **URL**: https://apify.com/fabrikit/google-play-apps-scraper.md
- **Developed by:** [Fabrikit](https://apify.com/fabrikit) (community)
- **Categories:** Developer tools, Automation, AI
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.60 / 1,000 app scrapeds

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/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 Apps Scraper — App Details, Ratings & Installs

Google Play Apps Scraper extracts app listings from play.google.com: name, developer, category, rating and review counts, install numbers, price and in-app purchases, current version, release and update dates, description, screenshots, **permissions** and the **data safety** summary. Give it package IDs, Play Store URLs or developer names, pick a storefront country and language, and get one clean row per app as JSON, CSV or Excel. No API key, no login, no browser.

**Pricing: US$1.60 per 1,000 apps**, platform compute included.

### What you get for each app

| Group | Fields |
|---|---|
| Identity | `appId`, `url`, `title`, `summary`, `description` (plain text, trimmed to `descriptionMaxChars`), `icon`, `headerImage`, `screenshots`, `videoUrl` |
| Developer | `developer`, `developerId`, `developerUrl`, `developerWebsite`, `privacyPolicyUrl` |
| Classification | `category`, `categoryId`, `categories`, `contentRating`, `contentRatingNotes`, `isPreregister` |
| Popularity | `rating` (0-5), `ratingText`, `ratingCount`, `reviewCount`, `histogram` (ratings per star), `installs`, `installsMin`, `installsExact` |
| Monetization | `price`, `currency`, `priceText`, `isFree`, `originalPrice`, `inAppPurchases`, `inAppPurchasesRange`, `containsAds` |
| Release | `version`, `minAndroidVersion`, `releasedAt`, `releasedText`, `updatedAt`, `recentChanges` |
| Trust | `permissions` (as `Group: permission` strings), `dataSafety` (shared / collected data, encryption, deletion) |
| Request | `country`, `language`, `scrapedAt` |

Numbers are numbers (`ratingCount: 246010955`, not `"246,010,955"`), dates are ISO 8601 and every row has the same columns, so the dataset drops straight into a spreadsheet or a database.

### How it works

The Actor opens the public listing page of each app for the storefront you choose (`country` + `language`) and reads the data Google embeds in the page itself — the same data the Play website renders. Developer pages (`/store/apps/developer?id=Name` or `/store/apps/dev?id=123`) are read the same way and every app shown on them is then fetched as a full listing. Only pages that play.google.com's robots.txt allows are requested; the Actor does not use the store search (which Google disallows for robots), so there is no keyword search — start from package IDs, URLs or developers.

### Input

| Field | Description |
|---|---|
| `appIds` | Package IDs (`com.whatsapp`), listing URLs or developer page URLs, one per line |
| `developers` | Developer names as shown on Google Play (`WhatsApp LLC`), numeric developer IDs or developer page URLs. All apps on the developer's first page are scraped |
| `country` | Two-letter storefront (`us`, `gb`, `de`, `br`, `in`, `jp`...). Prices, availability, installs and ratings are storefront-specific |
| `language` | Language of the texts (`en`, `es`, `de`, `pt-br`...) |
| `descriptionMaxChars` | Trim the description to this many characters (default 1500, 0 = full) |
| `maxItems` | Exact cap on the number of apps (default 50) |
| `proxyConfiguration` | Apify Proxy; datacenter is enough in our tests, residential of the chosen country is used automatically if Google starts blocking |

#### Examples

Three apps on the US storefront (the default run):

```json
{ "appIds": ["com.whatsapp", "com.spotify.music", "org.telegram.messenger"], "country": "us", "language": "en" }
```

Every app published by two developers, German storefront, full descriptions:

```json
{
  "appIds": [],
  "developers": ["https://play.google.com/store/apps/dev?id=4772240228547998649", "WhatsApp LLC"],
  "country": "de",
  "language": "de",
  "descriptionMaxChars": 0,
  "maxItems": 100
}
```

Prices and availability of a watch-list of apps in Brazil:

```json
{ "appIds": ["com.mojang.minecraftpe", "com.nianticlabs.pokemongo", "com.king.candycrushsaga"], "country": "br", "language": "pt-br" }
```

### Output example

```json
{
  "appId": "com.whatsapp",
  "url": "https://play.google.com/store/apps/details?id=com.whatsapp&hl=en&gl=us",
  "title": "WhatsApp Messenger",
  "summary": "Simple. Reliable. Private.",
  "description": "WhatsApp from Meta is a FREE messaging and video calling app. It's used by over 2B people in more than 180 countries. ...",
  "developer": "WhatsApp LLC",
  "developerId": "WhatsApp LLC",
  "developerUrl": "https://play.google.com/store/apps/developer?id=WhatsApp+LLC",
  "developerWebsite": "http://www.whatsapp.com/",
  "privacyPolicyUrl": "https://www.whatsapp.com/legal/privacy-policy",
  "category": "Communication",
  "categoryId": "COMMUNICATION",
  "categories": ["Communication"],
  "contentRating": "Everyone",
  "rating": 4.62,
  "ratingCount": 246010955,
  "reviewCount": 1948271,
  "histogram": { "1": 10674609, "2": 3409385, "3": 8880638, "4": 21946379, "5": 201099891 },
  "installs": "10,000,000,000+",
  "installsMin": 10000000000,
  "installsExact": 12417265547,
  "price": 0,
  "currency": "USD",
  "priceText": "Free",
  "isFree": true,
  "inAppPurchases": true,
  "inAppPurchasesRange": "$0.40 - $199.99 per item",
  "containsAds": false,
  "version": null,
  "releasedAt": "2010-10-18T20:58:53.000Z",
  "updatedAt": "2026-10-19T10:03:33.000Z",
  "recentChanges": "- You can now choose to share recent group history with new members ...",
  "icon": "https://play-lh.googleusercontent.com/Gqxk4T0u...",
  "screenshots": ["https://play-lh.googleusercontent.com/...", "..."],
  "permissions": ["Contacts: read your contacts", "Location: precise location (GPS and network-based)", "Camera: take pictures and videos", "..."],
  "dataSafety": [
    "No data shared with third parties",
    "This app may collect these data types: Location, Personal info and 5 others",
    "Data is encrypted in transit",
    "You can request that data be deleted"
  ],
  "country": "us",
  "language": "en",
  "scrapedAt": "2026-10-19T22:20:11.000Z"
}
```

`version` is `null` when Google shows "Varies with device". Apps that do not exist on the chosen storefront are reported in the log and in the `SUMMARY` record of the key-value store, not as rows.

### Use cases

- **Competitive intelligence**: track installs, ratings, prices and update cadence of competitor apps across countries.
- **App store optimization**: compare titles, summaries, categories and screenshots of the apps that rank next to yours.
- **Due diligence and research**: permissions and data-safety declarations of hundreds of apps in one table.
- **Catalog enrichment**: fill an app directory or a developer portfolio page from a list of package IDs.
- **Monitoring**: schedule a daily run and diff `version`, `updatedAt`, `price` or `rating`.

### Pricing

| Event | Price |
|---|---|
| App scraped (`app-result`) | US$1.60 per 1,000 |

1,000 app listings cost US$1.60, 10,000 cost US$16. There is no start fee and nothing is charged for apps that are not found. The Apify free plan covers a few thousand apps per month.

Compared with the alternatives on Apify: the most used Google Play scraper charges US$2.30 per 1,000 results on the free plan for a similar listing; scrapers below US$1 per 1,000 usually return the card-level data of a search page (name, rating, price) rather than the full listing with permissions and data safety. If you need reviews instead of listings, use our [Google Play Reviews Scraper](https://apify.com/fabrikit/google-play-reviews-scraper), which this Actor is built on.

### Integrations

Run it from the Apify API or the JavaScript / Python clients, trigger it from n8n, Make or Zapier with the Apify modules, schedule it in the Apify Console, push results to Google Sheets, a webhook or your database, or call it from an AI agent through the Apify MCP server. The dataset can be downloaded as JSON, CSV, Excel, XML or HTML.

### FAQ

**Can I search by keyword?** No. Google's robots.txt disallows the store search pages, so the Actor only works from package IDs, listing URLs and developer pages. A developer page is the easiest way to get a whole portfolio at once.

**Where do I find the package ID?** It is the `id=` parameter of any Play Store URL (`.../details?id=com.whatsapp`). You can also paste the whole URL.

**Why are installs, prices or ratings different from what I see?** They are storefront-specific. Set `country` (and `language`) to the storefront you want to compare with.

**Does it need a proxy?** Google Play served every page from a plain IP in our tests. The Actor uses Apify's datacenter proxy by default and falls back to a residential proxy of the chosen country if Google starts answering with captchas.

**Is there a limit?** No hard limit; `maxItems` caps the run. Developer pages return the apps Google shows on the first page (typically up to a few dozen).

**Is this legal?** The Actor collects publicly visible store listings and declared metadata about apps and companies; it does not collect user data or reviews. Use the data in line with Google Play's terms and applicable law. The Actor is not affiliated with Google.

### Changelog

- **0.1 (October 2026)** — first release: listings by package ID, URL and developer page; permissions and data safety; any storefront and language.

***

### En español

Scraper de **fichas de apps de Google Play**: nombre, desarrollador, categoría, nota y cantidad de reseñas, instalaciones, precio y compras dentro de la app, versión, fechas de lanzamiento y actualización, descripción, capturas, **permisos** y resumen de **seguridad de datos**. Entrada por package ID, URL de la ficha o página del desarrollador; cualquier país e idioma de la tienda. Sin API key ni login. **US$1,60 por 1.000 apps**. No incluye búsqueda por palabra clave (robots.txt de Google no lo permite); para reseñas, usa nuestro Google Play Reviews Scraper.

# Actor input Schema

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

One entry per app: a package ID (the `id=` part of the Play URL, e.g. `com.whatsapp`) or a full Play Store URL (`https://play.google.com/store/apps/details?id=com.spotify.music`). Developer page URLs (`/store/apps/developer?id=...` or `/store/apps/dev?id=...`) are accepted too and expand to all apps listed on that page.

## `developers` (type: `array`):

Optional. Developer names exactly as shown on Google Play (e.g. `WhatsApp LLC`), numeric developer IDs (the `id=` of a `/store/apps/dev?id=...` URL) or developer page URLs. The Actor scrapes every app on the developer's first page (the list Google serves without scrolling).

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

Two-letter store country code (`us`, `gb`, `de`, `br`, `in`, `jp`...). Price, currency, availability, installs and ratings are storefront-specific.

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

Language of the texts (title, description, category names, permissions): `en`, `es`, `de`, `pt-br`, `ja`...

## `descriptionMaxChars` (type: `integer`):

Cut the plain-text description after this many characters to keep rows small. 0 = keep the full description.

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

Stop after this many apps (exact; also caps the cost). Useful with developer pages.

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

Apify Proxy settings. Datacenter IPs are enough for Google Play in our tests; if Google starts answering with captchas the Actor moves to a residential proxy of the chosen country automatically.

## Actor input object example

```json
{
  "appIds": [
    "com.whatsapp",
    "com.spotify.music",
    "org.telegram.messenger"
  ],
  "developers": [],
  "country": "us",
  "language": "en",
  "descriptionMaxChars": 1500,
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `apps` (type: `string`):

All apps collected during the run (one row per app)

# 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 = {
    "appIds": [
        "com.whatsapp",
        "com.spotify.music",
        "org.telegram.messenger"
    ],
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fabrikit/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 = {
    "appIds": [
        "com.whatsapp",
        "com.spotify.music",
        "org.telegram.messenger",
    ],
    "maxItems": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("fabrikit/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 '{
  "appIds": [
    "com.whatsapp",
    "com.spotify.music",
    "org.telegram.messenger"
  ],
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call fabrikit/google-play-apps-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,fabrikit/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/wTt5q2Uhs538Fp3SO/builds/MIj2EGaHGpKW7PiZp/openapi.json