# Apple App Store Scraper (`solidcode/apple-app-store-scraper`) Actor

\[💰 $0.55 / 1K] Extract Apple App Store data at scale. Search by keyword or pull apps by URL/ID for full metadata: developer, ratings, price, version, screenshots, size. Add reviews per app across 50+ storefronts and 30+ languages. Clean JSON/CSV/Excel for ASO and market research.

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

## Pricing

from $0.55 / 1,000 app 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Apple App Store Scraper

Pull complete app metadata from the Apple App Store at scale — developer, average rating and total ratings count, price and currency, version and update history, file size, content rating, screenshots, supported languages, and full descriptions — across 50+ country storefronts and 30+ languages, with optional customer reviews. Built for ASO specialists, app marketers, and market researchers who need fresh, structured App Store data without manually opening one listing at a time.

### Why This Scraper?

- **50+ country storefronts in one actor** — pull region-specific price, currency, availability, and ranking from the US, UK, Germany, Japan, Brazil, India, and 45+ more, switching storefront with a single dropdown.
- **30+ localized languages** — get titles, descriptions, and category names in English, German, Japanese, Arabic, Chinese (Simplified & Traditional), and 25+ others to match your target market.
- **Lookup by App Store URL, numeric App ID, or bundle ID** — paste `https://apps.apple.com/...id493145008`, the bare ID `493145008`, or the bundle ID `com.getsomeheadspace.headspace`. Mix all three with keyword searches in one run.
- **Full 30-field app records in a single pass** — average rating + total ratings count, current-version rating count, price & currency, file size in bytes, content rating, minimum OS version, release and last-update dates, and primary genre, all on every row.
- **Up to ~500 customer reviews per app** — opt in to collect reviewer name, star rating, title, body, app version, and date, linked back to each app by App ID.
- **Sort reviews by most recent or most helpful** — surface the latest sentiment for release monitoring, or the highest-voted reviews for the issues users care about most.
- **Up to 200 apps per search term** — hits the App Store's own keyword ceiling; stack multiple terms to widen coverage in one job.
- **iPhone and iPad screenshot galleries** — separate `screenshotUrls` and `ipadScreenshotUrls` arrays, plus the high-resolution app icon, for competitive creative analysis.

### Use Cases

**App Store Optimization (ASO)**
- Track competitor titles, subtitles, and descriptions across localized storefronts
- Compare ratings and total ratings count to benchmark your app against category leaders
- Monitor version numbers and update cadence to spot competitor release patterns
- Audit screenshot and icon creative across markets

**Market & Category Research**
- Map the top 200 apps for any keyword to size a category
- Compare price and currency across 50+ storefronts to plan regional pricing
- Identify free vs. paid mix and content ratings within a niche
- Discover which languages and devices competitors support

**Competitor Tracking**
- Watch a fixed list of rival apps by bundle ID or App ID for version and rating changes
- Detect new releases entering your category by keyword
- Benchmark file size and minimum OS requirements against peers

**Review & Sentiment Mining**
- Pull the latest reviews to catch bugs and complaints after a release
- Collect most-helpful reviews to surface recurring feature requests
- Analyze star-rating distribution and review volume per market
- Feed review text into sentiment and topic-modeling pipelines

**Data Enrichment & Integration**
- Enrich an existing app catalog with current ratings, pricing, and metadata
- Power dashboards that track app performance over time
- Build alerting on version bumps or rating drops for tracked apps

### Getting Started

#### Simple Keyword Search

The simplest run — one keyword, default US storefront:

```json
{
    "searchTerms": ["meditation"],
    "maxResultsPerQuery": 50
}
````

#### Direct Lookup by URL, App ID, or Bundle ID

Pull exact apps with no search — mix all three input formats:

```json
{
    "appUrlsOrIds": [
        "https://apps.apple.com/us/app/headspace/id493145008",
        "493145008",
        "com.getsomeheadspace.headspace"
    ]
}
```

#### Localized Storefront

Get German-localized titles and EUR pricing from the German storefront:

```json
{
    "searchTerms": ["fitness", "photo editor"],
    "country": "de",
    "language": "de-DE",
    "maxResultsPerQuery": 100
}
```

#### Reviews-Enabled Advanced Run

Search, look up specific apps, and collect the most recent reviews for each:

```json
{
    "searchTerms": ["sleep"],
    "appUrlsOrIds": ["493145008"],
    "country": "us",
    "language": "en-US",
    "maxResultsPerQuery": 25,
    "includeReviews": true,
    "maxReviewsPerApp": 200,
    "reviewsSort": "mostRecent"
}
```

### Input Reference

#### What to Scrape

Fill in either or both — search terms discover apps by keyword, and direct inputs pull specific apps.

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchTerms` | string\[] | `["meditation"]` | Keywords to search the App Store (e.g. `meditation`, `photo editor`, `vpn`). Each term produces its own set of apps. |
| `appUrlsOrIds` | string\[] | `[]` | App Store page URLs, numeric App IDs, or bundle IDs. Each input returns one full-detail record. |

#### Localization

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `country` | select | `United States` | Storefront to pull from. Affects price, currency, availability, ranking, and review language. 50+ options across the Americas, Europe, Asia-Pacific, and MENA. |
| `language` | select | `English (US)` | Language used for localized titles, descriptions, and category names. 30+ options. |

#### Results

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResultsPerQuery` | integer | `50` | Maximum apps per search term. Set to `0` for as many as Apple returns. The App Store caps keyword search at 200 results per term. Ignored for direct URL/ID lookups. |

#### Reviews (optional)

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `includeReviews` | boolean | `false` | For each app found, also collect its customer reviews as separate rows linked by App ID. Slower and costs more. |
| `maxReviewsPerApp` | integer | `100` | Maximum reviews per app when reviews are enabled. Set to `0` for as many as possible. The App Store provides up to ~500 reviews per app per country. |
| `reviewsSort` | select | `Most recent` | Order in which reviews are collected: Most recent or Most helpful. |

### Output

Every row carries a `recordType` field — `app` or `review` — so you can filter cleanly downstream. Reviews are emitted only when `includeReviews` is on, each linked to its app by `appId`.

#### App (`recordType: "app"`)

```json
{
    "recordType": "app",
    "appId": 493145008,
    "bundleId": "com.getsomeheadspace.headspace",
    "appName": "Headspace: Sleep & Meditation",
    "appUrl": "https://apps.apple.com/us/app/headspace-sleep-meditation/id493145008",
    "developer": "Headspace Inc.",
    "developerId": 493145011,
    "developerUrl": "https://apps.apple.com/us/developer/headspace-inc/id493145011",
    "description": "Headspace is your guide to mindfulness for everyday life...",
    "releaseNotes": "We squashed some bugs and made performance improvements.",
    "version": "4.120.0",
    "price": 0.0,
    "currency": "USD",
    "formattedPrice": "Free",
    "rating": 4.8,
    "ratingCount": 912340,
    "ratingCountCurrentVersion": 12045,
    "contentRating": "4+",
    "primaryGenre": "Health & Fitness",
    "genres": ["Health & Fitness", "Lifestyle"],
    "iconUrl": "https://is1-ssl.mzstatic.com/image/.../512x512bb.png",
    "screenshotUrls": ["https://is1-ssl.mzstatic.com/image/.../screen1.png"],
    "ipadScreenshotUrls": ["https://is1-ssl.mzstatic.com/image/.../ipad1.png"],
    "minimumOsVersion": "15.0",
    "fileSizeBytes": 254839808,
    "languages": ["EN", "DE", "FR", "ES", "PT"],
    "supportedDevices": ["iPhone13", "iPadAir5"],
    "releaseDate": "2012-01-04T08:00:00Z",
    "currentVersionReleaseDate": "2026-06-12T15:30:00Z",
    "country": "us"
}
```

##### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"app"` |
| `appId` | number | Apple's numeric App (track) ID — the join key for reviews |
| `bundleId` | string | Reverse-DNS bundle identifier |
| `appName` | string | App title (localized to the chosen language) |
| `appUrl` | string | Canonical App Store listing URL |
| `description` | string | Full app description |
| `releaseNotes` | string | Release notes for the current version |
| `primaryGenre` | string | Primary category name |
| `genres` | string\[] | All category names the app appears in |
| `country` | string | Storefront the record was pulled from |

##### Developer

| Field | Type | Description |
|-------|------|-------------|
| `developer` | string | Developer / seller name |
| `developerId` | number | Apple's numeric developer (artist) ID |
| `developerUrl` | string | App Store developer page URL |

##### Ratings & Price

| Field | Type | Description |
|-------|------|-------------|
| `rating` | number | Average user rating (0–5) |
| `ratingCount` | number | Total number of ratings |
| `ratingCountCurrentVersion` | number | Ratings count for the current version only |
| `price` | number | Numeric price in the storefront's currency |
| `currency` | string | ISO currency code for the storefront |
| `formattedPrice` | string | Display price (e.g. `Free`, `$4.99`) |
| `contentRating` | string | Content advisory rating (e.g. `4+`, `12+`) |

##### Version, Media & Metadata

| Field | Type | Description |
|-------|------|-------------|
| `version` | string | Current version string |
| `minimumOsVersion` | string | Minimum OS version required |
| `releaseDate` | string | ISO date the app first launched |
| `currentVersionReleaseDate` | string | ISO date of the latest update |
| `fileSizeBytes` | number | App download size in bytes |
| `iconUrl` | string | High-resolution app icon URL |
| `screenshotUrls` | string\[] | iPhone screenshot URLs |
| `ipadScreenshotUrls` | string\[] | iPad screenshot URLs |
| `languages` | string\[] | Supported language codes (ISO) |
| `supportedDevices` | string\[] | Device models the app supports |

#### Review (`recordType: "review"`)

Emitted only when `includeReviews: true`. Up to ~500 per app per storefront.

```json
{
    "recordType": "review",
    "appId": 493145008,
    "appName": "Headspace: Sleep & Meditation",
    "reviewId": "11483920571",
    "title": "Life-changing for my anxiety",
    "content": "I've used this app every night for a year and my sleep has never been better.",
    "rating": 5,
    "author": "calm_seeker_99",
    "appVersion": "4.120.0",
    "voteSum": 42,
    "voteCount": 45,
    "date": "2026-06-20T09:14:00Z",
    "country": "us"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"review"` |
| `appId` | number | App ID this review belongs to (join key) |
| `appName` | string | Name of the reviewed app |
| `reviewId` | string | Unique review identifier |
| `title` | string | Review headline |
| `content` | string | Full review text |
| `rating` | number | Star rating (1–5) |
| `author` | string | Reviewer display name |
| `appVersion` | string | App version the review was written for |
| `voteSum` | number | Net helpfulness score |
| `voteCount` | number | Total helpfulness votes cast |
| `date` | string | ISO timestamp the review was posted or updated |
| `country` | string | Storefront the review came from |

### Tips for Best Results

- **Use bundle ID for exact matches.** Keyword search can miss or rank an app low; pasting the bundle ID (`com.company.app`) or App ID returns that exact app every time.
- **Pricing and reviews are region-specific.** Price, currency, and review language all follow the `country` storefront — run the same app across several storefronts to compare regional pricing, ratings, and sentiment.
- **Stack search terms to beat the 200-cap.** The App Store returns at most 200 apps per keyword. Use several specific terms (`meditation`, `sleep sounds`, `breathing`) instead of one broad term to widen coverage.
- **Sort by most recent for release monitoring.** After a competitor or your own update ships, `reviewsSort: "mostRecent"` surfaces the freshest feedback; switch to `mostHelpful` to see the issues users vote up most.
- **Keep `maxReviewsPerApp` modest for big runs.** Reviews multiply your row count and cost — ask for 50–100 per app when scanning many apps, and raise it only for the handful you want to study in depth.
- **Match `language` to `country`.** Pair `country: "jp"` with `language: "ja-JP"` to get fully localized Japanese titles and descriptions rather than English fallbacks.
- **Mix searches and direct lookups in one job.** Combine `searchTerms` for discovery with `appUrlsOrIds` for a tracked watchlist — you pay one start fee for both.

### Pricing

**From $0.55 per 1,000 apps** — charged per app collected, plus a small per-review rate when you enable reviews. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows the total app cost at each discount tier.

| Apps | No discount | Bronze | Silver | Gold |
|------|-------------|--------|--------|------|
| 100 | $0.11 | $0.09 | $0.075 | $0.055 |
| 1,000 | $1.10 | $0.90 | $0.75 | $0.55 |
| 10,000 | $11.00 | $9.00 | $7.50 | $5.50 |
| 100,000 | $110.00 | $90.00 | $75.00 | $55.00 |

Reviews are charged separately — **from $0.20 per 1,000 reviews** — and only when you enable reviews. The table below shows the total review cost at each discount tier:

| Reviews | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.04 | $0.033 | $0.027 | $0.020 |
| 1,000 | $0.40 | $0.33 | $0.27 | $0.20 |
| 10,000 | $4.00 | $3.30 | $2.70 | $2.00 |
| 100,000 | $40.00 | $33.00 | $27.00 | $20.00 |

**No compute or time-based charges — you pay per app (plus a small per-review rate when you enable reviews), plus a small fixed per-run start fee.** A "result" is any app row in your dataset; reviews are billed on their own per-review rate. See the Pricing tab for the live rates on your plan.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate app market research, ASO, competitor analysis, and review sentiment work. Users are responsible for complying with applicable laws and Apple's terms of service. Review text and reviewer names are user-generated public content — handle any personal data responsibly and in line with privacy regulations. Do not use extracted data for spam, harassment, or any illegal purpose. </content> </invoke>

# Actor input Schema

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

Keywords to search the App Store (e.g. `meditation`, `photo editor`, `vpn`). Each term produces its own set of apps. Leave empty if you only want to look up specific apps below.

## `appUrlsOrIds` (type: `array`):

App Store page URLs (e.g. `https://apps.apple.com/us/app/headspace/id493145008`), numeric App IDs (e.g. `493145008`), or bundle IDs (e.g. `com.getsomeheadspace.headspace`). Each input returns one full-detail record.

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

App Store storefront to pull from. Affects price, currency, availability, ranking, and the language of reviews.

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

Language used for localized titles, descriptions, and category names.

## `maxResultsPerQuery` (type: `integer`):

Maximum number of apps to collect per search term. Set to 0 for as many as Apple returns. Note: the App Store caps keyword search at 200 results per term — to gather more apps, use more specific terms. Ignored for direct URL/ID lookups (those always return one record each).

## `includeReviews` (type: `boolean`):

For each app found, also collect its customer reviews. Reviews are added as separate rows linked to the app by App ID. This adds extra work per app, so it is slower and costs more.

## `maxReviewsPerApp` (type: `integer`):

Maximum number of reviews to collect per app when reviews are enabled. Set to 0 for as many as possible. Note: the App Store provides at most about 500 reviews per app per country.

## `reviewsSort` (type: `string`):

Order in which reviews are collected. Only used when reviews are enabled.

## Actor input object example

```json
{
  "searchTerms": [
    "meditation"
  ],
  "appUrlsOrIds": [],
  "country": "us",
  "language": "en-US",
  "maxResultsPerQuery": 50,
  "includeReviews": false,
  "maxReviewsPerApp": 100,
  "reviewsSort": "mostRecent"
}
```

# Actor output Schema

## `overview` (type: `string`):

Compact table of scraped apps — name, developer, rating, price, and URL.

## `details` (type: `string`):

Full app metadata including genre, content rating, version, size, and update date.

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

Customer reviews collected when reviews are enabled — rating, title, author, and date, linked to each app.

# 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": [
        "meditation"
    ],
    "appUrlsOrIds": [],
    "country": "us",
    "language": "en-US",
    "maxResultsPerQuery": 50,
    "includeReviews": false,
    "maxReviewsPerApp": 100,
    "reviewsSort": "mostRecent"
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/apple-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": ["meditation"],
    "appUrlsOrIds": [],
    "country": "us",
    "language": "en-US",
    "maxResultsPerQuery": 50,
    "includeReviews": False,
    "maxReviewsPerApp": 100,
    "reviewsSort": "mostRecent",
}

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

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": [
    "meditation"
  ],
  "appUrlsOrIds": [],
  "country": "us",
  "language": "en-US",
  "maxResultsPerQuery": 50,
  "includeReviews": false,
  "maxReviewsPerApp": 100,
  "reviewsSort": "mostRecent"
}' |
apify call solidcode/apple-app-store-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=solidcode/apple-app-store-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Apple App Store Scraper",
        "description": "[💰 $0.55 / 1K] Extract Apple App Store data at scale. Search by keyword or pull apps by URL/ID for full metadata: developer, ratings, price, version, screenshots, size. Add reviews per app across 50+ storefronts and 30+ languages. Clean JSON/CSV/Excel for ASO and market research.",
        "version": "1.0",
        "x-build-id": "8wCjvCt9JcNtEHLxV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~apple-app-store-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-apple-app-store-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/solidcode~apple-app-store-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-apple-app-store-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/solidcode~apple-app-store-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-apple-app-store-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchTerms": {
                        "title": "Search Terms",
                        "type": "array",
                        "description": "Keywords to search the App Store (e.g. `meditation`, `photo editor`, `vpn`). Each term produces its own set of apps. Leave empty if you only want to look up specific apps below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "appUrlsOrIds": {
                        "title": "App URLs or IDs",
                        "type": "array",
                        "description": "App Store page URLs (e.g. `https://apps.apple.com/us/app/headspace/id493145008`), numeric App IDs (e.g. `493145008`), or bundle IDs (e.g. `com.getsomeheadspace.headspace`). Each input returns one full-detail record.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Country / Storefront",
                        "enum": [
                            "us",
                            "gb",
                            "ca",
                            "au",
                            "nz",
                            "ie",
                            "de",
                            "fr",
                            "es",
                            "it",
                            "nl",
                            "be",
                            "at",
                            "ch",
                            "pt",
                            "lu",
                            "dk",
                            "fi",
                            "is",
                            "no",
                            "se",
                            "pl",
                            "cz",
                            "sk",
                            "hu",
                            "ro",
                            "bg",
                            "gr",
                            "tr",
                            "jp",
                            "kr",
                            "cn",
                            "hk",
                            "tw",
                            "sg",
                            "my",
                            "th",
                            "id",
                            "ph",
                            "vn",
                            "in",
                            "br",
                            "mx",
                            "ar",
                            "cl",
                            "co",
                            "pe",
                            "za",
                            "eg",
                            "il",
                            "ae",
                            "sa",
                            "ru",
                            "ua"
                        ],
                        "type": "string",
                        "description": "App Store storefront to pull from. Affects price, currency, availability, ranking, and the language of reviews.",
                        "default": "us"
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en-US",
                            "en-GB",
                            "nl-NL",
                            "de-DE",
                            "fr-FR",
                            "es-ES",
                            "it-IT",
                            "pt-PT",
                            "pt-BR",
                            "pl-PL",
                            "cs-CZ",
                            "da-DK",
                            "sv-SE",
                            "nb-NO",
                            "fi-FI",
                            "el-GR",
                            "tr-TR",
                            "ar-SA",
                            "he-IL",
                            "ja-JP",
                            "ko-KR",
                            "zh-Hans-CN",
                            "zh-Hant-TW",
                            "th-TH",
                            "vi-VN",
                            "id-ID",
                            "ms-MY",
                            "hi-IN",
                            "ru-RU",
                            "uk-UA",
                            "ro-RO",
                            "hu-HU"
                        ],
                        "type": "string",
                        "description": "Language used for localized titles, descriptions, and category names.",
                        "default": "en-US"
                    },
                    "maxResultsPerQuery": {
                        "title": "Max Results per Search Term",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of apps to collect per search term. Set to 0 for as many as Apple returns. Note: the App Store caps keyword search at 200 results per term — to gather more apps, use more specific terms. Ignored for direct URL/ID lookups (those always return one record each).",
                        "default": 50
                    },
                    "includeReviews": {
                        "title": "Include Customer Reviews",
                        "type": "boolean",
                        "description": "For each app found, also collect its customer reviews. Reviews are added as separate rows linked to the app by App ID. This adds extra work per app, so it is slower and costs more.",
                        "default": false
                    },
                    "maxReviewsPerApp": {
                        "title": "Max Reviews per App",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of reviews to collect per app when reviews are enabled. Set to 0 for as many as possible. Note: the App Store provides at most about 500 reviews per app per country.",
                        "default": 100
                    },
                    "reviewsSort": {
                        "title": "Sort Reviews By",
                        "enum": [
                            "mostRecent",
                            "mostHelpful"
                        ],
                        "type": "string",
                        "description": "Order in which reviews are collected. Only used when reviews are enabled.",
                        "default": "mostRecent"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
