Extract Google Play data with Node.js in minutes (no API key)

Scraping Google Play data shouldn’t require reverse-engineering nested JSON arrays or battling rate limits. With the right tools, you can extract clean app details, reviews, and ratings as structured JSON in just a few lines of Node.js code—no API keys, proxies, or HTML parsers needed. Here’s how to get started with a hosted scraper actor and when this approach makes sense for your project.

Why scraping Google Play beats manual parsing

Google Play embeds app data in deeply nested, undocumented JavaScript arrays that shift with every page update. For example, the app’s rating might live at data[1][2][51][0][1], while the ratings histogram could be buried elsewhere. Reviews require parsing responses from a batchexecute RPC endpoint, which also throttles aggressively. These challenges make hand-rolled scrapers fragile and time-consuming to maintain.

Instead of reinventing the wheel, using a maintained scraper actor like Apify’s Google Play Scraper shifts the burden of parsing and rate-limit handling to a dedicated service. The result? Stable, named fields like rating, ratingHistogram, installs, and developerResponse—ready for ASO tracking, review analysis, or machine learning datasets.

Setting up the scraper in under five minutes

To begin, create a free account on Apify and generate an API token from Settings → Integrations. Install the official client library and store your token as an environment variable to avoid hardcoding sensitive credentials:

npm install apify-client

export APIFY_TOKEN="your_api_token_here"

With the setup complete, you’re ready to pull app details, reviews, or search results—all in a single API call.

Pulling app details with one request

To fetch full details for multiple apps, use the details mode with a list of package names (the id= part of a Play Store URL) and optional country or language parameters. Here’s a minimal example for Spotify and WhatsApp:

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('freshactors/google-play-scraper').call({
  mode: 'details',
  appIds: ['com.spotify.music', 'com.whatsapp'],
  country: 'us',
  lang: 'en',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();

for (const app of items) {
  console.log(`${app.title} — ${app.rating}★ (${app.ratingCount.toLocaleString()} ratings), ${app.installs}`);
}

Each returned item is a clean object containing structured data. For instance, Spotify’s record includes fields like rating, ratingCount, installs, currency, and genre. The ratingHistogram breaks down reviews by star count—useful for tracking trends like the share of 1-star reviews over time.

Collecting reviews without pagination headaches

Switching to reviews mode lets you pull up to 500 recent reviews per app while the scraper handles pagination and rate limits automatically. You can sort by newest, most helpful, or rating:

const reviewsRun = await client.actor('freshactors/google-play-scraper').call({
  mode: 'reviews',
  appIds: ['com.spotify.music'],
  maxReviewsPerApp: 500,
  reviewsSort: 'newest',
  country: 'us',
});

const { items: reviews } = await client.dataset(reviewsRun.defaultDatasetId).listItems();

// Count recent negative reviews
const negative = reviews.filter((r) => r.rating <= 2);
console.log(`${negative.length}/${reviews.length} recent reviews are 1–2★`);

Each review includes userName, rating, body, thumbsUp, date, and appVersion—helpful for spotting issues tied to specific releases or tracking developer responses.

Searching the Play Store by keyword

When you don’t know the package names upfront, the search mode queries Google Play and returns full app details for every match. This is ideal for competitive research or niche discovery:

const searchRun = await client.actor('freshactors/google-play-scraper').call({
  mode: 'search',
  searchTerms: ['habit tracker', 'budget app'],
  maxSearchResults: 20,
  country: 'us',
});

const { items: found } = await client.dataset(searchRun.defaultDatasetId).listItems();

// Rank top-rated apps in the niche
found
  .sort((a, b) => (b.rating ?? 0) - (a.rating ?? 0))
  .slice(0, 5)
  .forEach((a) => console.log(`[${a._searchTerm}] ${a.title} — ${a.rating}★`));

This approach gives you a full competitive snapshot—app names, ratings, install ranges, and ad support—without manual browsing.

Handling large datasets efficiently

For review pulls exceeding thousands of entries, avoid memory overload by processing data in chunks. This snippet iterates through pages of results:

const dataset = client.dataset(reviewsRun.defaultDatasetId);
let offset = 0;
const limit = 1000;

while (true) {
  const { items } = await dataset.listItems({ offset, limit });
  if (items.length === 0) break;

  // Process this page (write to database, file, etc.)
  offset += items.length;
}

Cost efficiency and scalability

Pricing is event-based, so you pay only for the data returned—not server uptime or proxy costs. At current rates:

• App details: $0.002 per app (e.g., 100 apps = $0.20).
• Reviews: $0.0001 per review (e.g., 1,000 reviews = $0.10).

No subscriptions or infrastructure setup is required, making this ideal for one-off projects or daily competitor tracking. Whether you’re building an ASO dashboard, an ML dataset, or a review sentiment analyzer, this method delivers reliable data without the usual scraping overhead.

As Google Play continues to evolve, relying on a dedicated scraper actor ensures your extraction pipeline stays resilient. Start small with a single app, then scale to thousands—all with the same clean JSON output and predictable costs.