# Google Play Scraper - Apps, Ratings & Installs ($1/1K) (`lukehunter/google-play-scraper`) Actor

Scrape Google Play app details or monitor known app IDs for rating, ratings-count, install-band, update, price and developer-contact changes. Stateful scheduled runs emit only changes plus a free run summary.

- **URL**: https://apify.com/lukehunter/google-play-scraper.md
- **Developed by:** [Luke Hunter](https://apify.com/lukehunter) (community)
- **Categories:** Developer tools, Marketing
- **Features:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.00 / 1,000 apps

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 Scraper - Apps, Ratings & Installs ($1/1K)

**For ASO teams, competitor-monitoring and app-market researchers who need a current app snapshot or compact change alerts.** Normal mode returns one rich row per known app ID. Turn on `onlyChangesSinceLastRun` to persist a baseline across scheduled runs and emit only rating, ratings-count, install-band, update, price and developer-contact changes.

Pay-per-result: **$0.001 per app — 1,000 apps = $1.**
Try it free with Apify's monthly platform credit.

### Quick start (2 minutes)

1. Find an app on Google Play and copy its package id from the URL (e.g. `com.spotify.music` from
   `https://play.google.com/store/apps/details?id=com.spotify.music`), or just paste the whole URL.
2. Open the **Input** tab and use this prefill (swap in your own apps):

```json
{
  "appIds": ["com.spotify.music"],
  "maxItems": 5
}
```

3. Click **Start**. Export the resulting dataset to CSV/Excel/JSON, or pull it through the API
   shown below.

### Use cases

- **ASO teams** tracking rating, install bucket and content rating for competitor apps over time.
- **Competitor and market researchers** building a comparison sheet across many apps in a category.
- **Business-development teams** collecting a developer's public contact info (email/website/
  address, when Google publishes it) for outreach or partnership research.
- **Pricing researchers** tracking free/paid status, price and in-app purchase price ranges across
  a set of apps.

### Monitor changes on a schedule + webhook

Monitor mode turns repeated snapshots into a compact event stream. The first run for each app/language/country watch saves a baseline and emits no billable changes. Later runs emit:

- `rating_changed` when the absolute score delta reaches `ratingChangeThreshold` (default `0.05`)
- `ratings_count_changed`
- `installs_band_changed`
- `updated` when Google's published `updated` date or `recentChanges` text changes
- `price_changed`
- `developer_contact_changed`

Every monitor run also writes one free `run_summary` row.

Example scheduled input:

```json
{
  "appIds": ["com.spotify.music", "com.whatsapp"],
  "language": "en",
  "country": "US",
  "onlyChangesSinceLastRun": true,
  "ratingChangeThreshold": 0.05,
  "stateStoreName": "competitor-app-watch",
  "maxItems": 100
}
```

A concrete recipe:

1. Run that input once to establish baselines.
2. In **Apify Console → Schedules**, run it daily at 09:00 (or your preferred cadence) with the same `stateStoreName`.
3. In **Integrations → Webhooks**, add an **Actor run succeeded** webhook to your endpoint or automation tool.
4. Have the receiver read the run's default dataset and route rows where `eventType != "run_summary"` to Slack/email/a database. Those are the change rows; the summary is diagnostic and free.

Example change row:

```json
{
  "eventType": "rating_changed",
  "appId": "com.spotify.music",
  "title": "Spotify: Music and Podcasts",
  "previousScore": 4.28,
  "currentScore": 4.35,
  "scoreDelta": 0.07,
  "ratingChangeThreshold": 0.05,
  "observedAt": "2026-09-28T09:00:00.000Z"
}
```

### Get Google Play app change alerts in Discord, Telegram, Slack, Teams, Google Chat, your phone (ntfy/Pushover) or any app (webhook)

Want a **Google Play rating or update alert** in Discord, Telegram, Slack or on your phone instead of reading change rows from a dataset? Turn on monitor mode (`onlyChangesSinceLastRun`), add one or more destinations in the Actor's **Notifications (optional)** section, and each run sends the change events it delivered. It is a **monitor that notifies you**: it only reads public Google Play app pages, and it never installs apps, posts reviews or logs in to Google.

| Channel | Fill in | What you get |
|---|---|---|
| Discord | `discordWebhookUrl` | One card per change, 10 per message |
| Telegram | `telegramBotToken` + `telegramChatId` | Up to 10 changes per message, one line each |
| Slack | `slackWebhookUrl` | Block Kit message, up to 10 changes per message |
| Mattermost, Rocket.Chat | `slackCompatibleWebhookUrl` | Slack-style incoming webhook: a Markdown list (these apps do not render Slack Block Kit) |
| Microsoft Teams | `teamsWebhookUrl` | Adaptive Card from a Teams Workflows webhook, up to 10 changes per card |
| Google Chat | `googleChatWebhookUrl` | Card in a space, up to 10 changes per message |
| ntfy (phone push, no account) | `ntfyTopic` (optional `ntfyServer`, `ntfyToken`) | A push per change, up to 10, then one "...and N more" |
| Pushover (phone push) | `pushoverUserKey` + `pushoverAppToken` | A push per change, up to 10, then one "...and N more" |
| Any app: Zapier, Make, n8n, Pipedream, IFTTT, Home Assistant | `webhookUrl` | One JSON POST per run with every delivered row |

Fill in as many as you like; each channel works on its own and a failing one never stops the others.

#### Setup, channel by channel

- **Discord (1 minute):** Server Settings → Integrations → Webhooks → New Webhook → pick the channel → **Copy Webhook URL**.
- **Telegram (2 minutes):** chat with **@BotFather**, send `/newbot`, paste the token into `telegramBotToken`. Add the bot to the chat or channel (administrator for a channel; for a chat with yourself press **Start** on the bot). `telegramChatId` is a numeric id (`123456789`, or `-1001234567890` for a group or channel) or a public `@channelusername`.
- **Slack:** at api.slack.com/apps create an app (**From scratch**) → **Incoming Webhooks** → switch it on → **Add New Webhook to Workspace** → pick the channel → copy the `https://hooks.slack.com/services/...` URL.
- **Mattermost or Rocket.Chat:** create an **incoming webhook** in the app and paste its public `https://` URL into `slackCompatibleWebhookUrl`. It must be reachable from the internet: localhost, private IP addresses and `.local` / `.internal` names are rejected.
- **Microsoft Teams:** in the channel open **... → Workflows** → **Post to a channel when a webhook request is received** → finish the wizard and copy the URL (a host ending in `.logic.azure.com` or `.powerplatform.com`). The old "Office 365 connector" webhooks are retired and not supported.
- **Google Chat:** in the space open **Apps & integrations → Webhooks → Add webhook**, name it and copy the `https://chat.googleapis.com/v1/spaces/...` URL (needs a Google Workspace account that allows webhooks).
- **ntfy (free, no account):** install the ntfy app (or open ntfy.sh), subscribe to a topic with a long random name, and put the same name in `ntfyTopic`. Anyone who knows the topic can read it, so make it unguessable. Own server or a protected topic: set `ntfyServer` (public `https://` address) and `ntfyToken`.
- **Pushover:** copy your user key from pushover.net into `pushoverUserKey`, create an application at pushover.net/apps/build and put its API token in `pushoverAppToken`. Pushover itself is a separate paid app after its trial: check their pricing.
- **Any app (webhook):** paste the catch-hook URL from Zapier, Make, n8n, Pipedream, IFTTT or Home Assistant into `webhookUrl`. It must be a public `https://` address.

#### The recipe: a competitor-app alert in five steps

1. Add the apps to watch to `appIds` (package ids or details URLs).
2. Turn on `onlyChangesSinceLastRun`, and set `ratingChangeThreshold` if the default 0.05 is too sensitive.
3. Add your destination(s) from the table above.
4. Run it once. The first run saves a baseline and sends nothing, because nothing has changed yet.
5. Create a **Schedule** (daily works well). From then on each run sends the changes it found.

```json
{
  "appIds": [
    "com.spotify.music",
    "com.whatsapp"
  ],
  "onlyChangesSinceLastRun": true,
  "ratingChangeThreshold": 0.05,
  "stateStoreName": "competitor-app-watch",
  "maxItems": 100,
  "discordWebhookUrl": "https://discord.com/api/webhooks/<id>/<token>",
  "ntfyTopic": "your-long-random-topic-name",
  "maxNotifications": 25
}
```

#### The generic webhook (`webhookUrl`)

Each run sends **one POST per 100 delivered rows** (so usually one) with this body, followed by whatever your tool does with it:

```json
{
  "source": "apify",
  "actor": "google-play-scraper",
  "runId": "HG7ML7M8z78YcAPEB",
  "count": 2,
  "total": 2,
  "part": 1,
  "parts": 1,
  "items": [
    {
      "...": "the full dataset rows"
    }
  ]
}
```

`count` is the number of rows in this POST, `total` the number delivered in the run, and `part` / `parts` number the POSTs when a run delivers more than 100 rows. `maxNotifications` does not cap the webhook: your tool gets every delivered row. Your endpoint should answer with a 2xx status; redirects are not followed and a failure is reported in the run status, never retried in a loop.

#### What each message contains

Each change event is announced with the app's name and a link to its Play page: `Rating up: 4.28 → 4.35`, `Price drop: $1.99 → $0.99`, `Installs: 1,000,000,000+ → 5,000,000,000+`, `Ratings: 36,380,579 → 36,381,102 (+523)`, `Updated` (with the new and previous update date and the release notes), or `Developer contact changed` (naming only the contact fields that changed, with their old and new values). Messages are ordered by importance: rating, price, update, installs and developer contact first, then the ratings count, which moves on almost every run for a popular app. Discord gets a card per change, Telegram one line per change, Slack Block Kit sections, Teams an Adaptive Card, Google Chat a card, and ntfy/Pushover a push that opens the app page. Link previews are off, and titles are escaped so a title can never inject formatting or mentions.

#### What to expect

- **Only delivered change rows are sent, and only in monitor mode.** A normal run delivers a full snapshot of every app rather than changes, so it sends nothing (the status message says so). The free `run_summary` row and baselines are never sent, and a run with no changes sends nothing.
- **`maxNotifications` (default 25, max 100)** caps how many changes go to chat and phone channels per run (the webhook is not capped). The rest are still in the dataset and the status message says so. ntfy and Pushover send at most 10 individual pushes, then one "...and N more" summary.
- **Cost: notifications are free.** You pay only the usual price for delivered changes, exactly as without alerts. There is no extra charge for any channel.
- **Failures never fail the run.** A deleted webhook or an unreachable service leaves the run successful and the dataset complete, and the status message says what happened, for example `Notified: Discord 12, Slack 12, ntfy 10 (+summary). Teams failed (HTTP 404) - check the webhook URL.` The logs show the channel name and HTTP status only, never a URL or token.
- **Your URLs, tokens and ntfy topic are stored as secret inputs.** Anyone holding a webhook URL can post to that channel, so treat it like a password.
- **It is a monitor that notifies you.** It never installs apps, posts reviews or logs in to Google. The messages go only to the destinations you set up.
- **Nothing changes by default.** With no destination set, a run behaves exactly as before and the dataset rows are identical.

### Input

```json
{
  "appIds": ["com.spotify.music"],
  "maxItems": 50,
  "language": "en",
  "country": "US"
}
```

| Field | Type | Default | Description |
|---|---|---:|---|
| `appIds` | string\[] | required | 1–500 Android package ids or Play Store details URLs |
| `maxItems` | integer | 50 | 1–5000. Hard cap on apps delivered across the whole run |
| `language` | string | `en` | Play Store UI language code (`hl`), e.g. `de`, `es` |
| `country` | string | `US` | 2-letter Play Store country code (`gl`), affects price/currency |
| `onlyChangesSinceLastRun` | boolean | `false` | Opt-in stateful monitoring. First run saves a baseline; later runs emit only change events. |
| `stateStoreName` | string | `google-play-scraper-state` | Named cross-run state store used only in monitor mode. Reuse it for the same watch. |
| `discordWebhookUrl` | string (secret) | *(none)* | Discord webhook URL. Must look like `https://discord.com/api/webhooks/<id>/<token>`. Empty means no Discord messages. See the alerts section above. |
| `telegramBotToken` | string (secret) | *(none)* | Telegram bot token from @BotFather. Needs `telegramChatId`. |
| `telegramChatId` | string | *(none)* | Telegram chat to post to: a numeric chat id or `@channelusername`. The bot must be added to that chat or channel. Needs `telegramBotToken`. |
| `slackWebhookUrl` | string (secret) | *(none)* | Slack incoming webhook, `https://hooks.slack.com/services/...`. |
| `slackCompatibleWebhookUrl` | string (secret) | *(none)* | Mattermost / Rocket.Chat incoming webhook (public `https://` URL; Markdown list, no Block Kit). |
| `teamsWebhookUrl` | string (secret) | *(none)* | Microsoft Teams Workflows webhook (host ending `.logic.azure.com` or `.powerplatform.com`). |
| `googleChatWebhookUrl` | string (secret) | *(none)* | Google Chat space webhook, `https://chat.googleapis.com/v1/spaces/...`. |
| `ntfyTopic` | string (secret) | *(none)* | ntfy topic name; setting it turns ntfy phone pushes on. Pick a long, unguessable name. |
| `ntfyServer` | string | `https://ntfy.sh` | ntfy server. Only change it for your own public `https://` ntfy server. |
| `ntfyToken` | string (secret) | *(none)* | Optional ntfy access token for a self-hosted server or protected topic. Needs `ntfyTopic`. |
| `pushoverUserKey` | string (secret) | *(none)* | Pushover user key. Needs `pushoverAppToken`. |
| `pushoverAppToken` | string (secret) | *(none)* | Pushover application API token. Needs `pushoverUserKey`. |
| `webhookUrl` | string (secret) | *(none)* | Generic JSON webhook (Zapier, Make, n8n, Pipedream, IFTTT, Home Assistant): every delivered row, 100 per POST. Public `https://` only. |
| `maxNotifications` | integer | 25 | 1–100. Most changes sent to chat and phone channels per run (the webhook is not capped). Extra changes are still in the dataset. Only used when a destination is set. |
| `ratingChangeThreshold` | number | `0.05` | Monitor mode: minimum absolute score delta for `rating_changed`. |

For most users, the only setting that matters is **App ids**.

#### Why there's no keyword search

`https://play.google.com/robots.txt` disallows `/store/search` outright — verified against the
live file, with no wildcard exception for a query string. This Actor honours robots.txt on every
request, so it does not perform Play Store keyword search at all: `searchTerms` is accepted in the
input schema for forward compatibility but any non-empty value fails the run with an explanation.
Find the package id for the app you want in your own browser (it's the `id=` value in the details
URL) and pass that instead.

### Google Play app data fields

| Category | Fields |
|---|---|
| Identity | `appId`, `url`, `title` |
| Developer | `developer`, `developerId`, `developerEmail`, `developerWebsite`, `developerAddress` |
| Classification | `category`, `genreId`, `contentRating` |
| Pricing | `price`, `currency`, `free`, `containsAds`, `offersIAP`, `iapPriceRange` |
| Popularity | `installsText`, `minInstalls`, `realInstalls` |
| Ratings | `score`, `ratingsCount`, `reviewsCount`, `histogram` |
| Dates | `released`, `updated` |
| Content | `summary`, `descriptionText`, `recentChanges` |
| Media | `icon`, `screenshots`, `video` |
| Compatibility | `version`, `androidVersion` (usually null — see Limitations) |
| Freshness | `scrapedAt`, `language`, `country` |

Missing values are returned as `null`. The Actor does not invent missing app data.

### Google Play output example

Real output for `com.spotify.music` (trimmed — `descriptionText` runs to ~3000 characters and
`screenshots` holds up to 5 URLs in the full row):

```json
{
  "appId": "com.spotify.music",
  "url": "https://play.google.com/store/apps/details?id=com.spotify.music&hl=en&gl=US",
  "title": "Spotify: Music and Podcasts",
  "developer": "Spotify AB",
  "developerId": "6523013212965523194",
  "developerEmail": "support@spotify.com",
  "developerWebsite": "https://www.spotify.com",
  "developerAddress": "Regeringsgatan 19\n111 53 Stockholm\nSweden",
  "category": "Music & Audio",
  "genreId": "MUSIC_AND_AUDIO",
  "price": 0,
  "currency": "USD",
  "free": true,
  "containsAds": true,
  "offersIAP": true,
  "iapPriceRange": "$4.99 - $203.88 per item",
  "installsText": "1,000,000,000+",
  "minInstalls": 1000000000,
  "realInstalls": 3135692442,
  "score": 4.347309,
  "ratingsCount": 36380579,
  "reviewsCount": 1853986,
  "histogram": { "1": 3704002, "2": 1068685, "3": 1311103, "4": 3100952, "5": 27195814 },
  "contentRating": "Teen",
  "updated": "2026-09-25T08:00:14.000Z",
  "released": "2014-05-27T13:12:17.000Z",
  "scrapedAt": "2026-09-27T00:00:00.000Z",
  "language": "en",
  "country": "US"
}
```

| Field | Value |
|---|---|
| `developer` / `developerEmail` | `Spotify AB` / `support@spotify.com` |
| `score` / `ratingsCount` | `4.35` / `36,380,579` |
| `installsText` / `realInstalls` | `1,000,000,000+` / `3,135,692,442` |
| `free` / `containsAds` / `offersIAP` | `true` / `true` / `true` |
| `contentRating` | `Teen` |

### Use it as a Google Play API

The Actor can be called from your own application through the Apify API. No Google account or
Play Store login is required.

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("lukehunter/google-play-scraper").call(
    run_input={
        "appIds": ["com.spotify.music"],
        "maxItems": 50,
    }
)

for app in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(app["title"], app["score"], app["installsText"])
```

Use Apify schedules for recurring app snapshots, and webhooks or integrations to send completed
datasets into the rest of your workflow.

### Pricing and cost control

This Actor uses **pay per delivered app** pricing.

**Current configured rate: $0.001 per app delivered.** Check the Apify **Pricing** tab for the
latest published rate.

| Apps delivered | Cost at $0.001/app |
|---:|---:|
| 100 | $0.10 |
| 1,000 | $1.00 |
| 5,000 | $5.00 |

There is no charge for merely starting a run, and a not-found app id (HTTP 404) is never charged. In monitor mode, only change rows use the existing `app` charge; the single `run_summary` row is free. `maxItems` caps billable rows (app rows in normal mode, change events in monitor mode).

Notifications to Discord, Telegram, Slack, Teams, Google Chat, ntfy, Pushover and webhooks are free: you pay only for delivered changes, never for messages sent.

### Reliability and data quality

The Actor is designed to make data problems visible instead of hiding them.

- Two independent data sources are read on every page — Google's own embedded page data and the
  page's JSON-LD structured data — and cross-checked against each other for `title`, `developer`,
  `score`, `ratingsCount`, `price`, `currency` and `free`.
- If neither source can be parsed at all, the run fails loudly for that app instead of returning an
  empty-looking row.
- A not-found app id (HTTP 404) is reported per-app and never charged.
- Missing values are returned as `null` rather than guessed.
- Every outgoing request is checked against `robots.txt` in code before it is made; the Actor
  refuses to request a disallowed path.

### Important limitations

- **App ids only — no keyword search.** See "Why there's no keyword search" above:
  `play.google.com/robots.txt` disallows `/store/search`.
- **No individual reviews.** Verified against real captured pages: Google
  Play's details page does not embed individual review text server-side — only the aggregate
  rating and star histogram. The individual reviews shown in a browser are filled in by a
  client-side request this Actor does not make (it would require the `/_` batchexecute endpoint,
  which robots.txt disallows and this Actor refuses to call). This Actor does **not** implement
  full paginated review scraping.
- **`version` and `androidVersion` are usually `null`.** Most current Play Store listings no longer
  publish a static version/minimum-OS field (Google's redesigned page delivers per-device instead).
- **`video` is rarely populated.** Not every app publishes a promo video, and this field has not
  been observed populated against any real page used to build this Actor.
- **`developerEmail`/`developerWebsite`/`developerAddress`** are returned only when Google publishes
  them on the page as the developer's public business contact info; many apps do not show all three.
- Ratings, installs and pricing can change after the run. `scrapedAt` records the observation time.
- The Actor does not use CAPTCHA bypass, proxy rotation, credential capture, or impersonation. It
  identifies itself honestly and respects a 1-request-per-2-seconds pace.
- Public catalogue data only; no personal data beyond a developer's own published business contact
  info is collected.
- This is an independent tool and is **not affiliated with, endorsed by, or connected to Google
  LLC.** Google Play is a trademark of its owner. You are responsible for using the data in
  accordance with applicable terms and laws.

### Use it from your code, Make, Zapier or n8n

Built for automated pipelines: small runs, stable field names, one row per item, and you pay only for rows actually delivered.

**One API call that runs the Actor and returns the data** (replace `$APIFY_TOKEN` with your token from Apify Console → Settings → Integrations):

```bash
curl -s -X POST "https://api.apify.com/v2/acts/lukehunter~google-play-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"appIds": ["com.spotify.music"], "maxItems": 5, "language": "en", "country": "US"}'
```

**JavaScript** (`npm i apify-client`):

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('lukehunter~google-play-scraper').call({
  "appIds": [
    "com.spotify.music"
  ],
  "maxItems": 5,
  "language": "en",
  "country": "US"
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**Python** (`pip install apify-client`):

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('lukehunter~google-play-scraper').call(run_input={"appIds": ["com.spotify.music"], "maxItems": 5, "language": "en", "country": "US"})
items = client.dataset(run['defaultDatasetId']).list_items().items
```

**Schedules, webhooks and no-code tools:** save your input as a Task, add a Schedule (e.g. hourly or daily), and attach a webhook or one of the Integrations tab's connectors (Make, Zapier, n8n, Google Sheets, Slack) to push each run's results into your own system.

**Feedback:** an honest rating on the Store page, good or bad, helps others decide if this Actor fits their needs. Missing a field or found a problem? Open an issue on the Actor page.

### FAQ

#### Can I search Google Play by keyword?

No. `play.google.com/robots.txt` disallows `/store/search`, and this Actor honours robots.txt for
every request. Pass the app's package id or details URL instead — see "Why there's no keyword
search".

#### Is it legal to scrape Google Play app data?

This Actor only collects public app data already shown on Google Play's own details pages: names,
ratings, prices, and similar catalogue fields, plus a developer's own publicly published business
contact info. It does not bypass any login, CAPTCHA, or paywall, and it honours robots.txt. It is
an independent tool, not affiliated with or endorsed by Google LLC, and you are responsible for
using the collected data in accordance with Google's terms of service and the laws that apply to
you.

#### Does it return individual reviews?

No. Google Play's details page does not embed individual review text in the initial
page load — only the aggregate rating and histogram are present server-side. See "Important
limitations" above.

#### How do I find an app's package id?

Open the app on play.google.com. For a URL such as
`https://play.google.com/store/apps/details?id=com.spotify.music`, the package id is
`com.spotify.music` — you can paste the whole URL or just that id.

#### Does it work for apps in other countries/languages?

Yes — set `language` (`hl`) and `country` (`gl`) to affect the page's display language and
price/currency. The app itself is the same regardless of these settings.

#### Can I get Google Play change alerts in Discord, Telegram, Slack or on my phone?

Yes. Set `discordWebhookUrl`, `telegramBotToken` + `telegramChatId`, `slackWebhookUrl`, `teamsWebhookUrl` or `googleChatWebhookUrl`, or use `ntfyTopic` (free, no account) or `pushoverUserKey` + `pushoverAppToken` for phone pushes. Mattermost and Rocket.Chat work through `slackCompatibleWebhookUrl`. Alerts need monitor mode (`onlyChangesSinceLastRun`) and a schedule: each run then sends only the rating, price, update, install-band, ratings-count and developer-contact changes it delivered. Setup steps for each are in the alerts section above. Notifications cost nothing extra.

#### Can I get Google Play change alerts by email?

Not natively. There are two routes. (1) Set `webhookUrl` to a Zapier, Make or n8n catch hook and add an email or Gmail step: the webhook delivers every row as JSON, so the email can list the changes. (2) Apify's own run integrations and run notifications can email you when a run finishes, but they only send a link to the run or dataset, not the changes themselves. For instant alerts without building anything, Telegram, ntfy or Pushover reach your phone directly.

#### Can I get Google Play change alerts in WhatsApp?

Not natively, and we do not use unofficial WhatsApp APIs, which risk getting your number banned. The official route is the WhatsApp Business Platform (Cloud API) with its own business account, message templates and pricing: point `webhookUrl` at a Zapier, Make or n8n flow that calls it. For free phone alerts use Telegram or ntfy instead.

### Related Actors

Other data tools from the same developer, built to the same standard: official or public sources, hard cost caps, and honest documentation of limits.

- **[YouTube Channel Scraper](https://apify.com/lukehunter/youtube-stats-tracker)**: new-video alerts and channel monitoring for any list of YouTube channels: subscribers, latest videos and a new-uploads-only mode for scheduled runs.
- **[Apple App Store Reviews Scraper](https://apify.com/lukehunter/app-store-reviews-scraper)**: Apple App Store reviews for any iOS app, across countries, with rating, version and date.
- **[Spotify Scraper](https://apify.com/lukehunter/spotify-scraper)**: play counts, monthly listeners and playlist track lists for any public Spotify artist, playlist, album or track.
- **[Shopify Product Scraper by URL](https://apify.com/lukehunter/shopify-product-tracker)**: price, compare-at price and stock for specific Shopify product URLs, with a change-only feed.
- **[Walmart Category Scraper](https://apify.com/lukehunter/walmart-category-scraper)**: product names, prices, was-prices and ratings from Walmart category pages.
- **[Shopify Store Products Scraper](https://apify.com/lukehunter/shopify-store-products-scraper)**: full product catalogues from any Shopify store, with prices, sale prices, variants and stock.
- **[Vinted Cross-Country Price Comparison](https://apify.com/lukehunter/vinted-cross-country-prices)**: compare the same search across Vinted country markets with EUR-normalized summaries and median price gaps.
- **[Vinted Scraper](https://apify.com/lukehunter/vinted-scraper)**: Vinted search results with prices, brands and sizes in any Vinted country, plus scheduled new-listing alerts sent to Discord or Telegram.

# Actor input Schema

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

Android package ids (e.g. "com.spotify.music") or full Play Store details URLs (e.g. https://play.google.com/store/apps/details?id=com.spotify.music). Keyword search is not supported — see "searchTerms" below for why. Maximum 500 app ids per run.

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

Hard cap on delivered rows, 1-5000, default 50. In normal mode these are app rows; in monitor mode these are billable change-event rows (the free run_summary does not count).

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

Google Play UI language code, e.g. "en", "de", "es". Affects display text (contentRating, category name, descriptions) but not which app is returned. Default "en".

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

2-letter Play Store country code, e.g. "US", "DE", "GB". Affects price/currency and availability shown. Default "US".

## `onlyChangesSinceLastRun` (type: `boolean`):

Off by default. Turn on for scheduled known-app monitoring: the first run saves a baseline and emits only a free run_summary row; later runs emit only change events and charge only those event rows. Normal one-off scraping remains unchanged.

## `stateStoreName` (type: `string`):

Only used when change monitoring is on. Named Apify key-value store that persists per-app snapshots across scheduled runs. Keep the same name for the same watch; change it to start a fresh baseline. Letters, numbers and hyphens only.

## `discordWebhookUrl` (type: `string`):

Post results to a Discord channel. In Discord: Server Settings -> Integrations -> Webhooks -> New Webhook -> choose the channel -> Copy Webhook URL. Looks like https://discord.com/api/webhooks/<id>/<token>. Leave empty to skip Discord.

## `telegramBotToken` (type: `string`):

Post results to Telegram. Create a bot by chatting with @BotFather on Telegram (send /newbot) and paste the token it gives you, e.g. 123456789:AA.... Needs "Telegram chat ID" below. Leave empty to skip Telegram.

## `telegramChatId` (type: `string`):

Where the bot should post: a numeric chat id (e.g. 123456789, or -1001234567890 for a group or channel) or a public @channelusername. The bot must be added to that chat or channel first (as an administrator for a channel), and for a private chat you must press Start on the bot. Needs "Telegram bot token" above.

## `slackWebhookUrl` (type: `string`):

Post results to a Slack channel (Block Kit cards, up to 10 per message). Create an incoming webhook at api.slack.com/apps -> Create New App -> Incoming Webhooks -> Add New Webhook to Workspace. Looks like https://hooks.slack.com/services/T000/B000/XXXX. Leave empty to skip Slack.

## `slackCompatibleWebhookUrl` (type: `string`):

Post results to a Mattermost or Rocket.Chat incoming webhook, which accept Slack-style webhook payloads. Must be a public https:// address (no localhost, private IP or .local/.internal hosts). These apps do not render Slack Block Kit, so they get a plain Markdown list. For real Slack use "Slack webhook URL" above. Leave empty to skip.

## `teamsWebhookUrl` (type: `string`):

Post results to a Teams channel as an Adaptive Card. In Teams: channel -> ... -> Workflows -> "Post to a channel when a webhook request is received" -> copy the URL. The host must end in .logic.azure.com or .powerplatform.com. The retired Office 365 connector webhooks are not supported. Leave empty to skip Teams.

## `googleChatWebhookUrl` (type: `string`):

Post results to a Google Chat space. In the space: Apps & integrations -> Webhooks -> Add webhook -> copy the URL. Looks like https://chat.googleapis.com/v1/spaces/<space>/messages?key=...\&token=.... Leave empty to skip Google Chat.

## `ntfyTopic` (type: `string`):

Get a phone push with no account via ntfy (ntfy.sh). Install the ntfy app, subscribe to a topic name, and enter the same name here. Anyone who knows the topic can read it, so pick a long, unguessable name (letters, numbers, - and \_). At most 10 individual pushes per run, then one "...and N more". Leave empty to skip ntfy.

## `ntfyServer` (type: `string`):

Only used with "ntfy topic". Leave as https://ntfy.sh, or enter the public https:// address of your own ntfy server.

## `ntfyToken` (type: `string`):

Only used with "ntfy topic", for a self-hosted server or a reserved topic that needs a login. An access token from ntfy (starts with tk\_). Leave empty for open topics.

## `pushoverUserKey` (type: `string`):

Get a phone push via Pushover. Your user key is shown on the Pushover dashboard (pushover.net). Needs "Pushover app token" below. At most 10 individual pushes per run, then one "...and N more". Leave empty to skip Pushover.

## `pushoverAppToken` (type: `string`):

The API token of a Pushover application you create at pushover.net/apps/build (name it after this Actor). Needs "Pushover user key" above.

## `webhookUrl` (type: `string`):

POST the delivered rows as JSON to any public https:// URL: {source, actor, runId, count, items}. At most 100 rows per POST; every delivered row is sent regardless of the max-notifications cap. Use it to route results to email, a spreadsheet or any app. Localhost, private IP and .local/.internal addresses are rejected. Leave empty to skip.

## `maxNotifications` (type: `integer`):

Caps how many results are sent to chat and phone channels per run (Discord, Telegram, Slack, Teams, Google Chat, ntfy, Pushover), 1-100, default 25. Extra results are still in the dataset. The generic webhook is not capped. Only used when a destination above is set.

## `ratingChangeThreshold` (type: `number`):

Monitor mode only. Emit rating_changed when the absolute score delta is at least this amount. Default 0.05 rating points; set 0 to report every numeric rating change.

## Actor input object example

```json
{
  "appIds": [
    "com.spotify.music"
  ],
  "maxItems": 5,
  "language": "en",
  "country": "US",
  "onlyChangesSinceLastRun": false,
  "stateStoreName": "google-play-scraper-state",
  "ntfyServer": "https://ntfy.sh",
  "maxNotifications": 25,
  "ratingChangeThreshold": 0.05
}
```

# Actor output Schema

## `apps` (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 = {
    "appIds": [
        "com.spotify.music"
    ],
    "maxItems": 5,
    "language": "en",
    "country": "US",
    "onlyChangesSinceLastRun": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("lukehunter/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 = {
    "appIds": ["com.spotify.music"],
    "maxItems": 5,
    "language": "en",
    "country": "US",
    "onlyChangesSinceLastRun": False,
}

# Run the Actor and wait for it to finish
run = client.actor("lukehunter/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 '{
  "appIds": [
    "com.spotify.music"
  ],
  "maxItems": 5,
  "language": "en",
  "country": "US",
  "onlyChangesSinceLastRun": false
}' |
apify call lukehunter/google-play-scraper --silent --output-dataset

```

## MCP server setup

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