# Steam Game Price, Discount & Review Monitor (`johnatan029/steam-game-data-monitor`) Actor

Monitor Steam game prices, discounts, release status, and review changes across up to 200 app IDs. Get change-only events or full game details with regional pricing, developers, publishers, genres, platforms, Metacritic, recommendations, and review totals.

- **URL**: https://apify.com/johnatan029/steam-game-data-monitor.md
- **Developed by:** [Johnn Mottin](https://apify.com/johnatan029) (community)
- **Categories:** Automation, E-commerce, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 change events

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Steam Game Price, Discount & Review Monitor

### Monitor Steam game prices, discounts, release status, and review changes

Track up to **200 Steam app IDs or Store URLs per run** and receive either:

- **change-only monitoring events**, or
- **full normalized game details**.

The Actor reads Steam's public storefront endpoints and can monitor signals such as:

- price changes;
- discount starts;
- discount ends;
- a game moving from coming soon to released;
- review-score changes;
- review-count changes above your chosen threshold.

The first healthy `monitor` run for each **app + country** creates a free baseline. Later runs compare the current storefront data with that saved state and write only the selected changes.

Every monitor run also writes one free:

```text
BATCH_SUMMARY
```

record, so a successful run with no changes still produces a clear monitoring result.

No Steam API key. No login. No browser automation. No LLM.

#### Key features

- **Monitor up to 200 Steam games per run**
- **Accept Steam app IDs or Store URLs**
- **Regional pricing through `countryCode`**
- **Price-change events**
- **Discount-start events**
- **Discount-end events**
- **Released-state events**
- **Review-score change events**
- **Review-count delta events**
- **Configurable minimum review delta**
- **Free first-run baseline per app + country**
- **Free `BATCH_SUMMARY` on every monitor run**
- **One-shot full details mode**
- **Persistent diff state**
- **Per-app status and diagnostics**
- **Rate-limit aware request pacing**
- **Result-cap state protection**
- **Schedule-ready for daily competitive monitoring**
- **Pay only for written change events or detail records**

> **Unofficial community Actor. Not affiliated with, sponsored by, or endorsed by Valve Corporation or Steam.** Data comes from Steam's public storefront endpoints and remains subject to Steam's applicable terms and policies.

***

### What this Actor is for

This Actor is designed for recurring game-market monitoring rather than just one-time scraping.

Use it to answer questions such as:

```text
Which games in my competitive set changed price today?
```

```text
Which competitor just started or ended a discount?
```

```text
Which monitored games accumulated a meaningful number of new reviews since the last run?
```

```text
Which coming-soon titles are now released?
```

You can also switch to `details` mode when you want a one-time normalized export of the currently available Steam Store metadata.

***

### Who it's for

#### Indie developers and publishers

Monitor a defined competitive set and detect:

- competitor price changes;
- discount launches;
- discount endings;
- release-state changes;
- changes in review totals.

Route those events to Slack, Sheets, a database, or your own internal tooling.

#### Game-market analysts

Build recurring datasets around:

- regional pricing;
- discounts;
- review totals;
- review score;
- release status;
- developers and publishers;
- genres;
- platforms;
- Metacritic;
- recommendations.

#### Deal and wishlist tools

Consume structured events such as:

```text
PRICE_CHANGE
DISCOUNT_START
DISCOUNT_END
```

without maintaining your own Steam storefront monitor.

#### Competitive-intelligence teams

Track a portfolio of games and retain only meaningful changes rather than storing an identical full record every day.

***

### Important: review deltas are signals, not sales figures

The Actor can monitor changes in total review counts.

A:

```text
REVIEW_DELTA
```

event can be useful as a momentum or engagement signal.

However, review growth is **not exact unit-sales data**.

Do not interpret:

```text
reviewsDelta
```

as an exact number of copies sold.

If you use review growth as a market proxy, apply your own analytical assumptions downstream.

***

### Two operating modes

The Actor supports:

```text
monitor
details
```

***

### Monitor mode

`monitor` is the default mode.

It stores state per:

```text
appid + countryCode
```

This is important because Steam pricing can vary by region.

Changing the pricing country therefore does not compare one regional price directly against a baseline from another country.

#### First healthy run

The first healthy monitor run for an app + country creates a baseline.

The baseline is free and does not pretend that the game's current price, discount, review total, or other state is a new event.

A per-app status can report:

```text
BASELINE_CREATED
```

Every monitor run also writes the free:

```text
BATCH_SUMMARY
```

record.

#### Later runs

Later healthy runs compare current Steam storefront data against the saved state.

Selected differences are written as:

```text
CHANGE_EVENT
```

records.

***

### Supported change events

The Actor supports these six event types:

```text
PRICE_CHANGE
DISCOUNT_START
DISCOUNT_END
RELEASED
REVIEW_SCORE_CHANGE
REVIEW_DELTA
```

#### `PRICE_CHANGE`

Emitted when the monitored final price changes between healthy states.

#### `DISCOUNT_START`

Emitted when a discount appears after the previous healthy state had no discount.

#### `DISCOUNT_END`

Emitted when an active discount ends.

#### `RELEASED`

Emitted when the monitored Steam release state changes from coming soon to released.

#### `REVIEW_SCORE_CHANGE`

Emitted when the storefront review score changes.

#### `REVIEW_DELTA`

Emitted when the total review count changes by at least:

```text
minReviewDelta
```

The event can include:

```text
reviewsDelta
positiveDelta
negativeDelta
```

***

### Details mode

Use:

```json
{
  "mode": "details"
}
```

for a one-time full export.

Instead of diff events, the Actor writes one rich normalized detail record per successfully processed app.

The documented detail dataset can include current fields such as:

- app ID;
- game name;
- Store URL;
- regional price;
- discount;
- free-game status;
- release information;
- developers;
- publishers;
- genres;
- supported platforms;
- Metacritic data;
- recommendation data;
- review score;
- review totals.

Use `details` mode for:

- portfolio exports;
- market research;
- game metadata enrichment;
- dashboards;
- one-time competitor analysis.

***

### Input

#### Daily competitive monitoring example

```json
{
  "appids": ["1091500", "730"],
  "mode": "monitor",
  "minReviewDelta": 10
}
```

#### Input fields

| Field | Type | Default | Description |
|---|---|---|---|
| `appids` | array | required | 1–200 Steam app IDs or Store URLs. |
| `mode` | string | `monitor` | `monitor` for change events + free summary, or `details` for full one-time exports. |
| `countryCode` | string | `us` | Steam pricing region. Monitor state is stored per app + country. |
| `eventTypes` | array | all 6 | Select any subset of `PRICE_CHANGE`, `DISCOUNT_START`, `DISCOUNT_END`, `RELEASED`, `REVIEW_SCORE_CHANGE`, `REVIEW_DELTA`. |
| `minReviewDelta` | integer | `10` | Minimum total-review change required for a `REVIEW_DELTA` event. |
| `maxResults` | integer | `5000` | Hard cap on charged records. A truncated app's diff state is not advanced. |
| `requestDelayMs` | integer | `1500` | Deliberate pacing before every request. Minimum accepted value is 1000 ms. |

***

### Example: monitor price and discount changes only

```json
{
  "appids": ["1091500", "730"],
  "mode": "monitor",
  "countryCode": "us",
  "eventTypes": [
    "PRICE_CHANGE",
    "DISCOUNT_START",
    "DISCOUNT_END"
  ]
}
```

***

### Example: review momentum monitoring

```json
{
  "appids": ["1091500", "730"],
  "mode": "monitor",
  "eventTypes": [
    "REVIEW_SCORE_CHANGE",
    "REVIEW_DELTA"
  ],
  "minReviewDelta": 50
}
```

***

### Example: another pricing region

```json
{
  "appids": ["1091500"],
  "mode": "monitor",
  "countryCode": "br"
}
```

Because state is stored per app + country, the Brazilian-price baseline remains separate from the US-price baseline.

***

### Change-event output

Monitor mode writes one:

```text
CHANGE_EVENT
```

record per selected detected change.

Example — end of a sale:

```json
{
  "recordType": "CHANGE_EVENT",
  "eventType": "DISCOUNT_END",
  "appid": "1091500",
  "name": "Cyberpunk 2077",
  "url": "https://store.steampowered.com/app/1091500",
  "currency": "USD",
  "oldPriceFinal": 17.99,
  "newPriceFinal": 59.99,
  "oldDiscountPct": 70,
  "newDiscountPct": 0,
  "priceDeltaPct": 233.46,
  "detectedAt": "2026-07-30T13:00:00.000Z"
}
```

***

### Review-delta output

A:

```text
REVIEW_DELTA
```

event can include:

```text
reviewsDelta
positiveDelta
negativeDelta
```

This lets downstream workflows observe review-count movement between healthy monitor runs.

The meaning of that movement depends on your own analysis; the Actor does not convert review deltas into estimated unit sales.

***

### Free batch summary

Every valid monitor run writes one free:

```text
BATCH_SUMMARY
```

record.

The summary can include:

- `statusCounts`;
- `eventCounts`;
- per-app processing status.

Examples of app statuses include:

```text
OK
BASELINE_CREATED
APP_NOT_FOUND
RATE_LIMITED
```

This means a valid no-change day still produces useful run-level confirmation.

Example interpretation:

```text
2 apps checked
2 OK
0 change events
1 free BATCH_SUMMARY
```

***

### Persistent monitor state

Diff state is stored in the named key-value store:

```text
STEAM-MONITOR-STATE
```

with one state key per:

```text
appid!country
```

This state is what allows later runs to determine what changed.

#### Force a fresh baseline

Delete a specific app + country key from:

```text
STEAM-MONITOR-STATE
```

to force the next healthy run to create a new baseline.

Use this deliberately because the previous comparison state for that app + region will be removed.

***

### Result-cap state protection

`maxResults` limits the number of charged output records.

If a particular app's event set would be truncated by the output cap, that app's diff state is **not advanced**.

This prevents the Actor from silently moving the baseline past change events that were not actually written to the dataset.

***

### Regional pricing

Steam prices depend on the selected:

```text
countryCode
```

The Actor normalizes Steam's price values into currency units.

For example, a source value represented internally in cents is returned as a value such as:

```text
17.99
```

with the corresponding currency field.

Free games can return:

```text
priceFinal: null
isFree: true
```

Regional availability also depends on Steam's response for the selected country.

***

### Release monitoring

The Actor can monitor the storefront release state.

When a game changes from coming soon to released, the monitor can emit:

```text
RELEASED
```

This is a release-state event.

The documented event set does not include a separate generic event for every possible release-date text change.

***

### Rate-limit handling

Steam rate limits are respected rather than bypassed.

Requests are processed serially with deliberate pacing.

Default request delay:

```text
1500 ms
```

Minimum:

```text
1000 ms
```

When Steam responds with:

```text
429
```

the Actor uses long backoff intervals.

The documented retry timing includes:

```text
30 seconds
60 seconds
120 seconds
```

If an app remains rate-limited after the controlled retry path, it becomes:

```text
RATE_LIMITED
```

rather than triggering evasion behavior.

For larger batches, reduce batch size or increase:

```text
requestDelayMs
```

if needed.

***

### One bad app does not kill the batch

An invalid or unavailable app can receive:

```text
APP_NOT_FOUND
```

without automatically stopping healthy apps in the same run.

The run fails globally only when no app completes successfully, using:

```text
ALL_APPS_FAILED
```

This makes batch processing safer for portfolios containing stale or regionally unavailable app IDs.

***

### Region-specific availability

Steam can return an app successfully in one region and not in another.

For example, an `appdetails` response can report:

```text
success: false
```

for one pricing region even when the same app is available elsewhere.

The Actor reports Steam's regional response as-is rather than inventing availability.

***

### Run health and diagnostics

Operational data is stored in:

```text
STATS
```

The run statistics can include:

- per-app summary;
- HTTP counters;
- 429 counts;
- events by type;
- field-completeness checks;
- warnings.

Failures and diagnostic errors can be stored in:

```text
ERRORS
```

***

### Request footprint

The Actor makes approximately:

```text
2 HTTP requests per app per run
```

using the documented Steam storefront data and review-summary sources.

Because requests are deliberately paced, large batches are intentionally slower than an aggressive high-concurrency scraper.

The original implementation target is approximately:

```text
~5 minutes per 100 apps
```

under the documented pacing assumptions, although actual runtime depends on network responses and rate limiting.

***

### Scheduling

Monitor mode is intended for recurring use.

Diff quality depends on how often you run the Actor.

#### Why cadence matters

Suppose a game:

1. drops from $59.99 to $39.99;
2. later drops to $29.99;
3. returns to $59.99;

between two monitor runs.

The next comparison sees the current state against the last saved healthy state.

Intermediate changes that occur entirely between runs cannot be reconstructed automatically.

For that reason, daily monitoring is a practical default for competitive price and discount tracking.

***

### Recommended daily setup

1. Save your app IDs and `monitor` configuration as an Apify **Task**.
2. Run it once to establish the free baseline.
3. Go to **Console → Schedules → Create schedule**.
4. Add the Task.
5. Choose a daily schedule.
6. Route the resulting events to your downstream system.

Example daily 6:00 AM cron:

```text
0 6 * * *
```

Possible destinations include:

- Slack;
- Google Sheets;
- databases;
- dashboards;
- webhooks;
- internal analytics pipelines;
- deal-alert systems.

The Actor runs in Apify's cloud, so your local computer does not need to remain on.

***

### Pay only for written events or details

This Actor uses **Pay Per Event** pricing.

In `monitor` mode, you are billed for change-event records actually written.

The free:

```text
BATCH_SUMMARY
```

is not billed as a change event.

The first healthy baseline does not create fake paid change events.

Events removed through:

- `eventTypes`;
- `minReviewDelta`;
- output caps

are not billed as written change-event records.

In `details` mode, billing is based on the detail records actually written.

The **Pricing** tab on the Actor page is always the authoritative source for current prices and any run-start fee.

***

### Cost-control options

Use:

```text
eventTypes
```

to monitor only the event classes you need.

Use:

```text
minReviewDelta
```

to avoid writing small review-count changes.

Use:

```text
maxResults
```

to cap charged output records.

You can also split large portfolios into separate scheduled tasks if you want independent cost or monitoring boundaries.

***

### Honest limits

#### You provide the app IDs

The Actor does not discover the full Steam catalog.

Input is based on:

- Steam app IDs;
- Steam Store URLs.

This version intentionally focuses on monitoring a known game portfolio.

#### No exact sales estimates

Review totals and review deltas are public storefront signals.

The Actor does not convert them into exact unit sales, revenue, or ownership estimates.

#### Diff quality depends on run cadence

Only the difference between two recorded healthy states is available.

Multiple intermediate changes between runs can collapse into a single observed event.

#### Rate limits are respected

The Actor deliberately paces requests and backs off on 429 responses.

It does not try to bypass Steam rate limits.

#### Regional prices differ

Pricing and availability depend on:

```text
countryCode
```

Monitor state is therefore kept separately by region.

#### Free games have no normal final price

Free titles can return:

```text
priceFinal: null
isFree: true
```

#### Some apps are regionally unavailable

Steam can return different results for the same app in different regions.

The Actor reports the source response.

#### One failed app does not guarantee run failure

Individual failures are controlled per app.

The batch fails only when no app answers successfully.

***

### FAQ

#### Do I need a Steam API key?

No.

The Actor reads the documented public storefront sources without requiring an API key.

#### Do I need a Steam account?

No.

No login is required.

#### Does the Actor use browser automation?

No.

#### Can I provide Steam Store URLs instead of app IDs?

Yes.

The `appids` input accepts app IDs or Store URLs.

#### How many games can I monitor?

Up to:

```text
200
```

app IDs or Store URLs per run.

#### What is the default mode?

```text
monitor
```

#### What happens on the first monitor run?

The first healthy run for each app + country creates a free baseline.

It does not emit fake change events for the existing state.

#### What happens if nothing changes?

The run can produce zero change events while still writing the free:

```text
BATCH_SUMMARY
```

record.

#### Can I export full game details?

Yes.

Use:

```json
{
  "mode": "details"
}
```

#### Can I monitor another pricing region?

Yes.

Set:

```text
countryCode
```

to the desired supported region code.

Monitor state remains separate by app + country.

#### Can I monitor only discounts?

Yes.

For example:

```json
{
  "eventTypes": [
    "DISCOUNT_START",
    "DISCOUNT_END"
  ]
}
```

#### Can I monitor price changes only?

Yes.

```json
{
  "eventTypes": ["PRICE_CHANGE"]
}
```

#### Can I control review-delta sensitivity?

Yes.

Use:

```text
minReviewDelta
```

For example:

```json
{
  "minReviewDelta": 100
}
```

requires at least 100 total-review change before a `REVIEW_DELTA` event is written.

#### Is review velocity the same as sales?

No.

Review changes may be useful as a market signal but are not exact sales counts.

#### Does `RELEASED` mean the exact release date changed?

`RELEASED` represents a monitored change from coming soon to released.

It should not be described as a generic release-date-change event.

#### What happens when Steam rate-limits a request?

The Actor uses controlled backoff.

If the app remains unavailable due to rate limiting after the retry path, its status can become:

```text
RATE_LIMITED
```

#### What happens if an app ID is invalid?

It can receive:

```text
APP_NOT_FOUND
```

without stopping other valid apps.

#### Where is monitor state stored?

In:

```text
STEAM-MONITOR-STATE
```

one key per app + country.

#### Can I reset a baseline?

Yes.

Delete the corresponding state key from `STEAM-MONITOR-STATE`.

#### What am I charged for?

Change events written in monitor mode or detail records written in details mode.

The monitor `BATCH_SUMMARY` is free.

Always check the Actor's **Pricing** tab for current prices and run fees.

#### Can I schedule it?

Yes.

Daily scheduling is the recommended starting point for change monitoring.

#### Is this affiliated with Valve or Steam?

No.

This is an unofficial community Actor and is not affiliated with, sponsored by, or endorsed by Valve Corporation or Steam.

***

### Part of the JM Forge suite

Also from the same developer:

- [Shopify Price, Stock & Catalog Monitor — Batch + Diff](https://apify.com/johnatan029/shopify-price-catalog-monitor) — Monitor Shopify stores for price changes, restocks, sell-outs, new products, and removed products.

- [Reddit Feed Monitor](https://apify.com/johnatan029/reddit-feed-monitor) — Monitor new posts in public subreddits through Reddit's public RSS feed.

- [Google, Bing & YouTube Keyword Suggest Scraper](https://apify.com/johnatan029/keyword-autocomplete-intelligence) — Expand seed keywords into structured long-tail autocomplete suggestions across Google, Bing, and YouTube.

### Support

Report issues in the **Issues** tab of this actor — I respond within 24h. Feature requests welcome.

# Actor input Schema

## `appids` (type: `array`):

1–200 Steam app IDs or store URLs (e.g. "1091500" or "https://store.steampowered.com/app/1091500/"). 2 polite requests per app — 100 apps take roughly 5 minutes by design (rate-friendly pacing).

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

monitor (default): diff vs the previous run — only change events are charged; first visit of an app creates a free baseline. details: full data export, one record per app.

## `countryCode` (type: `string`):

2-letter country code for regional pricing (e.g. "us", "br", "de"). Monitor state is kept per app+country, so switching regions never produces false price events.

## `eventTypes` (type: `array`):

Which change events to emit. Default: all of PRICE\_CHANGE, DISCOUNT\_START, DISCOUNT\_END, RELEASED, REVIEW\_SCORE\_CHANGE, REVIEW\_DELTA.

## `minReviewDelta` (type: `integer`):

REVIEW\_DELTA fires only when total reviews changed by at least this much since the last run (review velocity is the sales proxy). Filtered deltas cost nothing.

## `maxResults` (type: `integer`):

Global cap on charged records (events or app results). The free batch summary does not count. If the cap truncates an app's events, that app's diff state is NOT advanced, so nothing is silently lost.

## `requestDelayMs` (type: `integer`):

Polite pacing before every request (serial). The 1000 ms floor is deliberate — Steam's storefront rate limit (~200 req/5 min) is respected by construction, never worked around.

## `debug` (type: `boolean`):

Verbose logs.

## Actor input object example

```json
{
  "appids": [
    "1091500",
    "730"
  ],
  "mode": "monitor",
  "countryCode": "us",
  "eventTypes": [
    "PRICE_CHANGE",
    "DISCOUNT_START",
    "DISCOUNT_END",
    "RELEASED",
    "REVIEW_SCORE_CHANGE",
    "REVIEW_DELTA"
  ],
  "minReviewDelta": 10,
  "maxResults": 5000,
  "requestDelayMs": 1500,
  "debug": false
}
```

# 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": [
        "1091500",
        "730"
    ],
    "mode": "monitor"
};

// Run the Actor and wait for it to finish
const run = await client.actor("johnatan029/steam-game-data-monitor").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": [
        "1091500",
        "730",
    ],
    "mode": "monitor",
}

# Run the Actor and wait for it to finish
run = client.actor("johnatan029/steam-game-data-monitor").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": [
    "1091500",
    "730"
  ],
  "mode": "monitor"
}' |
apify call johnatan029/steam-game-data-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,johnatan029/steam-game-data-monitor"
        }
    }
}

```

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/aPMNlWUB3C8ulDHph/builds/e8108WbCQfkxo5hTC/openapi.json