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

App Store and Google Play app data as JSON: search results, full app details and top charts (free, paid and grossing, with genre for iOS). Both stores, one schema, no start fee, from $0.30 per 1,000 apps.

- **URL**: https://apify.com/subimpact/app-store-scraper.md
- **Developed by:** [subimpact network](https://apify.com/subimpact) (community)
- **Categories:** Developer tools, SEO tools, E-commerce
- **Features:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.24 / 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

Scrape app data from the **iOS App Store** and **Google Play** in one run: keyword search results, full app details, and today's top charts including **top grossing** and **genre-filtered** iOS charts. Every app is one JSON row with price, rating, installs, version, genres, screenshots, developer contacts and the search or chart rank it came from.

No login, no API key and no browser. Pay only for apps delivered: **$0.0003 per app** ($0.30 per 1,000), with no start fee and no charge for error rows.

### What you can do

- **Search both stores by keyword.** iOS returns up to 200 results per term; Google Play returns about 30 per term. Add as many terms as you need.
- **Look up apps by id, URL, bundle id or package name.** Mix both stores in one list. A bare dotted id such as `com.burbn.instagram` is tried as a Google Play package and as an App Store bundle id, and each hit becomes a row.
- **Read the top charts.** Top free, top paid and top grossing. iOS charts accept an Apple genre id (for example 6014 for Games), Google Play charts accept a category id (for example `GAME_ACTION`). Google Play search and chart rows can be upgraded to full details with `fullDetails`.

Each row tells you where it came from (`source`, `detailLevel`), which search term or chart it belongs to (`searchTerm` / `searchRank`, `chartCollection` / `chartCategory` / `chartRank`), the storefront (`country`) and the language the run used.

### Input example

```json
{
  "mode": "search",
  "store": "both",
  "searchTerms": ["todo", "photo editor"],
  "country": "us",
  "language": "en",
  "maxItems": 50
}
```

App details by id and URL:

```json
{
  "mode": "details",
  "store": "both",
  "appIds": [
    "id389801252",
    "https://play.google.com/store/apps/details?id=com.microsoft.todos",
    "com.burbn.instagram"
  ],
  "maxItems": 20
}
```

Top grossing action games on Google Play and top free games on iOS:

```json
{
  "mode": "charts",
  "store": "both",
  "chartCollection": "topGrossing",
  "iosGenreId": "6014",
  "playCategory": "GAME_ACTION",
  "country": "us",
  "maxItems": 20
}
```

An empty input (`{}`) runs the Console prefill: search for `todo` on both stores, 50 apps.

### Output example

Real values from these stores, trimmed to the interesting fields:

```json
{
  "store": "ios",
  "appId": "1212616790",
  "bundleId": "com.microsoft.to-do",
  "appTitle": "Microsoft To Do",
  "developerName": "Microsoft Corporation",
  "sellerName": "Microsoft Corporation",
  "price": 0,
  "currency": "USD",
  "priceText": "Free",
  "isFree": true,
  "rating": 4.72067,
  "ratingCount": 270528,
  "genre": "Productivity",
  "genreId": "6007",
  "genres": ["Productivity"],
  "contentRating": "4+",
  "releasedAt": "2017-04-19T12:44:06Z",
  "updatedAt": "2026-07-06T05:06:19Z",
  "version": "2.177",
  "minOsVersion": "17.6",
  "sizeBytes": 167581696,
  "appUrl": "https://apps.apple.com/us/app/microsoft-to-do/id1212616790",
  "country": "us",
  "detailLevel": "full",
  "source": "itunes-search",
  "searchTerm": "todo",
  "searchRank": 1
}
```

A Google Play details row carries the Play-only fields:

```json
{
  "store": "play",
  "appId": "com.mojang.minecraftpe",
  "appTitle": "Minecraft: Dream it, Build it!",
  "developerName": "Mojang",
  "developerId": "4772240228547998649",
  "price": 6.99,
  "currency": "GBP",
  "priceText": "£6.99",
  "isFree": false,
  "rating": 4.29347,
  "ratingCount": 5889749,
  "reviewCount": 93187,
  "histogram": [640134, 191300, 246440, 533777, 4277999],
  "installs": "100,000,000+",
  "minInstalls": 100000000,
  "genre": "Arcade",
  "genreId": "GAME_ARCADE",
  "contentRating": "PEGI 7",
  "updatedAt": "2026-11-18T17:29:00Z",
  "version": "1.26.66.1",
  "minOsVersion": "8.0",
  "iapRange": "£0.50 - £49.99 if billed through Play",
  "developerEmail": "help@minecraft.net",
  "privacyPolicyUrl": "http://go.microsoft.com/fwlink/?LinkId=521839",
  "country": "gb",
  "detailLevel": "full",
  "source": "play-details-html"
}
```

Rows that cannot be delivered are never charged. They carry `status` (`invalid-input`, `not-found` or `error`), `error` and, for list input, `inputValue` with the raw entry:

```json
{
  "store": "play",
  "appId": "com.example.missing",
  "inputValue": "com.example.missing",
  "status": "not-found",
  "error": "Play details com.example.missing returned HTTP 404 (not found)",
  "country": "us"
}
```

### Fields

`store`, `appId`, `bundleId`, `appTitle`, `developerName`, `developerId`, `sellerName`, `price`, `currency`, `priceText`, `isFree`, `rating`, `ratingCount`, `reviewCount`, `histogram`, `installs`, `minInstalls`, `genre`, `genreId`, `genres`, `contentRating`, `releasedAt`, `updatedAt`, `version`, `minOsVersion`, `sizeBytes`, `summary`, `description`, `releaseNotes`, `iapRange`, `iconUrl`, `headerImageUrl`, `screenshotUrls`, `videoUrl`, `appUrl`, `developerWebsite`, `developerEmail`, `privacyPolicyUrl`, `languages`, `searchTerm`, `searchRank`, `chartCollection`, `chartCategory`, `chartRank`, `country`, `language`, `detailLevel`, `source`, `scrapedAt`, plus `status`, `error` and `inputValue` on uncharged rows.

Google Play listing rows (search and charts) have no rating count, review count, version, update date or developer contacts. Set `fullDetails: true` to fetch each details page and fill them in. It is one extra request per app and still one app event. iOS rows from search, lookup and chart enrichment are always full.

### Pricing

**$0.0003 per app** ($0.30 per 1,000 apps), billed as the `app` event. Platform usage is included. There is no start fee.

- 50 apps (the default) cost about **$0.015**.
- 1,000 apps cost about **$0.30**.
- Error rows (`invalid-input`, `not-found`, `error`) are never charged.
- A row is charged only after it is pushed with an app id and an app title.
- `fullDetails` enrichment is free: same row, same app event.

### How this compares

Free-plan list prices checked on 2026-11-20. Competitor platform usage is billed on top of these event prices; see each listing.

| Actor | Stores | Price per app | Start fee | Grossing and genre charts |
| --- | --- | --- | --- | --- |
| **This actor** | iOS and Play | $0.0003 | none | Both stores, iOS genre filter |
| automation-lab/google-play-scraper | Play | $0.0007 | $0.001 | No genre filter |
| automation-lab/apple-app-store-scraper | iOS | $0.00345 | $0.005 | Free and paid only |
| curious_coder/google-play-scraper | Play | $0.0003 | none | No |
| solidcode/google-play-apps-scraper | Play | $0.0006 | $0.01 | No |
| epctex/appstore-scraper | iOS | $0.0001 per item plus $0.0003 per app query | per search query $0.005 | No |
| epctex/google-play-scraper | Play | $0.001 per app detail | per search $0.003 | No |

Two competitors already charge $0.0003 or less for a single store, so this actor does not claim to be the cheapest per app on Play or the cheapest on iOS list rows. The difference is that one actor covers both stores, top grossing, genre-filtered iOS charts and one output schema, with no start fee. Competitor prices and feature sets change; check their listings before relying on this table.

### Limits

- **Google Play search is shallow.** Measured on 2026-11-20: 13 apps for `todo` in the US and 30 for `photo editor` in GB. The page has no usable continuation token, so more coverage comes from more search terms, not from paging.
- **iOS search** returns up to 200 results per term. Apple does not honour an offset reliably, so the actor does not page search results.
- **iOS charts** come from Apple's legacy iTunes RSS feed, the only feed with top grossing and genre filtering. It returns at most 100 entries per feed and storefront. If it fails, the actor falls back to Apple's newer RSS v2 host (10 second timeout); v2 has no grossing feed and no genre filter.
- **Google Play charts** return up to 200 apps per chart and have no next page.
- **iOS lookups** are batched at up to 100 ids per request. When Apple drops ids from a batch, the actor retries the missing ids in smaller batches. iTunes requests are kept under 20 per minute per run.
- **Google Play details** run with at most 4 concurrent requests.
- **`maxItems`** (1 to 5000, default 50) is a global cap on delivered app rows across every term and store. Stores take turns, so a small cap does not starve the second store or the second term. Error rows are free and do not count against the cap.
- **Dotted ids with `store: both`** are genuinely ambiguous: `com.burbn.instagram` can be a Play package and an Apple bundle id. Both are tried and each hit is a separate row and a separate app event. Set `store` to `ios` or `play` if you know which one you want.
- **Undocumented Google Play internals.** The Play parsers read the page's embedded data blocks and the `vyAe2` chart RPC. They validate the shape they need and deliver an uncharged error row instead of partial data if Play changes the layout.

### Responsible use

This actor calls public, keyless endpoints that the stores' own web and app clients use. Both robots.txt files restrict some of these paths (Google Play disallows `/store/search`; itunes.apple.com disallows `/search`, `/*/rss/*` and `/*/lookup?`), while the iTunes Search API is Apple's published public API with guidance of about 20 calls per minute. Keep volumes modest, use the built-in rate limits, and respect the stores' terms of service and any rights they claim in the data. Do not use the output to republish app descriptions, screenshots or other store content as your own.

# Actor input Schema

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

search = find apps by keyword (up to 200 results per iOS term, about 30 per Play term). details = look up specific apps by id, URL, bundle id or package name. charts = today's top charts.

## `store` (type: `string`):

Which store to query. both interleaves the two stores so a small maxItems does not starve one of them.

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

One keyword per line, e.g. todo, photo editor, meditation. iOS returns up to 200 results per term; Google Play returns about 30 per term and has no paging. Search mode only.

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

Apps to look up when mode is details. One per line: apps.apple.com URLs, numeric App Store ids (id389801252 or 389801252), Apple bundle ids (com.burbn.instagram), play.google.com URLs or Play package names (com.instagram.android). With store=both a bare bundle id or package name is tried against both stores.

## `chartCollection` (type: `string`):

topFree and topPaid work on both stores. topGrossing is iOS-only on Apple's legacy feed; Google Play has its own grossing chart.

## `iosGenreId` (type: `string`):

Apple genre id to filter the iOS chart, e.g. 6014 for Games or 6007 for Productivity. Genre filtering works on the iOS legacy iTunes feed only; Google Play uses playCategory instead.

## `playCategory` (type: `string`):

Google Play chart category id: APPLICATION (default), GAME, GAME_ACTION, GAME_ARCADE, PRODUCTIVITY, TOOLS and so on.

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

Two-letter storefront: us, gb, de, my, sg, in, jp. Prices and currencies follow the storefront. uk is accepted as an alias for gb.

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

Language code for Google Play pages, e.g. en, de, pt-BR. iOS text follows the storefront. Each row carries the language the run used.

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

Google Play search and chart listings lack rating count, review count, version, update date and developer contacts. Turn this on to fetch each app's details page and fill them in (one extra request per app, still one app event). iOS rows are always full.

## `maxItems` (type: `integer`):

Global cap on delivered app rows across all terms and stores (1-5000). The default of 50 costs about $0.015. Error rows are never charged and do not count against this cap.

## `proxy` (type: `object`):

Off by default. Both stores answer direct requests from Apify; turn Apify Proxy on only if your runs get blocked. When it is on, a failed proxy setup fails the request instead of silently going direct.

## Actor input object example

```json
{
  "mode": "search",
  "store": "both",
  "searchTerms": [
    "todo"
  ],
  "chartCollection": "topFree",
  "playCategory": "APPLICATION",
  "country": "us",
  "language": "en",
  "fullDetails": false,
  "maxItems": 50,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

One dataset item per app, with search rank or chart rank when it came from a list. Rows with status/error are uncharged.

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

Delivered rows per source, error row count and the stop reason.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchTerms": [
        "todo"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("subimpact/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 = { "searchTerms": ["todo"] }

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

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

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

```

## CLI example

```bash
echo '{
  "searchTerms": [
    "todo"
  ]
}' |
apify call subimpact/app-store-scraper --silent --output-dataset

```

## MCP server setup

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