# Apple App Store Scraper: Apps, Search & Reviews (`rjmacarthy/app-store-scraper`) Actor

Scrape the Apple App Store: app details (ratings histogram, in-app purchases, privacy labels), keyword search and reviews with developer responses - past the 500-review RSS cap, many countries in one run, and an "only new reviews" mode.

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

## Pricing

from $0.10 / 1,000 review scrapeds

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: Apps, Search & Reviews

**Apple App Store Scraper** gets **app details, keyword search results and customer reviews** from the Apple App Store, for as many countries as you want, in one run. Reviews come with the **developer's response**, the **app version** they were written for, and go **past the 500-review limit** of Apple's RSS feed. App details include what the iTunes API doesn't give you: the **ratings histogram (1–5 stars)**, **in-app purchases with prices**, **privacy labels**, chart position, Editors' Choice and the new age rating.

Most App Store review scrapers only do reviews, stop at 500 per app, and handle one country per run. This one combines **apps + search + reviews in one Actor**, runs **many countries at once** (reviews are separate per country), has an **"only new reviews" mode** for scheduled monitoring, and charges **no start fee**: **$0.10 per 1,000 reviews**.

No login, no browser, no proxy needed by default.

### What can this App Store scraper do?

- 📱 **App details** from App Store IDs (`324684580`), bundle IDs (`com.spotify.client`) or App Store links: name, subtitle, developer, seller, price and currency, average rating and rating count, **ratings histogram**, genres, content and age rating, release date, current version and its date, release notes, size, minimum iOS, languages, description, icon and screenshots, **in-app purchases**, **privacy labels**, chart position, Editors' Choice and editors' notes, developer website and privacy-policy links.
- 🔎 **Search** the App Store by keyword (iPhone, iPad or Mac), up to 200 apps per term and country, each with its search rank.
- 💬 **Reviews**: star rating, title, text, reviewer nickname, date, app version, edited flag and **developer response** (with its date), sorted by **most recent** or **most helpful**.
- 🌍 **Many countries in one run**: `["us", "gb", "de", "jp"]`. Ratings, prices, chart positions and reviews are all per storefront, and each item says which country it comes from.
- ♾️ **More than 500 reviews per app**: the scraper reads the App Store website's own reviews API (20 per request, no 500 cap; tested past 10,000 reviews for one app), and joins Apple's RSS feed to add the app version.
- 🔁 **Only new reviews**: schedule the Actor and get, and pay for, only reviews that weren't output before, per app and country.
- 📅 **Only reviews since** a date or age ("7 days").
- 🛡️ **Built to keep running**: if the reviews API is busy for an app, the scraper switches to Apple's RSS feed automatically; retries with backoff; one bad app ID never fails the whole run.
- 💸 **Pay per result**, no start fee, no subscription.

### What data can you get?

| Data | Where it comes from | In this Actor |
|---|---|---|
| Name, developer, bundle ID, price, currency, genres | iTunes Lookup/Search API | ✅ |
| Average rating and rating count (all versions and current version) | iTunes API | ✅ |
| Ratings histogram (number of 1★ … 5★ ratings) | App Store page | ✅ |
| Version, release date, release notes, size, minimum OS, languages | iTunes API | ✅ |
| Description, icon, iPhone and iPad screenshots | iTunes API | ✅ |
| In-app purchases (name and price) | App Store page | ✅ (top items Apple lists) |
| Privacy labels ("Data Used to Track You", "Data Linked to You"…) | App Store page | ✅ |
| Subtitle, chart position, Editors' Choice, age rating, developer links | App Store page | ✅ |
| Keyword search results with rank | iTunes Search API | ✅ up to 200 per term and country |
| Reviews: stars, title, text, nickname, date | Reviews API / RSS feed | ✅ |
| Developer response to a review | Reviews API | ✅ |
| App version the review was written for | RSS feed | ✅ first 500 reviews per app and country |
| More than 500 reviews per app and country | Reviews API | ✅ |
| Several countries in one run | | ✅ |
| Only new reviews since the last run | | ✅ |
| Reviewer e-mails, profiles or other personal data | | ❌ Never collected |

### Use cases

- **Review monitoring and customer support:** get new 1★ and 2★ reviews from every country every morning, with the version they mention and whether you already replied.
- **Product and UX research:** mine thousands of reviews (not just the latest 500) for feature requests and bugs; compare the most helpful reviews across markets.
- **Competitor tracking:** follow competitors' ratings, histogram, price, in-app purchase prices, release cadence and chart position, country by country.
- **App Store optimisation (ASO):** see which apps rank for a keyword in each country, with their subtitles and ratings.
- **Market research and lead lists:** build lists of apps in a category with developer websites.
- **Privacy research:** compare privacy labels across apps.
- **Datasets for AI and sentiment analysis:** clean, flat JSON with ISO dates.

### How to use it

1. Click **Try for free** or **Start**.
2. In **Apps**, paste App Store IDs, bundle IDs or app links, one per line. Optionally add **Search terms**.
3. In **Countries**, list the storefronts you want (e.g. `us`, `gb`, `de`). Leave empty for `us`.
4. Choose what to output: **App details**, **Reviews** (sort, max per app), or both.
5. Click **Start**, then download the results as JSON, CSV, Excel or HTML, or fetch them with the API.

#### Input examples

Reviews and details for two apps in three countries:

```json
{
  "apps": ["324684580", "https://apps.apple.com/us/app/duolingo-learn-languages/id570060128"],
  "countries": ["us", "gb", "de"],
  "includeReviews": true,
  "maxReviewsPerApp": 500,
  "reviewsSort": "mostRecent"
}
```

Daily monitoring of new reviews (save as a Task and schedule it):

```json
{
  "apps": ["com.spotify.client"],
  "countries": ["us", "gb"],
  "includeAppDetails": false,
  "onlyNewReviews": true,
  "stateKey": "spotify-daily",
  "maxReviewsPerApp": 1000
}
```

Keyword search, no reviews:

```json
{
  "searchTerms": ["meditation", "budget planner"],
  "countries": ["us"],
  "maxSearchResults": 50,
  "includeReviews": false
}
```

The 200 most helpful reviews, keeping only those from the last 3 months:

```json
{
  "apps": ["389801252"],
  "reviewsSort": "mostHelpful",
  "reviewsSince": "3 months",
  "maxReviewsPerApp": 200,
  "includeAppDetails": false
}
```

### Output example

Each dataset item has a `type`: `app` or `review`. Use the **Apps** and **Reviews** views (or filter on `type`) to see them separately. Real items from a run on 2 Nov 2026 (long fields shortened):

```json
[
  {
    "type": "app",
    "id": "us:570060128",
    "appId": "570060128",
    "country": "us",
    "url": "https://apps.apple.com/us/app/duolingo-learn-languages/id570060128",
    "name": "Duolingo: Learn Languages",
    "subtitle": "Spanish, French, Chess & Math",
    "bundleId": "com.duolingo.DuolingoMobile",
    "developerName": "Duolingo",
    "developerId": "570060151",
    "price": 0,
    "currency": "USD",
    "isFree": true,
    "hasInAppPurchases": true,
    "inAppPurchases": [
      { "name": "Barrel of Gems (1200)", "price": "$4.99" },
      { "name": "Super Duolingo", "price": "$9.99" }
    ],
    "rating": 4.7225,
    "ratingCount": 5553374,
    "ratingsHistogram": { "1": 141247, "2": 46993, "3": 136284, "4": 562704, "5": 4666146 },
    "primaryGenre": "Education",
    "contentRating": "4+",
    "ageRating": "4+",
    "chartPosition": { "rank": 1, "chart": "Education" },
    "isEditorsChoice": true,
    "releaseDate": "2012-11-13T08:00:00.000Z",
    "currentVersion": "7.146.1",
    "currentVersionReleaseDate": "2026-10-28T16:01:08.000Z",
    "fileSizeBytes": 514102272,
    "minimumOsVersion": "17.0",
    "privacyLabels": [
      { "type": "DATA_USED_TO_TRACK_YOU", "title": "Data Used to Track You", "categories": ["Purchases", "Location", "Contact Info", "…"], "categoryIds": ["PURCHASES", "LOCATION", "CONTACT_INFO", "…"] }
    ],
    "developerWebsite": "https://www.duolingo.com",
    "pageScraped": true,
    "scrapedAt": "2026-11-02T13:30:55.332Z"
  },
  {
    "type": "review",
    "id": "14736559996",
    "appId": "324684580",
    "appName": "Spotify: Music and Podcasts",
    "country": "us",
    "url": "https://apps.apple.com/us/app/id324684580?see-all=reviews",
    "rating": 1,
    "title": "Horrible Lag and Crashes",
    "text": "My liked songs playlist is 113,000 songs deep, and trying to shuffle it crashes my app nonstop. …",
    "userName": "Chimp Pudding",
    "date": "2026-11-01T06:28:23.000Z",
    "appVersion": "9.1.94",
    "isEdited": true,
    "developerResponse": "Hi. Have you tried a quick reinstall? If that doesn't help, we'd recommend reaching out to our Customer Service at support.spotify.com. …",
    "developerResponseDate": "2026-05-15T16:04:37.000Z",
    "voteSum": 0,
    "voteCount": 0,
    "sort": "mostRecent",
    "position": 4,
    "source": "api",
    "scrapedAt": "2026-11-02T13:31:00.327Z"
  }
]
```

Full sample: [`samples/sample-output.json`](samples/sample-output.json). Missing values are `null` (never left out), dates are ISO 8601 in UTC, and numbers are numbers. A `RUN_SUMMARY` record in the run's key-value store lists every input with its status, item counts, the review sources used and any warnings.

### How much does it cost?

This Actor uses **pay-per-event** pricing. You pay only for items in your dataset, and there is **no start fee** from us.

| Event | Price | Per 1,000 |
|---|---|---|
| `review`: one review saved | $0.0001 | **$0.10** |
| `app`: one app (in one country) saved, including search results | $0.002 | **$2.00** |

Examples:

- **1,000 reviews ≈ $0.10.**
- The default prefill (Spotify, US, 20 latest reviews + app details): 20 × $0.0001 + 1 × $0.002 = **$0.004**.
- 10 apps × 3 countries with 200 reviews each: 30 app items ($0.06) + 6,000 reviews ($0.60) = **$0.66**.
- A daily "only new reviews" run that finds 40 new reviews: **$0.004**. Reviews already output in earlier runs are free.

Set **Maximum cost per run** in the run options to cap spending: the scraper stops cleanly at the limit and says so in its status message. Your Apify plan's free monthly credit applies.

### Scheduling: only new reviews

1. Turn on **Only new reviews** and give the monitor a name in **Monitor name** (e.g. `my-apps-daily`).
2. Save the input as a **Task** and add a **Schedule** (e.g. every morning).
3. The first run outputs up to **Max reviews per app and country** of the latest reviews and remembers them.
4. Later runs read the newest reviews first and output only reviews that weren't output before. They stop as soon as a whole page has nothing new, so a daily check of an app usually costs two or three requests plus the new reviews.

The memory is kept per monitor name, app and country in a named key-value store (`app-store-scraper-state`). Use a different monitor name for each independent schedule, and don't run two runs with the same name at the same time.

### Tips and limits

- **Reviews are per country.** An app's US reviews and UK reviews are different sets. Add every country you care about.
- **How many reviews?** The reviews API has no 500 cap (tested past 10,000 for one app). Big apps have hundreds of thousands of reviews per country, so `0` (no limit) can mean a long and costly run: use a limit or **Maximum cost per run**.
- **App version** (`appVersion`) and vote counts come from Apple's RSS feed, which only covers the first 500 reviews per app and country, and which Apple leaves empty for some apps (e.g. Duolingo in the US). Otherwise these fields are `null`.
- **If the reviews API is busy** (Apple answers "API capacity exceeded" for an app now and then), the scraper retries, then uses the RSS feed (up to 500 reviews, no developer responses) and tries the API again after that. Such reviews have `"source": "rss"`. The reviews API belongs to Apple's website and is not an official, documented API: if Apple changes it, the RSS fallback keeps the reviews coming (capped at 500) until the scraper is updated.
- **In-app purchases** are the items Apple lists on the app page (usually the top 10), with the price as displayed (e.g. `"£4.99"`).
- **Page data** (histogram, in-app purchases, privacy labels, subtitle, chart position, age rating) needs one extra request per app and country. Turn off **Add data from the App Store page** if you only need the basics. For search results it's off by default.
- **Search** returns at most 200 apps per term and country (Apple's limit).
- **Languages**: `languages` are ISO codes (`EN`, `DE`…). Texts such as descriptions, IAP names and privacy-label titles are in the storefront's language.
- **"Only reviews since" with "Most helpful"** sorting can't stop early (helpful reviews aren't in date order): the scraper reads the app's top *Max reviews per app* most helpful reviews and keeps the recent ones (or reads 1,000 if there is no limit).
- **Edited reviews** keep their ID, so "only new reviews" doesn't output them again.
- **Speed:** a single app with 20 reviews takes about 4 seconds. Apple's lookup and search API is limited to about 20 calls a minute, so the scraper batches lookups (up to 100 apps per call) and spaces searches 3 seconds apart.

### FAQ

**Do I need an Apple account, API key or proxy?**
No. Everything comes from public App Store pages and Apple's public endpoints. The proxy option is there for very large runs if Apple starts rate-limiting.

**Can I scrape Google Play too?**
Not with this Actor. It covers the Apple App Store (iPhone, iPad and Mac apps).

**Why does an app show "not found" in some countries?**
The app isn't sold in that country's App Store (or the ID is wrong). The other countries still run.

**Why is `ratingsHistogram` null?**
The App Store page couldn't be read for that app (see the run's warnings), or **Add data from the App Store page** is off.

**Can I get reviews for every app in a search?**
Yes: turn on **Scrape reviews of search results**.

**Is it legal to scrape the App Store?**
This Actor only collects data that Apple shows publicly to everyone: app listings and published reviews. Reviewers appear only with their public App Store nickname; no e-mails, profile links or other personal data are collected. You are responsible for using the data in line with Apple's terms and the laws that apply to you (for example GDPR when you process reviewers' nicknames and texts).

### Integrations

- **API.** Run the Actor and fetch results with the [Apify API](https://docs.apify.com/api/v2) or the JavaScript and Python clients:

  ```bash
  curl -X POST "https://api.apify.com/v2/acts/rjmacarthy~app-store-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
    -H "Content-Type: application/json" \
    -d '{"apps":["324684580"],"countries":["us","gb"],"maxReviewsPerApp":100}'
  ```

- **Make, Zapier, n8n.** Send new reviews to Slack, Google Sheets, Airtable, your helpdesk or CRM without code.

- **Webhooks.** Trigger your own pipeline when a run finishes.

- **AI agents (MCP).** Use the Actor as a tool through the Apify MCP server, e.g. "summarise this week's 1-star reviews of my app in the UK".

- **Google Sheets, Airbyte, Keboola** and more through Apify integrations.

### Changelog

- **0.1 (Nov 2026)** First release: app details with ratings histogram, in-app purchases and privacy labels; keyword search; reviews with developer responses beyond 500 per app (reviews API + RSS feed, automatic fallback); multiple countries per run; "only new reviews" and "only reviews since".

### More scrapers by the same developer

- [Telegram Channel Scraper](https://apify.com/rjmacarthy/telegram-channel-scraper)
- [ATS Jobs Scraper: Greenhouse, Lever, Ashby & Workday](https://apify.com/rjmacarthy/ats-jobs-scraper)
- [Workday Jobs Scraper](https://apify.com/rjmacarthy/workday-jobs-scraper)
- [Google Ads Transparency Scraper](https://apify.com/rjmacarthy/google-ads-transparency-scraper)
- [Substack Scraper](https://apify.com/rjmacarthy/substack-scraper)
- [Dice Jobs Scraper](https://apify.com/rjmacarthy/dice-jobs-scraper)

Browse all my Actors on [my Apify Store profile](https://apify.com/rjmacarthy).

### Support

Found an app that doesn't work, or need another field? Open an issue on the **Issues** tab with your input.

# Actor input Schema

## `apps` (type: `array`):

Apps to scrape. Each line can be a numeric App Store ID (324684580), a bundle ID (com.spotify.client) or an App Store link (https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580).

## `countries` (type: `array`):

Two-letter country codes, e.g. us, gb, de, fr, jp. Every app (and search term) is scraped in every country listed. Ratings, prices and reviews are separate per country. Leave empty to use "us", or the country in each App Store link.

## `includeAppDetails` (type: `boolean`):

Output one "app" item per app and country: name, developer, price, ratings, genres, version, release notes, size, description, screenshots and more.

## `includeAppPageData` (type: `boolean`):

Also read each app's apps.apple.com page for data the iTunes API does not have: ratings histogram (1-5 stars), in-app purchases with prices, privacy labels, subtitle, chart position, Editors' Choice, age rating and developer links. One extra request per app and country.

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

Output customer reviews ("review" items) for each app in each country.

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

Stop after this many reviews for each app in each country. 0 means no limit (large apps have hundreds of thousands of reviews - use with a cost limit).

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

Most recent first (best for monitoring) or most helpful first.

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

Optional. Skip reviews older than this date (2026-10-01) or age ("7 days", "24 hours", "3 months"). With "Most recent" sorting the scraper stops as soon as it reaches older reviews.

## `onlyNewReviews` (type: `boolean`):

Remember which reviews were already output (per app and country) and only output new ones on later runs. Ideal for scheduled runs. The first run outputs up to the review limit and becomes the baseline. Forces "Most recent" sorting.

## `stateKey` (type: `string`):

Name of the incremental-monitoring state. Use a different name for each independent schedule; runs with the same name share the list of already-seen reviews.

## `reviewsSource` (type: `string`):

Auto (recommended): the App Store website's reviews API (no 500-review cap, developer responses) with app versions from Apple's RSS feed, falling back to the RSS feed if the API fails. RSS only: the public RSS feed (max 500 reviews per app and country, includes app version, no developer responses). API only: no RSS requests and no app version.

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

Optional. Keywords to search the App Store for, e.g. "budget planner". Each result is output as an "app" item with its search rank, in every country listed above.

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

Apps per search term and country (1-200; Apple's search API returns at most 200).

## `searchPlatform` (type: `string`):

Which App Store to search.

## `searchResultsPageData` (type: `boolean`):

Also read the apps.apple.com page of every search result (ratings histogram, in-app purchases, privacy labels...). One extra request per result, so slower for large searches.

## `reviewsForSearchResults` (type: `boolean`):

Also scrape reviews (with the settings above) for every app found by search. Off by default: reviews are scraped only for the apps listed in "Apps".

## `stateStoreName` (type: `string`):

Named key-value store that keeps the incremental-monitoring state.

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

Usually not needed - Apple's public endpoints answer datacenter IPs. Enable Apify Proxy if you see HTTP 403/429 errors on big runs.

## Actor input object example

```json
{
  "apps": [
    "324684580",
    "com.duolingo.DuolingoMobile",
    "https://apps.apple.com/us/app/instagram/id389801252"
  ],
  "countries": [
    "us",
    "gb",
    "de"
  ],
  "includeAppDetails": true,
  "includeAppPageData": true,
  "includeReviews": true,
  "maxReviewsPerApp": 20,
  "reviewsSort": "mostRecent",
  "onlyNewReviews": false,
  "stateKey": "default",
  "reviewsSource": "auto",
  "searchTerms": [
    "meditation",
    "budget planner"
  ],
  "maxSearchResults": 20,
  "searchPlatform": "iphone",
  "searchResultsPageData": false,
  "reviewsForSearchResults": false,
  "stateStoreName": "app-store-scraper-state",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

App items: name, developer, price, rating, rating count, genre, version, chart position, URL.

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

Review items: stars, title, text, nickname, date, app version and developer response.

## `allItems` (type: `string`):

Every field of every app and review item.

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

Per-input status, counts, review sources used, request statistics and warnings.

# 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 = {
    "apps": [
        "324684580"
    ],
    "countries": [
        "us"
    ],
    "maxReviewsPerApp": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("rjmacarthy/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 = {
    "apps": ["324684580"],
    "countries": ["us"],
    "maxReviewsPerApp": 20,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("rjmacarthy/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 '{
  "apps": [
    "324684580"
  ],
  "countries": [
    "us"
  ],
  "maxReviewsPerApp": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call rjmacarthy/app-store-scraper --silent --output-dataset

```

## MCP server setup

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