# Google Play Store Scraper — Android Reviews & Data (`freshactors/google-play-scraper`) Actor

Fast, reliable Google Play scraper: app details + deep-paginated customer reviews as structured JSON. Monitored daily. No login.

- **URL**: https://apify.com/freshactors/google-play-scraper.md
- **Developed by:** [Freshactors](https://apify.com/freshactors) (community)
- **Categories:** Developer tools, E-commerce, Automation
- **Features:** Limited permissions
- **Stats:** 10 total users, 1 monthly users, 100.0% 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

## Google Play Store Scraper — Android App Reviews, Details & Search

Scrape **Google Play Store** and **Android app** data — **app details, customer reviews & ratings, ratings histogram, and keyword search** — as clean structured JSON, with no API key, no proxy setup, no monthly fee, and **no per-run start fee**. All three modes in one actor, fast HTTP, pay-per-use.

![Google Play Scraper example output — 27 structured fields incl. ratings histogram](https://raw.githubusercontent.com/Freshactors/freshactors-assets/main/gp-screenshot.png)

> ✅ **Last verified working: 2026-10-28.** Monitored by an automated daily canary. When Google changes its page structure, we patch fast and log it in the changelog — so your data pipeline doesn't silently break.

***

### Why this Google Play scraper

Most Google Play scrapers go stale and break. You'll see the same complaints across the Store: "crashes on a dead app," "returns nothing," "only 30 results," "stopped working weeks ago." When the data feeding your dashboard or model silently dies, you find out from your boss, not your logs.

This one is built to **stay working**:

- 🛡️ **Doesn't crash on bad input.** Each app is fetched in its own try/catch. A dead, removed, or 404 package is *skipped and logged*, never a run-killer — that's the exact failure mode that breaks the popular incumbent actor.
- 🔄 **Rate-limit resistant.** The reviews engine detects Google's throttle/block responses (missing RPC marker) and retries with exponential backoff + jitter and datacenter IP rotation, instead of quietly returning zero rows.
- 📦 **Comprehensive details** — 25+ fields including the full 1–5★ ratings histogram, exact rating, description, screenshots, genre, price, currency, content rating, and "contains ads" — not just title + rating.
- 🔢 **Deep, token-paginated reviews** — up to 4,000 per app, de-duplicated, with developer replies and reply dates.
- 🧱 **Stable output schema** (`_schemaVersion` on every record). If Google reshapes a positional array upstream, the affected field degrades to `null` — your job keeps running.
- 🔬 **A daily canary** runs `details` + `reviews` against a live app and writes a pass/fail status. The "last verified working" date above is real, not decorative.
- 🎯 **Three modes, one actor — no start fee.** Details, reviews, and keyword search all run from one actor (most Play Store scrapers do reviews only), pay-per-result with **no per-run start fee**.

### What data you get

Three modes, one actor:

| Mode | What it returns |
|---|---|
| `details` | Full app metadata for each package name you supply. |
| `reviews` | Paginated customer reviews for each package name (with developer replies). |
| `search` | Searches the Play Store by keyword, then returns **full details** for every matching app (tagged with the search term). |

**`details` / `search` output fields:**

| Field | Type | Description |
|---|---|---|
| `appId` | string | Package name, e.g. `com.spotify.music`. |
| `title` | string | App name. |
| `developer` | string | Developer / publisher name. |
| `developerWebsite` | string | Developer site, if listed. |
| `summary` | string | Short tagline. |
| `description` | string | Full store description. |
| `rating` | number | Exact average rating (e.g. `4.33`). |
| `ratingCount` | number | Total number of ratings. |
| `ratingHistogram` | object | `{1,2,3,4,5}` star counts. |
| `installs` | string | Install bucket, e.g. `1,000,000,000+`. |
| `price` / `free` / `currency` | number / bool / string | Price, free flag, currency code. |
| `genre` / `genreId` | string | Category name + ID. |
| `contentRating` | string | e.g. `Teen`, `Everyone`. |
| `containsAds` | boolean | Whether the app contains ads. |
| `updated` | string | Last-updated timestamp (ISO). |
| `icon` / `headerImage` / `screenshots[]` | string / array | Media URLs. |
| `url` | string | Canonical Play Store URL. |
| `_searchTerm` | string | (search mode only) the keyword that surfaced this app. |

**`reviews` output fields:** `reviewId`, `userName`, `userImage`, `rating`, `body`, `thumbsUp`, `date`, `appVersion`, `developerResponse`, `developerResponseDate`, `reviewUrl`, plus `appId` and `country`. Reviews are returned newest-first.

Every record also carries `_type`, `_schemaVersion`, `_source`, and `_scrapedAt`.

### Use cases

- **App Store Optimization (ASO) & competitor analysis** — track ratings, install buckets, descriptions, and the ratings histogram across rival apps over time. The kind of "Google Play app data API" coverage ASO tools sell, at pay-per-use cost.
- **Review monitoring & support triage** — pull new Google Play reviews (and your developer replies) on a schedule, route negative ones to Slack, and watch sentiment per app version.
- **Sentiment / ML training datasets** — collect clean review text + ratings + `appVersion` at scale for fine-tuning or classification. No HTML parsing on your side.
- **Market & category research** — run `search` mode on keywords like "budget tracker" or "habit app" to map a niche: who ranks, their ratings, pricing, and whether they're ad-supported.

### Input

| Field | Type | Notes |
|---|---|---|
| `mode` | string | `details`, `reviews`, or `search`. Default `details`. A mismatched mode is handled — see FAQ. |
| `appIds` | string\[] | Package names, e.g. `com.spotify.music` (the `id=` part of the URL). For `details` + `reviews`. |
| `searchTerms` | string\[] | Keywords to search the Play Store. For `search` mode. |
| `maxSearchResults` | int | Apps returned per keyword, 1–100. Default 30. |
| `country` | string | Two-letter storefront code (`us`, `gb`, `de`, …). Default `us`. |
| `lang` | string | Two-letter language code (`en`, `de`, `es`, …). Default `en`. |
| `maxReviewsPerApp` | int | Reviews cap per app, 1–4000. Default 200. |
| `reviewsSort` | string | `newest` (reviews are returned newest-first — the only order Google's public reviews API supports). |

#### Example — details

```json
{ "mode": "details", "appIds": ["com.spotify.music", "com.whatsapp"], "country": "us" }
```

#### Example — reviews

```json
{ "mode": "reviews", "appIds": ["com.spotify.music"], "maxReviewsPerApp": 1000, "reviewsSort": "newest" }
```

#### Example — search

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

### Output sample

A single `details` record (abridged):

```json
{
  "_type": "app_details",
  "_schemaVersion": "1.0",
  "_source": "play",
  "appId": "com.spotify.music",
  "country": "us",
  "title": "Spotify: Music and Podcasts",
  "developer": "Spotify AB",
  "rating": 4.33,
  "ratingCount": 35677435,
  "ratingHistogram": { "1": 3695081, "2": 1079953, "3": 1332269, "4": 3058122, "5": 26511993 },
  "installs": "1,000,000,000+",
  "free": true,
  "currency": "USD",
  "genre": "Music & Audio",
  "contentRating": "Teen",
  "containsAds": true,
  "updated": "2026-05-26T14:23:49.000Z",
  "icon": "https://play-lh.googleusercontent.com/...",
  "screenshots": ["https://play-lh.googleusercontent.com/..."],
  "url": "https://play.google.com/store/apps/details?id=com.spotify.music",
  "_scrapedAt": "2026-06-01T08:20:00.000Z"
}
```

A single `reviews` record:

```json
{
  "_type": "review",
  "appId": "com.spotify.music",
  "reviewId": "7e1815f2-36d1-4187-a936-12f969747892",
  "userName": "Catherine Hempel",
  "rating": 5,
  "body": "The paid version is excellent but very expensive...",
  "thumbsUp": 14,
  "date": "2026-04-21T11:35:57.000Z",
  "appVersion": "9.1.40.1486",
  "developerResponse": null,
  "reviewUrl": "https://play.google.com/store/apps/details?id=com.spotify.music&reviewId=7e1815f2-..."
}
```

### 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. *"Fetch the Google Play details and ratings histogram for Spotify (com.spotify.music), plus its latest reviews."* — the agent calls **`freshactors/google-play-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 price drops 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 — **no subscription, no platform rental.** You're charged only for data actually returned:

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

`search` mode charges the per-app **details** event for each matching app it returns.

**How much do 100 results cost?**

- **100 app details** → 100 × $0.002 = **$0.20**.
- **100 reviews** (one popular app) → 100 × $0.0001 = **$0.01**.
- **A 1,000-review pull** → 1,000 × $0.0001 = **$0.10**.
- **A `search` run** returning 20 apps for a keyword → 20 × $0.002 = **$0.04**.

So a competitor-tracking job covering 50 apps' details plus 200 reviews each costs roughly `50 × $0.002 + 50 × 200 × $0.0001 = $0.10 + $1.00 = $1.10` per run.

### FAQ

**Is scraping Google Play legal?** This actor collects **public** store data — app listings and publicly visible reviews — with no login and no personal account access. Public-data scraping is broadly permitted, but you are responsible for how you use the output. Use it responsibly and in line with applicable terms and laws; don't republish personal data.

**Do I need an API key?** No. Google Play has no official public data API for this. You provide package names or search terms and get JSON back — no key, no OAuth, no proxy account to manage.

**Should I pass a URL or a package name?** Use the package name — the `id=` part of the app URL. For `https://play.google.com/store/apps/details?id=com.spotify.music`, the `appId` is `com.spotify.music`.

**Why are there fewer reviews than the rating count?** Google's displayed number is total *ratings*; only a fraction of users write a *review*. This actor returns the written reviews, which is why a 35M-rating app yields far fewer review rows.

**How many reviews can I get per app?** Up to 4,000 via `maxReviewsPerApp`, paginated and de-duplicated. Reviews are returned newest-first (the only order Google's public reviews API supports).

**Which countries and languages are supported?** Any — set `country` (e.g. `us`, `gb`, `de`) and `lang` (e.g. `en`, `de`, `es`). Ratings, descriptions, and reviews are returned for that storefront.

**Can I search Google Play by keyword?** Yes — use `search` mode with `searchTerms`. It returns full details for each matching app, tagged with the `_searchTerm` that surfaced it, capped by `maxSearchResults` (1–100).

**Does it return the ratings histogram?** Yes — `details` includes `ratingHistogram` with per-star (1–5) counts, plus the exact average `rating` and total `ratingCount`.

**What happens if an app is removed or doesn't exist?** It's skipped and logged, and the run continues. One bad package never kills the whole job.

**Can I just type the app's name instead of the package name?** Yes — put the name in `appIds` (e.g. `Spotify Music`). It is matched to the Google Play 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. Name lookups are never charged.

**How often is it updated and maintained?** A daily automated canary verifies `details` and `reviews` against a live app. When Google changes its page structure, we patch quickly and record it in the changelog below — that's the whole point of FreshActors.

**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 |
|---|---|
| [App Store Scraper](https://apify.com/freshactors/app-store-scraper) | Apple App Store — app details, search, reviews |
| [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

Staying fresh is the product. An automated **daily canary** runs real `details` and `reviews` requests against a live app and records a pass/fail status; the "Last verified working" date at the top reflects that check. Every output record carries a `_schemaVersion`, and parsers access Google's positional data defensively, so an upstream reshape degrades one field to `null` rather than crashing your run. Fixes are shipped fast and recorded in the changelog below. Found a problem? Open an issue on the Issues tab — it's answered quickly.

**Changelog**

- **2026-10-28** — **A network blip no longer fails a run.** Loading an app page or a search page now retries a dropped connection or a temporary Google/proxy error (with backoff, on a fresh IP each try), as reviews already did. Before, one dropped connection could skip the app and fail a one-app run while blaming the appId. An unknown appId still fails at once and is named.
- **2026-10-26** — **A name never turns into a different app.** An app name in `appIds` is matched only to a Google Play search result whose title contains that name, and the run status shows the title it matched; if none does, the name is listed as not included instead of being replaced by the first search hit. A pasted App Store link is skipped with a pointer to our App Store scraper.
- **2026-10-15** — **Type an app's name where an id goes — it just works.** An app name in `appIds` (e.g. "Spotify Music") is matched to the top Google Play search result and named in the run status — one such entry used to reject the whole run. A non-Play URL is skipped and named.
- **2026-10-12** — **Requests now rotate across proxy IPs as intended.** A misconfigured proxy setting had sent every request from a single IP; rotation makes large pulls far less likely to hit Google's rate limits.
- **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”). 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** — **No more hung runs.** Every request now has a 30-second deadline: if the source accepts a connection but never answers, that request is retried like any other network error instead of stalling the run until its timeout (and billing compute for the wait). 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 Play Store URL and it just works.** A `play.google.com/store/apps/details?id=…` URL in *App IDs* now resolves to its package name — previously the whole input was rejected as invalid. Apify `{ "url": "…" }` objects are accepted too.
- **2026-08-03** — Volume discounts added: app details 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** — Honest-failure fix: if none of the requested apps could be fetched, the run now fails loudly and names them, instead of reporting success with zero results (a wrong answer stated confidently). Partial runs are unaffected — they keep every delivered record and list exactly what was unreachable in the run summary, so you can re-run just that slice. No change to pricing, output schema, or the behaviour of runs that return data.
- **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** popular apps (Spotify, WhatsApp, Instagram) instead of one, so your first run shows the full 27-field output across multiple apps. Still ~3 seconds and under a cent.
- **2026-06-06** — **Fixed deep review pagination:** reviews were silently capped at ~40 per app regardless of `maxReviewsPerApp` (the pagination token was placed in the wrong slot of the request, so page 2 came back empty). Token-paginated reviews up to 4,000/app now work as documented. Also made `reviewsSort` honest: Google's public reviews API only supports newest order, so `mostHelpful`/`rating` (which silently returned nothing) were removed.
- **2026-06-04** — Reviews: `developerResponseDate` now populated for developer replies (was always null — corrected an off-by-one in the reply tuple index). Details/search: de-duplicated repeated `screenshots` URLs. Added reply-mapping + screenshot tests.
- **2026-06-01** — v1.0 launch. App details, customer reviews (deep pagination), and keyword search. Throttle-aware reviews engine, defensive positional parsing, daily canary monitoring.

**Legal note.** This actor scrapes **public** Google Play pages only: app listings and publicly visible reviews. No login, no personal account data, no circumvention of access controls. You are responsible for complying with applicable terms and laws and for how you use and store the data, including any personal data contained in reviews.

# Actor input Schema

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

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

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

Google Play package names, e.g. com.spotify.music (the id= part of the app URL) — or paste the full play.google.com app URL — or just type the app's name (e.g. Spotify): it is matched to the Google Play search result with that name (never a guess) and named in the run status. For details + reviews modes.

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

Keywords to search the Play Store (search mode). Returns full details for each matching app.

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

Search mode: apps returned per keyword (1–100).

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

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

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

Two-letter language code for results (e.g. en, de, es).

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

Reviews mode. Cap per app (1–4000).

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

Reviews are returned newest-first — the only order Google's public reviews API supports (reviews mode).

## Actor input object example

```json
{
  "mode": "details",
  "appIds": [
    "com.spotify.music",
    "com.whatsapp",
    "com.instagram.android"
  ],
  "maxSearchResults": 30,
  "country": "us",
  "lang": "en",
  "maxReviewsPerApp": 200,
  "reviewsSort": "newest"
}
```

# 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": [
        "com.spotify.music",
        "com.whatsapp",
        "com.instagram.android"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("freshactors/google-play-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": [
        "com.spotify.music",
        "com.whatsapp",
        "com.instagram.android",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("freshactors/google-play-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": [
    "com.spotify.music",
    "com.whatsapp",
    "com.instagram.android"
  ]
}' |
apify call freshactors/google-play-scraper --silent --output-dataset

```

## MCP server setup

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