Google Play Apps Scraper

Collect public Google Play apps from category charts or supplied package IDs and listing URLs. The Actor returns one consistent app record with package identity, title, publisher, description, rating signals, install range, monetization labels, category, version, release dates, media, and the localized listing URL.

Use it to create repeatable app-market snapshots without managing a browser, Google account, or private API key. No AI models are used to collect or generate the output. This Actor is not affiliated with or endorsed by Google.

What does this Google Play scraper collect?

The Actor supports two complementary routes:

1. Browse a Google Play category chart such as top free Health & Fitness apps.
2. Fetch current details for known Android package IDs or public app-detail URLs.

Both routes produce the same typed dataset rows. This makes category discovery and later detail refreshes easy to combine in one data pipeline.

The Actor does not collect reviews, permissions, or private Play Console data.

Who is it for?

• App-market analysts tracking category composition and publisher activity.
• ASO teams comparing ratings, installs, versions, and monetization labels.
• Product teams maintaining a watchlist of Android competitors.
• Investors and researchers building recurring app-market datasets.
• Data engineers feeding Google Play metadata into a warehouse or dashboard.

Why use this Actor?

• Catalog plus details: discover category apps and refresh known packages with one schema.
• Localized results: choose a country and language for availability, prices, text, and charts.
• Stable identity: every row includes the Android package ID and canonical listing URL.
• Automation-ready: schedule runs and export JSON, CSV, Excel, XML, or RSS from Apify datasets.
• Bounded output: one global maxItems limit controls the size and price of every run.
• Fail-closed behavior: malformed URLs, package IDs, and locales are rejected instead of producing misleading empty data.

Supported Google Play category charts

Choose one or more categories and one collection:

• TOP_FREE — top free apps.
• TOP_PAID — top paid apps.
• GROSSING — top-grossing apps.

Supported category IDs include BUSINESS, EDUCATION, FINANCE, GAME, HEALTH_AND_FITNESS, MUSIC_AND_AUDIO, PHOTOGRAPHY, PRODUCTIVITY, SHOPPING, SOCIAL, SPORTS, TOOLS, TRAVEL_AND_LOCAL, and the other values listed in the input UI.

A public category URL can also carry the collection, for example:

https://play.google.com/store/apps/category/HEALTH_AND_FITNESS/collection/topselling_free

Extracted app fields

Group	Fields
Identity	appId, title, appUrl
Publisher	developer, developerId, developerEmail, developerWebsite
Listing text	summary, description, recentChanges
Rating signals	score, ratings, reviews
Adoption	installs, minInstalls, maxInstalls
Monetization	price, priceText, currency, free, offersInAppPurchases, containsAds
Classification	genre, genreId, contentRating
Release	released, updatedAt, version
Media	iconUrl, headerImageUrl, screenshots
Provenance	sourceType, sourceCategory, sourceCollection, sourceRank, country, language, scrapedAt

Fields can be null when Google Play does not expose a value for a listing or locale.

How to scrape Google Play apps

1. Open the Actor input page.
2. Add package IDs, app-detail URLs, categories, or category URLs.
3. Select the chart used by category inputs.
4. Set a two-letter country and language.
5. Choose maxItems to cap the total number of unique apps.
6. Click Start.
7. Open the Dataset tab to preview or export the records.

For a first run, use HEALTH_AND_FITNESS, TOP_FREE, us, en, and maxItems: 10.

Input parameters

Parameter	Type	Default	Meaning
startUrls	array	empty	Google Play app-detail or app-category URLs
appIds	string array	empty	Android package IDs such as com.spotify.music
categories	string array	empty	Google Play category IDs to browse
collection	string	TOP_FREE	TOP_FREE, TOP_PAID, or GROSSING
country	string	us	Two-letter storefront country code
language	string	en	Two-letter listing language code
maxItems	integer	50	Global unique-app output limit from 1 to 500
maxItemsPerCategory	integer	omitted	Chart positions fetched per unique category/collection, 1–500, bounded by remaining maxItems; applies to category URLs, ignored for app-only input

At least one app, URL, or category must be supplied. Direct app IDs and detail URLs are processed first. Duplicate packages found through multiple inputs are emitted once with their first-source provenance. Without maxItemsPerCategory, the first chart can fill the global cap, preserving existing behavior. With it, each chart fetches at most that many positions. Overlap, unavailable apps, failed requests, direct-input priority and the global cap can reduce category representation: a limit of 10 is not a promise of 10 unique rows.

sourceRank is the 1-based position in the returned chart before filtering or deduplication (gaps are possible), not an independently verified global Google ranking. Supplied app details have null category, collection and rank. containsAds preserves explicit booleans from the listing, including false, and is null only when unknown.

Example input

{
  "categories": ["PRODUCTIVITY", "BUSINESS"],
  "collection": "GROSSING",
  "country": "us",
  "language": "en",
  "maxItemsPerCategory": 10,
  "maxItems": 20
}

To refresh a known watchlist instead:

{
  "appIds": [
    "com.spotify.music",
    "com.google.android.apps.fitness"
  ],
  "country": "us",
  "language": "en",
  "maxItems": 2
}

Example output

A real run produces rows shaped like this:

{
  "appId": "com.google.android.apps.fitness",
  "title": "Google Fit: Activity Tracking",
  "developer": "Google LLC",
  "score": 3.9,
  "ratings": 620000,
  "installs": "100,000,000+",
  "price": 0,
  "priceText": "Free",
  "currency": "USD",
  "free": true,
  "offersInAppPurchases": false,
  "containsAds": false,
  "genre": "Health & Fitness",
  "genreId": "HEALTH_AND_FITNESS",
  "version": "Varies with device",
  "updatedAt": "2026-08-01T12:00:00.000Z",
  "appUrl": "https://play.google.com/store/apps/details?id=com.google.android.apps.fitness&hl=en&gl=US",
  "sourceType": "app",
  "sourceCategory": null,
  "sourceCollection": null,
  "sourceRank": null,
  "country": "us",
  "language": "en",
  "scrapedAt": "2026-08-30T12:00:00.000Z"
}

Live values change as publishers update their listings.

How much does it cost to collect Google Play app metadata?

Pay-per-event pricing has a $0.005 Actor start and one item event for each app record saved. The item event is the primary value event.

Plan	Price per app
Free	$0.000920
Bronze	$0.000800
Silver	$0.000624
Gold	$0.000480
Platinum	$0.000320
Diamond	$0.000224

At Bronze pricing, a run costs approximately:

• 1 app: $0.0058 including the start.
• 10 apps: $0.013 including the start.
• 100 apps: $0.085 including the start.

Failed, duplicate, or rejected records do not produce an item event. Your Apify plan and applicable platform rules determine the tier used.

Monitoring and change-detection workflow

Schedule the same input daily or weekly to create timestamped snapshots. Use appId as the stable join key, then compare fields such as:

• score, ratings, and reviews for rating movement.
• minInstalls and maxInstalls for adoption changes.
• price, free, offersInAppPurchases, and containsAds for monetization changes.
• version, updatedAt, and recentChanges for release monitoring.
• developer and listing text for publisher or positioning changes.

The Actor returns snapshots. It does not itself send alerts or calculate historical diffs.

Integrations and exports

Use Apify integrations to send dataset rows to:

• Google Sheets for analyst review.
• Make or Zapier for downstream automation.
• Webhooks for run-completion processing.
• BigQuery, Snowflake, or another warehouse through your ETL process.
• A BI dashboard for app-category and publisher reporting.

Dataset API parameters can select fields, unwind arrays, and choose JSON, CSV, Excel, XML, or RSS.

Run with the Apify API

cURL

curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~google-play-app-catalog-details/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"categories":["HEALTH_AND_FITNESS"],"collection":"TOP_FREE","country":"us","language":"en","maxItems":10}'

JavaScript

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/google-play-app-catalog-details').call({
    appIds: ['com.spotify.music', 'com.google.android.apps.fitness'],
    country: 'us',
    language: 'en',
    maxItems: 2,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Python

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/google-play-app-catalog-details').call(run_input={
    'categories': ['PRODUCTIVITY', 'BUSINESS'],
    'collection': 'GROSSING',
    'country': 'us',
    'language': 'en',
    'maxItemsPerCategory': 10,
    'maxItems': 20,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)

Use with MCP and AI assistants

Add this Actor to Claude Code through the Apify MCP server:

claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/google-play-app-catalog-details"

Claude Desktop setup

Add this server to Claude Desktop's MCP configuration:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/google-play-app-catalog-details"
    }
  }
}

Cursor setup

In Cursor, open Settings → Tools & MCP → New MCP Server and use the same HTTP URL shown above.

VS Code setup

In VS Code with MCP support, add an HTTP server named apify using the same Actor-specific MCP URL.

Example prompts:

• “Collect the top 25 free Finance apps from the US Google Play store.”
• “Refresh details for these Android package IDs and return rating and version changes.”
• “Create a current snapshot of top-grossing Productivity and Business apps.”

Bounded run-to-result workflow

1. Discover a stable subset. Use the Actor-specific endpoint above and scoped tools/list to inspect actual names and argument schemas. Actor selection also adds get-actor-run, get-dataset-items, get-key-value-store-record, and abort-actor-run; it is not exactly one tool. Discovery does not authorize execution or aborting a run.
2. Start once and follow the same run. For an authorized invocation, retain the returned run ID, status and storage IDs: these are metadata, not app rows. call-actor waits for waitSecs (0–45 seconds, default 30), not necessarily completion. If nonterminal, poll get-actor-run for that same ID with 2, 4, 8-second backoff capped at 10 seconds and a total deadline such as 120 seconds. Set the client request timeout above the selected server wait plus transport margin, within the total deadline. After a client timeout, recover the known run instead of starting another; if its ID is unknown, report uncertainty rather than blindly rerun. At the deadline, report pending with the run ID and stop polling. Report terminal failure honestly; available rows are partial, not a complete successful result.
3. Retrieve bounded rows. After success, use get-dataset-items with the returned defaultDatasetId, explicit limit:20, offset:0, and only needed fields, for example appId,title,score,containsAds,sourceCategory,sourceCollection,sourceRank, using the discovered argument schema. Prefer untransformed JSON. Advance by source offsets and pagination metadata, not transformed row counts: filtering and unwinding can change returned counts. Example total model-context budget: at most 100 source rows and 64 KiB of serialized UTF-8 result content across all pages, whichever comes first. The host must intercept pages before model injection, track cumulative bytes/rows, and omit or summarize an oversized page or row with disclosure. If your client cannot intercept responses, do not claim a hard byte guarantee or request unbounded results. Stop at exhaustion or budget and disclose admitted rows, continuation offset, and partial/truncated status. Read RUN_SUMMARY with get-key-value-store-record to identify incomplete sources or limit stops. Keep full exports in storage or downstream processing outside model context. These consumer limits do not change Actor collection defaults or output fields.
4. Qualify context claims. Discovery transport bytes are not necessarily model-visible context. Tool caching, progressive loading and prompt caching depend on client capabilities. No universal token savings are promised. Any numeric claim needs measured client/version, negotiated capabilities and cache/discovery mode, model/tokenizer, visible tool/result subset, and a stated baseline and measurement method.

See Apify MCP tools and results and dataset paging and field projection.

Reliability, limits, and troubleshooting

Google Play is a public but undocumented source and can change its response format. The Actor validates package identities and emits a failure when all requested routes fail.

Operational limits:

• maxItems is capped at 500 per run.
• Category composition and order vary by country and time.
• Some fields are absent for some apps or locales and therefore return null.
• The Actor does not use a residential proxy, browser, account, or automatic paid fallback.
• Removed, unavailable, or region-restricted apps may not produce a row.

If a category returns fewer records than expected, try a different country or collection and check whether Google Play currently exposes that category there.

Run completeness and diagnostics

Open Run completeness summary in the output tab, or read RUN_SUMMARY in the run's default key-value store. It records counts only:

• requestedSources: unique direct apps plus unique category/collection requests.
• completedSources / failedSources: visited sources with no exhausted operation errors / at least one exhausted operation error. A fetched chart stopped by a limit counts as completed unless a detail operation failed; completed does not mean every app was saved.
• skippedSources: sources not visited because of a stop (or fatal interruption).
• emptySources: successfully fetched charts with no positions; these are not reported as crashes.
• truncatedSources: fetched charts whose traversal stopped before its last fetched position.
• failedOperations: failed detail or chart requests; no upstream messages or raw input included.
• savedUniqueCount: rows saved to the dataset.
• partialResult: a source failed, was skipped, or chart traversal was truncated. This does not assert full Google Play coverage; empty charts and chart-depth limits still apply.
• stopReason: global_limit, source_exhaustion (all planned sources visited), or charge_limit.

Useful partial results remain successful. No useful records after source exhaustion remains a failed run. A charge-limited stop may succeed with zero rows: inspect the summary before treating it as a complete snapshot. A final successfully charged row is retained, and no further source fetch or app enrichment starts after the output budget is exhausted. Startup validation failures occur before a source plan exists and do not have a run summary.

Failed operations send sanitized diagnostic input, exceptions and Actor/build/run IDs to our private GlitchTip service for repair. Secret fields and URL queries are removed. Reports are retained for 30 days. We do not send upstream response bodies or publisher contact fields in these diagnostics.

Responsible use and legality

This Actor collects public Google Play listing metadata. Use it in accordance with applicable laws, Google Play terms, and Apify's terms. Do not use the output to harass publishers, misrepresent apps, or make automated decisions that require additional verification.

Public developer contact details may still be personal data in some jurisdictions. Only retain and process fields needed for a legitimate purpose. You are responsible for your input, schedule, storage, and downstream use. Dataset rows, run inputs, logs and the count-only summary remain in your Apify run storage under your account's retention settings; delete the corresponding run storage when no longer needed. The Actor keeps no separate persistent app cache. Apify hosts run storage, Google Play supplies public listings, and our private GlitchTip service receives only the sanitized repair diagnostics described above. There are no additional paid proxy, model or supplier dependencies.

For questions or problems, open an issue on this Actor's Apify Store page. Include a safe run link and the observed behavior, not credentials or private inputs.

FAQ

Does it need a Google account or API key?

No. It reads public Google Play app and category data. An Apify account is needed to run the Actor.

Can it scrape reviews?

No. This Actor returns app catalog and detail rows only. Use the related Google Play Store Scraper when review collection is part of the job.

Why is a field null?

Google Play does not expose every field for every app, country, or language. Null values preserve the stable schema without inventing data.

Why did my run fail with “invalid app ID”?

Package IDs must look like Android identifiers, for example com.spotify.music. For URLs, provide an HTTPS app-detail or category URL on play.google.com.

Can I compare changes automatically?

Schedule repeated runs and compare datasets by appId. The Actor creates snapshots but does not calculate diffs or send alerts itself.

Related automation-lab Actors

• Google Play Store Scraper — app search, details, and reviews when you need a broader workflow.
• AppBrain Google Play Rankings Scraper — AppBrain ranking views for complementary market-position tracking.
• Google Play Data Safety Scraper — public privacy and data-safety declarations for supplied apps.