# Google Play API | Android App Search, Details and Reviews (`johnvc/google-play-api`) Actor

Google Play Store API for Android app data. Search apps, track Play Store rankings, pull full listings with version, permissions and data safety, and read user reviews. Works as a Google Play scraper, pay per result billing. Pairs with the Apple App Store Actors, MCP ready for AI agents.

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

## Pricing

from $0.01 / 1,000 dataset item storeds

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 API

The Google Play API turns the Android app store into clean, structured JSON. Search apps by keyword, pull the full listing for any app including version, permissions and data safety disclosures, and read user reviews.

Built for app store optimisation, competitor tracking, market research and AI agents that need Play Store data on demand. If you came looking for a Google Play scraper, this is that, with a documented schema and pay-per-result billing instead of a brittle script.

### The cross-platform story

Most app intelligence stops at one platform, which is exactly where it stops being useful. Pair this with the Apple App Store Actors and you can answer the questions that need both halves: is a competitor shipping faster on iOS than Android, is a rating gap platform specific or product wide, does the same app carry different permissions in each store.

### Use cases

- **Release cadence tracking.** Store `version` and `updatedOn` on a schedule and you can see how fast a competitor ships, and spot an abandoned app by a stale update date.
- **Monetisation research.** Detail rows expose `containsAds`, `hasInAppPurchases` and the in-app purchase price range, which is how an app actually makes money.
- **Privacy and compliance auditing.** `dataSafety` returns the developer's own declared data collection and sharing practices, useful for vetting apps before recommending them.
- **App store optimisation.** Search returns ranked results with `position`, so you can track where an app sits for a keyword over time.
- **Review mining.** Pull user reviews with helpful-vote counts for sentiment and theme analysis.
- **Cross-platform comparison.** Run this against the Apple App Store Actors to compare the same app on both stores, which is the question neither half answers alone.

### Input parameters

| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `search_mode` | string | yes | `search` | `search` finds apps by keyword, `product` returns one listing in full, `reviews` returns user reviews. |
| `query` | string | in search mode | `fitness` | Keyword to search the [Google Play](https://play.google.com) store for. Ignored in the other modes. |
| `product_id` | string | in product and reviews modes | none | Android package name, such as `com.spotify.music`. Every search row returns it, or read it off a store URL after `id=`. |
| `max_results` | integer | no | `100` | Rows to return, 1 to 2000. Search and reviews return 20 per request and page automatically. Product mode always returns exactly one row. |
| `country` | string | no | `us` | Two letter country code. Availability, pricing and rankings genuinely differ by country. |
| `language` | string | no | `en` | Two letter language code, controlling description and review language. |

### Example output

A detail row, which carries the fields that make the mode worth its higher price:

```json
{
  "resultType": "appDetail",
  "productId": "homeworkout.homeworkouts.noequipment",
  "title": "Home Workout - No Equipment",
  "developer": "Leap Fitness Group",
  "rating": 4.9,
  "downloads": "100,000,000+",
  "contentRating": "Everyone",
  "price": "Install",
  "containsAds": true,
  "hasInAppPurchases": true,
  "version": "1.3.7",
  "requiresAndroid": "7.0 and up",
  "releasedOn": "Nov 8, 2017",
  "updatedOn": "Jul 16, 2026",
  "inAppPurchases": "$0.99 - $59.99 per item",
  "dataSafety": ["No data shared with third parties"],
  "developerWebsite": "https://www.example.com"
}
```

Search rows carry `position`, the rank in the returned order, which is what ASO position tracking needs. Failures arrive as one `resultType: "error"` row rather than a crash.

### Three modes, one Actor

| Mode | What it returns | What it needs |
|---|---|---|
| Search | Apps matching a keyword, with each package name | a query |
| Product | Full listing detail for one app | the package name |
| Reviews | User reviews for one app | the package name |

Every search result row hands you the `productId` (the Android package name), so the chain to detail or reviews is self contained. You can also read it straight off any Play Store URL, after the `id=` parameter.

### What the Google Play scraper returns

**Apps**

| Field | Description |
|---|---|
| `title` | App name |
| `developer` | Publisher, useful for pulling a whole portfolio |
| `category` | Store category |
| `rating` | Average stars out of 5 |
| `downloads` | Install band as the store reports it |
| `position` | Search rank, starting at 1 |
| `productId` | Android package name |

**App detail** adds the fields that matter for real competitive work:

| Field | Why it matters |
|---|---|
| `version` | Track release cadence over time |
| `updatedOn` | A stale date is a strong abandonment signal |
| `releasedOn` | How long the app has been in market |
| `requiresAndroid` | Minimum supported Android version |
| `inAppPurchases` | Monetisation range |
| `containsAds` | Whether the listing declares advertising |
| `hasInAppPurchases` | Whether the listing declares in-app purchases |
| `dataSafety` | Declared data collection and sharing practices |
| `ratingBreakdown` | Star-by-star distribution, not just the average |
| `developerWebsite`, `developerEmail`, `developerPrivacyPolicy` | Publisher contact block |

**Reviews**

| Field | Description |
|---|---|
| `title` / `snippet` | Review headline and full text |
| `rating` | Reviewer's stars out of 5 |
| `likes` | How many users found it helpful |
| `reviewDate` | When it was posted |
| `reviewId` | Stable id for deduplicating scheduled runs |

### How to get started

1. Run search mode with a keyword. Every row gives you the `productId`.
2. Switch to product mode for the full listing, or reviews mode for user feedback.
3. Paste the package name into the App package name field and run.

[View on Apify Store](https://apify.com/johnvc/google-play-api?fpr=9n7kx3)

Prefer to start from working code? The [example repo](https://github.com/johnisanerd/Apify-Google-Play-API) has a Python quick start plus MCP install walkthroughs for Claude, Cursor and ChatGPT.

### Pricing

Pay per result. Search and reviews are priced low because one upstream request returns 20 rows. Detail lookups cost more because each one is a single request returning a single, much richer row.

| Event | When it is charged |
|---|---|
| App returned | Once per app row in search mode |
| App detail returned | Once per detail lookup |
| Review returned | Once per user review |

Current per-unit prices are on the Actor's Store card and in the Console before you run.

### 🔌 Use this API from Claude (MCP)

Add this Actor as a tool in [Claude Code](https://claude.ai/referral/uIlpa7nPLg) (free trial), [Claude Cowork](https://claude.ai/referral/uIlpa7nPLg) (free trial), or any other MCP client, via the hosted Apify MCP server. Use this Actor-specific URL:

https://mcp.apify.com/?tools=actors,docs,johnvc/google-play-api

Setup walkthrough:

https://www.youtube.com/watch?v=jREWahDGhJM

Apify MCP integration docs: https://docs.apify.com/platform/integrations/mcp

### 💸 Pay per run with crypto (x402)

The Google Play API supports agentic payments via the [x402 protocol](https://docs.apify.com/platform/integrations/x402).
AI agents and MCP clients can pay for runs in USDC (on Base) with no Apify account or API token needed:
point your agent at the [Apify MCP server](https://mcp.apify.com/?tools=actors,docs,johnvc/google-play-api) and it can
discover, pay for, and run this Actor autonomously. Read the
[Apify x402 announcement](https://apify.com/change-log/pay-for-apify-actors-with-x402?fpr=9n7kx3) for details.

### 🔌 Integrations: track app changes on a schedule

**Tasks and Schedules first.** Save a product lookup as a Task and attach a Schedule. A weekly check on a competitor's `version` and `updatedOn` turns this from a snapshot into a release timeline, and it needs no code.

**n8n, Make and Zapier.** Trigger the Actor and route rows onward: a competitor version bump into Slack, a rating drop into a dashboard, or new reviews into a sentiment step.

**Storage.** Write into Supabase, Postgres or Google Sheets through the Apify integrations tab so version and rating history accumulates.

**MCP.** Point an AI assistant at the Actor and let it pull live app data mid-conversation. Server URL is in the MCP section above.

**Webhooks.** Fire an HTTP callback when a run finishes so your service can collect the dataset without polling.

### 🔗 Related Tools

Run these alongside for the full cross-platform picture:

- [Apple App Store Search](https://apify.com/johnvc/apple-app-store-search?fpr=9n7kx3) is the iOS half of the same question
- [Apple App Store Product](https://apify.com/johnvc/apple-app-store-product-api?fpr=9n7kx3) for iOS listing detail
- [Apple App Store Reviews](https://apify.com/johnvc/apple-app-store-reviews-api?fpr=9n7kx3) for iOS user reviews
- [Google Autocomplete API](https://apify.com/johnvc/google-autocomplete-api?fpr=9n7kx3) for keyword discovery before you search

Alternatives such as [scrapesage/google-play-scraper](https://apify.com/scrapesage/google-play-scraper?fpr=9n7kx3) exist, but it sits at around 7 users with no published rating. This API returns the version, update date, monetisation flags and data-safety declarations that make release and privacy tracking possible, rather than listing fields alone.

### FAQ

#### Where do I find an app's package name?

Two ways. Run search mode and copy the `productId` from any row, or open the app's Play Store page and take everything after `id=` in the URL. For example `https://play.google.com/store/apps/details?id=com.spotify.music` gives you `com.spotify.music`.

#### Can I track an app's release cadence?

Yes, and it is one of the better uses for this. Run product mode on a schedule and store `version` and `updatedOn`. The gap between updates tells you how actively a competitor is shipping, and a long-stale `updatedOn` usually means the app has been abandoned.

#### Why is the download count a range instead of a number?

Because that is all the Play Store publishes. Google reports install bands like "100,000,000+" rather than exact figures. Any tool claiming an exact Play Store install count is estimating.

#### Can I compare an app across Android and iOS?

That is the point of pairing this with the Apple App Store Actors listed above. Pull the same app from both, then compare ratings, version cadence, and declared data practices side by side.

#### What is the data safety field?

Google requires developers to declare what data their app collects and shares. Those declarations come back in `dataSafety` on detail rows, which is useful for privacy audits and for vetting apps before recommending them.

#### Is this a Google Play API or a web scraper?

You use it as an API: structured JSON in, structured JSON out, with a documented schema and pay-per-result billing. It reads public [Google Play](https://play.google.com) listing pages, so it is not an official product and is not affiliated with, endorsed by, or connected to Google.

#### Can I use this Google Play scraper for bulk review exports?

Yes. Reviews return 20 per request and the Actor pages automatically to your `max_results`. Billing is per result, so an export costs in proportion to what you receive. For recurring pulls, pair a Task with a Schedule as described in the Integrations section.

#### How do I call this from an AI agent using MCP?

Point any [Model Context Protocol](https://modelcontextprotocol.io) client at the server URL in the MCP section above. The agent reads the input schema itself and can look up an app during a conversation.

#### How do I run this on a schedule?

Save the configuration as a Task and attach a Schedule. The Integrations section above covers the downstream options.

#### What other tools work well alongside this one?

See Related Tools above. The Apple App Store Actors are the natural pairing: same question, other platform, and comparing the two is where most of the value sits.

#### Does it work outside the United States?

Yes. Set the country and language codes in the input. The Play Store genuinely varies by country: availability, pricing and rankings all differ, so set the country to the market you actually care about.

### Agent Skills

Ready-made skills for [Claude Code](https://claude.ai/referral/uIlpa7nPLg) (free trial) and other agents that drive this Actor. Install with `npx skills add johnisanerd/<name>`.

- [claude-skill-google-play-scraper](https://github.com/johnisanerd/claude-skill-google-play-scraper): apps, listings and reviews as structured JSON
- [claude-skill-play-store-rankings](https://github.com/johnisanerd/claude-skill-play-store-rankings): ASO keyword rank tracking per storefront

### Featured Tasks

Ready-to-run examples on the Apify Store.

- [App Version History on Google Play, Tracked](https://apify.com/johnvc/google-play-api/examples/app-version-history-google-play?fpr=9n7kx3)
- [Google Play Reviews Exporter to CSV and JSON](https://apify.com/johnvc/google-play-api/examples/google-play-reviews-exporter?fpr=9n7kx3)
- [Scrape Google Play Reviews and App Data](https://apify.com/johnvc/google-play-api/examples/scrape-google-play-reviews?fpr=9n7kx3)
- [Audit Google Play Data Safety Declarations](https://apify.com/johnvc/google-play-api/examples/google-play-data-safety-audit?fpr=9n7kx3)
- [Google Play App Data in Claude via MCP](https://apify.com/johnvc/google-play-api/examples/google-play-claude-mcp?fpr=9n7kx3)

***

### 🌐 About Alpha OSINT

This Actor is part of [Alpha OSINT](https://www.alphaosint.com), toolset of financial and operations data sources and APIs.
For support or requests for this actor, please start a ticket [directly on our support page](https://apify.com/johnvc/google-play-api/issues/open?fpr=9n7kx3).

Last Updated: 2026.08.06

# Actor input Schema

## `search_mode` (type: `string`):

What to fetch. 'Search' finds apps by keyword and returns each app's package name. 'Product' returns the full listing for one app, including version, permissions and data safety. 'Reviews' returns user reviews for one app.

## `query` (type: `string`):

Required when search mode is 'search'. The keyword to search the Play Store for, such as 'fitness tracker', 'budgeting' or 'photo editor'. Ignored in the other modes.

## `product_id` (type: `string`):

Required for product and reviews modes. The Android package name, such as com.spotify.music. Run search mode first and copy the productId from any result row, or take it from the app's Play Store URL after the id= parameter.

## `max_results` (type: `integer`):

How many rows to return before stopping. Search returns 20 apps per upstream call and reviews returns 20 per call, so the Actor pages automatically until it reaches this number or the source runs out. Product mode always returns exactly one row.

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

Optional two letter country code such as us, gb or de. The Play Store shows different apps, prices and availability by country.

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

Optional two letter language code such as en, es or fr. Controls the language of descriptions and reviews.

## Actor input object example

```json
{
  "search_mode": "search",
  "query": "fitness",
  "max_results": 100,
  "country": "us",
  "language": "en"
}
```

# Actor output Schema

## `allResults` (type: `string`):

Every row from this run.

## `overview` (type: `string`):

Apps with developer, category, rating and downloads in a scannable table.

## `reviews` (type: `string`):

User reviews with rating, text, helpful votes and date.

# 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 = {
    "query": "fitness"
};

// Run the Actor and wait for it to finish
const run = await client.actor("johnvc/google-play-api").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 = { "query": "fitness" }

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

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/m2EB9prGrPaRNS0uS/builds/frpLbH8Ernk5wY91c/openapi.json