# RAWG Video Game Catalog Scraper (`automation-lab/rawg-video-game-catalog`) Actor

Search RAWG's public video game catalog and export game identity, release, platform, genre, developer, publisher, rating, media, and source data.

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

## Pricing

from $2.76 / 1,000 item extracteds

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?

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

## RAWG Video Game Catalog Scraper

Search the **RAWG video game catalog** and turn public game pages into structured records.
Export game IDs, titles, release dates, platforms, genres, developers, publishers, ratings,
store links, images, descriptions, official websites, and canonical RAWG URLs.

The Actor works anonymously against RAWG's public web catalog.
It does not ask you for a RAWG API key, cookies, or an account.
Use it for one-off game research, scheduled catalog refreshes, enrichment pipelines,
and cross-platform game-market datasets.

### What does this RAWG catalog scraper do?

The Actor supports two input routes:

1. Search RAWG with one or more game names or catalog keywords.
2. Enrich one or more specific `rawg.io/games/...` URLs.

Both routes produce the same normalized game record.
Inputs are deduplicated by stable RAWG game ID.
Optional genre, platform, and release-date filters apply to both routes.

By default, every discovered game receives a detail request.
That detail step adds developers, publishers, descriptions, official websites,
store links, tags, ESRB ratings, and additional media when RAWG publishes them.
Disable it only when a lightweight identity and rating catalog is enough.

### Who is it for?

- **Game data teams** enriching internal title catalogs with cross-platform identity.
- **Market researchers** comparing releases, platforms, genres, ratings, and publishers.
- **Publishers and studios** monitoring related titles or category changes on a schedule.
- **Analysts** building CSV, Excel, JSON, or database-ready game datasets.
- **Developers and AI agents** that need typed game records instead of page HTML.

This Actor is for catalog metadata, not live prices, ownership data, private profiles,
or downloadable game assets.

### Why use this Actor?

- No user-supplied RAWG credential is required.
- Search and direct URL enrichment share one stable output contract.
- Full-detail mode includes developer and publisher data missing from lightweight lists.
- Results include canonical source URLs and collection timestamps for provenance.
- Bounded retries handle temporary network errors and rate limits.
- A public page-state fallback protects direct detail enrichment if JSON detail fails.
- The HTTP-only implementation runs at 256 MB without browser overhead.

### What data can I extract?

| Group | Fields |
| --- | --- |
| Identity | `rawgId`, `slug`, `name`, `sourceUrl` |
| Release | `released`, `updated`, `tba`, `playtimeHours` |
| Classification | `platforms`, `genres`, `tags`, `esrbRating` |
| Companies | `developers`, `publishers` |
| Ratings | `rating`, `ratingTop`, `ratingsCount`, `reviewsCount`, `metacritic` |
| Links | `website`, `stores`, `sourceUrl` |
| Media | `backgroundImage`, `backgroundImageAdditional` |
| Text | `description` |
| Provenance | `searchQuery`, `scrapedAt` |

Fields can be null or empty when RAWG does not publish the value.
The Actor does not manufacture missing metadata.

### Getting started

1. Open the Actor in Apify Console.
2. Enter at least one **Search query** or **RAWG game URL**.
3. Keep **Fetch full game details** enabled for complete enrichment.
4. Set **Maximum games** to control output and spend.
5. Add optional genre, platform, or release-date filters.
6. Click **Start**.
7. Open the Dataset tab to preview or export records.

The default input searches for `The Witcher` and limits the run to a small sample.

### Input parameters

#### `searchQueries`

An array of game names or keywords.
Queries run in order and share one global `maxItems` limit.
Examples: `The Witcher`, `city builder`, or `co-op survival`.

#### `startUrls`

A list of public RAWG game URLs.
Only URLs shaped like `https://rawg.io/games/<slug>` are accepted.
Other hosts and non-game RAWG pages fail validation.

#### `maxItems`

The maximum number of unique game records saved across every input.
Allowed range: 1–10,000.
The default is 100; the Console prefill uses 10.

#### `fetchDetails`

Defaults to `true`.
Keep it enabled for developers, publishers, descriptions, store links,
official websites, tags, ESRB ratings, and additional images.
Set it to `false` for faster search-list exports where those fields may be empty.

#### `genres` and `platforms`

Optional case-insensitive names or RAWG slugs.
A record is kept if it matches at least one requested value in each supplied filter.
Examples: `action`, `role-playing-games-rpg`, `PC`, `playstation5`, `nintendo-switch`.

#### `releaseDateFrom` and `releaseDateTo`

Optional inclusive dates in `YYYY-MM-DD` format.
Use them to focus recurring jobs on a release window.
An invalid date shape or reversed range fails before collection begins.

#### `ordering`

Choose relevance, name, release date, RAWG rating, or Metacritic score.
Options beginning with `-` sort descending.
Ordering affects search inputs; direct URLs retain input order.

### Input example: search and enrich

```json
{
  "searchQueries": ["co-op survival"],
  "genres": ["action"],
  "platforms": ["pc"],
  "releaseDateFrom": "2020-01-01",
  "ordering": "-rating",
  "maxItems": 25,
  "fetchDetails": true
}
```

### Input example: enrich exact games

```json
{
  "startUrls": [
    { "url": "https://rawg.io/games/the-witcher-3-wild-hunt" }
  ],
  "maxItems": 1,
  "fetchDetails": true
}
```

### Output example

The default dataset contains one item per unique game.
This abbreviated record reflects current Actor behavior:

```json
{
  "rawgId": 3328,
  "slug": "the-witcher-3-wild-hunt",
  "name": "The Witcher 3: Wild Hunt",
  "released": "2015-05-18",
  "platforms": [
    { "id": 4, "name": "PC", "slug": "pc", "releasedAt": "2015-05-18" }
  ],
  "genres": [
    { "id": 4, "name": "Action", "slug": "action" },
    { "id": 5, "name": "RPG", "slug": "role-playing-games-rpg" }
  ],
  "developers": [
    { "id": 9023, "name": "CD PROJEKT RED", "slug": "cd-projekt-red" }
  ],
  "publishers": [
    { "id": 7411, "name": "CD PROJEKT RED", "slug": "cd-projekt-red" }
  ],
  "rating": 4.64,
  "metacritic": 92,
  "backgroundImage": "https://media.rawg.io/media/games/...jpg",
  "sourceUrl": "https://rawg.io/games/the-witcher-3-wild-hunt",
  "searchQuery": null,
  "scrapedAt": "2026-09-07T20:00:00.000Z"
}
```

Values are snapshots and can change upstream.
Export the dataset as JSON, JSONL, CSV, Excel, XML, or RSS from Apify.

### How much does it cost to extract RAWG game records?

Pricing is pay per event:

- one **Start** event is charged once per run;
- one **Game record** event is charged for each accepted dataset item;
- filtered-out, duplicate, empty, and failed records are not charged as game records.

The current BRONZE price is **$0.0046 per game record**, plus a **$0.005 start fee**.
At that tier, 1 game costs about $0.0096, 10 games about $0.051,
and 100 games about $0.465.
Higher subscription tiers receive the lower per-record prices shown in Console.
Apify platform usage is included in event pricing; it is not added as a separate bill.

Use `maxItems` to place a hard ceiling on record volume.

### Recurring catalog enrichment workflow

Create a Task with stable queries and filters, then schedule it daily or weekly.
Each result includes `rawgId`, `updated`, `sourceUrl`, and `scrapedAt`.
Use the stable `rawgId` to upsert rows and compare the new snapshot with your previous run.

A typical workflow is:

1. Search one genre or market segment.
2. Restrict the release window and platforms.
3. Fetch full details.
4. Export to a dataset, spreadsheet, warehouse, or webhook.
5. Compare changed release, rating, platform, developer, and publisher fields.

The Actor outputs snapshots; it does not maintain history or send change alerts itself.

### Integration patterns

- Schedule a Task and send successful-run webhooks to a data pipeline.
- Use Make or Zapier to append new game records to a sheet.
- Pull dataset items into BigQuery, Snowflake, PostgreSQL, or a lakehouse.
- Feed descriptions and classification fields into search or recommendation systems.
- Join RAWG IDs and source URLs with an internal title master.
- Use `fetchDetails: false` for discovery, then enrich selected URLs in a second Task.

### Run through the Apify API with cURL

Replace `YOUR_TOKEN` with an Apify API token:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~rawg-video-game-catalog/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchQueries":["strategy games"],"maxItems":10,"fetchDetails":true}'
```

To wait for results in one request, use the `run-sync-get-dataset-items` endpoint.

### Run with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/rawg-video-game-catalog').call({
  searchQueries: ['strategy games'],
  maxItems: 10,
  fetchDetails: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Run with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/rawg-video-game-catalog').call(run_input={
    'searchQueries': ['strategy games'],
    'maxItems': 10,
    'fetchDetails': True,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use with MCP and AI agents

Add the Actor to Claude Code through Apify MCP:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/rawg-video-game-catalog"
```

#### Claude Desktop, Cursor, and VS Code setup

Claude Desktop, Cursor, and VS Code can use this equivalent MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/rawg-video-game-catalog"
    }
  }
}
```

#### Example MCP prompts

After setup, try these example prompts through MCP:

- “Search RAWG for ten recent PC city builders and return developer and rating fields.”
- “Enrich this RAWG game URL and summarize its platforms, genres, and stores.”
- “Build a scheduled input for highly rated action games released since 2024.”

### Reliability and retry behavior

The Actor first reads RAWG's anonymous web application configuration,
then uses the same public catalog data surface for bounded search and detail requests.
Transient network failures, HTTP 429, and temporary 5xx responses receive up to three attempts
with exponential backoff.

Deterministic client errors are not retried blindly.
If a detail JSON request fails, the Actor tries that game's public HTML state once.
If RAWG removes or changes the anonymous catalog surface, the run fails clearly
instead of returning a misleading empty dataset.

No proxy or browser mode is enabled.

### Limits and data freshness

- Output is limited to metadata RAWG exposes publicly at run time.
- RAWG can change fields, rankings, catalog coverage, rate limits, or page structure.
- Search relevance belongs to RAWG and may vary between runs.
- Missing developers, publishers, ratings, dates, stores, or images remain null or empty.
- Filters can naturally produce zero records.
- Full-detail mode makes one additional request per candidate and takes longer.
- `maxItems` limits accepted records, not necessarily upstream candidates inspected.
- This Actor does not scrape reviews, user profiles, prices, or game binaries.

### Legality and responsible use

Collect only public metadata you are allowed to use.
Review RAWG's terms, robots guidance, database rights, and applicable law for your use case.
Do not use the Actor to overload RAWG, evade access controls, or republish protected media.
The Actor does not grant rights to RAWG data, descriptions, artwork, trademarks, or third-party links.

Keep request volumes proportionate and schedule responsibly.
You are responsible for retention, attribution, licensing, and downstream processing.

### Troubleshooting

#### Why did the run return zero games?

Check spelling and remove filters one at a time.
A narrow platform, genre, and date combination can legitimately have no matches.
Inspect logs to confirm the source returned normally.

#### Why are developer or publisher arrays empty?

Ensure `fetchDetails` is `true`.
RAWG may still omit those fields for some records.

#### Why was my URL rejected?

Only canonical public RAWG game URLs are accepted.
Use `https://rawg.io/games/<game-slug>`, not a search, profile, API, or media URL.

#### Why did the run fail rather than save partial empty data?

The Actor fails closed when it cannot validate RAWG's public catalog response.
This prevents upstream blocks or schema changes from looking like legitimate empty results.
Retry later only if logs identify a temporary upstream error.

### Related Automation Lab Actors

- [Steam Game Sale Price Tracker](https://apify.com/automation-lab/steam-game-sale-price-tracker)
  tracks Steam regular prices, sale prices, discounts, and platform signals.
- [VALORANT Content API](https://apify.com/automation-lab/valorant-content-api)
  exports structured content metadata for one specific game ecosystem.

Choose this Actor for broad cross-platform RAWG catalog metadata.
Choose the Steam tracker when price and discount monitoring is the primary job.

### FAQ

#### Does it require a RAWG API key?

No. The Actor discovers the current anonymous public web-client configuration at run time.
You do not provide or store a RAWG key.

#### Can I combine searches and direct URLs?

Yes. Direct URLs are processed first, followed by searches.
Duplicate RAWG IDs are saved and charged only once.

#### Can I export to CSV or Excel?

Yes. Open the default dataset and select CSV or Excel, or retrieve those formats through the API.

#### Does it download screenshots or game files?

No. It exports public image URLs and metadata only.
It does not download artwork, videos, installers, or game binaries.

#### Can I monitor changes?

Yes, by scheduling repeated Tasks and comparing snapshots using stable `rawgId` values.
The Actor does not itself store historical versions or issue alerts.

#### Is every record complete?

No. RAWG coverage varies by game.
Every schema field is nullable so downstream systems can handle missing upstream values safely.

# Actor input Schema

## `searchQueries` (type: `array`):

Game names or catalog keywords to search on RAWG. Results from all queries are deduplicated by RAWG game ID.

## `startUrls` (type: `array`):

Specific public RAWG game pages to enrich. You can combine these with search queries.

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

Maximum number of unique game records saved across all inputs.

## `fetchDetails` (type: `boolean`):

Fetch each game detail to include developers, publishers, description, website, stores, and additional media. Disable for faster lightweight catalog searches.

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

Optional RAWG genre names or slugs. A game is kept when it matches at least one value, for example action or role-playing-games-rpg.

## `platforms` (type: `array`):

Optional platform names or RAWG slugs. A game is kept when it matches at least one value, for example PC, playstation5, or nintendo-switch.

## `releaseDateFrom` (type: `string`):

Keep games released on or after this date in YYYY-MM-DD format.

## `releaseDateTo` (type: `string`):

Keep games released on or before this date in YYYY-MM-DD format.

## `ordering` (type: `string`):

Order discovered games by relevance, name, release date, rating, or Metacritic score. A leading minus means descending.

## Actor input object example

```json
{
  "searchQueries": [
    "The Witcher"
  ],
  "startUrls": [
    {
      "url": "https://rawg.io/games/the-witcher-3-wild-hunt"
    }
  ],
  "maxItems": 10,
  "fetchDetails": true,
  "ordering": "relevance"
}
```

# Actor output Schema

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

Open the normalized RAWG game records in the dataset overview.

# 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 = {
    "searchQueries": [
        "The Witcher"
    ],
    "startUrls": [
        {
            "url": "https://rawg.io/games/the-witcher-3-wild-hunt"
        }
    ],
    "maxItems": 10,
    "fetchDetails": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/rawg-video-game-catalog").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 = {
    "searchQueries": ["The Witcher"],
    "startUrls": [{ "url": "https://rawg.io/games/the-witcher-3-wild-hunt" }],
    "maxItems": 10,
    "fetchDetails": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/rawg-video-game-catalog").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 '{
  "searchQueries": [
    "The Witcher"
  ],
  "startUrls": [
    {
      "url": "https://rawg.io/games/the-witcher-3-wild-hunt"
    }
  ],
  "maxItems": 10,
  "fetchDetails": true
}' |
apify call automation-lab/rawg-video-game-catalog --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/rawg-video-game-catalog"
        }
    }
}

```

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/lmGfXoDyeHPZ8x4dU/builds/mxdxxf2V1hGPP9Q6M/openapi.json