# GOG Games Scraper (`axiomworks/gog-games-scraper`) Actor

Reads GOG’s public JSON catalog and returns records for games, packs, and DLC. Each result can include its title, slug, release date, developers, publishers, genres, tags, operating systems, review data, and cover URL. Choose product types, search terms, genres, and regional catalog settings.

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

## Pricing

from $1.63 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

**Returns:** one row per game, pack or DLC with `title`, `slug`, `priceFinal`, `priceBase`, `discountPercent`, `features`, `genres` and `reviewsRating`.
**Input:** `{"searchQuery": "witcher", "maxItems": 20}`
**Best for:** GOG price and discount monitoring, game catalog datasets, and deal alerts filtered by genre.

```json
{
    "id": "1207658930",
    "title": "The Witcher 2: Assassins of Kings Enhanced Edition",
    "slug": "the_witcher_2",
    "productType": "game",
    "priceFinal": 2.99,
    "currency": "USD",
    "discountPercent": 85,
    "genres": [
        "Role-playing",
        "Action",
        "Fantasy"
    ]
}
```

### What does GOG Games Scraper do?

GOG Games Scraper is a GOG scraper and GOG API alternative that reads the public GOG.com game catalog and returns it as clean, structured rows. You can search by title, filter by genre, show only discounted products, pick the product types (game, pack, DLC) and sort by trending, price, release date, title or review rating. Each row holds the current price, the base price, the discount percentage, the currency, the release date, developers, publishers, genres, tags, supported operating systems, review rating and count, a cover image URL and the store page link.

The Actor calls the open JSON catalog that the GOG website itself uses. It needs no login, no browser and no API key, so runs are quick and light. It is built for three jobs: tracking GOG prices and sales over time, building a dataset of games with their metadata, and finding discounted games in a genre you care about.

Prices follow the country and currency you choose. Set `countryCode` and `currencyCode` to get regional prices, for example Germany and EUR. Results are paged at 48 products per request, with a pause between requests, until your `maxItems` limit is reached or the catalog runs out.

### What data can you get from GOG?

| Field | Description | Example |
|---|---|---|
| `id` | Stable GOG product ID | `1207658930` |
| `title` | Game title | `The Witcher 2: Assassins of Kings Enhanced Edition` |
| `slug` | GOG URL slug | `the_witcher_2` |
| `productType` | game, pack or dlc | `game` |
| `releaseDate` | Release date, YYYY.MM.DD | `2012.04.17` |
| `releaseDateIso` | Release date as YYYY-MM-DD, falls back to the store release date | `2012-04-17` |
| `storeReleaseDateIso` | Date the product was added to GOG, YYYY-MM-DD | `2023-08-17` |
| `priceFinal` | Current price | `2.99` |
| `priceBase` | Regular price before discount | `19.99` |
| `currency` | Currency code of the prices | `USD` |
| `discountPercent` | Current discount in percent, 0 if not on sale | `85` |
| `developers` | Developer names | `["CD PROJEKT RED"]` |
| `publishers` | Publisher names | `["CD PROJEKT RED"]` |
| `genres` | Genre names | `["Role-playing", "Action", "Fantasy"]` |
| `features` | Game feature names from the catalog | `["Cloud saves", "Controller support"]` |
| `tags` | Tag names | `["Story Rich", "Atmospheric"]` |
| `operatingSystems` | Supported platforms | `["windows", "linux", "osx"]` |
| `reviewsRating` | GOG user rating score, 0-50 scale as returned by GOG | `47` |
| `ratingOutOf5` | `reviewsRating` divided by 10, null when unrated | `4.7` |
| `reviewsCount` | Number of user reviews | `14522` |
| `coverUrl` | Cover image URL | `https://images.gog-statics.com/8355e657...png` |
| `storeUrl` | Product page on GOG | `https://www.gog.com/en/game/the_witcher_2` |
| `sourceUrl` | Catalog request the record came from | `https://catalog.gog.com/v1/catalog?...` |

Features are the catalog's own labels, such as Achievements, Cloud saves, Controller support, Overlay and Single-player. They help you identify titles that suit a controller-based setup or sync saved progress. The list is copied from each product's source JSON; it does not assert that a feature works on every operating system or every edition. A missing feature list is null, while a supplied empty list stays empty. No detail-page requests or AI enrichment are needed to collect this field.

Some products have no price (for example unreleased or free items) or no reviews yet. In that case the price or review fields are `null` instead of being guessed.

### How to use GOG Games Scraper

1. Open the Actor in Apify Console and go to the Input tab.
2. Optionally type a search query, tick Discounted only, add genre slugs such as `rpg`, and choose a sort field.
3. Set Maximum results to the number of games you want.
4. Click Start. The run finishes in seconds for a few hundred games.
5. Open the Output tab and export the dataset as JSON, CSV, Excel, XML or RSS.

Tips:
Leave all filters empty to get the trending catalog.
Genre filters use GOG slugs, for example `rpg`, `action`, `strategy`, `adventure`, `simulation`.
To watch prices over time, schedule the Actor daily and compare `priceFinal` per `id`.
`maxItems` is exact: a run with `maxItems` 7 returns 7 rows when at least 7 match.
No proxy is needed by default. If your runs are ever blocked, enable Apify Proxy in the Proxy section. Blocked requests are retried on a new IP. HTML block detection checks page titles and short visible messages, so loading an anti-bot script alone does not trigger retries.

Price-range filtering uses the current selling price, not the regular price. For a regional budget shortlist, set `minPrice` and `maxPrice` together with `countryCode` and `currencyCode`. For example, `{"minPrice": 5, "maxPrice": 10, "sortBy": "price", "sortOrder": "asc", "maxItems": 20}` requests a bounded catalog sorted from lowest current price upward. Bounds are inclusive, and either bound may be omitted. An omitted lower bound starts at zero; an omitted upper bound uses a generous catalog ceiling. Both inputs are off by default, so existing requests keep their current behavior. The Actor validates that bounds are finite, non-negative numbers and that the lower bound does not exceed the upper bound.

GOG applies the range on the same catalog request that supplies the records. Products excluded by the filters are not pushed or charged as results. Other filters still apply, so a narrow title, genre, sale and price combination may have fewer matches than `maxItems`. Empty results are a successful run with a message suggesting fewer title keywords, removing genre or price filters, disabling the sale filter, or including DLC. Search accepts title keywords rather than URLs or product IDs. Every query word must appear in the returned title, so fewer words can produce more matches. The current local prefill returned eight matching Witcher records; maxItems is a ceiling when fewer products match, not a promise of twenty records. Persistent blocking is also reported as a successful empty run after bounded retries. Unexpected catalog shapes are logged and do not produce placeholder dataset rows.

### Input

| Field | Type | Required | Description |
|---|---|---|---|
| `searchQuery` | string | No | Text to search in game titles, e.g. `witcher`. Empty browses the whole catalog. |
| `discountedOnly` | boolean | No | Only products currently on sale. Default false. |
| `minPrice` | number | No | Inclusive lower current-price bound in `currencyCode`; editor default 0, omitted API value leaves the lower bound unset. |
| `maxPrice` | number | No | Inclusive upper current-price bound in `currencyCode`; editor default 1000000, omitted API value leaves the upper bound unset. |
| `genres` | array of strings | No | GOG genre slugs, e.g. `["rpg"]`. Empty means all genres. |
| `productTypes` | array | No | game, pack and/or dlc. Default `["game","pack"]`. |
| `sortBy` | string | No | trending, price, releaseDate, title or reviewsRating. Default trending. |
| `sortOrder` | string | No | `desc` or `asc`. Default `desc`. |
| `countryCode` | string | No | Two-letter country for regional prices. Default `US`. |
| `currencyCode` | string | No | Three-letter currency code. Default `USD`. |
| `locale` | string | No | Language locale, e.g. `en-US`. Default `en-US`. |
| `maxItems` | integer | No | Maximum results, 1-10000. Default 50. |
| `proxyConfiguration` | object | No | Proxy settings. Default: no proxy. |

Example:

```json
{
    "searchQuery": "",
    "discountedOnly": true,
    "genres": ["rpg"],
    "productTypes": ["game", "pack"],
    "sortBy": "reviewsRating",
    "sortOrder": "desc",
    "countryCode": "US",
    "currencyCode": "USD",
    "locale": "en-US",
    "maxItems": 40
}
```

### Output

Each run writes one dataset item per product. Here is a real item from a test run:

```json
[
    {
        "id": "1207658930",
        "title": "The Witcher 2: Assassins of Kings Enhanced Edition",
        "slug": "the_witcher_2",
        "productType": "game",
        "releaseDate": "2012.04.17",
        "priceFinal": 2.99,
        "priceBase": 19.99,
        "currency": "USD",
        "discountPercent": 85,
        "developers": ["CD PROJEKT RED"],
        "publishers": ["CD PROJEKT RED"],
        "genres": ["Role-playing", "Action", "Fantasy"],
        "operatingSystems": ["windows", "linux", "osx"],
        "reviewsRating": 47,
        "reviewsCount": 14522,
        "coverUrl": "https://images.gog-statics.com/8355e657a19311b158a3553a154e109199d6991c7791a20c3305af1f84d15ed7.png",
        "storeUrl": "https://www.gog.com/en/game/the_witcher_2"
    }
]
```

You can download the data as JSON, CSV, Excel, XML or RSS, or read it through the Apify API.

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

GOG Games Scraper is charged per result. You pay only for the results returned, and `maxItems` caps how many that can be. See the Pricing tab for the current price. Because the Actor uses the open catalog JSON without a browser, runs use very little compute.

### Use with AI agents (MCP)

Connect GOG Games Scraper to Claude, Cursor or any MCP client through the Apify MCP server:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com/?tools=axiomworks/gog-games-scraper"
        }
    }
}
```

Example prompts:

1. "List the 20 best-reviewed discounted RPGs on GOG with their current price and discount."
2. "Search GOG for Witcher games and give me the price in EUR for Germany."
3. "Get the 50 trending games on GOG and show developers and release dates."

### Integrations and API

Run GOG Games Scraper from your own code with the Apify API. Set `APIFY_TOKEN` to your Apify API token (send it in the `Authorization` header, never in the URL).

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("axiomworks/gog-games-scraper").call(run_input={"discountedOnly": True, "maxItems": 50})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

**JavaScript**

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

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });
const run = await client.actor('axiomworks/gog-games-scraper').call({ discountedOnly: true, maxItems: 50 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**cURL**

```bash
curl -X POST "https://api.apify.com/v2/acts/axiomworks~gog-games-scraper/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"discountedOnly": true, "maxItems": 50}'
```

The Integrations tab connects the Actor to Make, Zapier, n8n, Google Sheets and webhooks, so you can send new deals to a spreadsheet or a chat channel on a schedule.

### FAQ

**How many games can I get in one run?**
Up to 10,000 per run through `maxItems`. The catalog holds several thousand products, and filters narrow that down.

**Why did my run return 0 results?**
The filters matched nothing. A search query combined with discounted only and a genre can be very narrow. Remove a filter and try again. The run then succeeds with a warning instead of failing.

**What game features are returned?**
Features are the catalog's own labels, such as Achievements, Cloud saves, Controller support, Overlay and Single-player. They help you identify titles that suit a controller-based setup or sync saved progress. The list is copied from each product's source JSON; it does not assert that a feature works on every operating system or every edition. A missing feature list is null, while a supplied empty list stays empty. No detail-page requests or AI enrichment are needed to collect this field.

**Why is a price empty?**
Some products have no price in the chosen country, for example unreleased titles. Those fields are `null`.

**How do I get prices in another currency?**
Set `countryCode` and `currencyCode`, for example `DE` and `EUR`. GOG decides which combinations it supports.

**What does reviewsRating mean?**
It is the user rating score exactly as GOG returns it, on a 0-50 scale, so 47 corresponds to 4.7 out of 5.

**How fresh is the data?**
Every run reads the catalog live, so prices and discounts match what GOG shows at that moment.

**Does it need a proxy?**
No. The catalog is open. A proxy option is there if you ever get blocked, and blocked requests are retried automatically.

**Can I schedule it?**
Yes. Use Apify schedules to run it daily or hourly and compare results over time.

**Are DLC items included?**
Only if you add `dlc` to `productTypes`. The default is games and packs.

### Is it legal to scrape GOG?

The Actor collects only publicly available catalog data that loads without logging in: game titles, prices, genres and review scores. It does not access accounts or any private data. You are responsible for how you use the data and for following the laws and terms that apply to you, including copyright and database rights. This is not legal advice. This Actor is an independent tool and is not affiliated with or endorsed by GOG.

### Feedback

Found a bug or need a field that isn't here? Open an issue on the Issues tab and we'll look at it.

# Actor input Schema

## `searchQuery` (type: `string`):

Title keywords, e.g. "witcher", up to 200 characters; accepts text, not URLs or product IDs. Omit or leave empty to browse trending games and packs. Every query word must occur in the returned title. All supplied filters apply together; no matches returns zero rows successfully. Adjust keywords or remove filters.

## `discountedOnly` (type: `boolean`):

Include only currently discounted products when true, e.g. true. Default false includes both sale and full-price products. Combines with searchQuery, genres, productTypes and price bounds.

## `genres` (type: `array`):

GOG genre slugs as a string array, e.g. \["rpg", "action"]. Default \[] applies no genre filter. Use slugs rather than display names; role-playing is also accepted as rpg. Other filters still apply.

## `productTypes` (type: `array`):

Product types as a string array, e.g. \["game", "dlc"]. Allowed values: game, pack, dlc. Default \["game", "pack"] excludes DLC; an empty array also uses that default.

## `sortBy` (type: `string`):

Catalog sort field: trending, price, releaseDate, title or reviewsRating, e.g. "price". Default trending returns trending products first with the default desc order. Set sortOrder to asc for lowest price or alphabetical title first.

## `sortOrder` (type: `string`):

Sort direction for sortBy: "asc" or "desc", e.g. "asc" with sortBy "price" for cheapest first. Default desc gives highest prices, newest release dates or highest ratings first for those fields.

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

Two-letter country code for regional availability and prices, e.g. "US" or "DE"; default US. Use with currencyCode, such as DE and EUR. Does not choose the text language; locale does that.

## `currencyCode` (type: `string`):

Three-letter currency code for priceFinal, priceBase and price bounds, e.g. "USD" or "EUR"; default USD. Combine with countryCode for the desired pricing region. Currency availability depends on GOG.

## `locale` (type: `string`):

Text language locale, two letters with an optional two-letter region, e.g. "en-US" or "de-DE"; default en-US. Does not set currency. Search title keywords must match the titles returned for this locale.

## `maxItems` (type: `integer`):

Total row limit across all catalog pages, 1-10000, e.g. 20; default 50. Returns exactly this many when enough products match, otherwise fewer. Combined filters may exhaust results earlier; this is not a per-page limit.

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

Apify proxy settings object, e.g. {"useApifyProxy": false}; default runs without a proxy. Enable {"useApifyProxy": true} if catalog requests are blocked. Persistent blocking returns zero rows successfully with guidance to retry or change proxy settings.

## `minPrice` (type: `number`):

Inclusive minimum current selling price in currencyCode, e.g. 5. Non-negative number; editor default 0. Omit to leave the lower bound unset. Use with maxPrice for a range; must not exceed maxPrice. Country and currency affect matching products.

## `maxPrice` (type: `number`):

Inclusive maximum current selling price in currencyCode, e.g. 10. Non-negative number; editor default 1000000. Omit to leave the upper bound unset. Use with minPrice for a range; must be at least minPrice. All other filters still apply.

## Actor input object example

```json
{
  "searchQuery": "witcher",
  "discountedOnly": false,
  "genres": [],
  "productTypes": [
    "game",
    "pack"
  ],
  "sortBy": "trending",
  "sortOrder": "desc",
  "countryCode": "US",
  "currencyCode": "USD",
  "locale": "en-US",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "minPrice": 0,
  "maxPrice": 1000000
}
```

# Actor output Schema

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

Dataset with one item per result, in the order found.

# 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 = {
    "searchQuery": "witcher",
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("axiomworks/gog-games-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 = {
    "searchQuery": "witcher",
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": False },
}

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

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

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

```

## CLI example

```bash
echo '{
  "searchQuery": "witcher",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call axiomworks/gog-games-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,axiomworks/gog-games-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/kQsAobvgbFmmH4LnE/builds/ItqMlpdhqyv1VI1o5/openapi.json