# RAWG.io Video Game Database Scraper (`lulzasaur/rawg-scraper`) Actor

Scrape RAWG.io video game database with 898K+ games. Extract titles, ratings, metacritic scores, platforms, genres, tags, developers, publishers, ESRB ratings, descriptions, screenshots and more.

- **URL**: https://apify.com/lulzasaur/rawg-scraper.md
- **Developed by:** [lulz bot](https://apify.com/lulzasaur) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 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.

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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## RAWG.io Video Game Database Scraper

Scrape the RAWG.io video game database -- one of the largest game databases with **898,000+ games**. Extract comprehensive game data including titles, ratings, metacritic scores, platforms, genres, tags, developers, publishers, ESRB ratings, descriptions, screenshots, and more.

### Features

- **898K+ games** in the RAWG.io database
- **Schema.org microdata** extraction for structured data
- **Direct slug matching** for fast single-game lookups
- **Browse pagination** for bulk catalog scraping
- **Full detail pages** with descriptions, screenshots, tags, and more
- **Pay-per-event** billing -- only pay for what you scrape

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `searchQueries` | string[] | `["The Witcher 3"]` | Game titles to search for |
| `maxListings` | integer | `100` | Max games per query (0 = unlimited) |
| `scrapeDetails` | boolean | `true` | Visit detail pages for full data |
| `proxyConfiguration` | object | `{}` | Proxy settings |

#### Example Input

```json
{
    "searchQueries": ["The Witcher 3", "Cyberpunk 2077"],
    "maxListings": 50,
    "scrapeDetails": true
}
````

### Output Fields

#### Browse mode (scrapeDetails: false)

- `title` -- Game name
- `slug` -- URL slug
- `url` -- Full RAWG URL
- `metacritic` -- Metacritic score
- `rating` -- Community rating (Exceptional/Recommended/Meh/Skip)
- `platforms` -- Platform list (PC, PlayStation, Xbox, etc.)

#### Detail mode (scrapeDetails: true)

All browse fields plus:

- `releaseDate` -- Release date
- `ratingValue` -- Numeric rating (1-5)
- `ratingsCount` -- Number of community ratings
- `averagePlaytimeHours` -- Average playtime in hours
- `genres` -- Genre list (Action, RPG, etc.)
- `developers` -- Developer studios
- `publishers` -- Publisher companies
- `tags` -- Community tags (Singleplayer, Open World, etc.)
- `esrbRating` -- ESRB age rating
- `description` -- Full game description
- `website` -- Official game website
- `imageUrl` -- Main game image
- `screenshots` -- Screenshot URLs

### Example Output

```json
{
    "title": "The Witcher 3: Wild Hunt",
    "slug": "the-witcher-3-wild-hunt",
    "url": "https://rawg.io/games/the-witcher-3-wild-hunt",
    "metacritic": 92,
    "rating": "Exceptional",
    "ratingValue": 5,
    "ratingsCount": 7188,
    "releaseDate": "May 18, 2015",
    "averagePlaytimeHours": 43,
    "platforms": ["PlayStation 5", "Xbox Series S/X", "macOS", "PlayStation 4", "Nintendo Switch", "PC", "Xbox One"],
    "genres": ["Action", "RPG"],
    "developers": ["CD PROJEKT RED"],
    "publishers": ["CD PROJEKT RED"],
    "tags": ["Singleplayer", "Full controller support", "Atmospheric", "Great Soundtrack", "RPG", "Story Rich", "Open World"],
    "esrbRating": "17+ Mature",
    "description": "The third game in a series, it holds nothing back from the player...",
    "website": "https://thewitcher.com/en/witcher3",
    "imageUrl": "https://media.rawg.io/media/games/618/618c2031a07bbff6b4f611f10b6bcdbc.jpg",
    "screenshots": ["https://media.rawg.io/media/screenshots/c0b/c0be67e7b55b5b7603e3a4e1a9de176d.jpg"]
}
```

### How It Works

1. **Small queries (maxListings <= 5)**: Converts the search query to a URL slug and tries direct game page access for instant results.
2. **Large queries**: Browses the RAWG catalog pages (40 games per page) and optionally visits each game's detail page.
3. **Detail extraction**: Parses Schema.org VideoGame microdata and CSS-class-based meta blocks for comprehensive data.

### Use Cases

- **Game market research** -- Analyze ratings, genres, and platform distribution
- **Price comparison databases** -- Build game catalogs with metadata
- **Game recommendation engines** -- Collect ratings, tags, and genres for ML models
- **Content creation** -- Gather game data for reviews, articles, and videos
- **Platform analytics** -- Track metacritic scores and community sentiment

### Cost

This Actor uses pay-per-event pricing. You are charged per game scraped. Check the Actor's pricing tab for current rates.

***

### Run on Apify

This scraper runs on the [Apify platform](https://apify.com/?fpr=lulzasaur) -- a full-stack web scraping and automation cloud. Sign up for a free account to get started with 30-day trial of all features.

[Try Apify free](https://apify.com/?fpr=lulzasaur)

### Related Scrapers

More scrapers and data tools by [lulzasaur](https://apify.com/lulzasaur):

- [AbeBooks Scraper](https://apify.com/lulzasaur/abebooks-scraper) -- Rare and used books
- [Bonanza Scraper](https://apify.com/lulzasaur/bonanza-scraper) -- Online marketplace listings
- [Goodreads Scraper](https://apify.com/lulzasaur/goodreads-scraper) -- Book ratings and reviews
- [Grailed Scraper](https://apify.com/lulzasaur/grailed-scraper) -- Luxury fashion resale
- [IMDb Scraper](https://apify.com/lulzasaur/imdb-scraper) -- Movie and TV show data
- [OfferUp Scraper](https://apify.com/lulzasaur/offerup-scraper) -- Local marketplace listings
- [Poshmark Scraper](https://apify.com/lulzasaur/poshmark-scraper) -- Fashion resale marketplace
- [PSA Population Report](https://apify.com/lulzasaur/psa-pop-scraper) -- Card grading data
- [Reverb Scraper](https://apify.com/lulzasaur/reverb-scraper) -- Music gear marketplace
- [StubHub Scraper](https://apify.com/lulzasaur/stubhub-scraper) -- Event ticket prices
- [TCGPlayer Scraper](https://apify.com/lulzasaur/tcgplayer-scraper) -- Trading card prices

# Actor input Schema

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

Game titles to search for (e.g., 'The Witcher 3', 'Cyberpunk 2077'). For small maxListings (<=5), tries direct slug match first. For larger runs, browses the full game catalog.

## `maxListings` (type: `integer`):

Maximum number of games to scrape per search query. Set to 0 for unlimited. The browse catalog has 40 games per page.

## `scrapeDetails` (type: `boolean`):

If enabled, visits each game's detail page to extract full description, screenshots, tags, developers, publishers, ESRB rating, website, and more. If disabled, only extracts summary data from browse cards (title, slug, platforms, metacritic, rating).

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

Proxy settings. RAWG.io is generally accessible without proxies, but recommended for large-scale runs.

## Actor input object example

```json
{
  "searchQueries": [
    "The Witcher 3"
  ],
  "maxListings": 100,
  "scrapeDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (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 = {
    "searchQueries": [
        "The Witcher 3"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lulzasaur/rawg-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 = { "searchQueries": ["The Witcher 3"] }

# Run the Actor and wait for it to finish
run = client.actor("lulzasaur/rawg-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 '{
  "searchQueries": [
    "The Witcher 3"
  ]
}' |
apify call lulzasaur/rawg-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "RAWG.io Video Game Database Scraper",
        "description": "Scrape RAWG.io video game database with 898K+ games. Extract titles, ratings, metacritic scores, platforms, genres, tags, developers, publishers, ESRB ratings, descriptions, screenshots and more.",
        "version": "1.0",
        "x-build-id": "RlkmuugsSRWrLFARP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lulzasaur~rawg-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lulzasaur-rawg-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/lulzasaur~rawg-scraper/runs": {
            "post": {
                "operationId": "runs-sync-lulzasaur-rawg-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/lulzasaur~rawg-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-lulzasaur-rawg-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",
                "required": [
                    "searchQueries"
                ],
                "properties": {
                    "searchQueries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "Game titles to search for (e.g., 'The Witcher 3', 'Cyberpunk 2077'). For small maxListings (<=5), tries direct slug match first. For larger runs, browses the full game catalog.",
                        "default": [
                            "The Witcher 3"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxListings": {
                        "title": "Max Games per Query",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of games to scrape per search query. Set to 0 for unlimited. The browse catalog has 40 games per page.",
                        "default": 100
                    },
                    "scrapeDetails": {
                        "title": "Scrape Full Details",
                        "type": "boolean",
                        "description": "If enabled, visits each game's detail page to extract full description, screenshots, tags, developers, publishers, ESRB rating, website, and more. If disabled, only extracts summary data from browse cards (title, slug, platforms, metacritic, rating).",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. RAWG.io is generally accessible without proxies, but recommended for large-scale runs.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
