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

Scrape App Store and Google Play in one run: ASO keyword research (suggestions, popularity, difficulty), keyword ranks, top charts up to 200, app details and developer portfolios. Ratings, installs, prices, IAPs, developer contacts.

- **URL**: https://apify.com/d_nepoch/app-store-google-play-scraper.md
- **Developed by:** [Dmitrii Nepochatykh](https://apify.com/d_nepoch) (community)
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 1,000 apps

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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

## App Store & Google Play Scraper

**App Store & Google Play Scraper** extracts app data from the **Apple App Store and Google Play in one run**: **ASO keyword research** (store search suggestions with popularity and difficulty scores), keyword search results with ranks, top charts (top free, top paid, top grossing, up to 200 apps per chart), full app details and every app of a developer. One clean dataset with the same fields for both stores — ready for Excel, Google Sheets, dashboards or your AI pipeline.

No login, no API keys, no cookies. About **2,000 apps in under 2 minutes**. Ratings, rating counts, installs, prices and discounts, ratings histogram, in-app purchases, developer email and website, privacy labels, data safety, version history and similar apps.

### Try it in one click

The input is prefilled with the US **top free apps** chart: click **Start** and get the top 20 apps from each store (40 rows) in about 10 seconds, for about $0.04.

Real output, US top free charts (October 2026):

| Rank | App Store | Rating (ratings) | Google Play | Rating (installs) |
|---|---|---|---|---|
| 1 | Capital One Mobile | 4.85 (11.2M) | Muse from Meta | 4.73 (5M+) |
| 2 | Muse from Meta | 4.85 (303K) | ChatGPT | 4.78 (1B+) |
| 3 | Vinted: Pre-loved marketplace | 4.88 (522K) | Settings Home | 4.45 (100K+) |
| 4 | ChatGPT | 4.83 (11.5M) | Vinted: Shop & sell pre-loved | 4.47 (100M+) |

Keyword search works the same way. Real ranks for the keyword **"vpn"** in the US (October 2026):

| Rank | App Store | Google Play |
|---|---|---|
| 1 | VPN - Super Unlimited Proxy (4.63, 2.1M ratings) | VPN - Super Unlimited Proxy (4.72, 100M+ installs) |
| 2 | VPN - Fast & Secure VPN ™ (4.67) | Proton VPN: Secure & Fast VPN (4.68, 100M+) |
| 3 | Proton VPN: Fast & Secure (4.65) | Turbo VPN - Secure VPN Proxy (4.72, 500M+) |

**Keyword research** turns one seed into a list of real store searches with scores. Seed **"meditation"**, US, both stores, tracking Calm: 200 keywords in 81 seconds (about $0.40). Real output, October 2026:

| Keyword | Store | Popularity | Difficulty | Calm's rank |
|---|---|---|---|---|
| meditation | App Store | 72 | 82 | 3 |
| meditation timer | App Store | 58 | 50 | 17 |
| meditation timer free | App Store | 47 | 33 | 6 |
| meditation tracker | App Store | 44 | 35 | 14 |
| meditation apps free | Google Play | 69 | 47 | 5 |
| meditation timer | Google Play | 57 | 65 | not in top 30 |

"Meditation timer free" is searched often enough to be suggested after 6 letters, but its top results are weak (median 782 ratings) — a better target for a small app than "meditation" itself.

### What can this App Store and Google Play scraper do?

- **ASO keyword research**: start from a seed keyword and get the searches the stores themselves suggest (plus `seed a` … `seed z` long-tail expansion), each with a **popularity score**, a **difficulty score**, the top 5 apps and **your app's rank** for that keyword.
- **Search apps by keyword** in both stores and get each app's **rank** — track ASO keyword positions for your app and competitors.
- **Scrape top charts**: top free, top paid and top grossing (Google Play), overall or per category (games, finance, health…), **up to 200 apps per chart**, any country.
- **Scrape app details** by ID or URL: rating, ratings count, **ratings histogram**, installs (Google Play, incl. exact install count), price and discount, in-app purchases, version, release notes, last update, release date, minimum OS, size, languages, screenshots, video.
- **Developer data**: developer name, ID, website, **support email and address** (Google Play), and every app of a developer.
- **Privacy**: App Store privacy labels and Google Play data safety summary.
- **Similar apps** and **more by this developer** for competitor mapping.
- **Many countries in one run**; same output format for both stores.

### Who uses app store data?

- **ASO specialists and app marketers**: daily keyword ranks and chart positions for your app and competitors in many markets.
- **Mobile product teams and investors**: spot rising apps in top charts, compare ratings, installs and pricing across categories.
- **Lead generation and agencies**: developer emails, websites and addresses of apps in a category or chart.
- **Market researchers and data teams**: build app datasets per category and country.
- **AI builders**: unified JSON is ready for LLM analysis, agent tools and RAG.

### Why this scraper

| | This Actor | Typical app store scrapers |
|---|---|---|
| App Store + Google Play in one run, same fields | ✅ | one store only |
| Search, charts, details and developers in one Actor | ✅ | one mode per Actor |
| Top charts up to 200 apps, per category and country | ✅ | often top 100 or one store |
| Rank on every search and chart row (ASO tracking) | ✅ | rarely |
| Keyword suggestions with popularity and difficulty | ✅ | separate ASO tool subscription |
| Ratings histogram on both stores | ✅ | rarely |
| Developer email and address (Google Play) | ✅ | sometimes |
| One flat price per app, details included | ✅ | extra charges per query |

### How to scrape App Store and Google Play

1. Click **Try for free**.
2. Fill one or more jobs: **Keyword research** seeds (e.g. `meditation`), **Search keywords**, **Top charts** with **Chart categories**, **App Store apps** / **Google Play apps** (IDs or URLs), or **Developers**.
3. Choose **countries** and how many results you want per search, chart or developer.
4. Turn on **Full details** if you also want histograms, developer emails and privacy data for search and chart results.
5. Click **Start**, then download JSON, CSV, Excel or HTML, or connect the dataset to Google Sheets.

### Input

| Field | Example | Notes |
|---|---|---|
| `keywordSeeds` | `["meditation", "habit tracker"]` | keyword research: one row per suggested keyword |
| `keywordExpansion` | `"alphabet"` | also ask for `seed a` … `seed z` (more long-tail keywords); `"none"` = seed only |
| `maxKeywords` | `50` | keywords per seed, store and country (max 300) |
| `keywordPopularity` / `keywordMetrics` | `true` | popularity score / difficulty, top apps and tracked ranks |
| `trackApps` | `["571800810", "com.calm.android"]` | your apps: their rank is added to every keyword row |
| `searchTerms` | `["meditation", "budget planner"]` | each result has `rank` and `searchTerm` |
| `charts` | `["top-free", "top-paid", "top-grossing"]` | top grossing is Google Play only |
| `chartCategories` | `["ALL", "GAMES", "FINANCE"]` | one name for both stores; App Store genre IDs (`7012`) and Google Play codes (`GAME_PUZZLE`) also work |
| `appStoreApps` | `["324684580", "https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580"]` | always full details |
| `googlePlayApps` | `["com.spotify.music"]` | always full details |
| `developers` | `["Spotify AB", "https://apps.apple.com/us/developer/spotify/id324684583"]` | Google Play name or URL, App Store URL or `apple:<id>` |
| `stores` | `["appstore", "googleplay"]` | for searches and charts; default both |
| `countries` | `["us", "gb", "de"]` | every job runs in every country |
| `language` | `"en"` | Google Play text language |
| `maxResults` | `50` | per search term, chart and developer (max 200) |
| `fullDetails` | `false` | open each app page for histogram, emails, privacy, similar apps |
| `appleDevice` | `"iphone"` | App Store charts for iPhone or iPad |

```json
{
  "searchTerms": ["meditation"],
  "charts": ["top-free", "top-grossing"],
  "chartCategories": ["HEALTH_AND_FITNESS"],
  "countries": ["us", "gb"],
  "maxResults": 100
}
```

### Output: app data

One row per app per job (the same app found by two keywords appears twice, each with its own rank):

```json
{
  "store": "googleplay",
  "appId": "com.moonactive.coinmaster",
  "title": "Coin Master",
  "developer": "Moon Active",
  "rating": 4.61,
  "ratingCount": 10423543,
  "price": 0,
  "currency": "EUR",
  "free": true,
  "installs": "100,000,000+",
  "genre": "Casual",
  "url": "https://play.google.com/store/apps/details?id=com.moonactive.coinmaster&hl=en&gl=de",
  "source": "chart",
  "chart": "top-grossing",
  "chartCategory": "GAMES",
  "rank": 1,
  "country": "de",
  "reviewCount": 154558,
  "ratingHistogram": {"1": 444580, "2": 116131, "3": 322590, "4": 1256940, "5": 8283227},
  "realInstalls": 349226463,
  "developerEmail": "support@coinmastergame.com",
  "hasInAppPurchases": true,
  "inAppPurchases": "€0.49 - €349.99 if billed through Play",
  "containsAds": true,
  "version": "3.5.2753",
  "updated": "2026-10-19T12:19:30+00:00",
  "chartBadge": "#1 top grossing casual",
  "similarApps": [{"appId": "com.superplaystudios.dicedreams", "title": "Dice Dreams™️"}],
  "detailLevel": "full"
}
```

Main fields: `store`, `appId`, `title`, `developer`, `rating`, `ratingCount`, `price`, `currency`, `free`, `installs`, `genre`, `url`, plus the job context `source` (`search`, `chart`, `details`, `developer`), `searchTerm`, `chart`, `chartCategory`, `rank`, `country`. `detailLevel` says how complete a row is: `listing` (search or chart card), `standard` (App Store API data) or `full` (app page opened). Fields a store does not publish are `null` (e.g. installs on the App Store).

### Output: ASO keyword research

Keyword research rows have `source: "keyword"` (the dataset has a **Keywords** view). One row per keyword, store and country:

```json
{
  "store": "appstore",
  "keyword": "meditation timer",
  "seed": "meditation",
  "country": "us",
  "source": "keyword",
  "isSeed": false,
  "foundVia": "meditation",
  "suggestionRank": 3,
  "popularity": 58,
  "popularityPrefix": 5,
  "difficulty": 50,
  "titleMatches": 6,
  "resultsChecked": 47,
  "topAppsAvgRating": 4.68,
  "topAppsAvgRatingCount": 46762,
  "topAppsMedianRatingCount": 985,
  "trackedAppRanks": {"571800810": 17},
  "topApps": [
    {"rank": 1, "appId": "337472899", "title": "Insight Timer: Meditate, Sleep", "rating": 4.9, "ratingCount": 448174},
    {"rank": 2, "appId": "1318993458", "title": "Simple Meditation Timer", "rating": 4.45, "ratingCount": 110}
  ]
}
```

- `foundVia` / `suggestionRank`: what was typed in the store search box and where the keyword appeared in the suggestions.
- `popularity` (1–100, 0 = not suggested even when typed in full): how many letters users must type before the store suggests the keyword — `popularityPrefix`. 1 letter = 100, each extra letter −7, lower suggestion slots slightly less. Stores suggest what people search often, so this is a free proxy for search volume.
- `difficulty` (0–100): 70% strength of the top 10 apps (ratings count on the App Store, installs on Google Play, log scale) + 30% share of them with the whole keyword in the title.
- `titleMatches`: how many of the top 10 apps have every word of the keyword in their title.
- `topAppsMedianRatingCount` (App Store) / `topAppsMedianInstalls` (Google Play): how big the typical top-10 app is.
- `trackedAppRanks`: rank of each of your `trackApps` in this keyword's results (`null` = not in the results checked).

### Ready-made setups

Copy the JSON into the **Input → JSON** tab, click **Save as a new task**, then add a **Schedule** and an integration (Google Sheets, Slack, email, webhook) on the task's **Integrations** tab.

**1. Daily ASO keyword rank tracker** (ASO specialists, app marketers). Your keywords in your main markets; filter the rows by your app ID to chart your rank over time. Schedule: daily. About $0.80 per run (5 keywords × 2 stores × 2 countries × up to 50 apps).

```json
{
  "searchTerms": ["habit tracker", "daily planner", "to do list", "routine", "goal tracker"],
  "countries": ["us", "gb"],
  "maxResults": 50
}
```

**2. Weekly category charts** (product teams, investors). Top free, top paid and top grossing in your category, up to 200 apps per chart. Schedule: weekly. About $1.00 per run (about 1,000 apps).

```json
{
  "charts": ["top-free", "top-paid", "top-grossing"],
  "chartCategories": ["FINANCE"],
  "countries": ["us"],
  "maxResults": 200
}
```

**3. Competitor watch** (mobile teams). Full details of your app and competitors on both stores: rating histogram, version, last update, price changes. Schedule: daily or weekly. A few cents per run.

```json
{
  "appStoreApps": ["324684580", "336353151"],
  "googlePlayApps": ["com.spotify.music", "com.soundcloud.android"],
  "countries": ["us", "de"]
}
```

**4. Keyword research for a new app or update** (ASO specialists, indie developers). Seeds that describe your app; sort by `popularity` (high) and `difficulty` (low), keep keywords where your app is close to the top. Schedule: monthly. About $0.80 per run (2 seeds × 2 stores × 100 keywords).

```json
{
  "keywordSeeds": ["habit tracker", "daily planner"],
  "keywordExpansion": "alphabet",
  "maxKeywords": 100,
  "trackApps": ["<your App Store ID>", "<your.google.play.package>"],
  "countries": ["us"]
}
```

### Use it from AI agents (MCP, Claude, ChatGPT, n8n)

**MCP server.** Add this URL to Claude, Cursor, VS Code or any other MCP client and sign in to Apify when asked:

```
https://mcp.apify.com?tools=d_nepoch/app-store-google-play-scraper
```

```json
{
  "mcpServers": {
    "app-store-google-play": { "url": "https://mcp.apify.com?tools=d_nepoch/app-store-google-play-scraper" }
  }
}
```

Then just ask, for example: *"What are the top 20 grossing games on Google Play in Germany right now, with their install counts?"*, *"Where does Headspace rank for 'meditation' on the App Store and Google Play in the US and UK?"* or *"List all apps by Spotify AB with ratings and last update dates"* or *"Find popular, low-competition App Store keywords around 'habit tracker' in the US"*. The agent fills search terms, charts, countries and app IDs itself.

**One HTTP call** (waits for the run and returns the apps as JSON; for runs longer than 5 minutes use the async `runs` endpoint):

```bash
curl -X POST "https://api.apify.com/v2/acts/d_nepoch~app-store-google-play-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchTerms": ["meditation"], "countries": ["us"], "maxResults": 20}'
```

**Python** (`pip install apify-client`, version 3):

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("d_nepoch/app-store-google-play-scraper").call(
    run_input={"charts": ["top-grossing"], "chartCategories": ["GAMES"], "countries": ["de"], "maxResults": 20},
    max_total_charge_usd=1,  # hard spending cap for this run
)
for app in client.dataset(run.default_dataset_id).iterate_items():
    print(app["rank"], app["store"], app["title"], app["rating"], app["installs"])
```

**No-code and agent frameworks**: the Apify integrations for n8n, Make, Zapier, LangChain, LlamaIndex and CrewAI call this Actor by the name `d_nepoch/app-store-google-play-scraper` with the same JSON input.

Tips for agents: keyword research rows have `source` = `keyword` and fields `keyword`, `popularity`, `difficulty`, `trackedAppRanks`; use `keywordExpansion: "none"` for a quick check of one keyword. Other rows: one row = one app in one job (search term, chart, app list or developer) and one country; `store` is `appstore` or `googleplay`; `rank` is the position in that search or chart; `appId` is the numeric App Store ID or the Google Play package name; set `maxTotalChargeUsd` to cap spend.

### How much does it cost to scrape app store data?

**$1.00 per 1,000 apps** saved to the dataset, the same price with or without full details. **Keyword research: $2.00 per 1,000 keywords**, popularity, difficulty, top apps and tracked ranks included. Paid Apify plans get lower prices: Starter −10%, Scale −20%, Business −30% (from **$0.70 per 1,000 apps** and **$1.40 per 1,000 keywords**). Platform usage is included — you pay only per app (see the **Pricing** tab).

Set **Max total charge** in run options to cap your spend — the Actor stops cleanly when the limit is reached. New Apify accounts get free monthly credits, enough for thousands of apps.

### FAQ

**How many results can I get?** Charts: up to 200 apps per chart, category and country. App Store keyword search: up to 200 apps per keyword. Google Play keyword search: about 30 apps per keyword (that is all the Google Play website shows); add related keywords to go wider.

**Is the rank the same as in the store app?** Chart ranks match the official charts on the App Store and Google Play websites. Google Play search ranks come from the Google Play website. App Store search ranks come from Apple's public search API, which is very close to, but not always identical with, the order in the App Store app on a phone.

**Where do the keywords come from?** From the search suggestions of the App Store and Google Play themselves (what the store shows while you type), for the country you choose. The App Store gives up to 10 suggestions per query, Google Play 5; the `alphabet` expansion asks for `seed a` … `seed z` to collect long-tail keywords.

**Is popularity the real search volume?** No store publishes search volume for free. Popularity measures how early the store suggests a keyword while you type it — stores rank suggestions by how often people search them, so it is a good relative signal. Keywords that start with rare letters (brand and app names) can score high after very few letters; check `topApps` before targeting them.

**Can I track my app's keyword rankings every day?** Yes: save the keywords as a task, add a daily schedule and filter the rows by your `appId`.

**Can I get reviews too?** Use the companion [App Store & Google Play Reviews Scraper](https://apify.com/d_nepoch/app-store-google-play-reviews) with the `appId` values from this dataset.

**Why is the App Store genre in English for other countries?** Apple's API returns genre names in English; titles, descriptions and privacy labels come in the country's language.

**Is scraping app store data legal?** The Actor collects only publicly visible store pages. Developer contact details are personal data in some cases, so use them in line with privacy laws such as GDPR and the stores' terms. If unsure, ask a lawyer.

### Limits

- **App Store web charts** publish top free and top paid only; top grossing is available for Google Play.
- **Google Play search** shows about 30 apps per keyword on the web.
- **Keyword popularity and difficulty** are estimates from public store data (suggestions and top results), not Apple Search Ads volumes. App Store suggestions are available for about 120 countries.
- **App Store details** include the ratings histogram, privacy labels and in-app purchases when Apple shows them on the app page for that country.
- Data is what each store shows for the selected country (and language on Google Play); apps not available in a country are reported in the log and skipped.

### Other scrapers by this developer

- [App Store & Google Play Reviews Scraper](https://apify.com/d_nepoch/app-store-google-play-reviews) — reviews from both stores with an insights report per app.
- [AliExpress Product Search Scraper](https://apify.com/d_nepoch/aliexpress-product-search-scraper) — AliExpress prices, sold counts and ratings for any keyword or category.
- [TikTok Shop Product Scraper](https://apify.com/d_nepoch/tiktok-shop-product-scraper) — TikTok Shop products with units sold, stock per variant and rating breakdown.
- [Google Hotels Scraper](https://apify.com/d_nepoch/google-hotels-scraper) — hotel prices for any city and dates, prices from every booking site and a price calendar.
- [Startup Funding Rounds Scraper](https://apify.com/d_nepoch/startup-funding-rounds-scraper) — new startup rounds from SEC Form D, Form C and the news, with filters and only-new monitoring.

### Feedback

Found a bug or need a field? Open an issue on the **Issues** tab — fixes usually ship within a few days.

# Actor input Schema

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

Keywords to search in the stores, e.g. 'meditation' or 'budget planner'. Each result gets its rank, so you can track ASO keyword positions over time.

## `charts` (type: `array`):

Top charts to scrape, up to 200 apps each with rank. The App Store web charts have top free and top paid only.

## `chartCategories` (type: `array`):

Categories for the charts. Use one name for both stores: ALL, GAMES, BOOKS, BUSINESS, DEVELOPER_TOOLS, EDUCATION, ENTERTAINMENT, FINANCE, FOOD_AND_DRINK, GRAPHICS_AND_DESIGN, HEALTH_AND_FITNESS, LIFESTYLE, MEDICAL, MUSIC, NAVIGATION, NEWS, PHOTO_AND_VIDEO, PRODUCTIVITY, SHOPPING, SOCIAL, SPORTS, TRAVEL, UTILITIES, WEATHER. Store-specific codes also work: an App Store genre ID (e.g. 7012 for puzzle games) or a Google Play category (e.g. GAME_PUZZLE). Default: ALL.

## `appStoreApps` (type: `array`):

Specific App Store apps: numeric IDs (324684580) or apps.apple.com URLs. Returns full details incl. ratings histogram, in-app purchases, privacy labels and similar apps.

## `googlePlayApps` (type: `array`):

Specific Google Play apps: package names (com.spotify.music) or play.google.com URLs. Returns full details incl. exact installs, ratings histogram, developer email and data safety.

## `developers` (type: `array`):

All apps of a developer. App Store: developer URL (apps.apple.com/us/developer/name/id123) or 'apple:123'. Google Play: developer URL or the exact developer name, e.g. 'Spotify AB'.

## `keywordSeeds` (type: `array`):

ASO keyword research. For each seed (e.g. 'meditation', 'budget planner') we collect the keywords the store itself suggests in its search box, then score each one: popularity (how few letters users type before the store suggests it), difficulty (strength of the top 10 apps and how many have the keyword in their title), the top 5 apps and the ranks of your tracked apps. One dataset row per keyword, charged as a 'keyword' result.

## `keywordExpansion` (type: `string`):

'Seed + a…z' also asks the store for 'seed a', 'seed b' … 'seed z', which finds many more long-tail keywords (up to ~260 on the App Store, ~130 on Google Play per seed).

## `maxKeywords` (type: `integer`):

How many keywords to keep for each seed, store and country (the seed itself comes first, then suggestions in store order).

## `keywordPopularity` (type: `boolean`):

Score 1–100: how early the store suggests the keyword while typing it. Keywords suggested after 1–2 letters are searched a lot. Adds a few quick requests per keyword.

## `keywordMetrics` (type: `boolean`):

Search each keyword in the store and add difficulty (0–100), title matches, average rating and ratings/installs of the top apps, the top 5 apps and the ranks of your tracked apps.

## `trackApps` (type: `array`):

Optional: your App Store IDs/URLs and Google Play package names/URLs. Each keyword row then shows where these apps rank for that keyword (null = not in the results checked; App Store checks up to 'Max results' apps, Google Play about 30).

## `stores` (type: `array`):

Stores used for search keywords and charts. Default: both.

## `countries` (type: `array`):

Two-letter country codes (us, gb, de, jp...). Every job runs once per country. Default: us.

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

Language of Google Play texts, e.g. en, de, es, pt-BR. App Store texts come in the country's default language.

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

How many apps to take from each search term, chart and developer (per store and country). Charts go up to 200; Google Play web search returns about 30 apps per keyword.

## `fullDetails` (type: `boolean`):

Also open each app's page to add ratings histogram, review count, exact installs, developer email, privacy labels and similar apps. Slower; the price per app stays the same. Apps listed by ID always get full details.

## `appleDevice` (type: `string`):

Which App Store charts to read.

## `proxyConfiguration` (type: `object`):

Apify datacenter proxy works for both stores; change only if you see blocks.

## Actor input object example

```json
{
  "charts": [
    "top-free"
  ],
  "chartCategories": [
    "ALL"
  ],
  "keywordExpansion": "alphabet",
  "maxKeywords": 50,
  "keywordPopularity": true,
  "keywordMetrics": true,
  "stores": [
    "appstore",
    "googleplay"
  ],
  "countries": [
    "us"
  ],
  "language": "en",
  "maxResults": 20,
  "fullDetails": false,
  "appleDevice": "iphone",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

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

No description

# 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 = {
    "charts": [
        "top-free"
    ],
    "chartCategories": [
        "ALL"
    ],
    "countries": [
        "us"
    ],
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("d_nepoch/app-store-google-play-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 = {
    "charts": ["top-free"],
    "chartCategories": ["ALL"],
    "countries": ["us"],
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("d_nepoch/app-store-google-play-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 '{
  "charts": [
    "top-free"
  ],
  "chartCategories": [
    "ALL"
  ],
  "countries": [
    "us"
  ],
  "maxResults": 20
}' |
apify call d_nepoch/app-store-google-play-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,d_nepoch/app-store-google-play-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/Z5h1yb1Qg8xcWGWMj/builds/gHPPlkhehrHhS5ZYe/openapi.json