# App Store & Google Play Scraper | Details, Updates, Ratings (`happyscrapper/app-store-google-play-app-details`) Actor

Scrape the store page of any app on the App Store and Google Play in one format: update date, release notes, ratings, installs, permissions, price per country. Only changed apps.

- **URL**: https://apify.com/happyscrapper/app-store-google-play-app-details.md
- **Developed by:** [Happy Scrapper](https://apify.com/happyscrapper) (community)
- **Categories:** Developer tools, Automation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 app records

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 app details in one clean format](https://api.apify.com/v2/key-value-stores/BQSjfOQ2i88EMdSPe/records/app-details-banner.png)

### What is App Store & Google Play Scraper?

It reads the **store page of any app on the Apple App Store and Google Play** and returns it in **one clean format for both stores**: name, developer, category, price, update date, release notes, average rating and number of ratings, plus what each store adds (App Store version, minimum iOS, size and languages; Google Play star histogram, install bracket and permissions).

**Don't have the list of apps yet?** Read the **top charts** (Top Free, Top Paid, Top Grossing, by country and category), give a **keyword** (the Actor returns the apps the App Store and Google Play searches give, with their position) or a **developer** (it returns all their apps). And **track where your apps rank on a keyword**, country by country.

Schedule it with **Only apps that changed**, and it returns **only the apps that shipped an update, changed price, release notes or rating** since the last run. You pay only for the records you get.

👉 Paste an App Store link and a Google Play package, press **Start**, and get both records in seconds.

### Why use it

| | This Actor | A typical app scraper |
|---|---|---|
| 🍏 + 🤖 Both stores | ✅ one run, one schema | one Actor per store, two formats |
| 🌍 Many countries per run | ✅ one record per app and country | one country per run |
| 🔎 Find apps by keyword or by developer | ✅ both stores | one mode per Actor, or search only |
| 📈 Keyword ranking of your apps, per country | ✅ both stores, alerts when a rank moves | separate rank trackers |
| 📊 Top charts, by country and category | ✅ Free, Paid, Grossing, both stores, alerts when a position moves | separate chart scrapers |
| 💡 Keyword suggestions (autocomplete) | ✅ both stores, one row per suggestion | separate keyword tools |
| 🔗 Same app on the other store (iOS and Android) | ✅ with a confidence level and the reasons | not offered |
| 🔔 Only what changed since the last run | ✅ built in, with the previous value | rarely built in |
| ⭐ Star histogram (1 to 5) | ✅ Google Play | varies |
| 🔐 Permissions the app asks for | ✅ Google Play, by group | varies |
| 🆔 Stable record IDs | ✅ store, app, country | not guaranteed |
| 🤖 LLM-ready compact mode | ✅ about 5 times lighter records, same fields | full records only, or raw store copies |
| 🛡️ Developer contact details | ❌ left out on purpose (personal data) | often included |

### What data do you get?

| Field | Example | Notes |
|---|---|---|
| `record_id` | `apple:324684580:us` | stable across runs |
| `store`, `app_id`, `country` | `apple`, `324684580`, `us` | |
| `name`, `developer`, `category` | `Spotify: Music and Podcasts`, `Spotify`, `Music` | |
| `price`, `price_label`, `currency` | `0`, `Free`, `USD` | the price in that country |
| `version` | `9.1.90` | **App Store only** |
| `updated_at`, `released_at` | `2026-10-08T07:37:17Z` | UTC, both stores |
| `release_notes` | | what's new, as the developer wrote it |
| `rating_average`, `rating_count` | `4.77`, `42587623` | all versions |
| `rating_histogram` | `{"1": 3716447, … "5": 27296726}` | Google Play |
| `rating_average_current_version` | `4.7` | App Store |
| `installs_label`, `installs_min` | `1,000,000,000+`, `1000000000` | Google Play |
| `min_os`, `languages`, `size_bytes` | `16.1`, `["EN","FR"…]`, `308086784` | App Store |
| `permissions` | `[{"group": "Location", "items": […]}]` | Google Play |
| `has_in_app_purchases`, `contains_ads` | `true`, `true` | Google Play |
| `content_rating` | `12+`, `Teen` | as each store words it |
| `summary`, `description`, `icon_url`, `screenshots` | | up to 10 screenshots |
| `bundle_id` | `com.spotify.client` | App Store: the iOS bundle identifier |
| `counterpart` | `{"store": "google_play", "app_id": "com.spotify.music", "confidence": "high", "reasons": [...]}` | with **Find the same app on the other store**: the matching app of the other store, `null` when nothing matches |
| `found_by` | `[{"type": "search", "term": "meditation", "country": "us", "position": 3}]` | how the app was found: search term and position, developer ID, or chart, category and position. `null` for apps you listed |
| `keyword_ranks` | `{"us:meditation": 3, "us:sleep": null}` | position of the app in the search results of each keyword and country, `null` = not in the results the store gives (App Store: 200, Google Play: first page, about 24) |
| `record_type` | `app` | `app`, or `keyword_suggestion` for a suggestion row (the app fields are then empty) |
| `keyword`, `seed_keyword`, `suggestion_rank`, `suggestion_source` | `meditation timer`, `meditation`, `3`, `app_store_autocomplete` | suggestion rows only |
| `changed`, `changed_fields`, `previous` | `true`, `["version"]`, `{"version": "9.1.88"}` | only with **Only apps that changed** |
| `scraped_at` | `2026-10-15T15:13:38Z` | UTC |

**Google Play does not show a version number on the app page.** The `version` field is `null` there: follow `updated_at` and `release_notes` to see an Android release. Fields a store does not give are always present and `null`.

#### A real record

| Store | App | Update | Rating | Ratings | Installs |
|---|---|---|---|---|---|
| App Store (US) | Spotify: Music and Podcasts, v9.1.90 | 2026-10-08 | 4.77 | 42,587,623 | n/a |
| Google Play (US) | Spotify: Music and Podcasts | 2026-10-14 | 4.35 | 36,486,803 | 1,000,000,000+ |

### Who uses it

- **Product and growth teams** tracking competitor releases, prices and ratings.
- **ASO and market research** (app store optimization): category, ratings, installs and release notes at scale. It reads store pages, it does not track keyword rankings.
- **Developers and AI agents** who need app data as clean JSON.

### How to use it

1. Paste your apps, one per line: a store URL, an Apple numeric ID (`324684580`) or an Android package (`com.spotify.music`). Mix both stores.
2. Pick the countries. You get one record per app and country.
3. Optional: turn on **Only apps that changed** (and **Compact output** for AI agents) and schedule the Actor (daily is typical). Give each list of apps its own **Tracking name**.
4. Press **Start**, then read the dataset as a table, JSON, CSV or Excel, or call it from the API.

#### Find apps and rank them

```json
{
  "searchTerms": ["meditation"],
  "maxAppsPerSearch": 10,
  "rankKeywords": ["meditation", "sleep sounds"],
  "countries": ["us", "gb"]
}
```

#### Input example

```json
{
  "apps": [
    "https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580",
    "com.spotify.music"
  ],
  "countries": ["us", "fr"],
  "googleLanguage": "en"
}
```

### Find apps by keyword or by developer (App Store and Google Play)

- **Search terms**: one keyword per line. For each keyword and country you get the top apps of **both stores** (10 per store by default). App Store: up to 200 results. Google Play: the first page of results, about 24.
- **Developers**: App Store: the numeric Apple developer ID (`324684583`) or the developer page URL. Google Play: the developer page URL (`play.google.com/store/apps/developer?id=Spotify+AB`) or the developer exactly as in that address, the name or the number after `dev?id=`. You can mix both in one list.
- **Stores to search**: both by default. Pick one store to get, and pay for, only its apps. Apps you list yourself are always read on their own store.
- You can mix these with your own list of apps. An app found twice appears once, with every way it was found.
- Each app returned is one record, billed like any other record.

### Top charts (App Store and Google Play)

Pick **Top charts** (Top Free, Top Paid, Top Grossing) and **Chart categories** (overall, games, health_fitness, social, productivity, finance, entertainment, education, lifestyle, music, news, photo_video, shopping, travel, utilities, weather). For each chart, category, country and store you get the top apps (20 by default, up to 200), each with its **full store page** and its position in `found_by`.

- The same category name is mapped to the matching App Store genre and Google Play category.
- Turn on **Only apps that changed** and schedule the Actor daily: you only get the apps whose chart position moved, with the previous positions in `previous`. An app that falls out of the chart is not reported.
- Each app returned is one record, billed like any other record.
- The App Store charts come from Apple's chart feeds. The Google Play charts use an internal Google call that is not documented: if Google changes it, the Actor fails and says so.

### Keyword suggestions (App Store and Google Play)

Fill **Keywords to get suggestions for** and you get the stores' own autocomplete suggestions, **one row per suggestion**: `record_type` is `keyword_suggestion`, the keyword is in `keyword`, the keyword you asked about in `seed_keyword`, and the app fields are empty. Each row is one record, billed like any other record.

- App Store suggestions follow the country's storefront (language and market). For the countries where the storefront is not known to the Actor (it knows the US, UK, France, Germany, Spain, Italy, the Netherlands, Brazil, Japan, Canada, Australia and Mexico), the US suggestions are returned and the run status says so.
- With **Only apps that changed**, you only get suggestions you have never received before.
- Suggestions are not a measure of search volume.

### Track your keyword rankings (App Store and Google Play)

Add **Keywords to rank your apps on** and every app in the run gets `keyword_ranks`: its position in the search results for each keyword and country. Turn on **Only apps that changed** and schedule the Actor daily: you only get the apps whose rank moved, with the previous rank in `previous`.

- **App Store**: position in Apple's public search API, up to 200 results. Close to what the App Store app shows but not guaranteed identical, and results can differ between iPhone and iPad. Apple can also swap two neighbouring apps depending on how many results a request asks for (measured: at 50 results, places 4 and 5 swap compared to 10, 25 or 200). The Actor always asks for 200, so its ranks are consistent from one run to the next, but another tool can differ by one place.
- **Google Play**: position on the first page of Google Play search, about 24 results, in the language you pick. `null` means not on that first page.

### Find the same app on the other store

Turn on **Find the same app on the other store** and every record gets a `counterpart`: the iOS app for an Android app, or the Android app for an iOS app, with a **confidence level** and the **reasons**.

There is no official link between the two. The Actor searches the other store with the app's name, then scores each candidate on checkable clues:

- **high**: the same package and bundle identifier, or the same developer website **and** the same app name.
- **medium**: the same developer website with a different or close name, or the same app name and the same developer name.
- **low**: only the name matches. Check by hand.
- Nothing credible: `counterpart` is `null`. A wrong match is worse than none.

When several candidates match equally (the phone and the TV version of an app, for example), the most rated one wins, `ambiguous` is `true` and `alternatives` lists the others. The match is a best effort, not a guarantee. It costs a few extra requests per app and **no extra charge**: you still pay one record per app.

### LLM-ready JSON for AI agents and pipelines

Turn on **Compact output** and each record drops from about 5 to 6 KB to about 1.2 KB (measured on Spotify, WhatsApp and Instagram, both stores). The heavy text fields (description, summary, screenshots, languages, permissions, icon and developer links) come back empty, release notes are cut at 300 characters, and **every field stays present**, so your code and your agent's tool schema never change. Name, version, update date, ratings, installs, price and the change tracking are all kept.

### How much does it cost?

**$1.00 per 1,000 app records** (one app in one country is one record), plus $0.00005 per run start. Paid Apify plans get volume discounts, down to $0.50 per 1,000. With **Only apps that changed**, apps without a change are not returned and **not charged**.

### Good to know

- **Where the data comes from.** App Store: Apple's public Lookup API. Google Play: the public app page. Google Play has no official API for this, so a layout change on Google's side can break the Actor. It then **fails and names the field it could not read**, it never returns an empty record in its place.
- **Countries.** Price, rating counts and availability can differ per country. An app missing in a country is named in the run status, and the other apps are still returned.
- **Apple limits.** Apple allows about 20 requests per minute. The Actor sends up to 50 apps per request and paces itself.
- **Personal data.** Developer contact details (email, address, phone) are not collected.
- **Google Play search, developer pages, charts and suggestions are not an official API.** App Store suggestions and the older chart feeds are not documented either.
- **Google Play search and developer pages are not an official API.** If Google changes them the Actor fails and names the problem. A search with no result list is reported in the run status: either no app matches, or Google changed its page.
- **Reviews are not included.** For reviews, use the sister Actors below.

### Related Actors

- [App Store & Google Play Reviews Scraper API](https://apify.com/happyscrapper/app-store-google-play-reviews): reviews from both stores in one run.
- [App Store Reviews Scraper API](https://apify.com/happyscrapper/app-store-reviews-scraper): App Store reviews, many countries.
- [Google Play Reviews Scraper API](https://apify.com/happyscrapper/google-play-reviews-scraper): Google Play reviews, full history.

### FAQ

**Can I track a competitor's releases?** Yes. List their apps, turn on **Only apps that changed**, schedule the Actor daily. Each returned record says which fields changed and what they were before.

**Why is the number of ratings not a change?** It moves every day for big apps and would flag every app on every run. The average rating is compared rounded to 0.1.

**Can I use it from my code or an AI agent?** Yes: the output format is stable, with a stable `record_id`. Call it through the Apify API or the client libraries.

**Any restriction on use?** The data is public and personal contact details are left out. You stay responsible for your own use and for the terms of the stores.

# Actor input Schema

## `apps` (type: `array`):

Fill Apps, Search terms or Developers (or several). One app per line: an App Store or Google Play URL, an Apple numeric ID (e.g. 324684580) or an Android package name (e.g. com.spotify.music). Mix both stores freely.

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

Where Search terms and Developers look for apps. Both stores by default: you get, and pay for, the apps of both. Pick one store to get only its apps. Apps you list yourself are always read on their own store.

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

One keyword per line. The Actor returns the apps that App Store and Google Play search give for each keyword, in each country, with their position in `found_by` (App Store: up to 200 results, Google Play: the first page, about 24).

## `maxAppsPerSearch` (type: `integer`):

How many of the top results to return for each search term, country and store. Apple gives at most 200, Google Play about 24.

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

One developer per line. App Store: the numeric Apple developer ID (e.g. 324684583) or the developer page URL. Google Play: the developer page URL (play.google.com/store/apps/developer?id=...), or the developer exactly as in that address (the name, or the number after dev?id=). The Actor returns every app of each developer.

## `maxAppsPerDeveloper` (type: `integer`):

Upper bound of apps returned for each developer and country.

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

Which store charts to read: Top Free, Top Paid, Top Grossing. For each chart, category, country and store (see 'Stores to search'), you get the top apps with their full store page and their position in `found_by`.

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

Categories of the charts above. 'overall' is the general chart. The same category name is mapped to the matching App Store genre and Google Play category.

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

How many apps to return for each chart, category, country and store. Each one is read in full, so keep it small to start.

## `suggestKeywords` (type: `array`):

One keyword per line. For each keyword, country and store you get the store's own autocomplete suggestions, one row each (`record_type` is `keyword_suggestion`, the app fields are empty). With 'Only apps that changed', you only get suggestions never seen before.

## `maxSuggestionsPerKeyword` (type: `integer`):

Upper bound of suggestions kept for each keyword, country and store. The stores give about 5 to 10.

## `rankKeywords` (type: `array`):

One keyword per line. For every app in the run, `keyword_ranks` gives its position in the search results of each keyword and country (1 = first, null = not in the results the store gives: 200 on the App Store, about 24 on Google Play). Combine with 'Only apps that changed' to be told when a rank moves.

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

Both stores sell per country: price, rating, availability and release notes can differ. Pick every country you need: you get one record per app and country.

## `googleLanguage` (type: `string`):

Language of the Google Play texts (description, release notes, category names). App Store texts follow the country storefront.

## `findCounterpart` (type: `boolean`):

For each app, search the other store and return the matching app in `counterpart`, with a confidence level (high, medium, low) and the reasons. There is no official link between an iOS app and its Android app: the match relies on the app identifier, the developer website and the names, so low confidence means check by hand. Costs a few extra requests per app, and no extra charge.

## `changesOnly` (type: `boolean`):

Schedule this Actor and get only the apps whose version, update date, release notes, price, name, category, age rating, minimum OS or average rating (rounded to 0.1), keyword rank or chart position changed. The first run returns everything. You pay only for the records returned.

## `compact` (type: `boolean`):

About 4 times lighter records, for AI agents and pipelines that pay per token. Description, summary, screenshots, languages, permissions, icon and developer links are left empty (null) and release notes are cut at 300 characters. All fields stay present.

## `trackingName` (type: `string`):

Name of the memory used by 'only changed apps'. Use one name per list of apps you track, so lists do not overwrite each other.

## Actor input object example

```json
{
  "apps": [
    "https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580",
    "com.spotify.music"
  ],
  "stores": [
    "apple",
    "google_play"
  ],
  "maxAppsPerSearch": 10,
  "maxAppsPerDeveloper": 50,
  "chartCategories": [
    "overall"
  ],
  "maxAppsPerChart": 20,
  "maxSuggestionsPerKeyword": 10,
  "countries": [
    "us"
  ],
  "googleLanguage": "en",
  "findCounterpart": false,
  "changesOnly": false,
  "compact": false,
  "trackingName": "default"
}
```

# Actor output Schema

## `apps` (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 = {
    "apps": [
        "https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580",
        "com.spotify.music"
    ],
    "stores": [
        "apple",
        "google_play"
    ],
    "chartCategories": [
        "overall"
    ],
    "countries": [
        "us"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("happyscrapper/app-store-google-play-app-details").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 = {
    "apps": [
        "https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580",
        "com.spotify.music",
    ],
    "stores": [
        "apple",
        "google_play",
    ],
    "chartCategories": ["overall"],
    "countries": ["us"],
}

# Run the Actor and wait for it to finish
run = client.actor("happyscrapper/app-store-google-play-app-details").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 '{
  "apps": [
    "https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580",
    "com.spotify.music"
  ],
  "stores": [
    "apple",
    "google_play"
  ],
  "chartCategories": [
    "overall"
  ],
  "countries": [
    "us"
  ]
}' |
apify call happyscrapper/app-store-google-play-app-details --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,happyscrapper/app-store-google-play-app-details"
        }
    }
}
```

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/sr0aLZxnd4pGKmkdT/builds/lEmDEjXZJThWzaTaL/openapi.json