Google Play scraper API

App stores · v1.1.0 · google_play_apps

$0.006 / app

$6.00 / 1K · pay per delivered app

A Google Play scraper API for a list of package names or store URLs: title, developer, category, description, rating and review count, price and currency, content rating, install band, icon and the localized store URL.

By Aldo Morese, founder of QuanticData · Published Aug 21, 2026 · Updated Sep 7, 2026

Run in dashboard See the request

$0.006 per delivered app · $2 free every month · Failed runs never billed

What it does

What a Google Play scraper API does

Play has no public catalogue API, so the store page is the source. Rather than dig through the page's internal data arrays — which Play reshuffles constantly — this collector reads the schema.org block the page publishes for search engines: the same values, in a format that stays put.

One detail cost us a silent bug worth knowing about: Play serializes the rating as a string, so a strict type check drops every rating without raising anything. The parser coerces, and the ratings are there.

Inputs

The whole request. Anything you leave out falls back to the default shown in the catalog.

Input	Type	Required	What it does
`packages`	array	yes	Android package names (com.spotify.music) or Play store URLs.
`country`	string	no	ISO 3166-1 alpha-2 code — picks the local site AND the proxy exit (default us).
`lang`	string	no	Interface language (hl), e.g. en, it, de.
`max_results`	integer	no	How many apps to deliver at most (1–50). You pay only for delivered apps.

Outputs — 26 fields, one row per app

What one app looks like

Every delivered app carries these fields. Nullable means the source did not publish it — the field stays empty instead of being guessed.

Field	Type	What it holds
`package`	string	Android package name.
`title`	string	App name.
`developer`	string · nullable	Developer name.
`developer_url`	string · nullable	Developer page URL.
`category`	string · nullable	Play category.
`description`	string · nullable	Store description (trimmed).
`rating`	number · nullable	Average rating.
`reviews`	integer · nullable	Rating count.
`price`	number · nullable	Numeric price (0 = free).
`currency`	string · nullable	Currency code.
`content_rating`	string · nullable	Content rating.
`operating_system`	string · nullable	Target OS.
`installs`	string · nullable	Install band when the page shows one.
`icon`	string · nullable	Icon URL.
`url`	string	Localized store URL.
`full_description`	string · nullable	The full store description (up to 6000 characters).
`genres`	string[]	Genre chips shown on the page.
`screenshots`	string[]	Screenshot URLs at original size (up to 12).
`updated`	string · nullable	"Updated on" date as shown.
`updated_at`	string · nullable	The same date as YYYY-MM-DD.
`in_app_purchases`	boolean	True when the page says the app has in-app purchases.
`contains_ads`	boolean	True when the page says the app contains ads.
`editors_choice`	boolean	True when the app carries the Editors' Choice badge.
`developer_id`	string · nullable	Developer id on Google Play.
`availability`	string · nullable	Offer availability (InStock…).
`free`	boolean · nullable	True when the price is 0.

Integration

One POST, typed rows

Base URL https://api.quanticdata.io/v1, Bearer auth, the same key as every other Data API. Endpoint: POST /v1/scraper/collectors/google_play_apps/run.

curl -X POST https://api.quanticdata.io/v1/scraper/collectors/google_play_apps/run \
  -H "Authorization: Bearer $QD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"packages":["com.spotify.music","com.whatsapp"],"country":"us","lang":"en","max_results":10}'

import requests

r = requests.post(
    "https://api.quanticdata.io/v1/scraper/collectors/google_play_apps/run",
    headers={"Authorization": f"Bearer {QD_API_KEY}"},
    json={
        "packages": [
            "com.spotify.music",
            "com.whatsapp"
        ],
        "country": "us",
        "lang": "en",
        "max_results": 10
    },
    timeout=120,
)
for row in r.json()["payload"]["results"]:
    print(row)

const res = await fetch(
  "https://api.quanticdata.io/v1/scraper/collectors/google_play_apps/run",
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.QD_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"packages":["com.spotify.music","com.whatsapp"],"country":"us","lang":"en","max_results":10}),
  },
);
const { payload } = await res.json();
console.table(payload.results);

claude mcp add quanticdata \
  -e QUANTICDATA_API_KEY=qd_live_your_key_here \
  -- npx -y quanticdata-mcp

# then, in the chat:
> run the google_play_apps collector with packages=["com.spotify.music","com.whatsapp"] and country="us"

Example response

POST /v1/scraper/collectors/google_play_apps/run

$ curl $QD/google_play_apps/run \
    -H "Authorization: Bearer $QD_API_KEY" \
    -d '{"packages": ["com.spotify.music", "com.whatsapp"], "country": "us", "lang": "en", "max_results": 10}'
{ "status": "done", "count": 10,
  "results": [
    {
      "package": "…",
      "title": "…",
      "developer": "…",
      "developer_url": "…" } ],
  "cost": 0.06 }
# 10 apps × $0.006 · nothing delivered, nothing charged

Try it

Google Play apps, running now

Change the input and run it against the live collector — nothing to install, no sign-up.

Run it from your own code, on your own inputs

Same collector, same rows — $2 of free API credit every month, no card.

Get my free API key

Google Play scraper API: from packages, country and lang, QuanticData reads the Google Play app page and returns one row per app with title, package and developer, at $0.006 per delivered app. — You send packages and country; the run goes out through a residential exit and comes back as apps with package, title and developer — 26 fields on every row — and you are billed $0.006 for each app actually delivered, nothing for a run that delivers none.

$0.006 / app333 apps on the free $2 every month

Semantic inputpackages, country, lang — no URL lists

Up to 50apps per run, pagination handled for you

No browserread over HTTP/TLS — cheaper and faster than rendering

Pricing

Google Play scraper API pricing

$0.006 per delivered app. A run that delivers nothing costs nothing: blocked pages, challenges and retries are on us, and the $2 monthly allowance covers about 333 apps before you spend anything.

$0.006per delivered app$6 per 1,000 delivered apps

333 appson the free allowance$2 every month, no card

Zero rowszero chargeblocks, captchas and retries are on us

−30%on volume tiersthe catalog returns your key's price

Pay as you go

$0/mo

$2 free credit / month
60 requests / min
List unit prices

Starter

$19/mo

$15 free credit / month
300 requests / min
10% off unit prices

Growth

$79/mo

$50 free credit / month
600 requests / min
20% off unit prices

Scale

$299/mo

$250 free credit / month
1,200 requests / min
30% off unit prices

Same wallet, same key and same $2 monthly allowance as every other Data API. Prices are launch pricing read live from the billing config — GET /v1/scraper/collectors returns the price your key actually pays.

What people build with the Google Play scraper API

Three shapes of work this endpoint was designed around.

Cross-store comparison

Match an app's Play numbers against its App Store numbers for the same market.

Portfolio monitoring

Track rating, review count and install band for your apps and your competitors'.

Store enrichment

Fill a catalogue with category, developer and content rating from the package name alone.

Google Play scraper API versus rolling your own

The differences that actually cost time when you build this in-house.

	DIY scraper	This collector
Data source	Internal arrays that move each build	The page's schema.org block
Failed packages	Empty rows	Reported under failed, never billed

What people search for

Live autocomplete demand around Google Play apps, pulled with our own Keyword ideas collector.

Why there is no search input

Google's Play Developer API manages your own releases, products and reports. It has no endpoint for reading another developer's listing, so it does not overlap with this at all.

This collector is package-keyed and deliberately has no search: Play's search results are personalised and rendered client-side, so a scraped "search" would return something no real user saw and would look authoritative while being noise. Package lookup returns exactly what the store publishes for that app. Discovering packages is a separate step — a site:play.google.com query through the search collector is the usual route.

Limits, durability and the legal bit

Up to 50 packages per run, one fetch each. Rows are read from the page's schema.org block rather than from CSS or internal structures, which is why Play's interface churn does not break them. Unresolvable packages return under failed, unbilled. Throughput is your plan's rate limit rather than anything about the collector: 60 requests/minute on pay-as-you-go, up to 1,200 on the top tier.

installs is Play's band — "1,000,000+" — delivered as the string shown, because converting it to a number would invent precision Google withheld.

Collecting publicly visible data is generally lawful in most jurisdictions, and courts have repeatedly declined to treat reading a public page as unauthorised access. Google's terms restrict automated access; icons, screenshots and descriptions belong to the developer. None of this is legal advice — get some for your actual use case.

Google Play scraper API: the POST to the google_play_apps collector, 10 apps delivered and the bill, 10 × $0.006 = $0.06 in usage.cost_usd; zero apps would cost $0. — The same call you would paste into a terminal: a Bearer key, packages, country and lang in the body, and back the envelope every QuanticData endpoint returns — type, message, payload — where count is how many apps arrived and usage.cost_usd is $0.06, which is 10 × $0.006. A run that delivers nothing costs nothing. The key is good for 60 req/min on the free tier.

Sources and standards

The platform documentation and standards this collector is built against — check any claim on this page against the primary source:

FAQ

Questions we get about the Google Play scraper API.

Something else? Ask us

What do I pass as input?

Android package names (com.spotify.music) or full Play store URLs — the collector extracts the id from the URL.

Do I get install counts?

You get the band Play publishes ("1B+"), because that is what the page states. Nothing more precise exists publicly.

Can I read a different country or language?

Yes — country and lang are passed to the store page and returned in the row's URL.

Is there a free Google Play scraper API?

Every account gets $2 of credit every month with no card, which is about 333 delivered apps on this endpoint at $0.006 each. It renews monthly, and a run that delivers nothing is never billed — so a failed or blocked attempt does not eat the allowance.

How much does one run cost?

Multiply the rows you actually receive by $0.006. A run capped at 50 apps — the maximum for this collector — costs $0.3 if every row comes back, and less when the source has fewer. Volume tiers take up to 30% off, and GET /v1/scraper/collectors returns the price your key actually pays.

Why can't I search Play with it?

Because Play search is personalised and client-side rendered — a scraped result set would not correspond to what any user was shown, while looking like it did. Package-keyed lookup is the part that is reproducible, so that is what the collector claims.

Are install counts exact?

No, and they cannot be: Google publishes bands rather than numbers. The band is delivered as-is rather than converted, so nothing downstream mistakes it for a measurement.

Run the Google Play scraper API now

$2 of free credit every month, no card. Your key returns its own prices from GET /v1/scraper/collectors.

Run in dashboard

Illustration: three coloured zones of the page that is read (Google Play app page) turn into clean JSON with the fields title, package and developer; 26 fields on every row.