# App Store Scraper β iOS App Data, Reviews & ASO API (`logiover/app-store-data-api`) Actor
Unofficial App Store scraper & API. Export iOS app details, reviews, ratings, top charts and ASO keywords to CSV/JSON β no API key, no login.
- **URL**: https://apify.com/logiover/app-store-data-api.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Developer tools, SEO tools
- **Features:** Limited permissions
- **Stats:** 33 total users, 4 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $0.70 / 1,000 results
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 Scraper β iOS App Data, Reviews, Ratings & ASO API (No API Key)
    
Scrape the **Apple App Store** in one Actor β **app details, user reviews, rating histograms, top charts, similar apps, developer catalogs, ASO keyword suggestions, Apple Privacy Labels and full version history**. Get clean structured JSON straight from the public `apps.apple.com` and iTunes endpoints across any country storefront. **Ten endpoints (modes) share one input form**, and every result is tagged with `_mode` so you can mix modes in a single dataset. **Fast pure HTTP, no browser, no App Store Connect account, no API key, no login.**
> ### π Why this App Store scraper?
>
> **10 endpoints in one Actor** Β· **thousands of apps, reviews & keywords per run** Β· pure HTTP with ~3-second cold start (no browser) Β· any country storefront Β· export to JSON / CSV / Excel. The unofficial **Apple App Store API alternative** for ASO, app market intelligence, review monitoring and privacy research.
***
### β¨ What this Actor does / Key features
- π **10 App Store endpoints in one Actor** β `search`, `app`, `reviews`, `list`, `similar`, `developer`, `suggest`, `ratings`, `privacy`, `versionHistory`. Pick a mode, fill the fields it needs, run.
- π¦ **Full app details** β title, description, icon, screenshots, developer, genres, pricing, size, min iOS version, content rating, release & update dates and more.
- π¬ **User reviews** β up to ~500 reviews per app/storefront with reviewer name, star score, title, full text, date and app version, sorted by `RECENT` or `HELPFUL`.
- β **Rating histograms** β precise 1-star to 5-star breakdown plus total rating count (histogram-corrected for accuracy).
- π **Top charts** β top free, paid and grossing lists by category and device (iOS, iPad, Mac).
- π **Similar apps** β the "You Might Also Like" graph for any app, ideal for competitor discovery.
- π€ **Developer catalogs** β every app published by a developer via numeric `artistId`.
- π‘ **ASO keyword research** β App Store autocomplete `suggest` terms plus ranked `search` results to find and rank long-tail keywords.
- π **Apple Privacy Labels** β data collected, tracking and purposes for App Tracking Transparency, GDPR and CCPA reviews.
- π **Version history** β the full release-notes timeline for any app.
- π·οΈ **`_mode`-tagged output** β every row carries `_mode` and `scrapedAt`, so mixed datasets stay easy to filter and pivot.
- β‘ **Pure HTTP, no browser** β Node 20 native fetch, ~3-second cold start, 256 MB, batch app lookups at 5Γ concurrency.
- π€ **4 pre-built dataset views** β Overview, App catalog, Reviews and App details slice the data with no post-processing; export as JSON, CSV, Excel (XLSX), HTML, RSS or JSONLines.
### π Quick start (3 steps)
1. **Pick a mode** β open the Actor and choose a **Mode** (e.g. `search`, `reviews`, `list`). The input form shows which fields that mode uses.
2. **Fill the fields & run** β add a `query` for `search`/`suggest`, a numeric `id` or bundle `appId` for app-targeted modes, a `devId` for `developer`, or a `collection` for `list`. Set `country` and `language`, then click **Start**.
3. **Get your data** β open the **Output** tab and export to **JSON, CSV, Excel, HTML, RSS or JSONLines**, or pull it via the Apify API.
### π₯ Input
Every run needs a **`mode`**. The remaining fields depend on which mode you pick β the input form highlights the relevant ones. Here are three ready-to-run scenarios.
#### Example β search for meditation apps (ASO / market discovery)
```json
{
"mode": "search",
"query": "meditation",
"country": "us",
"language": "en-us",
"maxResults": 50
}
```
#### Example β newest reviews for an app (Spotify)
```json
{
"mode": "reviews",
"id": 324684580,
"country": "us",
"language": "en-us",
"maxResults": 500,
"reviewSort": "RECENT"
}
```
#### Example β top free games chart in Japan
```json
{
"mode": "list",
"collection": "TOP_FREE_IOS",
"category": "GAMES",
"country": "jp",
"language": "ja-jp",
"maxResults": 100
}
```
#### Example β Apple Privacy Labels for an app
```json
{
"mode": "privacy",
"appId": "com.spotify.client",
"country": "us"
}
```
| Field | Type | Description |
|-------|------|-------------|
| `mode` | string | **Required.** Which App Store endpoint to call: `search`, `app`, `reviews`, `list`, `similar`, `developer`, `suggest`, `ratings`, `privacy` or `versionHistory`. |
| `id` | integer | Numeric App Store ID (the digits after `id` in an App Store URL, e.g. `324684580`). Used by `app`, `reviews`, `similar`, `ratings`, `privacy`, `versionHistory`. |
| `ids` | array | Numeric App Store IDs for batch operations (adds to `id`). |
| `appId` | string | Reverse-DNS bundle ID, e.g. `com.spotify.client`. Alternative to numeric `id`. |
| `appIds` | array | Bundle IDs for batch operations. |
| `query` | string | Keyword to search in `search` mode, or partial term for `suggest` autocomplete. |
| `devId` | integer | Numeric developer `artistId` for `developer` mode (found as `developerId` in any app result). |
| `collection` | string | Top chart for `list` mode: `TOP_FREE_IOS`, `TOP_PAID_IOS`, `TOP_GROSSING_IOS`, `NEW_IOS`, plus iPad and Mac variants. |
| `category` | string | Optional category filter for `list` mode, e.g. `GAMES`, `BUSINESS`, `SOCIAL_NETWORKING`, `HEALTH_AND_FITNESS` (and game sub-categories). |
| `device` | string | Optional device class: `IPAD`, `MAC` or `ALL`. |
| `reviewSort` | string | Review order for `reviews` mode: `RECENT` or `HELPFUL`. |
| `country` | string | App Store storefront (ISO 3166-1 alpha-2), e.g. `us`, `gb`, `de`, `jp`, `tr`. The same app can differ per storefront. Applies to every mode. |
| `language` | string | BCP 47 language + region, e.g. `en-us`, `de-de`, `ja-jp`. Affects localized title, description and screenshots. |
| `maxResults` | integer | Max results. For `reviews` it is per-app (App Store cap 500); for `list`/`search`/`similar`/`developer` it is overall (App Store cap ~200). |
| `idsOnly` | boolean | For `search` mode: return only numeric app IDs (much faster) for bulk pipelines you enrich later via `app` mode. |
> **Numeric `id` vs bundle `appId`:** either works for most modes. Numeric `id` is supported everywhere; bundle `appId` works for `app`, `reviews`, `similar`, `ratings`, `privacy` and `versionHistory`. For `ratings` and `privacy` the Actor resolves the bundle ID to the numeric ID automatically.
### π€ Output
One row per result β every item is tagged with `_mode` and `scrapedAt`, exportable to JSON, CSV, Excel, HTML, RSS or JSONLines. Here is a trimmed `app`-mode sample record:
```json
{
"_mode": "app",
"id": 324684580,
"appId": "com.spotify.client",
"title": "Spotify: Music and Podcasts",
"url": "https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580",
"description": "Spotify is the best way to listen to music and podcastsβ¦",
"icon": "https://is1-ssl.mzstatic.com/image/thumb/β¦/512x512bb.jpg",
"developer": "Spotify",
"developerId": 324684583,
"developerUrl": "https://apps.apple.com/us/developer/spotify/id324684583",
"developerWebsite": "https://www.spotify.com",
"score": 4.79,
"reviews": 29841203,
"currentVersionScore": 4.79,
"currentVersionReviews": 29841203,
"price": 0,
"currency": "USD",
"free": true,
"primaryGenre": "Music",
"primaryGenreId": 6011,
"genres": ["Music", "Entertainment"],
"genreIds": ["6011", "6016"],
"contentRating": "4+",
"requiredOsVersion": "13.0",
"size": "289538048",
"version": "9.0.10",
"released": "2011-07-14T02:27:33Z",
"updated": "2026-07-02T18:03:10Z",
"releaseNotes": "We're always making changes and improvements to Spotifyβ¦",
"screenshots": ["https://β¦/1.jpg", "https://β¦/2.jpg"],
"scrapedAt": "2026-07-06T12:00:00Z"
}
```
π Full field reference (click to expand)
Fields vary by mode. The `app` mode returns the widest record; other modes return the subset relevant to them.
| Field | Description |
|-------|-------------|
| `_mode` | Which endpoint produced the row (`app`, `search`, `reviews`, `list`, `similar`, `developer`, `suggest`, `ratings`, `privacy`, `versionHistory`) |
| `id` | Numeric App Store ID |
| `appId` | Reverse-DNS bundle ID (e.g. `com.spotify.client`) |
| `title` / `url` / `description` | App name, App Store URL, full description |
| `icon` / `screenshots` / `ipadScreenshots` / `appletvScreenshots` | Icon URL and screenshot galleries |
| `developer` / `developerId` / `developerUrl` / `developerWebsite` | Publisher name, numeric artistId, App Store & marketing URLs |
| `score` / `reviews` | Overall star rating and total review count |
| `currentVersionScore` / `currentVersionReviews` | Rating & review count for the current version |
| `price` / `currency` / `free` | Price, ISO currency code, free flag (normalized) |
| `primaryGenre` / `primaryGenreId` / `genres` / `genreIds` | Primary genre and full genre lists |
| `contentRating` | Age / content rating (e.g. `4+`, `12+`) |
| `requiredOsVersion` / `supportedDevices` / `languages` / `size` | Min iOS version, supported devices, languages, size in bytes |
| `version` / `released` / `updated` / `releaseNotes` | Current app version fields; `versionHistory` mode returns one standalone row per release with `version`, `released` and `releaseNotes` |
| `histogram` / `ratings` | 1β
β5β
rating breakdown and total ratings count (`ratings` mode) |
| `reviewId` / `userName` / `score` / `title` / `text` / `date` / `version` | Review fields (`reviews` mode; the review's own id is exposed as `reviewId`) |
| `term` / `position` | Autocomplete term and its rank (`suggest` mode) |
| `data` / `privacyTypes` / `managePrivacyChoicesUrl` | Privacy Labels: categories collected + purposes, tracking types, privacy-choices URL (`privacy` mode) |
| `scrapedAt` | Scrape timestamp (ISO 8601) β on every item |
### π‘ Use cases
- **ASO & App Store optimization** β rank keywords with `search`, mine long-tail terms with `suggest`, and track competitor metadata, ratings and version changes over time.
- **App market intelligence** β bulk-ingest `app` details, top charts by country and rating histograms into dashboards and BI tools.
- **Review monitoring & sentiment** β pull reviews for your app or competitors, alert on 1-star spikes, and feed NPS / sentiment models.
- **Competitor discovery** β expand the `similar` graph and enumerate a rival's full catalog with `developer` mode.
- **Privacy & compliance research** β extract Apple Privacy Labels for GDPR / CCPA vendor reviews and App Tracking Transparency analysis.
- **AI agents & RAG** β wrap the Actor as a tool so an LLM can answer "what are the top fitness apps in Japan?" or embed app descriptions and reviews.
### π₯ Who uses it
iOS & mobile developers tracking their own metadata, ratings and reviews Β· ASO agencies & platforms mining keywords and rankings Β· app intelligence & market-research teams building competitor dashboards Β· product & growth teams monitoring competitor releases and sentiment Β· privacy, legal & compliance analysts auditing Apple Privacy Labels Β· data scientists and AI-agent builders needing structured Apple App Store data on demand.
### π° Pricing
This Actor runs on a simple **pay-per-result** model β you pay for the results you extract, with no separate Apify platform fees to calculate. Try it on the **free tier** first, then scale up. See the **Pricing** tab on this page for the current rate.
### β Frequently Asked Questions
**Is it legal to scrape the App Store?**
The Actor only collects publicly available data from `apps.apple.com` and the public iTunes endpoints. You are responsible for using the data in compliance with Apple's terms and applicable laws such as GDPR and CCPA.
**Is this an App Store API alternative or unofficial App Store API?**
Yes. It works as an unofficial Apple App Store API and API alternative β no App Store Connect account or paid plan required. You get structured JSON from publicly available `apps.apple.com` and iTunes data over fast HTTP.
**Do I need an Apple Developer account, API key or login?**
No. This is an unofficial scraper that reads publicly available data β you only need an Apify account. No App Store Connect account, no JWT, no API key, no login.
**How do I export App Store data to CSV or JSON?**
Run any mode and download the dataset as CSV, JSON, Excel (XLSX), HTML, RSS or JSONLines from the run page, or pull it via the Apify API. This makes it a simple App Store data export and iOS app dataset tool.
**How much data / how many results can I get?**
You can pull thousands of apps, reviews and keywords per run across modes. Two App Store caps apply: `reviews` returns up to ~500 per app per storefront (10 pages Γ ~50), and `list`/`search`/`similar`/`developer` return up to ~200 apps. To gather more reviews, run `reviews` across additional `country` storefronts and dedupe.
**Can I scrape App Store reviews without an API key?**
Yes. This Apple App Store reviews scraper reads the public review feed with no API key and no login β just pick `reviews` mode, set the app `id` and `country`, and run.
**Can I run several modes in one run?**
Each run executes one mode. To combine modes, call the Actor multiple times and join the datasets on `id`. Every item carries a `_mode` field, so mixed datasets stay easy to filter.
**Should I use the numeric `id` or the bundle `appId`?**
Either works for most modes. Numeric `id` (e.g. `324684580`) is supported everywhere; bundle `appId` (e.g. `com.spotify.client`) works for `app`, `reviews`, `similar`, `ratings`, `privacy` and `versionHistory`. For `ratings` and `privacy` the Actor resolves the bundle ID to the numeric ID automatically.
**Can I get App Store data for a specific country storefront?**
Yes. Set the `country` code (e.g. `us`, `gb`, `de`, `jp`, `tr`) to pull storefront-specific pricing, ratings, screenshots and top charts, since the same iOS app differs per region.
**How do I do App Store keyword research for ASO?**
Use `search` mode to rank keywords, then `suggest` mode to mine long-tail autocomplete terms straight from the App Store, exported as CSV or JSON for ASO analysis.
**Does this scraper return Apple Privacy Labels?**
Yes. `privacy` mode extracts each app's Apple Privacy Labels β data collected, tracking and purposes β for GDPR, CCPA and App Tracking Transparency research.
### π More ecommerce & marketplace scrapers by logiover
Building app or marketplace intelligence pipelines? Pair this App Store scraper with its closest siblings:
| Actor | What it does |
|---|---|
| π€ [Google Play Data API](https://apify.com/logiover/google-play-data-api) | The Android counterpart β Google Play app details, reviews, charts & data API |
| π¨ [Booking Hotel Prices Scraper](https://apify.com/logiover/booking-hotels-prices-scraper) | Booking.com hotel prices & availability |
| βοΈ [Google Flights Scraper](https://apify.com/logiover/google-flights-scraper) | Flight prices & routes from Google Flights |
| π‘ [Airbnb Scraper](https://apify.com/logiover/airbnb-scraper) | Airbnb listings, prices & availability |
| β [Trustpilot Reviews Scraper](https://apify.com/logiover/trustpilot-reviews-scraper) | Company reviews & ratings from Trustpilot |
| π [Lazada Scraper](https://apify.com/logiover/lazada-scraper) | Lazada product & price data across SE Asia |
| π―π΅ [Mercari Japan Scraper](https://apify.com/logiover/mercari-japan-scraper) | Mercari Japan marketplace listings & prices |
| π [Shopify Competitor Spy](https://apify.com/logiover/shopify-store-product-scraper) | Shopify store products, prices & catalog intel |
| π [Similarweb Scraper](https://apify.com/logiover/similarweb-scraper) | Website traffic & competitive analytics |
| π«π· [Leboncoin Scraper](https://apify.com/logiover/leboncoin-scraper) | Leboncoin classified ads & prices (France) |
π Browse all **[logiover scrapers on Apify Store](https://apify.com/logiover)** β 180+ actors across real estate, jobs, crypto, social media & B2B data.
### β Support & feedback
Found a bug or need an extra field or mode? Open an issue on the **Issues** tab β response is usually fast (typically within 24 hours). If this Actor saves you time, a **β
β
β
β
β
review** on the Store page genuinely helps and is hugely appreciated. π
### βοΈ Legal
This Actor extracts only publicly available data from `apps.apple.com` and public iTunes endpoints, and is intended for legitimate research, ASO, analytics and app-intelligence use. You are responsible for complying with Apple's terms of service, GDPR, CCPA and any applicable local laws.
***
This Actor is an independent tool. It is not affiliated with, endorsed by, or sponsored by App Store; App Store and all other trademarks mentioned here are the property of their respective owners.
### App Store scraping β frequently asked questions
#### Do I need a App Store API key, account or login?
No. This Actor reads publicly available pages and feeds, so there is nothing to register for and no credentials to manage.
#### How do I export App Store data to CSV, Excel, JSON or Google Sheets?
Open the **Storage** tab after a run and pick the format you want β CSV, Excel, JSON, XML or an HTML table. For Google Sheets, Airtable or a database, use the dataset URL or the Apify API so the sheet refreshes itself on every run.
#### Can I schedule this App Store scraper to run daily or hourly?
Yes. Use the **Schedules** tab and pick a cadence. Daily is enough for most tracking work; pick hourly only if the products you care about really do change that fast.
#### How many products can I get, and what does it cost?
See the volume section above for a measured figure. Billing is per result, so you pay for the rows you actually receive and a run that finds nothing costs nothing.
#### Is scraping App Store legal?
This Actor collects only information that App Store publishes publicly. It does not log in, does not defeat access controls and does not touch private data. You remain responsible for how you use the output, including under GDPR and similar rules where personal data is involved.
#### What happens if App Store blocks the run or changes its layout?
A refused exit IP is swapped for a fresh one within a quarter of a second and retried, and rate limiting is waited out rather than fought. If nothing gets through, the run **fails with the reason** instead of reporting success with zero rows β so an empty result always means "no matches", never "the source would not answer".
#### Can I use this with an AI agent, LangChain or an MCP client?
Yes. The Actor is callable over the Apify API and through Apify's MCP server, so an agent can run it and read the dataset back as a tool call.
### π Changelog
#### 2026-11-01
- Monthly health check (2026-11-01): a live run on the current build completed successfully and returned data. Input options, output fields and pricing are unchanged.
- README refreshed: 1 link to renamed Actors updated, 1 link to retired Actors removed; independence disclaimer added.
#### 2026-10-15
- A run that reaches its maximum cost per run now stops cleanly with its results saved and a status message, instead of ending as aborted.
- A proxy group your account cannot use no longer stops the run at start-up; it falls back to the default Apify Proxy.
- Memory is managed within the run's own limit, which removes a rare out-of-memory crash on large pages.
- The prefilled example for `maxResults` is now 500 (was 100).
- The default used when the field is left out for `maxResults` is now 500 (was 100).
#### 2026-09-23
- Fleet-wide quality audit. Verified end to end against live data and re-checked the input schema, the output columns and the run configuration.
- Output verified on a live run: 36 columns returned, 96.7% of cells populated.
- Run reliability reviewed: 100.0% of public runs succeeded in the last 30 days.
- Input schema, output schema and pricing configuration reviewed.
- Noted that 1 column(s) came back empty in this sample (`appletvScreenshots`); these are under review.
#### 2026-09-01
- Fleet-wide health check. Verified against this Actor's real run history: 30-day success rate, output row counts, per-field fill rates, and peak memory against the configured memory limit.
- Reviewed for the failure patterns that have cost this fleet runs β unguarded proxy setup, retry loops that can outlast the run's own time budget, and full-page HTML parsing that can exhaust a small container.
- No change to input, output fields or scraping logic.
#### 2026-08-11
- Maintenance release: refreshed the build and dependencies.
- Re-verified live execution, non-empty structured output and dataset field/type integrity.
- Reviewed reliability (retries, pagination) and output quality as part of a full-fleet QA pass.
#### 2026-08-01
- Completed the August 2026 full health check: verified empty/programmatic default, Console UI default, and two source-informed alternative inputs on Apify.
- Confirmed successful live execution, non-empty structured output, dataset-field/type integrity, and logical sample quality within the 5-minute quality window.
- Declared 39 dataset fields from typed live cloud samples so the output contract is no longer an empty placeholder.
- Repaired `versionHistory` by parsing Apple's current public serialized app-page data instead of waiting for a field app-store-scraper 0.18 no longer returns.
- Corrected the README contract to describe standalone version rows and added a live version-history health-check variation.
- Declared 39 nullable dataset fields from typed live cloud samples so the output contract is no longer an empty placeholder or brittle to sparse modes.
#### 2026-08-01 β Health-check remediation
- Repaired `versionHistory` against Apple's current public serialized page data; the retired npm field no longer causes successful-but-empty runs.
- Clarified that version history is returned as standalone release rows, not as a `versionHistory` array on app rows.
- The final four-input matrix verdict will be appended after post-build cloud revalidation.
#### 2026-07-06
- β¨ README overhaul: richer `app`-mode output sample with real field names, four ready-to-run example scenarios (search, reviews, top charts, privacy), a collapsible full field reference, ecommerce & marketplace sibling links, and clearer quick-start.
#### 2026-07-01
- Maintenance pass: re-verified end-to-end on live data and confirmed successful runs within the 5-minute quality window on the default input.
- Sharpened Store metadata (SEO title & description) and expanded the FAQ with high-intent, long-tail questions for easier discovery in Google and Apify Store search.
- Added ready-to-run example tasks that cover common real-world use cases.
#### 2026-06-15
- Reliability pass: re-verified end-to-end on live data with real-world inputs. Routine maintenance build.
#### 2026-06-07
- Docs: added coverage for App Store API alternative usage, exporting App Store data to CSV/JSON, and scraping Apple App Store reviews without an API key.
#### 2026-06-05
- Reliability fix: results are no longer dropped by strict output validation β runs complete cleanly at high volume.
- Stability & performance hardening; fresh rebuild.
#### 2026-06-04
- Verified live & refreshed build β reliability/maintenance pass.
***
\*Maintained: last verified 2026-11-01 β checked end-to-end against live run history (reliability, output fields and types, and time/memory budgets).
***
### Scheduling and integrations
Run this Actor on a schedule β hourly, daily or weekly β and have every run append to the same dataset, which is how you turn a one-off export into a time series. Results can be pushed straight into **Google Sheets**, **Slack**, **Zapier**, **Make**, **Airtable** or any **Webhook**.
# Changelog
This Actor's version history is a separate document: https://apify.com/logiover/app-store-data-api/changelog.md
# Actor input Schema
## `mode` (type: `string`):
Which App Store endpoint to call.
β’ **search** β keyword search (most common)
β’ **app** β full details for one or more apps
β’ **reviews** β user reviews with pagination
β’ **list** β top charts (free/paid/grossing) by category
β’ **similar** β apps similar to a given app
β’ **developer** β all apps by a developer (artistId)
β’ **suggest** β autocomplete suggestions (great for ASO keyword research)
β’ **ratings** β rating histogram (1-star to 5-star breakdown)
β’ **privacy** β Apple Privacy Labels (data collected, tracking, etc.)
β’ **versionHistory** β version-release history of an app
## `id` (type: `integer`):
Numeric App Store ID β the digits after `id` in the App Store URL. E.g. for `https://apps.apple.com/us/app/spotify/id324684580`, use `324684580`. Used by **app**, **reviews**, **similar**, **ratings**, **privacy**, **versionHistory** modes.
## `ids` (type: `array`):
Array of numeric App Store IDs for batch operations. Adds to (or replaces) the single ID field above.
## `appId` (type: `string`):
Reverse-DNS bundle identifier (e.g. `com.spotify.client`). Use this instead of `id` when you have the bundle ID handy.
## `appIds` (type: `array`):
Array of bundle IDs for batch operations.
## `query` (type: `string`):
Keyword to search for in **search** mode, or partial term for **suggest** mode autocomplete.
## `devId` (type: `integer`):
Numeric artistId of the developer (e.g. `324684580` for Spotify Ltd.). Find it as `developerId` in any app result for that publisher. Used by **developer** mode.
## `collection` (type: `string`):
Which top chart to fetch in **list** mode. Pick an iOS, iPad, or Mac chart.
## `category` (type: `string`):
Optional category filter for **list** mode. Leave as "All categories" for the overall top charts.
## `device` (type: `string`):
Optional device filter. Apple App Store has separate top-chart collections per device class.
## `reviewSort` (type: `string`):
How reviews are ordered when fetched from App Store RSS feed.
## `country` (type: `string`):
Determines the App Store storefront β the same app can have different pricing, availability, screenshots, and ratings per country. Leave on the default (United States) for the broadest catalog.
## `language` (type: `string`):
Interface / listing language (BCP 47 with region). Affects localized title, description, and screenshots. Leave on the default (English US) for the broadest coverage.
## `maxResults` (type: `integer`):
Maximum results to return. For **reviews** mode, this is per-app (App Store hard cap: 500). For **list / search / similar / developer** modes, this is overall (App Store hard cap: ~200). Leave on the default (100) for a fast, cheap run; raise it to pull more.
## `idsOnly` (type: `boolean`):
For **search** mode: if enabled, returns only numeric app IDs (much faster). Useful for bulk pipelines where you'll enrich via **app** mode afterwards.
## Actor input object example
```json
{
"mode": "search",
"id": 324684580,
"ids": [],
"appId": "com.spotify.client",
"appIds": [],
"query": "spotify",
"devId": 324684580,
"collection": "TOP_FREE_IOS",
"category": "",
"device": "",
"reviewSort": "RECENT",
"country": "us",
"language": "en-us",
"maxResults": 500,
"idsOnly": false
}
```
# Actor output Schema
## `results` (type: `string`):
Full results dataset. Switch between Overview, App catalog, Reviews, and App details views depending on which mode you ran.
# 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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"query": "whatsapp",
"maxResults": 500
};
// Run the Actor and wait for it to finish
const run = await client.actor("logiover/app-store-data-api").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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"query": "whatsapp",
"maxResults": 500,
}
# Run the Actor and wait for it to finish
run = client.actor("logiover/app-store-data-api").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 '{
"query": "whatsapp",
"maxResults": 500
}' |
apify call logiover/app-store-data-api --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"type": "http",
"url": "https://mcp.apify.com/?tools=fetch-actor-details,logiover/app-store-data-api"
}
}
}
```
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 ` 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/MKHPeDmdrCw8J9LQR/builds/BVuKqiOOzUNSP92p1/openapi.json