# GOG Game Reviews Scraper (`automation-lab/gog-game-reviews-scraper`) Actor

🎮 Extract public GOG reviews with ratings, text, language, reviewer details, helpful votes, verified-owner labels, dates, and game-level rating context.

- **URL**: https://apify.com/automation-lab/gog-game-reviews-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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

## GOG Game Reviews Scraper

Collect public GOG game reviews as clean, structured records for sentiment research, reputation monitoring, localization, and market analysis.

The actor accepts GOG product IDs and public game URLs. It resolves each game, paginates its public review feed, applies your filters, and exports one row per review.

No GOG login, cookie, browser, proxy, or external API key is required.

### What does GOG Game Reviews Scraper do?

GOG Game Reviews Scraper extracts individual reviews from public GOG review services.

Each record can include:

- 🎮 game title, product ID, slug, and URL
- ⭐ numeric rating and game-level rating averages
- 💬 review title, review text, and language
- 👤 reviewer username, avatar, and public profile counters
- 👍 upvotes, downvotes, and net helpful votes
- ✅ GOG verified-owner labels
- 📅 creation and update dates
- 📊 total review and rating counts

Use one game for a focused export or process several games in a single run.

### Who is it for?

#### Game studios and publishers

Track feedback on your catalog, identify recurring complaints, and compare reception across releases.

#### Market researchers

Build review corpora for competitive analysis, category research, and rating benchmarks.

#### Localization teams

Filter by language to find translation issues, cultural feedback, and market-specific themes.

#### Reputation and support teams

Monitor low ratings and recent verified-owner comments so urgent feedback reaches the right team.

#### Data and AI teams

Export consistent review rows for dashboards, classifiers, embeddings, topic models, or retrieval systems.

### Why use this GOG reviews extractor?

- **Structured output:** skip fragile copy-and-paste workflows.
- **Flexible targeting:** use product IDs, game URLs, or both.
- **Useful filters:** select language, rating, date range, and verified ownership.
- **Batch support:** collect reviews from multiple GOG games together.
- **Safe pagination:** per-game and global limits keep runs predictable.
- **API-first reliability:** direct public JSON avoids browser overhead.
- **Scheduled monitoring:** rerun the same input daily or weekly.
- **Export anywhere:** download JSON, CSV, Excel, XML, or RSS from Apify.

### What GOG review data can I extract?

| Field | Type | Description |
|---|---|---|
| `productId` | string | Numeric GOG product identifier |
| `productTitle` | string | Public game title |
| `productSlug` | string | GOG product slug |
| `productUrl` | URL | Public GOG game page |
| `reviewId` | string | Stable review identifier |
| `reviewTitle` | string | Review headline |
| `reviewText` | string | Full public review text |
| `language` | string | Review locale such as `en-US` |
| `rating` | number | Rating from 1 to 5 |
| `reviewerUsername` | string | Public GOG username |
| `reviewerGamesOwned` | number | Public game counter |
| `reviewerReviewCount` | number | Public review counter |
| `upvotes` | number | Helpful upvotes |
| `downvotes` | number | Downvotes |
| `verifiedOwner` | boolean | Whether GOG labels the reviewer as an owner |
| `createdAt` | date | Review creation timestamp |
| `overallAverageRating` | number | Current game average |
| `totalReviewCount` | number | Current public review count |

The complete dataset also contains labels, status, avatar URL, update time, source URL, filtered average, and scrape timestamp.

### How much does it cost to scrape GOG game reviews?

This actor uses pay-per-event pricing.

A small one-time start event covers run initialization. A result event is charged only for each review saved to your dataset.

The current pricing is:

| Event | Free | Starter / Bronze | Scale / Silver | Business / Gold | Platinum | Diamond |
|---|---:|---:|---:|---:|---:|---:|
| Run start | $0.005 | $0.005 | $0.005 | $0.005 | $0.005 | $0.005 |
| Review saved | $0.00003293 | $0.000028634 | $0.000022335 | $0.000017181 | $0.000011454 | $0.00001 |

Higher Apify plans receive lower per-review prices. The Console shows the exact estimate before you start a run.

At the Free-tier event price, a 100-review extraction costs about **$0.0083**: the $0.005 start plus 100 × $0.00003293. This excludes any separate Apify plan charges that apply to your account.

Filters do not create paid rows for discarded reviews.

### How to scrape GOG reviews in 5 steps

1. Open the actor in Apify Console.
2. Add one or more numeric product IDs or GOG game URLs.
3. Choose review limits and optional filters.
4. Click **Start** and wait for the dataset link.
5. Export results or connect the dataset to your workflow.

For a first run, keep the prefilled Witcher 3 product ID and the 10-review limit.

### Input parameters

| Parameter | Type | Default | Purpose |
|---|---|---:|---|
| `productIds` | array | sample ID | Numeric GOG product IDs |
| `productUrls` | array | empty | Public GOG `/game/` URLs |
| `maxReviewsPerGame` | integer | 100 | Maximum matching rows per game |
| `maxReviewsTotal` | integer | 1000 | Global maximum across games |
| `languages` | array | all | Locale codes such as `en` or `de-DE` |
| `ratings` | array | all | Whole-number ratings from 1 to 5 |
| `verifiedOwnersOnly` | boolean | false | Require GOG's verified-owner label |
| `startDate` | string | empty | Inclusive `YYYY-MM-DD` start date |
| `endDate` | string | empty | Inclusive `YYYY-MM-DD` end date |
| `concurrency` | integer | 3 | Games processed in parallel |

Duplicate product IDs are processed once.

A base language such as `en` matches locales such as `en-US`.

### Input examples

#### Collect recent review records for one game

```json
{
  "productIds": ["1207664663"],
  "maxReviewsPerGame": 25,
  "maxReviewsTotal": 25
}
````

#### Collect low-rating English reviews

```json
{
  "productUrls": [
    "https://www.gog.com/en/game/the_witcher_3_wild_hunt"
  ],
  "languages": ["en"],
  "ratings": [1, 2],
  "verifiedOwnersOnly": true,
  "maxReviewsPerGame": 100,
  "maxReviewsTotal": 100
}
```

#### Monitor a date range across games

```json
{
  "productIds": ["1207664663", "1207664643"],
  "startDate": "2026-07-01",
  "endDate": "2026-07-31",
  "maxReviewsPerGame": 250,
  "maxReviewsTotal": 500,
  "concurrency": 2
}
```

### Output example

```json
{
  "productId": "1207664663",
  "productTitle": "The Witcher 3: Wild Hunt",
  "reviewId": "dd8fe86c-8335-11f1-9a01-8239e0b1b96a",
  "reviewTitle": "Bien!!!! mais",
  "reviewText": "Il manque un petit quelque chose...",
  "language": "fr-FR",
  "rating": 4,
  "reviewerUsername": "Shademaster",
  "reviewerGamesOwned": 3,
  "reviewerReviewCount": 1,
  "upvotes": 0,
  "downvotes": 0,
  "verifiedOwner": true,
  "createdAt": "2026-07-19T05:51:19.000Z",
  "overallAverageRating": 4.8,
  "totalReviewCount": 1645
}
```

Actual counts and reviews change as GOG users add feedback.

### Filtering behavior

Language matching is case-insensitive.

Supplying `en` matches `en`, `en-US`, and other English locale variants.

Ratings must be whole numbers from 1 through 5.

Date boundaries are inclusive and interpreted as UTC calendar days.

When a review date cannot be parsed, that review is excluded from date-filtered runs rather than leaking through the filter.

`verifiedOwnersOnly` checks GOG's public `verified_owner` label.

The actor keeps paging until it saves the requested number of matching reviews or reaches the end of the source.

### Tips for reliable review collection

- 🎯 Prefer product IDs when you already know them.
- 🔗 Use full public GOG game URLs, not checkout or account URLs.
- 📉 Start with 10–100 reviews when designing a workflow.
- 🌍 Use base language codes for broad locale coverage.
- 📅 Set `startDate` on scheduled runs to reduce irrelevant history.
- 🧪 Review a sample before feeding text into automated sentiment models.
- ⚙️ Keep concurrency at 3 or lower unless processing a large catalog.
- 🧾 Store the stable `reviewId` when deduplicating scheduled exports.

### Scheduling and monitoring workflows

Use an Apify schedule to run the same input daily, weekly, or monthly.

A practical reputation workflow is:

1. Select the games to monitor.
2. Filter for ratings 1 and 2.
3. Set a recent start date.
4. Run on a daily schedule.
5. Send the dataset to Slack, email, a webhook, or your warehouse.
6. Deduplicate downstream records by `reviewId`.

For localization monitoring, create separate tasks for each language group.

### Integrations

#### Google Sheets

Send each finished dataset to a spreadsheet for triage, tagging, and stakeholder comments.

#### Slack or Microsoft Teams

Trigger a webhook when new low-rating verified-owner reviews appear.

#### Make and Zapier

Start the actor from an automation, wait for completion, and route reviews by game, rating, or language.

#### Snowflake, BigQuery, and PostgreSQL

Export structured records into a warehouse for longitudinal game and sentiment reporting.

#### LLM and NLP pipelines

Use `reviewText`, `rating`, and `language` for classification, summarization, topic extraction, or embeddings.

### Use the Apify API with JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/gog-game-reviews-scraper').call({
  productIds: ['1207664663'],
  maxReviewsPerGame: 50,
  maxReviewsTotal: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Use the Apify API with Python

```python
from apify_client import ApifyClient

client = ApifyClient(token='YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/gog-game-reviews-scraper').call(run_input={
    'productIds': ['1207664663'],
    'ratings': [1, 2],
    'maxReviewsPerGame': 50,
    'maxReviewsTotal': 50,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use the Apify API with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~gog-game-reviews-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"productIds":["1207664663"],"maxReviewsPerGame":25,"maxReviewsTotal":25}'
```

Use the returned run and dataset IDs to fetch status and output.

### Use GOG reviews through MCP

Connect the actor to AI assistants through Apify's MCP server.

#### Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/gog-game-reviews-scraper"
```

#### Claude Desktop, Cursor, or VS Code

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/gog-game-reviews-scraper"
    }
  }
}
```

Example prompts:

- “Collect 50 English reviews for GOG product 1207664663.”
- “Find verified-owner one-star and two-star reviews for this GOG game URL.”
- “Summarize repeated complaints in the resulting GOG reviews dataset.”

### Data quality and limitations

This actor reads public data supplied by GOG services.

Review availability, aggregate values, and labels can change over time.

A GOG game URL may point to a specific edition whose product ID differs from another edition with a similar title.

The actor reports the resolved product ID so you can reproduce the same scope.

Product metadata is best-effort; review extraction can continue by ID if optional metadata is temporarily unavailable.

The public GOG endpoints are undocumented, so upstream response changes may require an actor update.

### Is scraping GOG reviews legal?

Public review data can still contain personal data such as usernames and user-written text.

Use the actor only for lawful purposes and follow applicable privacy, copyright, database, and platform rules.

Do not use output for harassment, identity profiling, spam, or decisions that unfairly affect individuals.

Respect deletion requests and retention requirements that apply to your organization.

You are responsible for your inputs, processing purpose, and downstream use.

### Troubleshooting

#### Why did my GOG URL not resolve?

Use a public URL containing `/game/`, such as `https://www.gog.com/en/game/the_witcher_3_wild_hunt`.

Checkout, account, support, and forum URLs are intentionally outside the accepted scope.

If resolution still fails, provide the numeric product ID shown in prior output or GOG's public product data.

#### Why are there fewer rows than my limit?

Your filters may match fewer public reviews, the game may have fewer reviews, or the global limit may have been reached first.

The actor does not duplicate rows merely to fill a requested limit.

#### Why did the run fail instead of returning an empty dataset?

Invalid inputs and total upstream extraction failures fail closed. This prevents scheduled workflows from treating broken extraction as a valid “no reviews” signal.

#### Can I scrape private account data?

No. The actor intentionally supports only anonymous public game and review surfaces.

### Frequently asked questions

#### Can I process several games?

Yes. Add multiple IDs or URLs. Duplicate resolved IDs are removed.

#### Can I get only English reviews?

Yes. Set `languages` to `["en"]`.

#### Can I get only verified purchases?

Use `verifiedOwnersOnly: true`. The output reflects GOG's public `verified_owner` label.

#### Can I scrape all reviews?

Raise both limits according to the expected source size. For large backfills, split catalogs into manageable tasks.

#### Does this actor use a proxy?

No. Version 0.1 uses anonymous public HTTP and JSON routes directly.

#### Can I export CSV or Excel?

Yes. Open the dataset and select the export format in Apify Console.

### Related scrapers

- [Steam Game Reviews Scraper](https://apify.com/automation-lab/steam-game-reviews-scraper) — collect individual Steam reviews and author context.
- [Steam Curator Reviews Scraper](https://apify.com/automation-lab/steam-curator-reviews-scraper) — collect curator recommendations and review text.
- [Steam Store Scraper](https://apify.com/automation-lab/steam-store-scraper) — collect game catalog and product metadata.

These automation-lab actors can complement GOG reviews in cross-store game research.

### Support

For reproducible support, include:

- the run URL or run ID
- a sanitized copy of the input
- the expected product or filter behavior
- the first relevant warning or error from the log

Do not include Apify tokens, GOG credentials, or other secrets.

# Actor input Schema

## `productIds` (type: `array`):

Enter numeric GOG product IDs, such as 1207664663 for The Witcher 3.

## `productUrls` (type: `array`):

Enter public GOG /game/ URLs. The scraper resolves each URL to its product ID.

## `maxReviewsPerGame` (type: `integer`):

Stop after saving this many matching reviews for each game.

## `maxReviewsTotal` (type: `integer`):

Global safety limit across all supplied games.

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

Optional language codes such as en, en-US, de, or fr. Leave empty for every language.

## `ratings` (type: `array`):

Optional whole-number ratings from 1 to 5. Leave empty for every rating.

## `verifiedOwnersOnly` (type: `boolean`):

Save only reviews carrying GOG's verified\_owner label.

## `startDate` (type: `string`):

Optional inclusive start date in YYYY-MM-DD format.

## `endDate` (type: `string`):

Optional inclusive end date in YYYY-MM-DD format.

## `concurrency` (type: `integer`):

Number of games processed in parallel. Keep the default for polite, stable API use.

## Actor input object example

```json
{
  "productIds": [
    "1207664663"
  ],
  "maxReviewsPerGame": 10,
  "maxReviewsTotal": 10,
  "verifiedOwnersOnly": false,
  "concurrency": 2
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "productIds": [
        "1207664663"
    ],
    "maxReviewsPerGame": 10,
    "maxReviewsTotal": 10,
    "concurrency": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/gog-game-reviews-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 = {
    "productIds": ["1207664663"],
    "maxReviewsPerGame": 10,
    "maxReviewsTotal": 10,
    "concurrency": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/gog-game-reviews-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "productIds": [
    "1207664663"
  ],
  "maxReviewsPerGame": 10,
  "maxReviewsTotal": 10,
  "concurrency": 2
}' |
apify call automation-lab/gog-game-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/gog-game-reviews-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GOG Game Reviews Scraper",
        "description": "🎮 Extract public GOG reviews with ratings, text, language, reviewer details, helpful votes, verified-owner labels, dates, and game-level rating context.",
        "version": "0.1",
        "x-build-id": "UHTCFr2NELRWmcGD0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~gog-game-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-gog-game-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~gog-game-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-gog-game-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~gog-game-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-gog-game-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "productIds": {
                        "title": "GOG product IDs",
                        "type": "array",
                        "description": "Enter numeric GOG product IDs, such as 1207664663 for The Witcher 3.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "productUrls": {
                        "title": "GOG game URLs",
                        "type": "array",
                        "description": "Enter public GOG /game/ URLs. The scraper resolves each URL to its product ID.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerGame": {
                        "title": "Maximum reviews per game",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after saving this many matching reviews for each game.",
                        "default": 100
                    },
                    "maxReviewsTotal": {
                        "title": "Maximum reviews in total",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Global safety limit across all supplied games.",
                        "default": 1000
                    },
                    "languages": {
                        "title": "Review languages",
                        "type": "array",
                        "description": "Optional language codes such as en, en-US, de, or fr. Leave empty for every language.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ratings": {
                        "title": "Ratings",
                        "type": "array",
                        "description": "Optional whole-number ratings from 1 to 5. Leave empty for every rating.",
                        "items": {
                            "type": "integer",
                            "minimum": 1,
                            "maximum": 5
                        }
                    },
                    "verifiedOwnersOnly": {
                        "title": "Verified owners only",
                        "type": "boolean",
                        "description": "Save only reviews carrying GOG's verified_owner label.",
                        "default": false
                    },
                    "startDate": {
                        "title": "Reviews from date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Optional inclusive start date in YYYY-MM-DD format."
                    },
                    "endDate": {
                        "title": "Reviews through date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Optional inclusive end date in YYYY-MM-DD format."
                    },
                    "concurrency": {
                        "title": "Concurrent games",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of games processed in parallel. Keep the default for polite, stable API use.",
                        "default": 3
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```