# RAWG Scraper | Video Game Database and Ratings (`parseforge/rawg-scraper`) Actor

Scrape video game data from the RAWG database including titles, genres, platforms, Metacritic scores, release dates, ratings, developers and publishers. Search the full catalog of 500,000+ games to power game discovery apps, market research or gaming datasets

- **URL**: https://apify.com/parseforge/rawg-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Games, Other, Marketing
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.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.
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.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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🎮 RAWG Video Games Scraper

> 🚀 **Export 500,000+ video games to CSV, Excel, JSON, or XML in seconds.** Search by genre, platform, Metacritic score, or release date. No scraping engineering required.

> 🕒 **Last updated:** 2026-05-22 · **📊 16 fields** per record · **🎮 500,000+ games** · **🕹️ 50+ platforms** · **🗂️ Genres, ESRB, Metacritic**

The **RAWG Video Games Scraper** connects to the RAWG Video Game Database REST API and returns structured game records with 16 fields each, including title, cover image, release date, ESRB rating, Metacritic score, genres, platforms, and average playtime. The RAWG dataset is the largest publicly accessible video game database, maintained by a global community and cited by Yandex, Discord bots, and Reddit recommendation engines worldwide.

The catalog spans every major console generation from Atari to PlayStation 5, covering PC, mobile, and retro platforms. Every record links directly to the game's RAWG page for attribution and further research.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Game developers, market analysts, journalists, data scientists, gaming platforms, content teams, academic researchers | Game catalog enrichment, competitive analysis, genre trend mapping, recommendation engine training data, content generation, store listings |

---

### 📋 What the RAWG Video Games Scraper does

Six filtering workflows in a single run:

- 🔍 **Keyword search.** Find games by title or keyword (e.g. "Grand Theft Auto", "Witcher", "Zelda").
- 🗂️ **Genre filter.** Restrict to one or more genre slugs like `action`, `rpg`, `strategy`, or `indie`.
- 🕹️ **Platform filter.** Scope to specific platform IDs such as `4` (PC), `187` (PS5), or `18` (PlayStation 4).
- ⭐ **Metacritic range.** Return only games with a critic score in a given range (e.g. `80,100` for acclaimed titles).
- 📅 **Date range.** Filter by release window using ISO date pairs (e.g. `2023-01-01,2023-12-31`).
- 🔃 **Custom ordering.** Sort by rating, Metacritic, release date, playtime, relevance, or recently added.

Each record includes image URL, unique ID, slug, release date, user rating, rating count, Metacritic score, average playtime, genres, platforms, ESRB rating, and a direct RAWG URL.

> 💡 **Why it matters:** building your own game data pipeline means dealing with authentication, pagination, rate limits, and schema changes. This Actor handles all of that and delivers clean structured data in under a minute. Free API key required - register in 60 seconds at rawg.io.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>apiKey</code></td><td>string</td><td>required</td><td>Your free RAWG API key. Get one at <a href="https://rawg.io/apidocs">rawg.io/apidocs</a> - sign up takes under a minute.</td></tr>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Records to return. Free Apify plan caps at 10, paid plan at 1,000,000.</td></tr>
<tr><td><code>searchQuery</code></td><td>string</td><td><code>""</code></td><td>Search by game title or keyword.</td></tr>
<tr><td><code>genres</code></td><td>string</td><td><code>""</code></td><td>Comma-separated genre slugs (e.g. <code>action,rpg</code>). Leave blank for all genres.</td></tr>
<tr><td><code>platforms</code></td><td>string</td><td><code>""</code></td><td>Comma-separated platform IDs (e.g. <code>4,187</code> for PC and PS5). Leave blank for all platforms.</td></tr>
<tr><td><code>ordering</code></td><td>select</td><td><code>""</code></td><td>Sort order. Options: rating, Metacritic, release date, playtime, relevance, recently added.</td></tr>
<tr><td><code>metacriticRange</code></td><td>string</td><td><code>""</code></td><td>Filter by Metacritic score range (e.g. <code>80,100</code>).</td></tr>
<tr><td><code>dates</code></td><td>string</td><td><code>""</code></td><td>Release date range in YYYY-MM-DD,YYYY-MM-DD format (e.g. <code>2023-01-01,2023-12-31</code>).</td></tr>
</tbody>
</table>

**Example: top-rated action games with Metacritic 85+.**

```json
{
    "apiKey": "YOUR_RAWG_API_KEY",
    "maxItems": 100,
    "genres": "action",
    "metacriticRange": "85,100",
    "ordering": "-metacritic"
}
````

**Example: RPGs released in 2023.**

```json
{
    "apiKey": "YOUR_RAWG_API_KEY",
    "maxItems": 50,
    "genres": "rpg",
    "dates": "2023-01-01,2023-12-31",
    "ordering": "-rating"
}
```

> ⚠️ **Good to Know:** RAWG's free API plan includes up to 20,000 requests per month. Each Actor run uses one request per 20 games collected. For 1,000 games, that is 50 requests. Platform IDs can be found via the RAWG API at `https://api.rawg.io/api/platforms?key=YOUR_KEY`. Common IDs: PC=4, PlayStation 5=187, Xbox Series S/X=186, Nintendo Switch=7, iOS=3, Android=21.

***

### 📊 Output

Each game record contains **16 fields**. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🖼️ `imageUrl` | string | `"https://media.rawg.io/media/games/20a/20aa03a10cda45239fe22d035c0ebe64.jpg"` |
| 🆔 `id` | integer | `3498` |
| 🏷️ `name` | string | `"Grand Theft Auto V"` |
| 🔗 `slug` | string | `"grand-theft-auto-v"` |
| 📅 `released` | string | `"2013-09-17"` |
| ⭐ `rating` | number | `4.47` |
| 🗳️ `ratingsCount` | integer | `7391` |
| 🏆 `metacritic` | integer | `92` |
| ⏱️ `playtime` | integer | `74` |
| 🗂️ `genres` | string | `"Action"` |
| 🕹️ `platforms` | string | `"PC, PlayStation 5, Xbox One, PlayStation 4, Xbox Series S/X, Xbox 360, PlayStation 3"` |
| 🔞 `esrbRating` | string | `"Mature"` |
| 🌐 `url` | string | `"https://rawg.io/games/grand-theft-auto-v"` |
| 🕐 `scrapedAt` | string | `"2026-05-22T00:13:42.251Z"` |
| ❌ `error` | string | `null` |

#### 📋 Sample Records

**Record 1 - Grand Theft Auto V**

```json
{
  "imageUrl": "https://media.rawg.io/media/games/20a/20aa03a10cda45239fe22d035c0ebe64.jpg",
  "id": 3498,
  "name": "Grand Theft Auto V",
  "slug": "grand-theft-auto-v",
  "released": "2013-09-17",
  "rating": 4.47,
  "ratingsCount": 7391,
  "metacritic": 92,
  "playtime": 74,
  "genres": "Action",
  "platforms": "PC, PlayStation 5, Xbox One, PlayStation 4, Xbox Series S/X, Xbox 360, PlayStation 3",
  "esrbRating": "Mature",
  "url": "https://rawg.io/games/grand-theft-auto-v",
  "scrapedAt": "2026-05-22T00:13:42.251Z",
  "error": null
}
```

**Record 2 - The Witcher 3: Wild Hunt**

```json
{
  "imageUrl": "https://media.rawg.io/media/games/618/618c2031a07bbff6b4f611f10b6bcdbc.jpg",
  "id": 3328,
  "name": "The Witcher 3: Wild Hunt",
  "slug": "the-witcher-3-wild-hunt",
  "released": "2015-05-18",
  "rating": 4.64,
  "ratingsCount": 7203,
  "metacritic": 92,
  "playtime": 43,
  "genres": "Action, RPG",
  "platforms": "PC, PlayStation 5, Xbox One, PlayStation 4, Xbox Series S/X, Nintendo Switch, macOS",
  "esrbRating": "Mature",
  "url": "https://rawg.io/games/the-witcher-3-wild-hunt",
  "scrapedAt": "2026-05-22T00:13:42.251Z",
  "error": null
}
```

**Record 3 - Portal**

```json
{
  "imageUrl": "https://media.rawg.io/media/games/7fa/7fa0b586293c5861ee32490e953a4996.jpg",
  "id": 13536,
  "name": "Portal",
  "slug": "portal",
  "released": "2007-10-09",
  "rating": 4.49,
  "ratingsCount": 5025,
  "metacritic": 90,
  "playtime": 4,
  "genres": "Action, Puzzle",
  "platforms": "PC, Nintendo Switch, Android, macOS, Linux, Xbox 360, PlayStation 3",
  "esrbRating": "Teen",
  "url": "https://rawg.io/games/portal",
  "scrapedAt": "2026-05-22T00:13:42.251Z",
  "error": null
}
```

***

### ✨ Why choose this Actor

| Feature | What it means for you |
|---|---|
| 🌐 **500,000+ games covered** | The largest open video game database available via public API |
| 🗂️ **16 structured fields** | Image, rating, Metacritic, ESRB, playtime, genres, platforms - all in one record |
| 📅 **Date range filtering** | Pin down any release window from 1970 to tomorrow |
| ⭐ **Metacritic range** | Filter only the games critics loved - or the overlooked gems |
| 🔃 **Flexible ordering** | Sort by relevance, rating, Metacritic, or recency |
| 📤 **4 export formats** | CSV, Excel, JSON, XML - no conversion scripts needed |
| 🔌 **API-ready output** | Clean JSON schema connects directly to Make, Zapier, and n8n |

***

### 📈 How it compares to alternatives

| Approach | Setup time | Maintenance | Data freshness | Fields |
|---|---|---|---|---|
| **This Actor** | 2 minutes | Zero | Real-time | 16 |
| Manual RAWG API calls | 30+ minutes | Pagination, key rotation | Real-time | Custom |
| Static game CSV databases | Hours | Manual updates | Stale (often months old) | Varies |
| Web scraping store pages | Hours | Breaks on UI changes | Real-time | Limited |

***

### 🚀 How to use

1. **Get a free RAWG API key** at [rawg.io/apidocs](https://rawg.io/apidocs) - registration takes under a minute.
2. **[Create a free Apify account](https://console.apify.com/sign-up?fpr=vmoqkp)** - includes $5 in free credits.
3. **Open the Actor** on the Apify Console.
4. **Paste your RAWG API key** into the `apiKey` field.
5. **Set filters** - genre, platform, date range, Metacritic range, ordering, or a search query.
6. **Set `maxItems`** - 10 for a preview, up to 1,000,000 for a full export.
7. **Click Run** and wait a few seconds.
8. **Download your dataset** as CSV, Excel, JSON, or XML from the Storage tab.

***

### 💼 Business use cases

#### Game Market Analysis

Track which genres dominate by Metacritic score, compare release cadence across platforms, or identify underserved niches. Export 10,000 games filtered by date range and sort by rating to spot trends in critic reception over time.

#### Game Catalog Enrichment

Enrich your own game database with RAWG cover images, ESRB ratings, average playtime, and platform lists. Use the slug field to link back to RAWG for attribution and additional detail pages.

#### Recommendation Engine Training Data

Export structured game records with genres, platforms, and ratings to train or validate content-based recommendation models. The `rating` and `ratingsCount` fields give signal on community reception quality.

#### Content and Journalism

Produce data-driven articles on game trends, publisher output, or platform exclusivity. Filter the 2024 release window, sort by Metacritic, and you have a ranked list of the year's best games in seconds.

***

### 🔌 Automating RAWG Video Games Scraper

Connect this Actor to your workflow tools without writing any code:

- **Make (Integromat):** Trigger a scenario whenever the Actor completes and send new game records to Airtable, Google Sheets, or Slack.
- **Zapier:** Automatically push game data to HubSpot, Notion, or a database whenever a run finishes.
- **n8n:** Use the Apify node to run the Actor on a schedule and feed results to any downstream service.
- **Apify Scheduler:** Run daily or weekly to keep your game catalog fresh without any manual intervention.

***

### 🌟 Beyond business use cases

#### Academic Research

Map the history of video game genres across decades. Filter by release year and platform to study how the industry evolved from 8-bit consoles to cross-platform releases.

#### Game Recommendation Bots

Power a Discord or Telegram bot with real game data. Export action games rated above 4.5 with Metacritic over 90 and surface them to users asking for recommendations.

#### Personal Game Libraries

Export every game on your preferred platform and import it into a personal spreadsheet tracker, Notion database, or Obsidian vault.

#### Indie Game Discovery

Filter by `genres=indie` and `ordering=-rating` to surface hidden gems that critics and community members loved but that never got mainstream attention.

***

### 🤖 Ask an AI assistant about this scraper

> "What RAWG scraper fields can I use to build a game recommendation system?"
> "How do I get all PS5 games released in 2024 with a Metacritic score above 80?"
> "Can I combine genre and platform filters with a date range in this Actor?"

The Actor's structured output is designed for downstream AI and analytics workflows. Every record has consistent field names and types, making it immediately compatible with pandas, OpenAI function calls, and LLM-powered pipelines.

***

### ❓ Frequently Asked Questions

**❓ Do I need a paid RAWG account?**
No. The free RAWG API tier includes 20,000 requests per month, which covers roughly 400,000 game records per month at the default page size.

**❓ Where do I get a RAWG API key?**
Visit [rawg.io/apidocs](https://rawg.io/apidocs), click "Get API Key", and register with an email address. The key appears immediately after filling out a short form.

**❓ How many games can I export?**
On Apify's paid plan, up to 1,000,000 per run. The RAWG database has 500,000+ games total, so a single run can export the entire catalog.

**❓ How fresh is the data?**
The data is fetched in real-time from the RAWG API on every run. No cached or stale records.

**❓ What genre slugs can I use?**
Common slugs: `action`, `adventure`, `rpg`, `shooter`, `strategy`, `simulation`, `puzzle`, `arcade`, `indie`, `platformer`, `sports`, `racing`, `fighting`, `casual`, `family`, `massively-multiplayer`. For the full list, query the RAWG platforms API.

**❓ What platform IDs should I use?**
Common IDs: PC=4, PlayStation 5=187, PlayStation 4=18, Xbox Series S/X=186, Xbox One=1, Nintendo Switch=7, iOS=3, Android=21, macOS=5, Linux=6. For the full list, query `https://api.rawg.io/api/platforms?key=YOUR_KEY`.

**❓ Can I combine multiple filters?**
Yes. You can combine `genres`, `platforms`, `metacriticRange`, `dates`, `searchQuery`, and `ordering` in a single run.

**❓ What does `ordering=-metacritic` do?**
It sorts results from highest to lowest Metacritic score. Use `-rating` for user ratings, `-added` for most recently added to RAWG.

**❓ Does the Actor handle pagination automatically?**
Yes. The Actor paginates through results automatically until it reaches `maxItems` or the end of the dataset.

**❓ Is the `error` field always null?**
For successful records, yes. If a page fails to load, the Actor pushes a record with the `error` field populated and continues running.

**❓ Can I run this on a schedule?**
Yes. Use Apify Scheduler or connect via Make/Zapier to run on any interval and keep your dataset current.

***

### 🔌 Integrate with any app

The Actor output connects natively with the full Apify integration ecosystem:

**Storage and spreadsheets:** Google Sheets, Airtable, Notion, Excel\
**Automation:** Make (Integromat), Zapier, n8n, Apify Scheduler\
**Databases:** PostgreSQL, MySQL, MongoDB, Supabase\
**Analytics:** BigQuery, Snowflake, Tableau, Power BI\
**AI and ML:** OpenAI API, Langchain, pandas, Jupyter notebooks\
**Messaging:** Slack, Discord, Microsoft Teams\
**CMS:** Webflow, WordPress, Contentful

***

### 🔗 Recommended Actors

| Actor | What it does |
|---|---|
| [Metacritic Scraper](https://apify.com/parseforge/metacritic-scraper) | Scrape critic and user reviews from Metacritic for any game title |
| [IGDB Game Database Scraper](https://apify.com/parseforge) | Structured game data from the Twitch-owned IGDB API |
| [Steam Store Scraper](https://apify.com/parseforge) | Game pricing, reviews, and store metadata from Steam |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) to find scrapers for hundreds of data sources - all with the same clean output format and zero-maintenance operation.

***

*Data sourced from the RAWG Video Game Database public API (rawg.io). ParseForge does not claim ownership of any game data or images. All data is attributed to RAWG per their Terms of Service. For commercial use exceeding 100,000 monthly active users, contact api@rawg.io for commercial licensing.*

# Actor input Schema

## `apiKey` (type: `string`):

Your free RAWG API key. Get one at https://rawg.io/apiv2-docs - sign up is free and takes under a minute.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

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

Search games by name (e.g. "Grand Theft Auto", "Witcher").

## `genres` (type: `string`):

Comma-separated genre slugs (e.g. "action,rpg"). Leave blank for all genres.

## `platforms` (type: `string`):

Comma-separated platform IDs (e.g. "4,5" for PC and macOS). Leave blank for all platforms.

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

Sort order for results.

## `metacriticRange` (type: `string`):

Filter by Metacritic score range (e.g. "80,100" for scores between 80 and 100).

## `dates` (type: `string`):

Filter by release date range in YYYY-MM-DD,YYYY-MM-DD format (e.g. "2023-01-01,2023-12-31").

## Actor input object example

```json
{
  "maxItems": 10
}
```

# 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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/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 = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/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 '{
  "maxItems": 10
}' |
apify call parseforge/rawg-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "RAWG Scraper | Video Game Database and Ratings",
        "description": "Scrape video game data from the RAWG database including titles, genres, platforms, Metacritic scores, release dates, ratings, developers and publishers. Search the full catalog of 500,000+ games to power game discovery apps, market research or gaming datasets",
        "version": "0.1",
        "x-build-id": "cm2sd44EWr3JknuyD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~rawg-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-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/parseforge~rawg-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-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/parseforge~rawg-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-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": [
                    "apiKey"
                ],
                "properties": {
                    "apiKey": {
                        "title": "API Key",
                        "type": "string",
                        "description": "Your free RAWG API key. Get one at https://rawg.io/apiv2-docs - sign up is free and takes under a minute."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search games by name (e.g. \"Grand Theft Auto\", \"Witcher\")."
                    },
                    "genres": {
                        "title": "Genres",
                        "type": "string",
                        "description": "Comma-separated genre slugs (e.g. \"action,rpg\"). Leave blank for all genres."
                    },
                    "platforms": {
                        "title": "Platforms",
                        "type": "string",
                        "description": "Comma-separated platform IDs (e.g. \"4,5\" for PC and macOS). Leave blank for all platforms."
                    },
                    "ordering": {
                        "title": "Ordering",
                        "enum": [
                            "-added",
                            "name",
                            "released",
                            "-relevance",
                            "rating",
                            "-rating",
                            "metacritic",
                            "-metacritic",
                            "playtime",
                            "-playtime"
                        ],
                        "type": "string",
                        "description": "Sort order for results."
                    },
                    "metacriticRange": {
                        "title": "Metacritic Range",
                        "type": "string",
                        "description": "Filter by Metacritic score range (e.g. \"80,100\" for scores between 80 and 100)."
                    },
                    "dates": {
                        "title": "Release Date Range",
                        "type": "string",
                        "description": "Filter by release date range in YYYY-MM-DD,YYYY-MM-DD format (e.g. \"2023-01-01,2023-12-31\")."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
