# Google Play & App Store Scraper (`brilliant_gum/google-play-app-store-scraper`) Actor

Scrape Google Play & Apple App Store: app details, reviews, top charts, search results & developer portfolios. 50+ fields, 45 countries, both platforms in one run. No browser needed.

- **URL**: https://apify.com/brilliant\_gum/google-play-app-store-scraper.md
- **Developed by:** [Yuliia Kulakova](https://apify.com/brilliant_gum) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 search result scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Google Play & App Store Scraper

![Google Play & App Store Scraper](https://i.postimg.cc/JhFzFGnz/appstore-banner-clean2.png)

Extract app metadata, user reviews, top charts, search results, and developer portfolios from both **Google Play Store** and **Apple App Store** in a single run. Get 50+ fields per app including ratings, installs, pricing, screenshots, developer contact info, and full review text with developer replies.

---

### What This Scraper Does

This actor supports **5 scraping modes** across **2 platforms**:

| Mode | Description |
|---|---|
| **Search** | Search apps by keyword, get ranked results with full details |
| **Details** | Fetch complete metadata for specific apps by ID |
| **Reviews** | Collect user reviews with ratings, dates, and developer replies |
| **Charts** | Scrape Top Free, Top Paid, Top Grossing, and Trending charts |
| **Developer** | Get all apps published by a specific developer |

Supports **Google Play Store** and **Apple App Store** simultaneously with a unified, normalized output schema.

---

### Key Features

- **Dual platform** — Google Play and Apple App Store in one actor
- **50+ data fields** per app including developer email, screenshots, permissions, changelog
- **Full reviews** with developer reply text and reply date
- **Top charts** — up to 660 apps per chart on Google Play, 200 on App Store
- **Multi-country** — any of 45+ supported countries with correct regional pricing and rankings
- **Multi-language** — app descriptions and reviews in any supported language
- **Developer portfolio** — all apps by a developer in one run
- **Pay-per-result** pricing — pay only for what you scrape, no monthly lock-in
- **No browser required** — pure HTTP, fast and efficient
- **Graceful rate-limiting** — automatic retry with exponential backoff

---

### Pricing

This actor uses **Pay Per Event** (PPE) pricing — you pay only for results:

| Event | Price per 1,000 |
|---|---|
| App detail scraped (50+ fields) | **$10.00** |
| Review scraped | **$6.00** |
| Search / chart result scraped | **$4.00** |

**Examples:**
- Scrape details for 500 apps → **$5.00**
- Collect 1,000 reviews for 10 apps → **$6.00**
- Get the Top 100 Free chart for 5 countries → **$2.00** (chart results) or **$5.00** (with full details)

---

### Use Cases

#### App Store Optimization (ASO)
Track how competitors rank for your target keywords. Analyze their titles, descriptions, and 13 tags. Monitor rating trends and review sentiment after their updates. Identify keyword gaps and opportunities.

#### Competitor Intelligence
Build a complete profile of any competitor's app portfolio — all their apps, ratings, install ranges, update frequency, and what users are saying. Track when a competitor launches a new app or major update.

#### Review Monitoring & Reputation Management
Set up recurring scraping runs to collect fresh reviews for your own apps or competitors. Filter by star rating to focus on 1-star complaints or 5-star praise. Developer reply tracking lets you see how responsive a company is to feedback.

#### Market Research
Scrape entire categories or chart positions to understand the competitive landscape. Who dominates the Top Grossing chart in Fitness? What's the average rating in the Photo Editor category? Which developer has the most apps?

#### Investment Due Diligence
Research a mobile-first company before investing. Check their app ratings, install trajectory, update frequency, and user sentiment. Compare their metrics against category benchmarks.

#### Lead Generation
Extract developer email addresses, websites, and company information from Google Play listings. Build targeted outreach lists for SDK vendors, ad networks, and B2B services targeting app developers.

#### AI Training Data
Collect large volumes of app descriptions, review text, and metadata for NLP model training. Filter by language, category, or rating to build targeted datasets.

---

### Input Configuration

#### Mode Selection

```json
{
    "mode": "search",
    "platform": "both",
    "country": "us",
    "language": "en"
}
````

**mode** (required): One of `search`, `details`, `reviews`, `charts`, `developer`

**platform**: `googlePlay`, `appStore`, or `both` (default: `googlePlay`)

**country**: Two-letter ISO 3166 country code (default: `us`). Affects pricing, rankings, and app availability.

**language**: Two-letter ISO 639-1 language code (default: `en`). Affects descriptions and reviews.

***

#### Search Mode

Find apps matching a keyword on either or both stores.

```json
{
    "mode": "search",
    "platform": "both",
    "searchQueries": ["fitness tracker", "calorie counter", "workout log"],
    "maxAppsPerQuery": 50,
    "fetchFullDetails": true,
    "country": "us",
    "language": "en"
}
```

| Parameter | Type | Default | Description |
|---|---|---|---|
| `searchQueries` | array | — | List of keywords to search |
| `maxAppsPerQuery` | integer | 50 | Max apps per keyword (max 250) |
| `fetchFullDetails` | boolean | true | Get 50+ fields per app. Set false for basic listing data (faster, cheaper) |

***

#### Details Mode

Fetch complete metadata for one or more specific apps.

```json
{
    "mode": "details",
    "platform": "googlePlay",
    "appIds": ["com.spotify.music", "com.netflix.mediaclient", "com.instagram.android"],
    "country": "us",
    "language": "en"
}
```

For **Google Play**, use the package name (e.g. `com.spotify.music`).\
For **Apple App Store**, use the numeric app ID (e.g. `324684580`).\
With `platform: "both"`, provide the appropriate ID for each store — the same ID is attempted on both.

| Parameter | Type | Description |
|---|---|---|
| `appIds` | array | App identifiers to scrape |

***

#### Reviews Mode

Collect user reviews for one or more apps.

```json
{
    "mode": "reviews",
    "platform": "both",
    "appIds": ["com.spotify.music"],
    "maxReviewsPerApp": 500,
    "reviewSort": "newest",
    "filterByStars": null,
    "country": "us",
    "language": "en"
}
```

| Parameter | Type | Default | Description |
|---|---|---|---|
| `appIds` | array | — | Apps to collect reviews for |
| `maxReviewsPerApp` | integer | 100 | Max reviews per app (Google Play: up to 3000, App Store: up to 500) |
| `reviewSort` | string | `newest` | Sort order: `newest`, `relevant`, or `rating` |
| `filterByStars` | array | null | Only return specific star ratings, e.g. `[1, 2]` for negative reviews. Null = all ratings |

***

#### Charts Mode

Scrape apps from the top charts.

```json
{
    "mode": "charts",
    "platform": "googlePlay",
    "chartType": "topFree",
    "chartCategory": "GAME",
    "maxAppsPerChart": 100,
    "fetchFullDetails": true,
    "country": "us",
    "language": "en"
}
```

| Parameter | Type | Default | Description |
|---|---|---|---|
| `chartType` | string | `topFree` | Chart to scrape: `topFree`, `topPaid`, `topGrossing`, `trending`, `newFree`, `newPaid` |
| `chartCategory` | string | `APPLICATION` | Category filter. `APPLICATION` = all apps, `GAME` = all games. See categories below. |
| `maxAppsPerChart` | integer | 100 | Max apps per chart (Google Play: up to 660, App Store: up to 200) |
| `fetchFullDetails` | boolean | true | Fetch full 50+ field details per app. False = basic chart entry only |

**Google Play Category IDs:**

| Category | ID |
|---|---|
| All Apps | `APPLICATION` |
| All Games | `GAME` |
| Action Games | `GAME_ACTION` |
| Puzzle Games | `GAME_PUZZLE` |
| Sports Games | `GAME_SPORTS` |
| Racing Games | `GAME_RACING` |
| Education | `EDUCATION` |
| Productivity | `PRODUCTIVITY` |
| Social | `SOCIAL` |
| Health & Fitness | `HEALTH_AND_FITNESS` |
| Tools | `TOOLS` |
| Entertainment | `ENTERTAINMENT` |
| Finance | `FINANCE` |
| Travel | `TRAVEL_AND_LOCAL` |
| Shopping | `SHOPPING` |
| Photography | `PHOTOGRAPHY` |
| Music & Audio | `MUSIC_AND_AUDIO` |
| News | `NEWS_AND_MAGAZINES` |

***

#### Developer Mode

Get all apps published by a specific developer on Google Play or Apple App Store.

```json
{
    "mode": "developer",
    "platform": "both",
    "developerIds": ["Google LLC", "5700313618786177705"],
    "maxAppsPerQuery": 100,
    "country": "us",
    "language": "en"
}
```

For **Google Play**, use the developer name (e.g. `Google LLC`) or numeric developer ID.\
For **Apple App Store**, use the numeric developer/artist ID (e.g. `389801255`).

| Parameter | Type | Description |
|---|---|---|
| `developerIds` | array | Developer name or numeric ID |
| `maxAppsPerQuery` | integer | Max apps per developer |

***

### Output Format

All records share a unified schema. The `platform` field identifies the source.

#### App Detail Record

```json
{
    "platform": "googlePlay",
    "appId": "com.spotify.music",
    "bundleId": "com.spotify.music",
    "title": "Spotify: Music and Podcasts",
    "summary": "Listen to music & podcasts you love",
    "description": "With Spotify, you can listen to music and podcasts for free...",
    "rating": 4.3,
    "ratingText": "4.3",
    "ratingsCount": 28450000,
    "reviewsCount": 8200000,
    "ratingHistogram": { "1": 450000, "2": 180000, "3": 320000, "4": 1200000, "5": 26300000 },
    "price": 0,
    "priceText": "Free",
    "currency": "USD",
    "free": true,
    "offersIAP": true,
    "iapRange": "$0.99 - $9.99 per item",
    "size": "31.7 MB",
    "installs": "1,000,000,000+",
    "minInstalls": 1000000000,
    "androidVersion": "5.0",
    "developer": "Spotify AB",
    "developerId": "Spotify+AB",
    "developerEmail": "android@spotify.com",
    "developerWebsite": "https://www.spotify.com",
    "developerAddress": "Regeringsgatan 19, 111 53 Stockholm, Sweden",
    "genre": "Music & Audio",
    "genreId": "MUSIC_AND_AUDIO",
    "icon": "https://play-lh.googleusercontent.com/...",
    "headerImage": "https://play-lh.googleusercontent.com/...",
    "screenshots": ["https://...", "https://..."],
    "contentRating": "Everyone",
    "adSupported": false,
    "editorsChoice": true,
    "released": "Feb 26, 2012",
    "updated": "2026-04-06T22:07:31.000Z",
    "version": "8.9.70.618",
    "recentChanges": "Bug fixes and performance improvements.",
    "url": "https://play.google.com/store/apps/details?id=com.spotify.music",
    "country": "us",
    "language": "en",
    "scrapedAt": "2026-04-13T10:30:00.000Z"
}
```

#### Review Record

```json
{
    "platform": "googlePlay",
    "appId": "com.spotify.music",
    "appTitle": "Spotify: Music and Podcasts",
    "reviewId": "gp:AOqpTOH...",
    "rating": 5,
    "title": null,
    "text": "Absolutely love this app. The playlist recommendations are spot on.",
    "date": "2026-04-10T08:22:00.000Z",
    "thumbsUpCount": 145,
    "appVersion": "8.9.70.618",
    "authorName": "John Smith",
    "authorImage": "https://lh3.googleusercontent.com/...",
    "replyText": "Thank you so much for the kind words! We work hard on our recommendation engine.",
    "replyDate": "2026-04-11T14:00:00.000Z",
    "country": "us",
    "language": "en",
    "scrapedAt": "2026-04-13T10:30:00.000Z"
}
```

#### Chart Entry Record

```json
{
    "platform": "googlePlay",
    "appId": "com.mojang.minecraftpe",
    "title": "Minecraft",
    "developer": "Mojang",
    "rating": 4.5,
    "icon": "https://play-lh.googleusercontent.com/...",
    "url": "https://play.google.com/store/apps/details?id=com.mojang.minecraftpe",
    "position": 1,
    "chart": "topselling_paid",
    "country": "us",
    "language": "en",
    "scrapedAt": "2026-04-13T10:30:00.000Z"
}
```

***

### Supported Countries

The following two-letter country codes are supported:

`us` `gb` `ca` `au` `de` `fr` `es` `it` `br` `mx` `in` `jp` `kr` `ru` `nl` `pl` `se` `no` `dk` `fi` `be` `at` `ch` `pt` `ar` `co` `cl` `pe` `tr` `sa` `ae` `za` `ng` `eg` `id` `th` `vn` `ph` `my` `sg` `hk` `tw` `nz` `il` `pk`

Country affects: regional pricing, top chart rankings, search result ordering, and app availability (some apps are geo-restricted).

***

### Apple App Store — What's Different

The Apple App Store is scraped through Apple's official **iTunes Search API** and **RSS feeds**, which are publicly available without authentication.

**Available on App Store:**

- Full app metadata: title, description, rating, price, screenshots, genre
- Developer name and website
- Version, release date, file size, minimum iOS version
- Content advisory rating

**Not available on App Store (Apple doesn't expose publicly):**

- Install counts (Apple does not disclose download numbers)
- Exact rating histogram (1–5 star breakdown)
- Developer email address
- In-app purchase price ranges
- Developer replies on reviews (not in RSS feed)

**Review limit:** Apple's public RSS feed provides up to **500 reviews per app** (10 pages × 50 reviews). If you need more, use Google Play mode.

***

### Tips for Best Results

**Getting more search results:**\
Set `maxAppsPerQuery` to 250 for maximum coverage. Use multiple specific keywords rather than one broad term.

**Getting more reviews:**\
For Google Play, `maxReviewsPerApp` up to 3000 works reliably. Set `reviewSort: "newest"` to always get the freshest reviews. Use `filterByStars: [1, 2]` to focus on negative reviews for competitive research.

**Multi-country pricing research:**\
Run multiple `details` scrapes with different `country` values to compare how an app is priced across regions.

**Chart monitoring:**\
Set `chartType: "trending"` and `fetchFullDetails: false` for a fast, cheap overview of rising apps. Then re-run with `fetchFullDetails: true` on the specific apps that interest you.

**Developer portfolio audit:**\
Use `developer` mode with `fetchFullDetails: true` to get a complete picture of every app a developer publishes.

***

### Rate Limits and Anti-Bot Notes

Google Play uses its own request-rate monitoring — not Cloudflare, not DataDome. This means:

- **No CAPTCHA solving required**
- **No browser automation** — pure HTTP requests are sufficient
- Rate limits are based on IP and request frequency

The actor automatically applies random delays between requests (600ms–3000ms) to stay within safe limits.

If you need to scrape large volumes (10,000+ apps), spread the work across multiple runs or use the `country` parameter to distribute load.

***

### Error Handling

The actor handles all errors gracefully:

- **App not found (404):** Logged as a warning, scraping continues with the next app
- **Rate limited (429):** Automatic exponential backoff — waits 8s, 25s, then 60s before retrying
- **Server errors (5xx):** Treated as temporary rate limits, retried automatically
- **Parse failures:** Logged as warnings with the affected URL, does not crash the actor
- **Proxy unavailable:** Falls back to direct connection automatically

***

### Frequently Asked Questions

**Can I scrape both stores in one run?**\
Yes. Set `platform: "both"` and the actor will query both Google Play and Apple App Store for each operation.

**How do I get developer emails for lead generation?**\
Use `mode: "details"` with `platform: "googlePlay"`. The `developerEmail` field is included in the output when the developer has made their email public on their Play Store listing. Not all developers expose their email.

**Why are install counts not exact?**\
Google Play only shows install ranges ("1,000,000+" not "1,234,567"). Apple does not expose install counts at all. Exact download data is only available to the app developer through their developer console.

**What's the maximum number of reviews I can get?**\
Google Play: up to 3,000 per app per run (configurable). Apple App Store: up to 500 per app (RSS feed limit). For large review datasets, run multiple scrapes with different `filterByStars` values.

**Can I track ranking changes over time?**\
Yes. Schedule the actor to run daily or weekly with `mode: "charts"` or `mode: "search"`. Each run captures the current rankings. Compare runs to identify movements.

**Is the actor maintained when Google changes their page structure?**\
Yes. This actor is actively maintained. If Google or Apple changes their data structure, it will be updated promptly.

**Does this work for all countries?**\
45 countries are fully supported. Rankings, prices, and sometimes app availability vary by country. Use the `country` parameter to target specific regional stores.

***

### Example Workflows

#### Workflow 1: Competitor Analysis

1. **Search** for your category keyword with `platform: "both"` — discover all competitors on both stores
2. **Details** mode to get full metadata, ratings, and developer contact info for the top results
3. **Reviews** mode with `filterByStars: [1, 2]` to find what users hate about competitor apps — these are your product improvement opportunities

#### Workflow 2: Daily Chart Monitoring

Run on a schedule with:

```json
{
    "mode": "charts",
    "platform": "googlePlay",
    "chartType": "trending",
    "chartCategory": "GAME",
    "maxAppsPerChart": 50,
    "fetchFullDetails": false,
    "country": "us"
}
```

This gives you the top 50 trending games every day for just $0.20 per run. Add `fetchFullDetails: true` when you want deep data on a specific app.

#### Workflow 3: App Store Intelligence Dashboard

Run weekly:

1. `mode: "charts"`, `chartType: "topGrossing"` — who's making the most money in your category
2. `mode: "reviews"`, `reviewSort: "newest"` — what users are saying this week
3. `mode: "search"` for 5–10 key industry terms — track which apps are rising in search

#### Workflow 4: B2B Lead Generation

```json
{
    "mode": "search",
    "platform": "googlePlay",
    "searchQueries": ["fitness app", "workout tracker", "gym app"],
    "maxAppsPerQuery": 100,
    "fetchFullDetails": true,
    "country": "us"
}
```

The `developerEmail` field in each result gives you direct contact information for app developers — ready for your outreach sequence.

***

### Changelog

#### v1.0 (April 2026)

- Initial release
- Google Play: search, details, reviews, charts, developer modes
- Apple App Store: search, details, reviews, charts modes
- Unified output schema for both platforms
- PPE pricing: $10/1K details, $6/1K reviews, $4/1K search results
- 45+ supported countries
- Automatic retry with exponential backoff
- Residential proxy routing on Apify cloud

***

### Support

If you encounter any issues, have feature requests, or need help with a specific use case, please open an issue on this actor's page. We aim to respond within 24 hours.

For large-scale enterprise use cases (millions of records, custom integrations, dedicated infrastructure), please reach out directly through the contact form.

# Actor input Schema

## `mode` (type: `string`):

What to scrape: search apps by keyword, fetch details by ID, collect reviews, browse top charts, or get all apps by a developer.

## `platform` (type: `string`):

Which store to scrape. Choose 'both' to get data from Google Play and Apple App Store in one run.

## `searchQueries` (type: `array`):

List of search keywords (e.g. 'fitness tracker', 'photo editor'). Used in Search mode.

## `maxAppsPerQuery` (type: `integer`):

Maximum number of apps to return per search keyword. Max 250.

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

List of app identifiers. For Google Play use package names (e.g. com.spotify.music). For App Store use numeric IDs (e.g. 324684580). Used in Details and Reviews modes.

## `maxReviewsPerApp` (type: `integer`):

Maximum number of reviews to scrape per app. Google Play supports up to 3000, Apple App Store up to 500 via public RSS.

## `reviewSort` (type: `string`):

How to sort reviews when fetching.

## `filterByStars` (type: `array`):

Only return reviews with specific star ratings. Leave empty for all ratings. Example: \[1, 2] for negative reviews only.

## `chartType` (type: `string`):

Which top chart to scrape.

## `chartCategory` (type: `string`):

App category for the chart. Use 'APPLICATION' for all apps or 'GAME' for games. Other values: GAME\_ACTION, GAME\_PUZZLE, EDUCATION, PRODUCTIVITY, SOCIAL, etc.

## `maxAppsPerChart` (type: `integer`):

Maximum number of apps to return from each chart. Google Play supports up to 660, Apple App Store up to 200.

## `developerIds` (type: `array`):

List of Google Play developer IDs or names (e.g. 'Google LLC' or numeric ID '5700313618786177705'). Used in Developer mode.

## `fetchFullDetails` (type: `boolean`):

If enabled, fetches the full app detail page for each search/chart result (50+ fields). If disabled, returns basic listing data only (faster, cheaper).

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

Two-letter country code for the store region. Affects search results, pricing, rankings, and app availability. Examples: us, gb, de, fr, ca, au, br, jp.

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

Two-letter ISO 639-1 language code for app descriptions and reviews. Examples: en, de, fr, es, pt, ja, ko.

## Actor input object example

```json
{
  "mode": "search",
  "platform": "googlePlay",
  "searchQueries": [
    "fitness tracker"
  ],
  "maxAppsPerQuery": 50,
  "appIds": [
    "com.spotify.music"
  ],
  "maxReviewsPerApp": 100,
  "reviewSort": "newest",
  "chartType": "topFree",
  "chartCategory": "APPLICATION",
  "maxAppsPerChart": 100,
  "developerIds": [
    "Google LLC"
  ],
  "fetchFullDetails": true,
  "country": "us",
  "language": "en"
}
```

# Actor output Schema

## `platform` (type: `string`):

Source platform: googlePlay or appStore

## `appId` (type: `string`):

Package name (Google Play) or numeric ID (App Store)

## `bundleId` (type: `string`):

App bundle identifier

## `title` (type: `string`):

App name

## `summary` (type: `string`):

Short description (Google Play only)

## `description` (type: `string`):

Full app description

## `rating` (type: `string`):

Average star rating (1–5)

## `ratingsCount` (type: `string`):

Total number of ratings

## `reviewsCount` (type: `string`):

Total number of written reviews

## `price` (type: `string`):

App price (0 = free)

## `priceText` (type: `string`):

Formatted price string e.g. '$2.99' or 'Free'

## `currency` (type: `string`):

Currency code e.g. USD, EUR

## `free` (type: `string`):

True if the app is free

## `offersIAP` (type: `string`):

True if the app offers in-app purchases

## `iapRange` (type: `string`):

In-app purchase price range e.g. '$0.99–$49.99'

## `size` (type: `string`):

App download size

## `installs` (type: `string`):

Install count range (Google Play only, e.g. '10,000,000+')

## `minInstalls` (type: `string`):

Minimum install count (Google Play only)

## `androidVersion` (type: `string`):

Minimum required Android version (Google Play only)

## `developer` (type: `string`):

Developer display name

## `developerId` (type: `string`):

Developer unique identifier

## `developerEmail` (type: `string`):

Developer contact email (Google Play only, if public)

## `developerWebsite` (type: `string`):

Developer website URL

## `developerAddress` (type: `string`):

Developer physical address (Google Play only, if public)

## `genre` (type: `string`):

Primary category / genre name

## `genreId` (type: `string`):

Primary category ID

## `icon` (type: `string`):

App icon image URL

## `headerImage` (type: `string`):

Featured header image URL (Google Play only)

## `contentRating` (type: `string`):

Content rating label e.g. 'Everyone', 'Teen', '17+'

## `adSupported` (type: `string`):

True if the app contains ads (Google Play only)

## `editorsChoice` (type: `string`):

True if marked as Editor's Choice (Google Play only)

## `released` (type: `string`):

Original release date

## `updated` (type: `string`):

Last update date

## `version` (type: `string`):

Current app version

## `recentChanges` (type: `string`):

Changelog for the latest version

## `url` (type: `string`):

App store page URL

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

Two-letter country code used for scraping

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

Two-letter language code used for scraping

## `scrapedAt` (type: `string`):

ISO 8601 timestamp of when the data was scraped

## `reviewId` (type: `string`):

Unique review ID (reviews only)

## `appTitle` (type: `string`):

App name (reviews only)

## `text` (type: `string`):

Review body text (reviews only)

## `date` (type: `string`):

Review submission date (reviews only)

## `thumbsUpCount` (type: `string`):

Number of helpful votes (reviews only)

## `appVersion` (type: `string`):

App version at time of review (reviews only)

## `authorName` (type: `string`):

Reviewer display name (reviews only)

## `replyText` (type: `string`):

Developer reply to review (reviews only)

## `replyDate` (type: `string`):

Date of developer reply (reviews only)

## `chartPosition` (type: `string`):

Position in top chart (charts mode only)

## `chartType` (type: `string`):

Chart name (charts mode only)

## `searchQuery` (type: `string`):

Original search keyword (search mode only)

## `searchPosition` (type: `string`):

Position in search results (search mode only)

# 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 = {
    "searchQueries": [
        "fitness tracker"
    ],
    "appIds": [
        "com.spotify.music"
    ],
    "developerIds": [
        "Google LLC"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("brilliant_gum/google-play-app-store-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 = {
    "searchQueries": ["fitness tracker"],
    "appIds": ["com.spotify.music"],
    "developerIds": ["Google LLC"],
}

# Run the Actor and wait for it to finish
run = client.actor("brilliant_gum/google-play-app-store-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchQueries": [
    "fitness tracker"
  ],
  "appIds": [
    "com.spotify.music"
  ],
  "developerIds": [
    "Google LLC"
  ]
}' |
apify call brilliant_gum/google-play-app-store-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=brilliant_gum/google-play-app-store-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Play & App Store Scraper",
        "description": "Scrape Google Play & Apple App Store: app details, reviews, top charts, search results & developer portfolios. 50+ fields, 45 countries, both platforms in one run. No browser needed.",
        "version": "1.0",
        "x-build-id": "c8LPUAf8F2ZN7WKJ9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/brilliant_gum~google-play-app-store-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-brilliant_gum-google-play-app-store-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/brilliant_gum~google-play-app-store-scraper/runs": {
            "post": {
                "operationId": "runs-sync-brilliant_gum-google-play-app-store-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/brilliant_gum~google-play-app-store-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-brilliant_gum-google-play-app-store-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "mode": {
                        "title": "Scraping Mode",
                        "enum": [
                            "search",
                            "details",
                            "reviews",
                            "charts",
                            "developer"
                        ],
                        "type": "string",
                        "description": "What to scrape: search apps by keyword, fetch details by ID, collect reviews, browse top charts, or get all apps by a developer.",
                        "default": "search"
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "googlePlay",
                            "appStore",
                            "both"
                        ],
                        "type": "string",
                        "description": "Which store to scrape. Choose 'both' to get data from Google Play and Apple App Store in one run.",
                        "default": "googlePlay"
                    },
                    "searchQueries": {
                        "title": "Search Keywords",
                        "type": "array",
                        "description": "List of search keywords (e.g. 'fitness tracker', 'photo editor'). Used in Search mode.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxAppsPerQuery": {
                        "title": "Max Apps per Keyword",
                        "minimum": 1,
                        "maximum": 250,
                        "type": "integer",
                        "description": "Maximum number of apps to return per search keyword. Max 250.",
                        "default": 50
                    },
                    "appIds": {
                        "title": "App IDs",
                        "type": "array",
                        "description": "List of app identifiers. For Google Play use package names (e.g. com.spotify.music). For App Store use numeric IDs (e.g. 324684580). Used in Details and Reviews modes.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerApp": {
                        "title": "Max Reviews per App",
                        "minimum": 1,
                        "maximum": 3000,
                        "type": "integer",
                        "description": "Maximum number of reviews to scrape per app. Google Play supports up to 3000, Apple App Store up to 500 via public RSS.",
                        "default": 100
                    },
                    "reviewSort": {
                        "title": "Review Sort Order",
                        "enum": [
                            "newest",
                            "relevant",
                            "rating"
                        ],
                        "type": "string",
                        "description": "How to sort reviews when fetching.",
                        "default": "newest"
                    },
                    "filterByStars": {
                        "title": "Filter by Star Rating",
                        "type": "array",
                        "description": "Only return reviews with specific star ratings. Leave empty for all ratings. Example: [1, 2] for negative reviews only."
                    },
                    "chartType": {
                        "title": "Chart Type",
                        "enum": [
                            "topFree",
                            "topPaid",
                            "topGrossing",
                            "trending",
                            "newFree",
                            "newPaid"
                        ],
                        "type": "string",
                        "description": "Which top chart to scrape.",
                        "default": "topFree"
                    },
                    "chartCategory": {
                        "title": "Chart Category",
                        "type": "string",
                        "description": "App category for the chart. Use 'APPLICATION' for all apps or 'GAME' for games. Other values: GAME_ACTION, GAME_PUZZLE, EDUCATION, PRODUCTIVITY, SOCIAL, etc.",
                        "default": "APPLICATION"
                    },
                    "maxAppsPerChart": {
                        "title": "Max Apps per Chart",
                        "minimum": 1,
                        "maximum": 660,
                        "type": "integer",
                        "description": "Maximum number of apps to return from each chart. Google Play supports up to 660, Apple App Store up to 200.",
                        "default": 100
                    },
                    "developerIds": {
                        "title": "Developer IDs",
                        "type": "array",
                        "description": "List of Google Play developer IDs or names (e.g. 'Google LLC' or numeric ID '5700313618786177705'). Used in Developer mode.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "fetchFullDetails": {
                        "title": "Fetch Full App Details",
                        "type": "boolean",
                        "description": "If enabled, fetches the full app detail page for each search/chart result (50+ fields). If disabled, returns basic listing data only (faster, cheaper).",
                        "default": true
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Two-letter country code for the store region. Affects search results, pricing, rankings, and app availability. Examples: us, gb, de, fr, ca, au, br, jp.",
                        "default": "us"
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Two-letter ISO 639-1 language code for app descriptions and reviews. Examples: en, de, fr, es, pt, ja, ko.",
                        "default": "en"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
