# Google Play App Search, Lookup & Reviews Scraper (`nimbryxo-studio/google-play-app-search-lookup-and-reviews-scraper`) Actor

Search Google Play by keyword or look up apps directly by package ID, with ratings, installs, pricing, developer contact details, and optional user reviews across dozens of countries and languages.

- **URL**: https://apify.com/nimbryxo-studio/google-play-app-search-lookup-and-reviews-scraper.md
- **Developed by:** [Nimbryxo-studio](https://apify.com/nimbryxo-studio) (community)
- **Categories:** Automation, Lead generation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 App Search, Lookup & Reviews Scraper

Search Google Play by keyword, or look up specific apps directly by package ID, and get back detailed app records — ratings, install counts, pricing, developer contact details, screenshots, and more — for 50 Google Play countries and 30 languages. Optionally add each app's newest user reviews.

### What this actor does

- Searches Google Play by keyword to discover matching apps, or looks up exact apps by package ID (e.g. `com.whatsapp`)
- Returns over 30 fields per app: ratings, installs, pricing, content rating, release/update dates, and developer contact info
- Optionally fetches the newest user reviews per app, including the developer's reply when one exists
- Targets one of 50 Google Play countries and 30 languages, affecting pricing, availability, and review language
- Combines both search and direct lookup in the same run
- Every field below is always present on each app record; fields Google Play doesn't publish for that app come back as an empty string, `0`, or empty array rather than being left out

### Output per app

- `appId` — package ID (e.g. `com.whatsapp`)
- `title` — app name
- `url` — Google Play Store URL
- `developer`, `developerId` — developer name and Google Play developer ID
- `developerEmail`, `developerWebsite`, `developerAddress` — developer contact details
- `score`, `ratings`, `reviewCount` — average rating, total ratings, and total reviews
- `histogram` — rating distribution as a five-number list, 1-star through 5-star counts
- `installs`, `minInstalls`, `realInstalls` — install count display text, minimum threshold, and estimated real installs
- `price`, `free`, `currency` — numeric price, whether the app is free, and price currency
- `genre`, `genreId`, `categories` — primary genre name and ID, and the category list (`{name, id}` objects)
- `icon`, `headerImage`, `screenshots`, `video` — icon, header image, screenshot URLs, and promo video URL
- `contentRating` — content rating (e.g. `"Everyone"`, `"Teen"`)
- `adSupported`, `containsAds` — advertising flags
- `released`, `lastUpdated`, `version` — release date, latest update date, and current version
- `description`, `recentChanges` — full description and latest changelog
- `privacyPolicy` — privacy policy URL
- `reviews` — array of review objects, newest first (empty unless `includeReviews` is enabled)
- `scrapedAt` — ISO 8601 collection timestamp

#### Review object fields

- `reviewId` — unique review identifier
- `userName`, `userImage` — reviewer's display name and profile image
- `score` — rating given (1–5)
- `content` — review text
- `thumbsUpCount` — number of helpful votes
- `date` — date the review was posted
- `replyContent`, `repliedAt` — developer's reply text and date, when one exists
- `appVersion` — app version the review was written for

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `searchTerms` | array of strings | – | Keywords to find apps on Google Play |
| `appIds` | array of strings | – | Package IDs for direct lookup (e.g. `com.whatsapp`) |
| `country` | string | `us` | One of 50 two-letter country codes — affects pricing, availability, and localized results |
| `language` | string | `en` | One of 30 two-letter language codes — affects descriptions and reviews |
| `maxResults` | integer | `50` | Maximum apps for the whole run, search results and direct lookups combined (1–250). Search terms fill it first |
| `includeReviews` | boolean | `false` | Fetch user reviews for each app |
| `reviewCount` | integer | `20` | Reviews to fetch per app when `includeReviews` is on (1–200) |

At least one of `searchTerms` or `appIds` must be provided.

#### Example: keyword search with reviews

```json
{
  "searchTerms": ["photo editor", "calculator"],
  "country": "us",
  "language": "en",
  "maxResults": 10,
  "includeReviews": true,
  "reviewCount": 5
}
```

#### Example: direct app lookup

```json
{
  "appIds": ["com.whatsapp", "com.google.android.calculator"],
  "country": "us",
  "language": "en"
}
```

#### Example: regional availability check

```json
{
  "appIds": ["com.whatsapp"],
  "country": "jp",
  "language": "ja"
}
```

### Use cases

- **Competitor monitoring** — track rivals' ratings, pricing, and update frequency over time
- **ASO research** — see which apps rank for a given keyword search
- **Market analysis** — survey a category's pricing and install-count distribution
- **Reputation tracking** — pull recent reviews with developer replies to spot trends
- **Localization research** — compare an app's pricing and availability across countries

### FAQ

**Can I scrape any app on Google Play?**
Yes, any app publicly listed on Google Play can be scraped. Region-restricted apps only appear when you set the matching `country`.

**Do I need a Google account or API key?**
No. The actor works without any authentication, API keys, or cookies.

**How many apps can I scrape in one run?**
Up to 250 apps per run (`maxResults`), shared between search terms and direct `appIds`. Each search term contributes at most 50 apps, so use several terms (or add `appIds`) to go beyond 50. Duplicates are skipped. If nothing is found at all, the run ends as failed.

**Can I get reviews for every app?**
Yes — enable `includeReviews` and set `reviewCount` (up to 200) to fetch that many reviews per app.

**What countries and languages are supported?**
50 countries and 30 languages, selectable from the `country` and `language` dropdowns using standard two-letter codes (e.g. `us`, `gb`, `de` for countries; `en`, `es`, `fr` for languages). If a keyword search fails for an unusual country/language pair, that search is retried in the US English store, so its results then reflect US listings.

**How fresh is the data?**
Every run fetches live data directly from Google Play, so results reflect the store's current state at scrape time.

**Why are some fields empty for certain apps?**
Not every app has every field populated on Google Play — for example, not all apps have a promo video or a published developer address. Those fields come back as an empty value for that app rather than being left out of the record. If an app's detail page can't be loaded during a search, the record keeps only what the search result showed, so more fields are empty.

**Is this affiliated with Google?**
No. This is an independent, third-party actor that reads Google Play's public app pages; it isn't affiliated with or endorsed by Google.

# Actor input Schema

## `searchTerms` (type: `array`):

List of search keywords to find apps on Google Play Store (e.g., "calculator", "fitness tracker", "photo editor")

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

List of Google Play app package IDs for direct lookup (e.g., "com.google.android.calculator", "com.whatsapp")

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

Country for localized results, pricing, and availability.

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

Language for app descriptions and reviews.

## `maxResults` (type: `integer`):

Maximum number of apps to scrape across all search terms

## `includeReviews` (type: `boolean`):

Fetch user reviews for each app. Increases run time.

## `reviewCount` (type: `integer`):

Number of reviews to fetch per app (only used when Include Reviews is enabled)

## Actor input object example

```json
{
  "searchTerms": [
    "calculator"
  ],
  "country": "us",
  "language": "en",
  "maxResults": 5,
  "includeReviews": false,
  "reviewCount": 20
}
```

# Actor output Schema

## `apps` (type: `string`):

Dataset containing all scraped Google Play app records.

# 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 = {
    "searchTerms": [
        "calculator"
    ],
    "country": "us",
    "language": "en",
    "maxResults": 5,
    "reviewCount": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("nimbryxo-studio/google-play-app-search-lookup-and-reviews-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 = {
    "searchTerms": ["calculator"],
    "country": "us",
    "language": "en",
    "maxResults": 5,
    "reviewCount": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("nimbryxo-studio/google-play-app-search-lookup-and-reviews-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 '{
  "searchTerms": [
    "calculator"
  ],
  "country": "us",
  "language": "en",
  "maxResults": 5,
  "reviewCount": 20
}' |
apify call nimbryxo-studio/google-play-app-search-lookup-and-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nimbryxo-studio/google-play-app-search-lookup-and-reviews-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/VCknmnj5f5O6X56Ho/builds/m3PVJglehrel4t8uE/openapi.json