# Apple App Store Scraper — iOS App Reviews & Details (`freshactors/app-store-scraper`) Actor

Reliable, always-fresh Apple App Store data: app details, search, and customer reviews. Monitored daily, throttle-resistant. By FreshActors.

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

## Pricing

from $1.30 / 1,000 app details fetcheds

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

## Apple App Store Scraper — iOS App Reviews, Details & Keyword Search

Scrape **Apple App Store** and **iOS app** data — full **app details**, ranked keyword **search**, and customer **reviews & ratings** — as clean, structured JSON, with no account, no login, no API key, and **no per-run start fee**. All three modes in one actor.

![App Store Scraper example output — 32 structured fields](https://raw.githubusercontent.com/Freshactors/freshactors-assets/main/appstore-screenshot.png)

> ✅ **Last verified working: 2026-11-11.** This Apple App Store scraper is monitored by an automated daily canary. When Apple changes something, we patch fast and note it in the changelog below — so your data pipeline doesn't silently break.

***

### Why this Apple App Store scraper

If you've used other App Store scrapers, you've probably hit the "stopped working / returns nothing" problem. The usual cause: most scrapers depend on Apple's legacy review RSS feed, which **silently returns an empty `200` response when it's rate-limited**. Your job "succeeds," your dataset is empty, and nobody finds out until a dashboard goes blank. This actor is built to avoid exactly that.

- **Throttle-resistant reviews.** We detect Apple's empty-but-`200` throttle response and **retry with backoff and proxy rotation** — and, when the app provably has reviews, wait out a short outage — instead of reporting a false "0 reviews." Reviews come from Apple's public review feed, which paginates to roughly 500 per app/storefront.
- **Rock-solid details and search.** App details and keyword search run on Apple's stable public endpoints — fast, reliable, and proxy-free.
- **Stable output schema.** Every record carries a `_schemaVersion` so your downstream code never breaks on a surprise field rename.
- **Monitored daily.** A canary tests every mode against known apps each day. Breakage gets patched fast and logged in the changelog at the bottom of this page — that "last verified working" date is real.
- **Three modes, one actor — no start fee.** App details, keyword search, and reviews all run from this single actor (many App Store scrapers do reviews only), and you pay only per result with **no per-run start fee**.

The moat here isn't a clever trick — it's **operational reliability**. This scraper is maintained to keep working, which is the one thing a scraper in a production pipeline actually needs to do.

### What data you get

The actor runs in three modes. Pick one with the `mode` input.

#### Mode: `details` — full app metadata

Look up apps by **App ID** or **Bundle ID**, one at a time or in bulk.

| Field | Type | Description |
|---|---|---|
| `title` | string | App name |
| `appId` | string | Numeric App Store ID |
| `bundleId` | string | Bundle identifier (e.g. `com.burbn.instagram`) |
| `sellerName` | string | Developer / seller name |
| `averageUserRating` | number | Overall star rating |
| `userRatingCount` | number | Total number of ratings |
| `version` | string | Current app version |
| `price` | number | Numeric price (0 for free) |
| `formattedPrice` | string | Display price (e.g. "Free", "$4.99") |
| `primaryGenre` | string | Primary category |
| `contentRating` | string | Age / content rating |
| `currentVersionReleaseDate` | string | Latest version release date |
| `icon` | string | App icon URL |
| `url` | string | App Store page URL |

Details records also include release notes, genres, size, supported languages, description, and screenshots.

#### Mode: `search` — find apps by keyword

Ranked search results carrying the same rich fields as `details`, for any keyword and storefront. Ideal for ASO keyword tracking and competitor discovery.

#### Mode: `reviews` — customer reviews

| Field | Type | Description |
|---|---|---|
| `appId` | string | App the review belongs to |
| `reviewId` | string | Unique review ID |
| `rating` | number | 1–5 stars |
| `title` | string | Review headline |
| `body` | string | Review text |
| `userName` | string | Reviewer display name |
| `appVersion` | string | App version reviewed |
| `voteSum` | number | Net helpful votes (RSS review feed reports 0) |
| `voteCount` | number | Total votes cast (RSS review feed reports 0) |
| `country` | string | Storefront code |

Sort reviews by most-recent or most-helpful, across any storefront.

### Use cases

- **App developers & founders — track ratings and version sentiment.** Pull `reviews` for your own app and competitors, segment by `appVersion`, and catch a post-release crash wave before it tanks your rating. Searches like *Apple App Store reviews API* and *scrape App Store reviews* land here.
- **ASO & growth marketers — keyword rank tracking.** Run `search` on your target keywords across storefronts to see who ranks where, then enrich the top results with `details` to study titles, genres, and rating counts. Covers *App Store keyword scraper* and *ASO data*.
- **Market & investment research — category landscapes.** Use `search` plus `details` to build a structured snapshot of any App Store category: pricing, developers, rating volume, and update cadence. Covers *Apple App Store data* and *app market research*.
- **Data teams & ML pipelines — review mining at scale.** Feed `reviews` into sentiment models, support-triage tooling, or feature-request mining. Stable JSON and `_schemaVersion` mean your *App Store data API* alternative won't break your ETL.

### Input

| Field | Type | Notes |
|---|---|---|
| `mode` | string | `details` | `search` | `reviews` (required). A mismatched mode is handled — see FAQ. |
| `appIds` | string\[] | Numeric App Store IDs (e.g. `389801252`). For `details` + `reviews`. |
| `bundleIds` | string\[] | Alternative for `details` mode (e.g. `com.burbn.instagram`). |
| `searchTerms` | string\[] | Keywords. For `search` mode. |
| `country` | string | Two-letter storefront code (`us`, `gb`, `de`, `jp`, …). Default `us`. |
| `lang` | string | Language tag for reviews (e.g. `en-US`). Default `en-US`. |
| `maxReviewsPerApp` | int | Reviews cap per app (1–500; Apple's public feed paginates to ~500). Default `200`. |
| `reviewsSort` | string | `mostRecent` | `mostHelpful`. Default `mostRecent`. |
| `maxSearchResults` | int | Per search term (1–200). Default `50`. |

#### Example — details

```json
{ "mode": "details", "appIds": ["389801252", "324684580"], "country": "us" }
```

#### Example — search

```json
{ "mode": "search", "searchTerms": ["habit tracker", "budget app"], "maxSearchResults": 50, "country": "us" }
```

#### Example — reviews

```json
{ "mode": "reviews", "appIds": ["389801252"], "maxReviewsPerApp": 500, "reviewsSort": "mostRecent", "country": "us", "lang": "en-US" }
```

### Output sample

A `reviews` record:

```json
{
  "_type": "review",
  "_schemaVersion": "1.0",
  "appId": "389801252",
  "reviewId": "11583920002",
  "country": "us",
  "rating": 1,
  "title": "Keeps crashing",
  "body": "Crashes on launch since the update on my iPad.",
  "userName": "mark_p",
  "appVersion": "430.1.0",
  "voteSum": 0,
  "voteCount": 0,
  "_scrapedAt": "2026-06-01T07:57:08.714Z"
}
```

A `details` record carries `title`, `appId`, `bundleId`, `sellerName`, `averageUserRating`, `userRatingCount`, `version`, `price`, `formattedPrice`, `primaryGenre`, `contentRating`, `currentVersionReleaseDate`, `icon`, and `url`.

### Use with AI agents (MCP)

This scraper is callable as a tool by AI agents via the **[Apify MCP server](https://mcp.apify.com)** — so assistants like **Claude, Cursor, and VS Code** can run it and use the structured results mid-conversation, with no glue code.

Simplest path: in a recent **Claude Desktop**, add the hosted server `https://mcp.apify.com` under **Settings → Connectors** and authorize with OAuth. For any config-file client:

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server"],
      "env": { "APIFY_TOKEN": "YOUR_APIFY_TOKEN" }
    }
  }
}
```

Then ask in plain language, e.g. *"Get the App Store details and 50 most recent reviews for Instagram (app ID 389801252)."* — the agent calls **`freshactors/app-store-scraper`** with the right input and reads back the JSON. Full setup: [Apify MCP docs](https://docs.apify.com/platform/integrations/mcp).

**No Apify account?** x402-enabled AI agents can also run this actor autonomously and **pay per use via the x402 payment protocol** — no signup, subscription, or API token required.

### Pricing

**Volume discounts — applied automatically.** Running at scale on a paid Apify plan? The app-details and search prices drop with your plan tier — up to **35% off at Gold** and more on Platinum/Diamond, with no start fee and nothing to apply for. Free and Bronze keep the standard price shown below.

Pay-per-event — you pay only for the data you actually get, with no subscription:

| Event | Price (USD) |
|---|---|
| App details fetched | $0.002 per app |
| Search result fetched | $0.001 per app |
| Review fetched | $0.0001 per review |

**How much does 100 results cost?**

- 100 **app details** → 100 × $0.002 = **$0.20**
- 100 **search results** → 100 × $0.001 = **$0.10**
- 100 **reviews** → 100 × $0.0001 = **$0.01**

For example, scraping 500 reviews of a single app costs about **$0.05**. (Apify platform compute usage is billed separately by Apify, as with any actor.)

### FAQ

**Is scraping the Apple App Store legal?**
This actor collects **public, non-personal** App Store data (app metadata, search rankings, and publicly posted reviews) through Apple's public endpoints. It performs no login and accesses no private account data. As with any scraping, use the data responsibly and in line with applicable terms and laws; if you're unsure about a specific use, consult a lawyer.

**Do I need an Apple Developer account or API key?**
No. There's no account, no login, and no API key. You provide App IDs, bundle IDs, or search terms — the actor handles the rest.

**Where do I find an App ID?**
It's the number in the App Store URL. For `apps.apple.com/us/app/instagram/id389801252`, the App ID is `389801252`. You can also use `bundleIds` (e.g. `com.burbn.instagram`) in `details` mode. Don't have the ID? Just type the app's name (e.g. `Instagram`) — it is matched to the App Store search result whose title contains that name (never just the first hit), and the run status names the app it picked; a name nothing matches is listed as not included.

**Can I get reviews?**
Yes — set `mode` to `reviews`, pass `appIds`, and optionally set `maxReviewsPerApp` (up to 500), `reviewsSort` (`mostRecent` or `mostHelpful`), `country`, and `lang`.

**Why do other App Store scrapers return zero reviews?**
Apple's legacy review feed silently returns an empty `200` response when rate-limited, so naive scrapers report "0 reviews" when there are plenty. This actor detects that throttle response and retries with backoff and proxy rotation instead of handing you an empty dataset. If a feed still comes back empty, we check the app against Apple's lookup endpoint to tell a rate-limited fetch apart from an app that genuinely has no reviews — so "0 reviews" always means zero, never "we gave up."

**What happens in a bulk reviews run if one app comes back empty?**
The run keeps everything it fetched and tells you exactly which apps were incomplete. Apps that genuinely have no reviews in that storefront are listed as such; apps whose reviews exist but couldn't be fetched (Apple rate-limiting) are named in the run status message and in the `RUN_SUMMARY` key-value record as `unavailableApps`, so you can re-run just those. A run only fails outright when nothing could be fetched at all — we never report an empty success for data we simply couldn't reach.

**Which countries / storefronts are supported?**
Any App Store storefront — pass a two-letter `country` code such as `us`, `gb`, `de`, or `jp`. Default is `us`.

**How many reviews can I pull per app?**
Up to about 500 per app via `maxReviewsPerApp` — Apple's public review feed paginates to roughly 500 reviews per app/storefront, and we return as many as Apple exposes.

**Can I look up many apps at once?**
Yes. `appIds`, `bundleIds`, and `searchTerms` all accept lists, so you can batch many apps or keywords in a single run.

**How often is the data updated?**
Every run fetches live data directly from Apple, so results are current as of run time. Each record includes a `_scrapedAt` timestamp.

**How do I export the data?**
Results land in the actor's dataset and can be exported as JSON, CSV, or Excel, or pulled via the Apify API / clients in your own code.

**What if the mode I picked doesn't match what I entered?**
The run follows the data you actually supplied instead of failing — and says exactly what it did in the run status message and the `RUN_SUMMARY` record (`modeNote`). `details` with only `searchTerms` runs a `search`; `search` with only `appIds` runs `details`; `reviews` with only `searchTerms` pulls the reviews of the **top search result** for each term (e.g. "spotify") and names the app it picked. If you fill in both, the mode you chose runs and the unused field is named, never silently dropped. This matters most for API and AI-agent (MCP) calls, where `mode` is easy to leave at its default.

### Other FreshActors tools

| FreshActors actor | What it scrapes |
|---|---|
| [Google Play Scraper](https://apify.com/freshactors/google-play-scraper) | Google Play — app details, reviews, search |
| [Microsoft Store Scraper](https://apify.com/freshactors/microsoft-store-scraper) | Microsoft Store — app details, rating windows, search, reviews |
| [VS Code Marketplace Scraper](https://apify.com/freshactors/vscode-marketplace-scraper) | VS Code extensions — install/trending stats, search, reviews |
| [Shopify App Store Scraper](https://apify.com/freshactors/shopify-app-store-scraper) | Shopify App Store — app details, reviews, discovery |
| [Redfin Scraper](https://apify.com/freshactors/redfin-scraper) | Redfin — US real-estate listings |
| [Greenhouse & Lever Jobs Scraper](https://apify.com/freshactors/greenhouse-lever-jobs-scraper) | Greenhouse + Lever — normalized job postings |
| [Workable Jobs Scraper](https://apify.com/freshactors/workable-jobs-scraper) | Workable — normalized job postings, full descriptions |
| [SmartRecruiters Jobs Scraper](https://apify.com/freshactors/smartrecruiters-jobs-scraper) | SmartRecruiters — normalized job postings, full descriptions |
| [Recruitee Jobs Scraper](https://apify.com/freshactors/recruitee-jobs-scraper) | Recruitee — normalized job postings + salary |
| [Teamtailor Jobs Scraper](https://apify.com/freshactors/teamtailor-jobs-scraper) | Teamtailor — normalized job postings, full descriptions |
| [Personio Jobs Scraper](https://apify.com/freshactors/personio-jobs-scraper) | Personio — normalized job postings, departments + seniority |

### Reliability

This actor is monitored by an **automated daily canary** that exercises every mode (`details`, `search`, `reviews`) against known apps. If Apple changes an endpoint or response shape, the canary catches it, we patch fast, and we record the fix in the changelog so you can see exactly what changed and when. The "Last verified working" date at the top of this page reflects that monitoring — staying fresh is the whole point of FreshActors.

**Changelog**

- **2026-10-26** — **A name never turns into a different app.** An app name in `appIds` is matched only to an App Store search result whose title contains that name; if none does, the name is listed as not included. Before, the first search hit was used, so a typo or a pasted link could return — and bill — an unrelated app. A pasted Google Play link is now skipped and named, with a pointer to our Google Play scraper.

- **2026-10-15** — **Type an app's name where an id goes — it just works.** An app name in `appIds` (e.g. "WhatsApp Messenger") is matched to the top App Store search result and named in the run status; it used to fail the whole run, valid ids included. An id Apple does not return for your country is now named instead of silently missing.

- **2026-10-12** — **Runs finish within your timeout, and say exactly what is missing.** A run now knows its own timeout and stops making requests shortly before it, so it ends with the data it already collected and a clear “Stopped early” note — instead of being killed as TIMED-OUT, which looked like a failure even though your data was there. If the source stops answering partway through a multi-page pull, that item is now listed as **INCOMPLETE** in the status message and `RUN_SUMMARY` (it used to end with a plain “Done”). During an Apple outage a bulk reviews run no longer spends minutes per app: once Apple’s feed is confirmed down, each remaining app gets one quick try and is listed for a re-run. And when a run fails because the source was rate-limiting or not responding, the message now says so first, instead of suggesting your input was wrong.

- **2026-10-08** — **Reviews get through Apple's cached empty feeds.** We measured why some review runs still failed after the 10-03 fix: Apple's CDN sometimes caches an *empty* review feed for several minutes, so every retry — from any IP — received the same cached empty answer. Each retry now asks Apple's servers directly, so a run recovers as soon as Apple does. Also: every request now has a 30-second deadline, so a source that never answers is retried instead of stalling the run. No change to output fields or pricing.

- **2026-10-03** — **Rides out Apple's short review-feed outages.** Apple's review feed sometimes goes empty for a minute or two; a run that hit one used to give up after about 50 seconds and fail. When an app's reviews provably exist, the run now waits (spaced retries, at most ~2.5 minutes per run in total) and delivers them once the feed is back. A longer outage still fails or names the app honestly. No change to output fields or pricing.

- **2026-09-28** — **The mode follows what you enter.** A run whose `mode` didn't match its input (most often `searchTerms` with `mode` left at the default `details` — typical of API and AI-agent calls) used to fail with "details mode requires …". It now runs what you supplied and states it in the status message and `RUN_SUMMARY.modeNote`; `reviews` by search term is new (top result per term, never charged for the lookup).

- **2026-09-23** — **Paste the App Store URL and it just works.** An `apps.apple.com/…/id389801252` URL (or a bare `id389801252`) in *App IDs* now resolves to the numeric id — previously it was sent to Apple as-is and the run failed with no app found. Apify `{ "url": "…" }` objects are accepted too.

- **2026-08-03** — Volume discounts added: app-details and search results now scale down with your Apify plan tier — about **35% off at Gold** and **60% off at Diamond**, applied automatically with nothing to apply for. **Free and Bronze pay exactly what they did before — no price went up**, and the per-review price is unchanged.

- **2026-08-03** — Freshness pass: re-verified across every mode. The honest-failure semantics added here on 2026-07-27 are now the standard across all twelve FreshActors actors.

- **2026-07-27** — Better bulk reviews runs. An empty review feed is now checked against Apple's lookup endpoint, so an app that genuinely has **no reviews** is reported as such instead of being mistaken for rate-limiting. A multi-app run now **keeps its data and names the incomplete apps** (run status message + `RUN_SUMMARY.unavailableApps`) instead of failing the whole run because one app came back empty; a run still fails loudly when nothing could be fetched. No change to output fields or pricing.

- **2026-07-08** — Freshness pass: re-verified working across every mode via the daily monitoring battery; documented **x402** support (AI agents can run this actor pay-per-use with no Apify account). No change to scraping behavior, output, or pricing.

- **2026-06-10** — First-run polish: the one-click default example now fetches **three** well-known apps (Instagram, Spotify, WhatsApp) instead of one, so your first run shows the full 32-field output across multiple apps. Still ~3 seconds and under a cent.

- **2026-06-06** — Made the reviews cap honest: `maxReviewsPerApp` is now 1–500 (was 1–5000). Apple's public review feed paginates to ~500 per app/storefront and the modern amp-api path needs a bearer token Apple no longer exposes publicly, so runs above 500 were silently returning only ~500. The cap now matches what's actually deliverable, and a deeper canary check guards it.

- **2026-06-04** — Docs: corrected the reviews output sample — `voteSum`/`voteCount` come back 0 on the RSS review feed (now clarified in the field table).

- **2026-06-01** — v1.0 launch. Details, search, reviews. Throttle-aware reviews engine (RSS + modern API fallback), daily canary monitoring.

#### Legal note

Scrapes **public, non-personal** App Store data via Apple's public endpoints. No login, no personal account data. Use responsibly and in line with applicable terms and laws.

*Found a problem? Open an issue on the actor — issues are answered fast.*

# Actor input Schema

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

What to scrape: app details, a keyword search, or customer reviews.

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

Numeric App Store IDs (the number in the app URL, e.g. 389801252 for Instagram) — or paste the full apps.apple.com app URL — or just type the app's name (e.g. Instagram): it is matched to the App Store search result with that name (never a guess) and named in the run status. Used by 'details' and 'reviews' modes.

## `bundleIds` (type: `array`):

Alternative to App IDs for 'details' mode (e.g. com.burbn.instagram).

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

Keywords to search the App Store. Used by 'search' mode.

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

Two-letter App Store storefront code (us, gb, de, jp, ...).

## `lang` (type: `string`):

Language tag for reviews (e.g. en-US).

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

Reviews mode only. Cap on reviews returned per app (1–500; Apple's public review feed paginates to ~500).

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

Order reviews by most recent or most helpful (reviews mode).

## `maxSearchResults` (type: `integer`):

Search mode only. Results per term (1–200).

## Actor input object example

```json
{
  "mode": "details",
  "appIds": [
    "389801252",
    "324684580",
    "310633997"
  ],
  "country": "us",
  "lang": "en-US",
  "maxReviewsPerApp": 200,
  "reviewsSort": "mostRecent",
  "maxSearchResults": 50
}
```

# Actor output Schema

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

App details / search results / reviews, depending on the selected mode.

# 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": [
        "389801252",
        "324684580",
        "310633997"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("freshactors/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": [
        "389801252",
        "324684580",
        "310633997",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("freshactors/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": [
    "389801252",
    "324684580",
    "310633997"
  ]
}' |
apify call freshactors/app-store-scraper --silent --output-dataset

```

## MCP server setup

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