# Steam Review Monitor & Player Feedback Alerts (`johnatan029/steam-review-monitor`) Actor

Monitor Steam player reviews without paying for the same reviews every run. Get only genuinely new reviews, persistent deduplication, native Steam review-score changes, review velocity, language dimensions, playtime and purchase/refund flags. First run creates a free baseline.

- **URL**: https://apify.com/johnatan029/steam-review-monitor.md
- **Developed by:** [Johnn Mottin](https://apify.com/johnatan029) (community)
- **Categories:** Social media, Automation, 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 new reviews

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?

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

### Monitor genuinely new Steam reviews without paying for the same feedback again

Track public Steam player reviews across one or more games and receive **only reviews that have not already been seen in that monitored game × language dimension**.

This Actor keeps persistent state keyed by Steam `recommendationid`. The first successful run for a dimension creates a free baseline; later runs emit `NEW_REVIEW` only for genuinely unseen review IDs.

It also provides **native Steam review-score description changes** and **per-game review velocity summaries** for free.

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

#### Key features

- **Stateful Steam review monitoring**
- **Persistent deduplication by `recommendationid`**
- **Free first-run baseline per game × language**
- **Only genuinely unseen reviews are billable**
- **Full public review text**
- **Thumbs up/down recommendation**
- **Author playtime**
- **Steam purchase flag**
- **Received-for-free flag**
- **Refunded flag**
- **Early Access flag**
- **Steam Deck flag**
- **Votes up and funny votes**
- **Review creation and update timestamps**
- **Native Steam review-score description changes**
- **Native positive/negative/total review counts**
- **Review velocity over the fetched 24-hour window**
- **Language-specific monitoring dimensions**
- **Up to 50 game × language dimensions per run**
- **Controlled request pacing and retries**
- **Free per-dimension summaries**
- **Free RUN\_SUMMARY**
- **Pay Per Event**

> **Unofficial community Actor. Not affiliated with, sponsored by, or endorsed by Valve Corporation or Steam.** Data comes from the public Steam Store `appreviews` endpoint and remains subject to Steam's public source behavior and policies.

***

### What this Actor is for

A normal review scraper returns a current page of reviews.

A monitor should answer a different question:

> Which player reviews appeared since I last checked?

This Actor remembers the review IDs already observed for each monitored dimension.

That makes it useful for:

- game launch monitoring;
- player-feedback pipelines;
- live-ops monitoring;
- publisher portfolio monitoring;
- competitor research;
- community and product research;
- QA feedback collection;
- recurring review dashboards;
- Slack or webhook alerts;
- database and BI pipelines.

***

### Important: the first run is a free baseline

The first successful observation of each:

```text
game × language
```

dimension learns the current recent review IDs.

It does not emit those existing reviews as new.

Example:

```text
First run:
100 recent reviews fetched
100 IDs remembered
0 NEW_REVIEW records
```

If 8 unseen reviews later enter the recent feed:

```text
Next run:
8 unseen recommendation IDs
8 NEW_REVIEW records
```

This prevents historical recent reviews from being presented as new activity.

***

### Important: edited reviews are not re-billed

Steam keeps the same:

```text
recommendationid
```

when a player edits an existing review.

The Actor deduplicates by that ID.

Therefore:

```text
same recommendationid
+
different timestamp_updated
=
already seen
```

An edit does not become another billable `NEW_REVIEW`.

***

### Who it's for

#### Game studios

Monitor player feedback during:

- launches;
- patches;
- DLC releases;
- events;
- major balance changes.

#### Publishers

Track review flow across a portfolio while keeping each title and language in its own monitoring dimension.

#### Community and product teams

Route new player feedback into:

- Slack;
- internal dashboards;
- issue-triage queues;
- spreadsheets;
- research databases.

#### Competitive research teams

Watch public reviews for competing titles without repeatedly re-exporting the same recent review IDs.

#### Automation builders

Connect results to:

- Apify webhooks;
- n8n;
- Make;
- Zapier;
- Google Sheets;
- Slack;
- databases;
- BI tools;
- custom applications;
- AI analysis downstream.

The Actor itself does not perform AI sentiment analysis.

***

### How it works

For every game × language dimension, the Actor:

1. validates the Steam app ID;
2. fetches recent public reviews from Steam;
3. follows Steam cursors up to `maxReviewsPerQuery`;
4. normalizes review fields;
5. loads persistent state for that dimension;
6. compares each `recommendationid` with the seen-ID set;
7. emits only unseen reviews after the baseline run;
8. remembers the fetched IDs in bounded persistent state;
9. compares Steam's native `review_score_desc` with the previous value;
10. writes a free score-change record when that native description changes;
11. calculates review velocity from fetched reviews created within the previous 24 hours;
12. writes a free `APP_REVIEW_SUMMARY`;
13. writes a free `RUN_SUMMARY`;
14. keeps operational diagnostics in `STATS`.

***

### Data source

The Actor uses the public Steam Store endpoint:

```text
https://store.steampowered.com/appreviews/<APP_ID>
```

with JSON output enabled.

The implementation requests:

```text
filter=recent
purchase_type=all
```

and a configured review language.

No authenticated Steam session is used.

***

### Input

#### Recommended example

```json
{
  "apps": [
    {
      "appId": 570,
      "label": "Dota 2"
    },
    {
      "appId": 730,
      "label": "Counter-Strike 2"
    }
  ],
  "languages": [
    "english"
  ],
  "maxReviewsPerQuery": 200,
  "maxResults": 500,
  "maxRuntimeMs": 300000
}
```

#### Input fields

| Field | Default | Description |
|---|---:|---|
| `apps` | required | Steam app IDs or `{ appId, label }` objects. |
| `languages` | `["english"]` | Steam review-language dimensions. Empty means all languages in one dimension. |
| `maxReviewsPerQuery` | `100` | Recent reviews read per dimension. Range: 20–500. |
| `maxResults` | `500` | Maximum billable `NEW_REVIEW` records. Range: 1–5,000. |
| `maxRuntimeMs` | `300000` | Hard runtime cap in milliseconds. |
| `debug` | `false` | Additional diagnostic logging. |

***

### How to find the Steam app ID

The app ID appears in the public Store URL.

Example:

```text
https://store.steampowered.com/app/570/Dota_2/
```

App ID:

```text
570
```

You can provide a bare numeric app ID:

```json
{
  "apps": [
    570
  ]
}
```

or add a label:

```json
{
  "apps": [
    {
      "appId": 570,
      "label": "Dota 2"
    }
  ]
}
```

***

### Language dimensions

Each language creates an independent monitoring dimension.

Example:

```json
{
  "apps": [
    {
      "appId": 570,
      "label": "Dota 2"
    }
  ],
  "languages": [
    "english",
    "brazilian"
  ]
}
```

This creates:

```text
570/english
570/brazilian
```

with independent state.

Common Steam language codes include:

```text
english
brazilian
german
french
spanish
schinese
tchinese
japanese
koreana
russian
```

#### All languages

Use:

```json
{
  "languages": []
}
```

to monitor all languages as one dimension.

The revised input validation also rejects combining:

```text
all
```

with specific languages in the same run, because those feeds overlap and could surface the same review in more than one monitored dimension.

***

### Dimension cap

The Actor enforces:

```text
apps × languages <= 50
```

When `languages` is empty, all languages count as one dimension per app.

Examples:

```text
10 games × 1 language = 10 dimensions
10 games × 3 languages = 30 dimensions
20 games × 3 languages = 60 dimensions → invalid
```

Split larger portfolios across separate Tasks or schedules.

***

### Recent-review window

The Actor does not download full historical review archives.

It reads Steam's:

```text
recent
```

review feed up to:

```text
maxReviewsPerQuery
```

per dimension.

This is the core operational rule:

> Your read window should be larger than the number of new reviews expected between scheduled runs.

For a quiet game, `100` may be more than enough.

For a launch or viral title, use:

- a larger `maxReviewsPerQuery`;
- a shorter schedule interval;
- or both.

***

### Important high-volume limitation

The current maximum is:

```text
500
```

recent reviews per dimension per run.

If more than 500 new reviews arrive between two runs, older unseen reviews can fall beyond the Actor's recent-feed read window before they are observed.

Persistent deduplication prevents duplicates.

It cannot recover reviews that were never fetched.

For very high-volume launch periods, schedule the Actor more frequently.

***

### Output

The default dataset can contain four record types:

```text
NEW_REVIEW
REVIEW_SCORE_CHANGE
APP_REVIEW_SUMMARY
RUN_SUMMARY
```

***

### `NEW_REVIEW`

This is the billable player-feedback event.

It is emitted only when:

- the dimension is past its first successful baseline;
- the review has a valid `recommendationid`;
- that ID is not already in persistent state;
- the record is admitted by result/runtime/billing caps.

#### Example

```json
{
  "recordType": "NEW_REVIEW",
  "entityId": "listening:steam:570/233081975",
  "source": "steam",
  "appId": 570,
  "appLabel": "Dota 2",
  "dimensionLanguage": "english",
  "recommendationId": "233081975",
  "language": "english",
  "review": "You can't get enough of it",
  "createdAt": "2026-08-17T22:26:26.000Z",
  "updatedAt": "2026-08-17T22:26:26.000Z",
  "votedUp": true,
  "votesUp": 0,
  "votesFunny": 0,
  "weightedVoteScore": 0.5,
  "steamPurchase": true,
  "receivedForFree": false,
  "refunded": false,
  "earlyAccess": false,
  "steamDeck": false,
  "authorSteamId": "76561198328512937",
  "playtimeForeverMin": 372004,
  "authorNumReviews": 2,
  "observedAt": "2026-08-18T00:00:00.000Z"
}
```

***

### `NEW_REVIEW` fields

| Field | Description |
|---|---|
| `recordType` | `NEW_REVIEW`. |
| `entityId` | Stable review identity based on app ID and recommendation ID. |
| `source` | `steam`. |
| `appId` | Steam app ID. |
| `appLabel` | User-provided game label. |
| `dimensionLanguage` | Monitored language dimension. |
| `recommendationId` | Steam review identity used for persistent deduplication. |
| `language` | Review language returned by Steam. |
| `review` | Public review text. |
| `createdAt` | Review creation time. |
| `updatedAt` | Review update time. |
| `votedUp` | Player recommendation direction. |
| `votesUp` | Helpful votes when provided. |
| `votesFunny` | Funny votes when provided. |
| `weightedVoteScore` | Steam-provided weighted vote score when available. |
| `steamPurchase` | Whether Steam marks it as a Steam purchase. |
| `receivedForFree` | Whether Steam marks the product as received for free. |
| `refunded` | Refund flag when returned. |
| `earlyAccess` | Whether written during Early Access. |
| `steamDeck` | Steam Deck primary-use flag when returned. |
| `authorSteamId` | Public author Steam ID when available. |
| `playtimeForeverMin` | Author lifetime playtime in minutes when available. |
| `authorNumReviews` | Author review count when available. |
| `observedAt` | Actor observation timestamp. |

***

### `REVIEW_SCORE_CHANGE`

This record is free.

It appears only after a baseline exists and Steam's native:

```text
review_score_desc
```

changes between observations.

Example:

```text
Mostly Positive
→
Very Positive
```

The Actor does not calculate its own review-score category.

It stores:

```text
previousScoreDesc
currentScoreDesc
native
```

where `native` is the Steam `query_summary` projection.

***

### Native Steam score block

The free score summary can include:

```text
reviewScore
reviewScoreDesc
totalPositive
totalNegative
totalReviews
```

These values come directly from Steam's response.

They are not reconstructed from only the fetched recent page.

***

### `APP_REVIEW_SUMMARY`

Every successfully processed dimension gets a free summary.

It can include:

```text
appId
appLabel
dimensionLanguage
baseline
reviewsFetched
newReviews
reviewsDelivered
seenBefore
skippedNoId
velocityPer24h
scoreNative
observedAt
```

#### Velocity meaning

`velocityPer24h` counts the fetched review records whose creation timestamp falls within the previous 24 hours.

It is **not** guaranteed to equal every review Steam received in the last 24 hours when your `maxReviewsPerQuery` window is smaller than that volume.

***

### `RUN_SUMMARY`

The final run summary is free.

It can include:

```text
billableRecords
freeRecords
baselineDimensions
scoreChanges
httpRequests
http429
httpRetries
capReason
qualityAlert
sourceUnavailable
warnings
units
cost
pricingLabel
```

This makes a quiet run visible even when no new review is billable.

***

### Persistent state

Each game × language dimension stores a bounded list of recent seen review IDs.

The current state cap is:

```text
10,000 recommendation IDs
```

per dimension.

For normal monitoring this provides a long dedup horizon.

Extremely high-volume dimensions can eventually age old IDs out of bounded state.

Because the Actor reads only the recent feed, IDs that have fallen far outside the recent source window normally do not reappear.

***

### Request pacing and retries

The Steam client enforces a minimum spacing of:

```text
2 seconds
```

between requests.

Retryable conditions use a controlled backoff ladder:

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

with jitter.

The Actor handles:

- HTTP 429;
- applicable 5xx responses;
- network failures;
- timeouts;
- unexpected source shape.

It does not attempt to bypass Steam access controls.

***

### Scheduling

This Actor is intended for recurring execution.

A practical starting point:

```text
daily
```

for normal games.

During launches or high-volume events, consider:

```text
hourly
```

or another interval appropriate to expected review volume.

Remember:

```text
expected new reviews between runs
<
maxReviewsPerQuery
```

is the condition you want for reliable novelty capture.

***

### Recommended scheduled workflow

1. Add games and review languages.
2. Run once to create the free baseline.
3. Save the input as an Apify **Task**.
4. Open **Schedules**.
5. Choose the monitoring cadence.
6. Send future `NEW_REVIEW` records downstream.

Possible destinations:

- Slack;
- Discord;
- Teams;
- email workflows;
- Google Sheets;
- n8n;
- Make;
- databases;
- dashboards;
- ticketing or feedback systems.

***

### Example launch-monitoring input

```json
{
  "apps": [
    {
      "appId": 123456,
      "label": "My Game"
    }
  ],
  "languages": [
    "english",
    "brazilian"
  ],
  "maxReviewsPerQuery": 500,
  "maxResults": 1000,
  "maxRuntimeMs": 300000
}
```

A downstream workflow can then:

- send new negative/positive reviews to a feedback channel;
- create a support or QA triage item;
- save review text to a research database;
- compare feedback by language;
- summarize batches downstream with AI;
- track Steam's native review-score description.

***

### API

Run the Actor through the Apify API:

```bash
curl -s "https://api.apify.com/v2/acts/<YOUR_USERNAME>~steam-review-monitor/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "apps":[{"appId":570,"label":"Dota 2"}],
    "languages":["english"],
    "maxReviewsPerQuery":200,
    "maxResults":500
  }'
```

Replace:

```text
<YOUR_USERNAME>
<YOUR_APIFY_TOKEN>
```

with your Apify account values.

***

### Integrations

Use with:

- Apify API;
- Tasks;
- Schedules;
- webhooks;
- n8n;
- Make;
- Google Sheets;
- Slack;
- Discord;
- Teams;
- databases;
- BI tools;
- internal applications;
- AI agents downstream.

***

### Pricing

This Actor uses **Pay Per Event**.

The code uses two custom billing events:

```text
actor-start
new-review
```

#### `actor-start`

Called once after valid input has been accepted.

Invalid input is rejected before the billing gate opens.

#### `new-review`

Charged once for each delivered `NEW_REVIEW`.

The Actor does not charge `new-review` for:

- baseline review IDs;
- already-seen review IDs;
- edited reviews with the same recommendation ID;
- `REVIEW_SCORE_CHANGE`;
- `APP_REVIEW_SUMMARY`;
- `RUN_SUMMARY`.

The **Pricing** tab on the Actor page is always the authoritative source for current prices.

***

### What is free

Free by design:

```text
first baseline
edited reviews
already-seen reviews
REVIEW_SCORE_CHANGE
APP_REVIEW_SUMMARY
RUN_SUMMARY
```

A quiet scheduled run therefore does not create a `new-review` charge.

The configured start event can still apply.

***

### Cost control

The primary controls are:

```text
apps
languages
maxReviewsPerQuery
maxResults
maxRuntimeMs
```

#### Lower-volume monitoring

Use:

- fewer dimensions;
- a lower review-read cap when the source volume is safely below it;
- a reasonable schedule.

#### Launch monitoring

Use:

- shorter schedule intervals;
- `maxReviewsPerQuery` closer to 500;
- language-specific dimensions when needed.

***

### Run health

Operational statistics are written to:

```text
STATS
```

in the default Key-Value Store.

Depending on the run, they can include:

- HTTP requests;
- retries;
- 429 responses;
- dimensions completed;
- dimensions failed;
- baseline dimensions;
- billable records;
- free records;
- score changes;
- source availability;
- quality warnings;
- runtime;
- cost metrics.

***

### Honest limits

#### Recent-feed monitor, not a full-history exporter

The Actor reads Steam's recent review feed.

It is not designed to download every historical review ever written.

#### Maximum 500 reviews per dimension per run

If more new reviews arrive between runs than the read window can contain, unseen older reviews can be missed.

Schedule high-volume games more frequently.

#### Game × language state is independent

The same app monitored in different language dimensions has separate state.

Avoid overlapping aggregate and language-specific feeds in the same run.

The revised validator blocks `all` plus specific language codes.

#### Review edits are intentionally not emitted

An edited review keeps its recommendation ID and remains already seen.

This Actor is a new-review monitor, not an edit-history monitor.

#### Score-change records use Steam's native category

The Actor does not create its own sentiment score.

#### Velocity is based on the fetched window

`velocityPer24h` counts qualifying fetched reviews, not necessarily the full 24-hour Steam volume when the read window is truncated.

#### No comment-thread or forum monitoring

The Actor does not monitor:

- Steam Community discussions;
- comments on reviews;
- forums;
- guides;
- workshop content.

#### No AI sentiment analysis

`votedUp` is the player's own Steam recommendation flag.

The Actor does not infer sentiment from review text.

#### Public source behavior can change

Steam can change rate limits, fields, or endpoint behavior.

The Actor includes retries, source-shape checks, and health signals to surface problems instead of inventing records.

***

### FAQ

#### Do I need a Steam account?

No.

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

No.

#### Does it use a browser?

No.

#### What happens on the first run?

The current recent review IDs are learned as a free baseline.

No historical recent review is emitted as `NEW_REVIEW`.

#### Why did I receive no billable reviews?

Possible reasons:

- this was the baseline;
- no unseen review ID appeared;
- the result cap stopped further delivery.

#### If a player edits a review, am I charged again?

No.

Deduplication uses `recommendationid`.

#### Can I monitor multiple games?

Yes.

The combined game × language dimension count must be 50 or less.

#### Can I monitor Portuguese reviews?

Yes.

Steam commonly uses:

```text
brazilian
```

for Brazilian Portuguese reviews.

#### Can I monitor all languages?

Yes.

Use:

```json
{
  "languages": []
}
```

#### Can I combine all languages and English?

Not in the revised input validation.

That would create overlapping feeds and is rejected.

#### Does it tell me whether the review is positive?

The source field:

```text
votedUp
```

is preserved.

#### Does it return review text?

Yes.

#### Does it return player playtime?

Yes, when Steam provides it.

The field is:

```text
playtimeForeverMin
```

#### Does it show refunds or free copies?

The output can include:

```text
refunded
receivedForFree
steamPurchase
```

when returned by Steam.

#### What is a review-score change?

A free record produced when Steam's native:

```text
review_score_desc
```

changes from the value stored on the previous run.

#### Can I schedule this Actor?

Yes.

#### Are score changes charged?

No.

#### Are summaries charged?

No.

#### What am I charged for?

The custom start event shown in Pricing plus genuinely unseen `NEW_REVIEW` records delivered after baseline.

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

No.

This is an independent community Actor using public Steam Store review data.

***

### Support

For bugs, questions, or requested fields:

```text
johnatan291303@gmail.com
```

You can also use the **Issues** tab on the Actor page.

***

### Part of the JM Forge suite

Also from the same developer:

- **Steam Game Price, Discount & Review Monitor** — monitor price, discount, catalog, and native review-count changes.
- **NHTSA Recall, Complaint & Safety Spike Monitor** — stateful US vehicle-safety monitoring.
- **ATS Salary, Skills & Seniority Intelligence** — structured hiring intelligence from public ATS boards.

JM Forge Actors remain independent tools.

Use this Actor for player-review novelty and feedback monitoring.

Use the Steam game-data monitor for catalog, pricing, and aggregate game metrics.

# Actor input Schema

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

One entry per game: { "appId": 570, "label": "Dota 2" }. A bare numeric appId also works. Find the appId in the store URL (store.steampowered.com/app/<appId>/...).

## `languages` (type: `array`):

Steam review language codes (english, brazilian, schinese, german, french...). Each language is a separate monitored dimension. Empty = all languages in one dimension.

## `maxReviewsPerQuery` (type: `integer`):

How many recent reviews each run reads per game×language (pages of 100). Keep it above your schedule interval's expected volume so nothing falls between runs — dedup guarantees no double charging.

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

Hard cap on charged NEW\_REVIEW records. The run stops gracefully and keeps what it delivered.

## `maxRuntimeMs` (type: `integer`):

Hard time cap. The Steam store rate limit is respected by construction, so large portfolios take proportionally longer.

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

Log pacing waits and per-app decisions.

## Actor input object example

```json
{
  "apps": [
    {
      "appId": 570,
      "label": "Dota 2"
    }
  ],
  "languages": [
    "english"
  ],
  "maxReviewsPerQuery": 100,
  "maxResults": 500,
  "maxRuntimeMs": 300000,
  "debug": false
}
```

# Actor output Schema

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

Default dataset containing NEW\_REVIEW, REVIEW\_SCORE\_CHANGE, APP\_REVIEW\_SUMMARY, and RUN\_SUMMARY records.

## `stats` (type: `string`):

STATS record with requests, retries, billing counters, quality signals, runtime, limits, and operational metrics.

# 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": [
        {
            "appId": 570,
            "label": "Dota 2"
        }
    ],
    "languages": [
        "english"
    ],
    "maxReviewsPerQuery": 100,
    "maxResults": 500,
    "maxRuntimeMs": 300000,
    "debug": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("johnatan029/steam-review-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 = {
    "apps": [{
            "appId": 570,
            "label": "Dota 2",
        }],
    "languages": ["english"],
    "maxReviewsPerQuery": 100,
    "maxResults": 500,
    "maxRuntimeMs": 300000,
    "debug": False,
}

# Run the Actor and wait for it to finish
run = client.actor("johnatan029/steam-review-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 '{
  "apps": [
    {
      "appId": 570,
      "label": "Dota 2"
    }
  ],
  "languages": [
    "english"
  ],
  "maxReviewsPerQuery": 100,
  "maxResults": 500,
  "maxRuntimeMs": 300000,
  "debug": false
}' |
apify call johnatan029/steam-review-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,johnatan029/steam-review-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/0j1RM4P5B0y4UR3QL/builds/dWYv7IMI5HuzeIeoL/openapi.json