# Apple App Store Scraper: App Details, Reviews, Search (`datagleaner/app-store-scraper`) Actor

Apple App Store scraper: app details, customer reviews, keyword search and developer apps for any country. Reviews filtered by stars, date, keyword and version. Developer website in every app row. No login.

- **URL**: https://apify.com/datagleaner/app-store-scraper.md
- **Developed by:** [Data Gleaner](https://apify.com/datagleaner) (community)
- **Categories:** Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Apple App Store Scraper: App Details, Reviews, Search

An Apple App Store scraper for app details, customer reviews, keyword search and developer portfolios, in one Actor. Pull **app details** by App Store ID, bundle ID or URL (rating, rating count, price, version, update date, category, screenshots, and the **developer website** in every row), **App Store reviews** with star, date, keyword and version filters, **ranked search results** by keyword and everything a **developer** publishes. Plain HTTP against Apple's public iTunes Search/Lookup API and review feed: no browser, no login, no Apple ID, no API key. Any of Apple's storefronts, and several countries in one run.

It costs **$0.0003 per app** and **$0.0001 per review** ($0.30 per 1,000 apps, $0.10 per 1,000 reviews), with no start fee and no separate platform charge. Filtered-out reviews and apps that do not exist are never billed.

### What does Apple App Store Scraper do?

It returns the data a visitor sees on the App Store, through the Apify dataset and API as JSON, CSV or Excel. Typical uses:

- **App review monitoring:** pull the newest reviews of your app every day, or only the 1-star ones with `reviewScore: 1`, with title, text, stars, version and helpful votes. `reviewsLastDays: 1` returns only the past day and stops reading as soon as it reaches older reviews, so a daily monitor is a request or two. Send new complaints to Slack, email or a ticket system.
- **Release checks:** `reviewVersions: ["9.1"]` keeps reviews of one version, and `reviewKeywords: ["crash", "refund", "login"]` keeps only reviews that mention those words in the title or text.
- **ASO and competitor tracking:** search a keyword and record which apps rank where (`position`), with rating, rating count, price, category and last update. Schedule it daily to see rank, rating and release-cadence changes over time, in any country.
- **Market and category research:** list the apps for `habit tracker`, `invoice maker` or `period tracker` with rating counts, price, category and release dates before you build. `developerIds` lists everything a competitor publishes.
- **Country comparison:** `country: "US, GB, DE, JP"` runs the same keywords, apps and reviews in each storefront and stamps every row with its country, so you can compare prices, ratings and rankings by market.
- **Voice of customer:** feed thousands of reviews of a competitor into your own analysis or an LLM to find what users ask for and complain about.
- **Lead lists from apps:** every app row carries `developerWebsite` and `sellerName`, so a keyword search becomes a list of companies with their sites (see below).
- **AI agents and apps:** feed live App Store data into an agent or product.

### Developer websites and contacts

Every app record has a `developerWebsite` field: the website Apple lists for the app's seller (for most apps; it is `null` when the developer left it empty). Pass those websites to [Website Contact Details Scraper](https://apify.com/datagleaner/website-contact-details-scraper) to get emails, phones and social profiles for the companies behind a search or a category:

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("datagleaner/app-store-scraper").call(run_input={"searchQueries": ["habit tracker"], "maxItems": 50})
sites = sorted({a["developerWebsite"] for a in client.dataset(run.default_dataset_id).iterate_items() if a.get("developerWebsite")})
contacts = client.actor("datagleaner/website-contact-details-scraper").call(run_input={"websites": sites})
for row in client.dataset(contacts.default_dataset_id).iterate_items():
    print(row)
```

You can also give Website Contact Details Scraper this Actor's `datasetId` and set its `datasetUrlField` to `developerWebsite`. Apps without a website then fall back to the App Store page, so the Python route above, which skips them, is the cleaner one. For a developer's other emails and socials across the App Store, Google Play, Steam and Chrome Web Store, use [App Developer Email Finder](https://apify.com/datagleaner/app-developer-email-finder).

### Input

| Field | Meaning |
|---|---|
| `appIds` | **Details mode.** Numeric App Store IDs (`324684580`), bundle IDs (`com.spotify.client`) or App Store URLs. One app record each, looked up in batches. Apps that do not exist in the chosen country are skipped and not charged. |
| `searchQueries` | **Search mode.** Keywords as typed in the App Store. Up to `maxItems` apps per keyword in store rank order, with full details. |
| `developerIds` | **Developer mode.** A developer name as shown on the App Store (`Spotify AB`), a numeric developer ID, or a developer page URL. Returns the apps that developer publishes, each record with `developerQuery`. |
| `reviewAppIds` | **Reviews mode.** Apps whose reviews to fetch, as IDs, bundle IDs or URLs, up to `maxReviews` each per country. Returns review records only (no app record). |
| `maxItems` | Apps per search keyword or developer, per country, default 30, up to 200 (the most the App Store API returns for one keyword). |
| `maxReviews` | Reviews to keep per app and country after filters, default 100, up to 500. Apple's review feed holds the newest 500 reviews of an app in each country; list several countries for more. |
| `reviewSort` | `newest` (default, best for monitoring) or `helpful`. |
| `reviewScore` | Optional, 1 to 5. Only reviews with exactly that many stars. |
| `reviewsSince` | Optional date, `YYYY-MM-DD`. Skips older reviews. With `reviewSort: "newest"` the Actor stops reading at the first older page. |
| `reviewsLastDays` | Optional number of days, for example `7`. If you also set `reviewsSince`, the later cut-off applies. |
| `reviewKeywords` | Optional list of words. Keeps reviews whose title or text contains any of them (case-insensitive). You pay only for the matches. |
| `reviewVersions` | Optional list of version prefixes. `9.1` matches `9.1.90`. |
| `country`, `language` | Store country (`US`, `GB`, `DE`, `JP`) or several separated by commas (`US, GB, DE`), and language (`en`, `de`, `pt-BR`). Country changes prices, availability, ratings and which reviews appear. |
| `entity` | What search and developer mode return: `software` (iPhone and iPad apps, default), `iPadSoftware` or `macSoftware`. |
| `requestDelaySecs` | Pacing between requests, default 0.5. |
| `proxyConfiguration` | Optional, off by default. |

With no input at all, the Actor runs a built-in example (1 app, 2 search results for `habit tracker`, 2 reviews) and says so in the run's status message. If you already call another App Store Actor, these input names are also accepted: `startUrls`, `queries`, `searchTerms`, `countryCode`, `countries`, `languageCode`, `maxResults`, `sortBy`, `maxReviewsPerApp`.

App details and a keyword search in one run:

```json
{
  "appIds": ["https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580", "com.apple.dt.Xcode"],
  "searchQueries": ["habit tracker"],
  "maxItems": 30,
  "country": "US",
  "language": "en"
}
```

The same keyword in three countries (one set of records per country):

```json
{ "searchQueries": ["habit tracker"], "maxItems": 25, "country": "US, GB, DE" }
```

Reviews of two apps, newest first:

```json
{
  "reviewAppIds": ["324684580", "com.burbn.instagram"],
  "maxReviews": 200,
  "reviewSort": "newest"
}
```

Only the 1-star reviews of an app:

```json
{ "reviewAppIds": ["324684580"], "reviewScore": 1, "maxReviews": 100 }
```

Daily monitor: new reviews from the last day that mention a problem word.

```json
{ "reviewAppIds": ["324684580"], "reviewsLastDays": 1, "reviewKeywords": ["crash", "bug", "refund"], "reviewSort": "newest" }
```

Everything a developer publishes:

```json
{ "developerIds": ["Spotify AB"], "maxItems": 50 }
```

### Output

Every record has `source` (`appIds`, `search`, `developer` or `reviews`), `country`, `language` and `scrapedAt`. App records:

```json
{
  "type": "app",
  "appId": 324684580,
  "trackId": 324684580,
  "bundleId": "com.spotify.client",
  "title": "Spotify: Music and Podcasts",
  "description": "With the Spotify app, you can explore an extensive library of music and podcasts for free...",
  "developer": "Spotify",
  "sellerName": "Spotify",
  "developerId": 324684583,
  "developerUrl": "https://apps.apple.com/us/developer/spotify/id324684583",
  "developerWebsite": "https://www.spotify.com/",
  "rating": 4.77,
  "ratingCount": 42671055,
  "currentVersionRating": 4.77,
  "currentVersionRatingCount": 42671055,
  "price": 0.0,
  "currency": "USD",
  "formattedPrice": "Free",
  "free": true,
  "genre": "Music",
  "genreId": 6011,
  "genres": [
    "Music",
    "Entertainment"
  ],
  "released": "2011-07-14T11:22:37+00:00",
  "updated": "2026-10-19T13:57:56+00:00",
  "version": "9.1.92",
  "contentRating": "12+",
  "recentChanges": "We're always making changes and improvements to Spotify. ...",
  "minimumOsVersion": "16.1",
  "fileSizeBytes": 323621888,
  "languages": [
    "AF",
    "AM",
    "AR"
  ],
  "supportedDevices": [
    "iPhone5s-iPhone5s",
    "iPadAir-iPadAir"
  ],
  "features": [
    "iosUniversal"
  ],
  "isGameCenterEnabled": false,
  "kind": "software",
  "url": "https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580",
  "icon": "https://is1-ssl.mzstatic.com/image/thumb/Purple211/v4/b7/ed/61/b7ed610...",
  "screenshots": [
    "https://is1-ssl.mzstatic.com/image/thumb/PurpleSource211/v4/f3/ce/05/f..."
  ],
  "ipadScreenshots": [
    "https://is1-ssl.mzstatic.com/image/thumb/PurpleSource211/v4/31/15/15/3..."
  ],
  "source": "appIds",
  "searchQuery": null,
  "position": null,
  "inputUrl": "https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580",
  "developerQuery": null,
  "country": "US",
  "language": "en",
  "scrapedAt": "2026-10-21T08:00:00+00:00"
}
```

Search records carry `searchQuery` and `position` (the rank within that keyword), developer-mode records carry `developerQuery` and `position`. `appId` and `trackId` are the same number. The field names match [Google Play Scraper](https://apify.com/datagleaner/google-play-scraper) where the data is the same (`title`, `developer`, `developerWebsite`, `rating`, `ratingCount`, `price`, `genre`, `updated`, `version`, `url`, `icon`, `screenshots`), so one pipeline can read both stores.

Review records:

```json
{
  "type": "review",
  "reviewId": "14685076517",
  "appId": 324684580,
  "userName": "Ackerly9",
  "userUrl": "https://itunes.apple.com/us/reviews/id561127545",
  "title": "Freezing",
  "text": "The app always freezes and plays the same songs on dj mode",
  "score": 1,
  "thumbsUp": 0,
  "voteCount": 0,
  "version": "9.1.90",
  "at": "2026-10-19T11:19:04+00:00",
  "source": "reviews",
  "inputUrl": "324684580",
  "reviewSort": "newest",
  "country": "US",
  "language": "en",
  "scrapedAt": "2026-10-21T08:00:00+00:00"
}
```

The dataset has an **Apps** view and a **Reviews** view with the main columns.

#### Which fields are filled

- **Always, on every app record:** `appId`, `bundleId`, `title`, `developer`, `sellerName`, `developerId`, `developerUrl`, `price`, `currency`, `free`, `genre`, `version`, `released`, `updated`, `contentRating`, `url`, `icon`, `source`, `scrapedAt`.
- **Sometimes empty by nature:** `developerWebsite` is empty when the developer did not list one. `rating` and `currentVersionRating` are empty for apps without ratings yet. `recentChanges` is empty when the developer wrote no release notes.
- **Reviews:** `reviewId`, `userName`, `title`, `score`, `version` and `at` are always there. `thumbsUp` is the net helpful votes and `voteCount` all votes on the review.

### Related Data Gleaner Actors

- [Website Contact Details Scraper](https://apify.com/datagleaner/website-contact-details-scraper): emails, phones and social profiles from the `developerWebsite` of the apps in your results.
- [App Developer Email Finder](https://apify.com/datagleaner/app-developer-email-finder): developer email, website and socials for App Store, Google Play, Steam and Chrome Web Store apps.
- [Google Play Scraper](https://apify.com/datagleaner/google-play-scraper): the same app details, reviews and search for Android, with the same filters.

### Pricing

Pay per event, two events, and nothing else: **$0.0003 per app record** ($0.30 per 1,000) and **$0.0001 per review record** ($0.10 per 1,000). There is no start fee and no extra charge for compute or proxies. An app record is any app pushed to the dataset, whether it came from `appIds`, a keyword search or a developer page. You pay only for records pushed: apps that do not exist cost nothing, and reviews removed by `reviewScore`, `reviewsSince`, `reviewsLastDays`, `reviewKeywords` or `reviewVersions` cost nothing. The run stops at your maximum charge.

Worked examples:

- 3 keywords at 30 apps each (90 apps) plus the 200 newest reviews of 5 apps (1,000 reviews): 90 x $0.0003 + 1,000 x $0.0001 = **$0.127**. Run daily for 30 days that is about $3.80.
- The same 3 keywords in 4 countries (360 apps): **$0.108**.
- A daily review monitor: `reviewsLastDays: 1` on 10 apps with about 30 new reviews each is 300 reviews, **$0.03 a day**, about $0.90 a month.
- A developer's full catalogue of 40 apps: **$0.012**.
- A 10-app test run costs $0.003.

#### How this compares

App Store Actors on the Apify Store range from about $0.0001 per review to a few thousandths of a dollar per app, and many do only one job: app details, or search, or reviews. This Actor's case is one input format, one dataset schema and one bill for app details, keyword search, developer pages and reviews, at a price in the same range as the cheapest of them, with date, keyword, star and version filters on reviews that only bill the reviews you keep.

### Use it from the API

Run it synchronously and get the records back as JSON. Replace `<YOUR_APIFY_TOKEN>` with your token.

```bash
curl -X POST "https://api.apify.com/v2/acts/datagleaner~app-store-scraper/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"reviewAppIds": ["324684580"], "maxReviews": 50, "reviewSort": "newest"}'
```

It also works from n8n, Make or Zapier through the Apify integrations, since the output is a flat JSON record.

### Use with Python

`pip install apify-client`, set the `APIFY_TOKEN` environment variable, and run. This input returns 20 one-star reviews, about $0.002.

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("datagleaner/app-store-scraper").call(run_input={
    "reviewAppIds": ["324684580"],
    "maxReviews": 20,
    "reviewScore": 1,
})
for review in client.dataset(run.default_dataset_id).iterate_items():
    print(review["at"], review["score"], review["title"], review["text"])
```

### Use with JavaScript / Node.js

`npm install apify-client`, set `APIFY_TOKEN`, and run it as an ES module (`.mjs`).

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('datagleaner/app-store-scraper').call({
    searchQueries: ['habit tracker'],
    maxItems: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const app of items) console.log(app.position, app.title, app.rating, app.developerWebsite);
```

### Use it from n8n, Make, Zapier or an AI agent

Actor ID: `datagleaner/app-store-scraper`

Minimal input:

```
{"searchQueries": ["habit tracker"], "maxItems": 10}
```

Each tool below runs this Actor with your own Apify API token.

- **n8n:** add the **Apify** node (`@apify/n8n-nodes-apify`). On n8n Cloud you install it from the community node registry. Choose **Run an Actor and get dataset**, set Actor to `datagleaner/app-store-scraper` and paste the input above.
- **Make:** use the Apify app's **Run an Actor** module, then **Get Dataset Items** to read the results. **Watch Actor Runs** can trigger a scenario when a run finishes.
- **Zapier:** use the Apify action **Run Actor**, then the search **Fetch dataset items**. The trigger **Finished Actor run** starts a Zap when a run ends.
- **AI agents (MCP):** connect to `https://mcp.apify.com?tools=datagleaner/app-store-scraper`. In Claude Code:

  ```
  claude mcp add --transport http apify "https://mcp.apify.com?tools=datagleaner/app-store-scraper"
  ```

  Then run `/mcp` to sign in to Apify in your browser. Then ask in plain language, for example: "Get the 50 newest 1-star App Store reviews of Spotify and summarise the top complaints." An agent without the Actor preloaded can find it with Apify's `search-actors` tool by searching "app store".
- **LangChain (Python):**

```python
## pip install langchain-apify, then set APIFY_TOKEN in your environment
import json
from langchain_apify import ApifyActorsTool
tool = ApifyActorsTool("datagleaner/app-store-scraper")
result = tool.invoke({"run_input": json.loads('{"reviewAppIds": ["324684580"], "maxReviews": 20}')})
```

### Limits

- **Reviews come from Apple's public review feed.** It holds the newest 500 reviews of an app in each country (10 pages of 50), so `maxReviews` stops at 500 per app and country. For more, list several countries. Apple's feed has no star filter and no sort by rating, so `reviewScore` is applied after reading: a rare star level can return fewer than you asked for within the 500. The feed has no developer replies, and a review the reviewer edited shows its latest edit date.
- **Search returns up to 200 apps per keyword and country.** Use several related keywords for wider coverage.
- **No rating histogram.** Apple's API gives the average and the count, not the split by stars.
- **Developer websites** are what the developer lists with Apple; most apps have one, some do not.
- **Prices and ratings depend on country.** Set `country` to the market you care about.
- **Rankings and numbers change by the minute.** Schedule runs and compare `scrapedAt`.
- At very high volume Apple may start refusing requests. The Actor backs off, refreshes its connection and finishes what it has. Enable `proxyConfiguration` if that happens.
- Apple changes its API now and then. If a field starts coming back empty, report it and it will be fixed.

### FAQ

**Is there an official App Store API for this?** Apple's App Store Connect API only gives you data about your own apps. This Actor reads Apple's public search, lookup and review feeds instead, so it works for any app, yours or a competitor's.

**How do I monitor new reviews?** Schedule the Actor daily with `reviewSort: "newest"` and `reviewsLastDays: 1`, and use `reviewId` to skip the ones you have seen. Add `reviewScore: 1` to watch only complaints.

**How do I track keyword rankings?** Run `searchQueries` daily for your keywords and store `position` for your app and its rivals. `position` is the 1-based store rank for that keyword in that country.

**Where do I find an app's ID?** It is the number after `id` in the App Store link: `https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580` is `324684580`. A bundle ID such as `com.spotify.client` works too.

**Can I get the developer's email?** Apple does not publish developer emails. The app record gives `developerWebsite`; run [Website Contact Details Scraper](https://apify.com/datagleaner/website-contact-details-scraper) on it for emails, phones and socials.

**How do I find competitors of my app?** Search the keywords your app targets, and put a rival's developer name in `developerIds` for everything they publish.

**Which countries work?** Any two-letter storefront Apple serves. Give one or several, for example `US, GB, DE`.

**What happens when an app is not available in a country?** It is skipped and not charged; the log says which app.

**Do I need a proxy?** No, it works without one on Apify in testing. A proxy option is there for very high volume.

### Responsible use

This Actor reads publicly visible App Store data without logging in. Use the data in line with Apple's terms. App records are business data. Reviews contain the display names and text that users posted publicly; if you store or combine them with other data about individuals, the data-protection obligations are yours.

# Actor input Schema

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

Details mode: numeric App Store IDs (`324684580`), bundle IDs (`com.spotify.client`) or App Store URLs (`https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580`). Each returns one app record. Apps that do not exist in the chosen country are skipped and not charged.

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

Search mode: keywords as you would type them in the App Store, e.g. `habit tracker`. Each returns up to `maxItems` apps in store rank order, with full details.

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

Developer mode: a developer name as shown on the App Store (`Spotify AB`), a numeric developer ID (`324684583`) or a developer page URL (`https://apps.apple.com/us/developer/spotify/id324684583`). Returns the apps that developer publishes, up to `maxItems`. Records carry `developerQuery`.

## `reviewAppIds` (type: `array`):

Reviews mode: apps whose customer reviews to fetch, as numeric IDs, bundle IDs or URLs. Returns review records only (no app record), up to `maxReviews` each per country. Narrow them with `reviewScore`, `reviewsSince`, `reviewsLastDays`, `reviewKeywords` and `reviewVersions`.

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

Stops after this many apps for each keyword in `searchQueries` and each developer in `developerIds`, per country. The App Store API returns at most 200 results per keyword.

## `maxReviews` (type: `integer`):

Reviews to keep for each app in `reviewAppIds` and each country (after filters). Apple's review feed holds the newest 500 reviews of an app per country (10 pages of 50), so 500 is the most one app and country can return; list several countries in `country` for more.

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

Order of the reviews: newest first (best for monitoring) or most helpful first. Apple's feed has no sort by rating; use `reviewScore` to keep one star level.

## `reviewScore` (type: `integer`):

Optional. Keep only reviews with exactly this star rating, e.g. `1` to monitor complaints. Leave empty for all ratings.

## `reviewsSince` (type: `string`):

Optional. `YYYY-MM-DD` (or ISO date-time, UTC if no zone). Skips older reviews; with newest-first sort the run also stops reading at the first older page, so a daily monitor costs one or two requests.

## `reviewsLastDays` (type: `integer`):

Optional. For example `7` for the past week. If you also set a date, the later cut-off applies.

## `reviewKeywords` (type: `array`):

Optional. Keeps reviews whose title or text contains any of the words, case-insensitive, e.g. `crash`, `refund`, `login`. Only matching reviews are returned and charged.

## `reviewVersions` (type: `array`):

Optional. Keeps reviews whose app version starts with one of these, e.g. `9.1` matches `9.1.90.2270`. Use it to check a release.

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

Two-letter country code of the App Store to read, e.g. `US`, `GB`, `DE`, `JP`. Give several separated by commas (`US, GB, DE`) to run every mode in each store: one set of records per country. It changes prices, availability, ratings and which reviews appear.

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

Language code for store text, e.g. `en`, `de`, `ja`, `pt-BR`. Changes localised fields such as category names; review text stays in the language it was written in.

## `entity` (type: `string`):

Which apps keyword search and developer mode return. App IDs always resolve to whatever the ID is.

## `requestDelaySecs` (type: `number`):

Polite pacing. Lower is faster and raises the chance of being blocked.

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

Optional. Off by default: Apple's API answered Apify datacenter IPs in testing. Enable a proxy if runs start getting blocked at high volume.

## Actor input object example

```json
{
  "appIds": [
    "https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580"
  ],
  "maxItems": 30,
  "maxReviews": 100,
  "reviewSort": "newest",
  "country": "US",
  "language": "en",
  "entity": "software",
  "requestDelaySecs": 0.5
}
```

# Actor output Schema

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

No description

## `reviews` (type: `string`):

No description

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

// Run the Actor and wait for it to finish
const run = await client.actor("datagleaner/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 = { "appIds": ["https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580"] }

# Run the Actor and wait for it to finish
run = client.actor("datagleaner/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 '{
  "appIds": [
    "https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580"
  ]
}' |
apify call datagleaner/app-store-scraper --silent --output-dataset

```

## MCP server setup

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