# Google Play App Details Scraper (`fetchsmith-labs/google-play-scraper`) Actor

Extract Google Play app details (ratings, installs, histogram, developer contact, release dates) and developer app lists. Fast, cheap and robots.txt friendly.

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

## Pricing

from $2.00 / 1,000 app records

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 App Details Scraper

Extract structured app data from the Google Play Store: ratings, rating histogram, installs, price, genre, content rating, release and update dates, developer contact details, screenshots and more. Give the Actor a list of Android package names or Google Play URLs and get one clean JSON record per app. You can also list all apps shown on a developer's Google Play page. It is built for app store optimization (ASO) teams, market researchers, investors, mobile growth marketers and lead generation for app developers, and it works without a Google account or API key.

The Actor only reads public Google Play pages that the site's `robots.txt` allows (app detail pages and developer pages). No login, no cookies, no browser: it is a light HTTP scraper, so runs are fast and cheap.

### What data you get

#### Mode `apps` (app details)

| Field | Description |
| --- | --- |
| `appId`, `title`, `url` | Package name, app name and Google Play URL |
| `developer`, `developerId` | Developer name and Google Play developer id |
| `developerEmail`, `developerWebsite` | Public support email and website listed on the store page |
| `score`, `ratings`, `reviews`, `histogram` | Average rating, number of ratings, number of written reviews, count per star (1 to 5) |
| `installs`, `minInstalls`, `maxInstalls` | Install bracket as text and as numbers |
| `price`, `free`, `currency` | Price in the storefront currency |
| `genre`, `genreId`, `contentRating` | Category and age rating |
| `released`, `updated`, `version` | First release date (`YYYY-MM-DD` when the language is English), last update (ISO timestamp), current version (Google shows `VARY` for many apps) |
| `androidVersion` | Minimum Android version text |
| `adSupported`, `containsAds`, `offersIAP` | Contains ads / offers in-app purchases |
| `summary`, `description` | Short and full description as plain text |
| `icon`, `screenshots` | Image URLs |
| `country`, `language`, `scrapedAt` | Storefront used and scrape time |

#### Mode `developer` (apps of a developer)

`appId`, `title`, `url`, `developer`, `developerId`, `score`, `price`, `free`, `icon`, `summary` (truncated to 300 characters), `position`, `source` (always `developer`), `query` (the developer you asked for) and `scrapedAt`. Use the `appId` values as input for mode `apps` to get full details.

### How to use

1. Choose a **mode**: `apps` or `developer`.
2. For `apps`, add package names (`com.duolingo`) or Google Play URLs to **App IDs or URLs**. For `developer`, add developer ids, developer names or developer page URLs.
3. Set **language** (`hl`) and **country** (`gl`) to pick the storefront. Prices, availability and ratings depend on the country.
4. Keep **Max items** low for a first run, then raise it.
5. Click Start and download the dataset as JSON, CSV, Excel or via API.

### Input parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `mode` | string | `apps` | `apps` (full app details) or `developer` (apps listed on a developer page) |
| `appIds` | string\[] | `["com.duolingo"]` | Android package names or Google Play app URLs. Used by mode `apps` |
| `developerIds` | string\[] | none | Developer ids, developer names or developer page URLs. Used by mode `developer` |
| `language` | string | `en` | Google Play language code (`hl`), for example `en`, `de`, `fr` |
| `country` | string | `us` | Two-letter storefront country code (`gl`), for example `us`, `gb`, `de` |
| `maxItems` | integer | `20` | Apps processed in mode `apps`, apps returned per developer in mode `developer` |
| `proxyConfiguration` | object | no proxy | Optional Apify Proxy, only needed for large volumes |

### Input example

```json
{
    "mode": "apps",
    "appIds": [
        "com.duolingo",
        "https://play.google.com/store/apps/details?id=com.whatsapp&hl=en"
    ],
    "language": "en",
    "country": "us",
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": false }
}
```

Developer example:

```json
{
    "mode": "developer",
    "developerIds": ["Duolingo", "https://play.google.com/store/apps/dev?id=5700313618786177705"],
    "maxItems": 20
}
```

### Output example

```json
{
  "appId": "com.duolingo",
  "title": "Duolingo: Learn Languages",
  "url": "https://play.google.com/store/apps/details?id=com.duolingo&hl=en&gl=us",
  "developer": "Duolingo",
  "developerId": "6957685454452609502",
  "developerEmail": "super-support@duolingo.com",
  "developerWebsite": "https://www.duolingo.com/help/support-request",
  "score": 4.7375727,
  "ratings": 50808930,
  "reviews": 964934,
  "histogram": {
    "1": 1012963,
    "2": 365444,
    "3": 1176344,
    "4": 5832680,
    "5": 42421464
  },
  "installs": "500,000,000+",
  "minInstalls": 500000000,
  "maxInstalls": 981438421,
  "price": 0,
  "free": true,
  "currency": "USD",
  "genre": "Education",
  "genreId": "EDUCATION",
  "contentRating": "Everyone",
  "released": "2013-05-29",
  "updated": "2026-10-06T18:53:36.000Z",
  "version": "VARY",
  "androidVersion": "Varies with device",
  "adSupported": true,
  "containsAds": true,
  "offersIAP": true,
  "summary": "Make language learning fun with Spanish, French, English, chess, math & music.",
  "description": "Learn a new language, chess, math & more with the world’s most downloaded education app! Duolingo is the fun, free app for learning 40+ languages through quick,...",
  "icon": "https://play-lh.googleusercontent.com/tw_coGKgk1K_zO-Ypf9zBKV1s-KT3dYN1MIUxIqtnbfmON5x_YmuoAr31gE4oSfJHNtA-aStTd-qe9R8S6NVyA",
  "screenshots": [
    "https://play-lh.googleusercontent.com/twmCellsRXWs4bZsSXRv19x-3BIp19FzlQPdu_Va-zE10aL468HHFKJBvEOXo0g67Xsvl3nkIKnpjY7L62OOiA",
    "https://play-lh.googleusercontent.com/VtdxxfTA0xfkAgAj7iIr2DfvYJUoQctTvFDC_1xrX1NLm4d4av-xqaHMH8zqicW7AoXo56kT55LOQCW7gRFRyg"
  ],
  "country": "us",
  "language": "en",
  "scrapedAt": "2026-10-11T06:45:52.400Z"
}
```

### Use the Google Play scraper from your code (API)

Every run can be started over the Apify API, so you can feed Google Play data into your own scripts, spreadsheets, dashboards or ASO tools.

Node.js with the `apify-client` package:

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('fetchsmith-labs/google-play-scraper').call({
    mode: 'apps',
    appIds: ['com.duolingo', 'com.spotify.music'],
    country: 'us',
    language: 'en',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const app of items) console.log(app.title, app.score, app.installs);
```

Python with the `apify-client` package:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("fetchsmith-labs/google-play-scraper").call(run_input={
    "mode": "developer",
    "developerIds": ["Duolingo"],
    "maxItems": 30,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["appId"], item["title"])
```

cURL, synchronous run that returns the dataset items directly:

```bash
curl -X POST "https://api.apify.com/v2/acts/fetchsmith-labs~google-play-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode": "apps", "appIds": ["com.whatsapp", "org.telegram.messenger"], "country": "de", "language": "de"}'
```

Results can also go straight to Google Sheets, Make, Zapier, n8n, Slack or a webhook through the Apify integrations on the Actor page. A typical workflow: run mode `developer` to collect a publisher's package names, then pass those `appId` values to mode `apps` for full details.

### Pricing

This Actor uses pay-per-event pricing. You only pay for results.

| Event | Price | Charged when |
| --- | --- | --- |
| `app` | $0.002 | One app detail record is returned (mode `apps`) |
| `app-listing` | $0.0008 | One app is returned in a developer list (mode `developer`) |

Example: 1,000 app detail records cost 1,000 x $0.002 = $2.00. 1,000 developer list entries cost 1,000 x $0.0008 = $0.80. Apps that cannot be found are not charged. The run stops cleanly when your maximum charge limit is reached.

### Use cases

- **ASO and competitor tracking:** monitor ratings, install brackets, update frequency and metadata of competing apps.
- **Market research:** build datasets of apps by category, price model or developer.
- **Lead generation:** find app publishers and their public support email and website.
- **Investor and analyst research:** track growth signals such as installs and rating counts over time by scheduling your own runs.
- **Catalog enrichment:** turn a list of package names into full app records.

### FAQ

**Which data sources are used?** Public Google Play detail pages and developer pages, read over HTTP. The Actor intentionally only requests paths that Google Play's `robots.txt` allows. For that reason it does not include user reviews or keyword search, which would need paths that `robots.txt` disallows.

**Is it legal?** The Actor collects only publicly visible store data and no personal data beyond what developers themselves publish on their store pages (such as a support email). You are responsible for using the data in line with the applicable laws and Google Play's terms.

**Does it need a proxy?** Usually not for moderate volumes. If you scrape thousands of apps and see HTTP 429 errors in the log, enable Apify Proxy in the proxy configuration. Requests are retried 3 times with exponential backoff, with 3 apps processed in parallel.

**Why does the developer mode return only a few apps?** It returns the apps shown on the first page of the developer's Google Play page (typically 3 to 30 apps). Further apps are loaded by Google through a path that `robots.txt` disallows, so they are not fetched. Developers with very large catalogs may therefore be only partially listed.

**Why is `version` sometimes `VARY`?** Google Play does not publish a version number for many apps ("Varies with device"). The Actor returns what the store page shows.

**Why is `released` not a date?** Release dates are parsed into `YYYY-MM-DD` for English storefront texts. For other languages the original localized text is returned.

**Can I export Google Play data to CSV or Excel?** Yes. Every run stores its results in a dataset that you can download as JSON, CSV, Excel, XML or HTML from the Output tab, or fetch over the API.

**Can I track ratings and installs over time?** Run the Actor regularly on the same package names (for example from your own scheduler or an Apify schedule you create in your account) and compare `score`, `ratings` and `minInstalls` between runs.

**What if an app is not found?** The Actor logs a warning, skips it and continues. The run fails only if the input is invalid or nothing at all could be processed.

**What does Max items do?** In mode `apps` it limits how many of the given apps are processed in total. In mode `developer` it limits the apps returned per developer.

### Support

Found a bug or need an extra field? Open an issue on the Actor page in Apify Console and describe the input that failed.

# Actor input Schema

## `mode` (type: `string`):

What to scrape. apps: full details of apps by package ID or URL. developer: the apps listed on a developer's Google Play page.

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

Used by mode apps. Package names like com.duolingo or full Google Play URLs like https://play.google.com/store/apps/details?id=com.duolingo.

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

Used by mode developer. A numeric developer ID (e.g. 5700313618786177705), a developer name (e.g. Duolingo, Google LLC) or a developer page URL. Only the apps shown on the developer page are returned.

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

Maximum number of results. In mode apps it limits the total number of apps processed. In mode developer it limits the apps returned per developer. Keep it low for test runs.

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

Two-letter language code (hl) for texts, for example en, de, fr, es, pt, ja.

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

Two-letter country code (gl) of the Play Store storefront, for example us, de, gb, in, br. Affects availability, prices and rankings.

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

Optional. Google Play usually works without a proxy for moderate volumes. Enable Apify Proxy if you get blocked (HTTP 429) on large runs.

## Actor input object example

```json
{
  "mode": "apps",
  "appIds": [
    "com.duolingo"
  ],
  "maxItems": 20,
  "language": "en",
  "country": "us",
  "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 = {
    "mode": "apps",
    "appIds": [
        "com.duolingo"
    ],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetchsmith-labs/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 = {
    "mode": "apps",
    "appIds": ["com.duolingo"],
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("fetchsmith-labs/google-play-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 '{
  "mode": "apps",
  "appIds": [
    "com.duolingo"
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call fetchsmith-labs/google-play-scraper --silent --output-dataset

```

## MCP server setup

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