# Google Play Store Scraper (`googleapi/google-play-store-scraper`) Actor

Collect normalized app metadata from public Google Play detail, search, and category pages with bounded requests.

- **URL**: https://apify.com/googleapi/google-play-store-scraper.md
- **Developed by:** [Google API](https://apify.com/googleapi) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

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

The Google Play Store Scraper collects **public app listing and detail data** from [Google Play](https://play.google.com/store). Direct app-detail inputs return a rich app record; search and category inputs can optionally enrich discovered cards with their public detail pages. It does not log in, access private APIs, collect reviewer identities, solve CAPTCHAs, or bypass access controls.

### Why use this Actor?

Use the structured records for app catalog research, market comparisons, store monitoring, or downstream spreadsheets and BI. The Actor accepts app package IDs, public Play URLs, search terms, and category slugs. Repeated package IDs can be deduplicated across the requested sources. Search/category detail enrichment is disabled by default and capped because each app detail page adds another public request.

Result and detail limits help keep runs within the scope you need. The Actor collects public Google Play listing information and does not bypass access controls.

### What data can the Actor extract?

Values are omitted when Google Play does not expose them on the fetched page. Full app descriptions and release notes are retained without text truncation; `descriptionHtml` preserves safe source formatting. Screenshot and related-app arrays are also capped. Device-availability text reflects the device/session associated with the page and is not a universal compatibility or regional-availability guarantee. Explicit rating qualifiers (for example, “Users Interact”) are listed separately from the age rating.

| Area | Example fields |
|---|---|
| App identity | `appId`, `title`, `appUrl`, `appCategory`, `appCategoryId` |
| Developer | `developer`, `developerId`, `developerUrl`, `developerWebsiteUrl`, `developerSupportUrl`, `developerEmail`, `supportEmail`, `developerPhone` |
| Ratings and reach | `rating`, `ratingCount`, `reviewCount`, `ratingDistribution`, `installs`, `installsMinimum` |
| Price and flags | `price`, `priceText`, `priceCurrency`, `free`, `containsAds`, `inAppPurchases`, `inAppPurchasesText` |
| Listing details | `contentRating`, `contentRatingDescriptors`, `releasedOn`, `updatedOn`, `version`, `requiredAndroidVersion`, `downloadSize` |
| Description and media | `shortDescription`, full-text `description`, sanitized `descriptionHtml`, `whatsNew`, `iconUrl`, `screenshotUrls`, `videoUrl`, `videoThumbnailUrl` |
| Device availability | `compatibilityText`, `deviceAvailabilityText`, `deviceAvailabilityStatus`, `familyLibraryAvailable` |
| Play badges | `editorsChoice`, `chartRankText` |
| Privacy and related apps | `dataSafety`, `dataSafetyUrl`, `permissionsUrl`, `privacyPolicyUrl`, `familyLibraryAvailable`, `relatedApps` |

The `dataSafety` values are the developer-provided statements shown by Google Play, not an independent security assessment. Device-specific account details and reviewer content are excluded.

### How to scrape Google Play apps

1. Open the Actor’s **Input** tab.
2. Enter one package ID, a list of package IDs, a Google Play URL, a search term, or a category.
3. Choose a locale and country when the listing region matters.
4. Enable `includeAppDetails` and adjust `maxDetailApps` for enriched search/category results.
5. Start the run and inspect the app records in **Dataset**.

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

Apify compute use depends on your plan and the amount of data collected. Optional detail-page enrichment and larger result limits can increase usage. Check the run’s usage in Apify Console for the applicable current price.

### Input

See the input tab for the complete configuration. Inputs support `startUrls` (objects containing `url`), compatibility aliases `sourceUrls`, `urls`, or `url`, `appId`, `appIds`, `category`, `searchTerm`, and `searchTerms`. Sources from different input properties are combined and identical normalized URLs are deduplicated. If no source is specified, the Actor uses the Google Maps app listing on Google Play.

`page` is fixed at `1`: the public Google Play search/category view does not expose a stable numeric page offset. `maxPages` (default 10, 1–50) caps explicitly supplied source URLs processed; each URL represents one source page. `maxTargets` remains a compatibility alias for `maxPages`; conflicting aliases are rejected. `maxApps` (default 20, 1–100) caps cards per search/category source; `maxItems` (default 100, 1–500) is the global record limit. `maxResults` is a compatibility alias for `maxItems`. Records are deduplicated by package ID by default.

`includeAppDetails` defaults to `false`. The Actor fetches detail pages for at most `maxDetailApps` apps (default 100, 1–100) across the run. A detail record is emitted only when its detail page is successfully parsed; failed detail requests are reported in run health instead of downgrading the row to a sparse search card. Set `includeAppDetails` to `false` to receive visible search/category cards without detail fetches. A direct app-detail source is parsed as a detail record regardless of this toggle.

Locale defaults to `en-US`. You can provide `language` and `country` separately; `location` is accepted as a country alias.

Runnable input examples:

```json
{"appId":"com.google.android.apps.maps"}
```

```json
{"appIds":["com.google.android.apps.maps","com.google.android.youtube"],"maxItems":10}
```

```json
{"category":"TRAVEL_AND_LOCAL","maxApps":10}
```

```json
{"searchTerm":"music","maxApps":5}
```

```json
{"searchTerms":["navigation","weather"],"includeAppDetails":true,"maxDetailApps":5,"maxItems":10}
```

```json
{"startUrls":[{"url":"https://play.google.com/store/apps/details?id=com.google.android.apps.maps&hl=en&gl=US"}],"page":1,"maxPages":1,"maxItems":1}
```

```json
{"searchTerm":"music","locale":"en-IN","includeAppDetails":true,"maxDetailApps":3}
```

```json
{"appId":"com.google.android.apps.maps","locale":"en-IN","maxItems":10}
```

### Output

App detail pages usually contain more information than search cards. Search cards may also show prices and video previews. The Editors' Choice badge appears only when Google displays it. Missing values are omitted rather than guessed. Developer and support contact details are included only when they appear in the app-support section. The safe HTML description preserves paragraphs, lists, emphasis, and links.

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

Example of the record structure (optional source values omitted here):

```json
{
  "appId": "com.example.store",
  "title": "Store Demo",
  "developer": "Example Labs",
  "developerEmail": "contact@example.com",
  "supportEmail": "help@example.com",
  "developerUrl": "https://play.google.com/store/apps/dev?id=example-labs",
  "appUrl": "https://play.google.com/store/apps/details?id=com.example.store",
  "appCategory": "Productivity",
  "appCategoryId": "PRODUCTIVITY",
  "rating": 4.4,
  "ratingCount": 567,
  "reviewCount": 55,
  "ratingDistribution": {"oneStar": 2,"twoStar": 1,"threeStar": 3,"fourStar": 4,"fiveStar": 45},
  "installs": "10,000+ Downloads",
  "installsMinimum": 10000,
  "price": 0,
  "priceCurrency": "USD",
  "free": true,
  "containsAds": true,
  "inAppPurchases": true,
  "contentRating": "Everyone 10+",
  "contentRatingDescriptors": ["Users Interact"],
  "releasedOn": "Feb 26, 2019",
  "updatedOn": "Sep 10, 2026",
  "version": "2.1.0",
  "requiredAndroidVersion": "7.0 and up",
  "downloadSize": "119 MB",
  "description": "A public app description with the source's paragraph and bullet structure.",
  "descriptionHtml": "<p>A public app description with its paragraph structure.</p><ul><li>Source-visible list item</li></ul>",
  "whatsNew": "Bug fixes and performance improvements.",
  "iconUrl": "https://play-lh.googleusercontent.com/icon=s128",
  "screenshotUrls": ["https://play-lh.googleusercontent.com/screen-one=w440-h960"],
  "videoThumbnailUrl": "https://i.ytimg.com/vi/example/hqdefault.jpg",
  "privacyPolicyUrl": "https://example.com/privacy",
  "permissionsUrl": "https://play.google.com/store/apps/permissions?id=com.example.store",
  "dataSafetyUrl": "https://play.google.com/store/apps/datasafety?id=com.example.store",
  "dataSafety": {"encryptedInTransit": true,"deletionRequestAvailable": true},
  "familyLibraryAvailable": true,
  "deviceAvailabilityText": "This app is available for your device",
  "deviceAvailabilityStatus": "available_for_current_device"
}
```

### Tips and advanced options

Use a direct app ID or detail URL for the richest output. Search and category pages begin with card details; turn on app-detail enrichment if you need fuller listings. Lower `maxItems`, `maxApps`, or `maxDetailApps` when you need a smaller run.

### FAQ, support, and responsible use

If a run returns no app rows, verify that the app ID or URL is valid and publicly accessible. Review the Actor’s Issues tab for bugs or feature requests and include the run ID. The API tab explains how to start runs and retrieve dataset items.

This Actor is not affiliated with Google. It reads publicly visible store information only and does not attempt authentication or access-control circumvention. App listings and data-safety disclosures may contain information about people or organizations; use results lawfully, minimize personal-data handling, and follow Google Play’s terms and applicable privacy laws. The Actor does not independently verify developer-provided statements.

# Actor input Schema

## `startUrls` (type: `array`):

Public HTTPS Google Play detail, search, or category pages.

## `sourceUrls` (type: `array`):

Compatibility list of public Google Play URLs.

## `urls` (type: `array`):

Compatibility list of public Google Play URLs.

## `url` (type: `string`):

One public Google Play URL.

## `appId` (type: `string`):

Google Play package ID.

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

Google Play package IDs.

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

Optional Play category slug such as TRAVEL_AND_LOCAL.

## `searchTerm` (type: `string`):

Term used with the public Play app search page.

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

Terms used with public Play app search pages.

## `maxApps` (type: `integer`):

Maximum app cards read from each search or category source page.

## `page` (type: `integer`):

Google Play currently exposes no stable numeric offset for its app search/category pages. This Actor reads the first public result view only, so page is fixed at 1.

## `maxPages` (type: `integer`):

Maximum number of explicitly supplied Google Play source URLs to process. Each source URL is one page; app-detail requests are separately bounded by maxDetailApps.

## `maxTargets` (type: `integer`):

Compatibility alias for maxPages. If both are supplied, they must match.

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

Maximum normalized app records across all sources.

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

Compatibility alias for maxItems.

## `locale` (type: `string`):

Language-country locale such as en-US.

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

Two-letter Google Play language code.

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

Two-letter Google Play country code.

## `location` (type: `string`):

Compatibility alias for country.

## `deduplicate` (type: `boolean`):

Deduplicate repeated package IDs across sources.

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

Optionally fetch each discovered app's public detail page for rich records. Disabled by default; bounded by maxDetailApps.

## `maxDetailApps` (type: `integer`):

Maximum discovered app detail pages fetched when includeAppDetails is enabled.

## `requestTimeoutSecs` (type: `integer`):

Maximum seconds per public request.

## `requestTimeoutMs` (type: `integer`):

Compatibility timeout in milliseconds.

## `timeoutSecs` (type: `integer`):

Compatibility alias for requestTimeoutSecs.

## `maxRequestRetries` (type: `integer`):

Finite retries for transient public-request failures.

## `requestDelayMs` (type: `integer`):

Delay before later public requests.

## `maxResponseBytes` (type: `integer`):

Maximum HTML bytes accepted per public page.

## `userAgent` (type: `string`):

Optional ordinary browser user agent.

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

Optional active Apify Proxy configuration.

## Actor input object example

```json
{
  "maxApps": 20,
  "page": 1,
  "maxPages": 10,
  "maxItems": 100,
  "deduplicate": true,
  "includeAppDetails": false,
  "maxDetailApps": 100,
  "requestTimeoutSecs": 30,
  "maxRequestRetries": 1,
  "requestDelayMs": 250,
  "maxResponseBytes": 2500000
}
```

# Actor output Schema

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

No description

## `output` (type: `string`):

No description

## `runSummary` (type: `string`):

No description

## `runHealth` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("googleapi/google-play-store-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 = {}

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,googleapi/google-play-store-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/SLwPqcJW3hQB0P3Ew/builds/sCEzgL3N25dvUZZsP/openapi.json