# BoardGameGeek Scraper (`crawlerbros/boardgamegeek-scraper`) Actor

Scrape BoardGameGeek, ratings, mechanics, categories, designers, publishers, weights, ranks. Search games, fetch by ID, browse the hot list, look up user profiles. No login required.

- **URL**: https://apify.com/crawlerbros/boardgamegeek-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 8 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## BoardGameGeek Scraper

Scrape **BoardGameGeek** — the world's largest tabletop-gaming database — for board game ratings, ranks, mechanics, categories, designers, publishers, weights (complexity), expansions, ownership counts, and user profiles. No login, cookies, proxy, or API key required. Free-plan ready.

### What you get

- **Game ratings & ranks** — average rating, Bayesian (geek) rating, overall BGG rank, plus sub-category ranks (Strategy, Family, Thematic, etc.)
- **Mechanics & categories** — every BGG-tagged mechanic and theme category per game
- **Credits** — designers, artists, publishers, families, honors / awards
- **Game flow** — player counts, playing time, recommended age, language dependence, community-voted best player counts
- **Community signal** — owned / wanting / wishing / commentsCount / number of plays
- **Complexity** — average game weight (1–5) and vote count
- **Expansions, integrations, reimplementations, accessories** — with full BGG IDs and URLs
- **Images** — high-res cover image + thumbnail, both hosted on cf.geekdo-images.com (no Referer required)
- **User profiles** — username, real name (when public), location, registration date, supporter years, avatar

### Modes

| Mode | What it does |
|---|---|
| `hot` | Pull the current **BGG Hot List** (top ~50 games) with full game details |
| `search` | Free-text keyword search → enriched game records |
| `byIds` | Look up specific games by BGG ID (or full URL) |
| `userProfile` | Fetch a BGG user's public profile |

### Input

| Input | Type | Required | Default | Description |
|---|---|---|---|---|
| `mode` | enum | yes | `hot` | One of `hot`, `search`, `byIds`, `userProfile` |
| `searchQuery` | string | mode=search | `catan` | Free-text keyword |
| `gameIds` | string\[] | mode=byIds | `["174430", "161936"]` | Numeric IDs or BGG URLs |
| `username` | string | mode=userProfile | `Aldie` | BGG username |
| `enrichHot` | bool | no | `true` | When mode=hot, fetch full detail per game (slower; complete records) |
| `gameType` | enum | no | – | `boardgame`, `boardgameexpansion`, `boardgameaccessory`, `videogame`, `rpgitem`, `rpgissue` |
| `minYear` / `maxYear` | int | no | – | Year-published bounds |
| `minRating` / `maxRating` | int | no | – | Average rating bounds (0–10) |
| `minPlayers` / `maxPlayers` | int | no | – | Player-count overlap filter |
| `minPlaytime` / `maxPlaytime` | int | no | – | Playing-time bounds (minutes) |
| `minAge` | int | no | – | Minimum recommended age |
| `categories` | string\[] | no | – | Curated BGG **Categories** — genre tags like `Wargame`, `Fantasy`, `Abstract Strategy`. Note: BGG **Families** (e.g. `Strategy Games`, `Cooperative Games`) are not Categories; use `searchQuery` for Family-style filtering |
| `mechanics` | string\[] | no | – | Curated BGG mechanics (e.g. `Worker Placement`, `Deck, Bag, and Pool Building`) |
| `containsKeyword` | string | no | – | Substring filter against name, alternate names, description |
| `maxItems` | int | no | `20` | Hard cap on emitted records (1–1000) |

### Output

Each emitted game record contains (omit-empty — only populated fields are present):

```jsonc
{
  "id": 174430,
  "name": "Gloomhaven",
  "alternateNames": ["クルームヘヴン", "Gloomhaven (Korean)", "..."],
  "yearPublished": 2017,
  "gameType": "boardgame",
  "description": "Gloomhaven is a game of Euro-inspired tactical combat in a persistent world...",
  "shortDescription": "Vanquish monsters with strategic cardplay. Fame and fortune await...",
  "image": "https://cf.geekdo-images.com/.../pic2437871.jpg",
  "thumbnail": "https://cf.geekdo-images.com/.../pic2437871.jpg",
  "minPlayers": 1,
  "maxPlayers": 4,
  "playingTime": 120,
  "minPlayTime": 60,
  "maxPlayTime": 120,
  "minAge": 14,
  "communityMinAge": "12+",
  "languageDependence": "Extensive use of text - massive conversion needed to be playable",
  "bestPlayerCounts": [2],
  "recommendedPlayerCounts": [1, 2, 3, 4],
  "categories": ["Adventure", "Exploration", "Fantasy", "Fighting", "Miniatures"],
  "mechanics": ["Action Queue", "Action Retrieval", "Campaign / Battle Card Driven", "..."],
  "designers": ["Isaac Childres"],
  "artists": ["Alexandr Elichev", "..."],
  "publishers": ["Cephalofair Games", "Albi", "..."],
  "families": ["Components: Miniatures", "Crowdfunding: Kickstarter", "..."],
  "subdomains": ["Thematic Games", "Strategy Games"],
  "expansions": [
    {"id": 230985, "name": "Gloomhaven: Forgotten Circles", "url": "https://boardgamegeek.com/boardgameexpansion/230985/..."}
  ],
  "rating": 8.55,
  "bayesRating": 8.39,
  "ratingsCount": 53000,
  "ratingStdDev": 1.45,
  "weight": 3.88,
  "weightCount": 11000,
  "rank": 1,
  "ranks": [
    {"category": "Board Game Rank", "rank": 1, "bayesRating": 8.39},
    {"category": "Strategy Game Rank", "rank": 1, "bayesRating": 8.35},
    {"category": "Thematic Rank", "rank": 1, "bayesRating": 8.46}
  ],
  "ownedCount": 92000,
  "tradingCount": 1100,
  "wantingCount": 500,
  "wishingCount": 12500,
  "commentsCount": 8200,
  "playsCount": 250000,
  "fansCount": 4200,
  "geekListsCount": 8900,
  "honors": ["2017 Golden Geek Best Thematic Board Game Winner", "..."],
  "gameUrl": "https://boardgamegeek.com/boardgame/174430",
  "officialWebsite": "https://www.cephalofair.com/",
  "recordType": "game",
  "scrapedAt": "2026-05-21T07:30:00+00:00"
}
````

User-profile records (mode=userProfile) include:

```jsonc
{
  "userId": 688,
  "username": "Aldie",
  "firstName": "Scott",
  "lastName": "Alden",
  "city": "Dallas",
  "state": "TX",
  "country": "United States",
  "countryCode": "US",
  "registrationDate": "1999-12-01",
  "avatar": "https://cf.geekdo-images.com/avatars/.../avatar_id216013.gif",
  "supporterYears": [2004, 2005, 2006, ..., 2026],
  "adminBadges": ["boardgame", "puzzle", "rpg", "videogame"],
  "profileUrl": "https://boardgamegeek.com/user/Aldie",
  "recordType": "user",
  "scrapedAt": "2026-05-21T07:30:00+00:00"
}
```

### FAQ

#### Does this require an API key, cookies, or login?

No. BGG's public JSON API is open and free.

#### Does it work on the Apify free plan?

Yes. No paid proxies or add-ons required.

#### How fast is it?

About 1–2 games per second (BGG asks consumers to be polite). 20 hot games with full detail finish in ~30 seconds.

#### Can I scrape a user's game collection?

Not in this version. BGG's classic XML collection endpoint currently returns 401 from non-residential IPs (Cloudflare gating). User profile metadata (`mode=userProfile`) works fine.

#### How are ranks structured?

The `rank` field is the overall Board Game Rank. The `ranks` array also includes sub-category ranks (Strategy, Family, Thematic, Customizable, Party, Children's, Abstract, Wargame, etc.) when available.

#### Are images permanent?

BGG hosts images on `cf.geekdo-images.com`, an open CDN with no Referer/cookie requirements. The URLs are stable and customer-safe.

#### Will alternate-language names be included?

Yes — up to 50 are emitted in `alternateNames`.

#### How are filters combined?

All filters are AND-ed. `categories` and `mechanics` use **match-any** semantics — at least one option must match. A game missing a filter-relevant field is treated as pass-through (not excluded) for the missing field.

#### Why does `"Strategy Games"` get rejected from `categories`?

BGG distinguishes **Categories** (genre tags like `Wargame`, `Abstract Strategy`, `Card Game`) from **Families** (such as `Strategy Games`, `Card Drafting`, `Cooperative Games`). The `categories` input only accepts canonical Categories from the dropdown. To filter by Family-style genres, leave `categories` empty and use `searchQuery` instead.

### Data Source

This actor reads from the public `boardgamegeek.com/api/geekitems` and `api.geekdo.com/api/{dynamicinfo,hotness,users,geekitems}` JSON endpoints — the same endpoints powering the BGG website. We deliberately do not use the older `xmlapi2/*` endpoints, which were restricted to authenticated/residential traffic in 2025.

### Pricing

Pricing is configured in the Apify UI (not in code). Typical runs are inexpensive — the JSON API is fast and the actor uses ~1024 MB memory.

# Actor input Schema

## `mode` (type: `string`):

What to fetch from BoardGameGeek.

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

Free-text keyword (matches game name).

## `gameIds` (type: `array`):

BGG game IDs (integers or `https://boardgamegeek.com/boardgame/<id>/<slug>` URLs).

## `username` (type: `string`):

BGG username, e.g. `Aldie`, `tomvasel`. Lookup is public.

## `enrichHot` (type: `boolean`):

When mode=hot, fetch full game details (ratings/mechanics/etc.) for each hot item. Slower but produces complete records.

## `gameType` (type: `string`):

Restrict results to a specific BGG game type.

## `minYear` (type: `integer`):

Drop games published before this year.

## `maxYear` (type: `integer`):

Drop games published after this year.

## `minRating` (type: `integer`):

Drop games with average rating below this. BGG ratings are 0–10. Decimals may be entered as integers (e.g. enter 7 for >=7.0).

## `maxRating` (type: `integer`):

Drop games with average rating above this.

## `minPlayers` (type: `integer`):

Game must support at least this many players (no overlap with \[min,max] excludes).

## `maxPlayers` (type: `integer`):

Game must support no more than this many players.

## `minPlaytime` (type: `integer`):

Drop games with playing time shorter than this.

## `maxPlaytime` (type: `integer`):

Drop games with playing time longer than this.

## `minAge` (type: `integer`):

Drop games with recommended age below this.

## `categories` (type: `array`):

Restrict to games tagged with ANY of these categories. Common BGG categories listed. Note: BGG distinguishes Categories (genre tags like "Wargame", "Abstract Strategy", "Card Game") from Families (such as "Strategy Games", "Card Drafting", "Cooperative Games"). Use one of the canonical Categories from the dropdown above. To filter by Family-style genres, leave this empty and use `searchQuery` instead.

## `mechanics` (type: `array`):

Restrict to games with ANY of these mechanics. Common BGG mechanics listed.

## `containsKeyword` (type: `string`):

Drop games whose name, description, or alternate names do not contain this substring (case-insensitive).

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

Hard cap on emitted records.

## Actor input object example

```json
{
  "mode": "hot",
  "searchQuery": "catan",
  "gameIds": [
    "174430",
    "161936"
  ],
  "username": "Aldie",
  "enrichHot": true,
  "maxItems": 20
}
```

# Actor output Schema

## `games` (type: `string`):

Dataset containing all scraped BoardGameGeek games and user profiles.

# 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 = {
    "mode": "hot",
    "searchQuery": "catan",
    "gameIds": [
        "174430",
        "161936"
    ],
    "username": "Aldie",
    "enrichHot": true,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/boardgamegeek-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 = {
    "mode": "hot",
    "searchQuery": "catan",
    "gameIds": [
        "174430",
        "161936",
    ],
    "username": "Aldie",
    "enrichHot": True,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/boardgamegeek-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 '{
  "mode": "hot",
  "searchQuery": "catan",
  "gameIds": [
    "174430",
    "161936"
  ],
  "username": "Aldie",
  "enrichHot": true,
  "maxItems": 20
}' |
apify call crawlerbros/boardgamegeek-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "BoardGameGeek Scraper",
        "description": "Scrape BoardGameGeek, ratings, mechanics, categories, designers, publishers, weights, ranks. Search games, fetch by ID, browse the hot list, look up user profiles. No login required.",
        "version": "1.0",
        "x-build-id": "kuRy5FIbdSvgviRlC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~boardgamegeek-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-boardgamegeek-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/crawlerbros~boardgamegeek-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-boardgamegeek-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/crawlerbros~boardgamegeek-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-boardgamegeek-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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "byIds",
                            "hot",
                            "userProfile"
                        ],
                        "type": "string",
                        "description": "What to fetch from BoardGameGeek.",
                        "default": "hot"
                    },
                    "searchQuery": {
                        "title": "Search query (mode=search)",
                        "type": "string",
                        "description": "Free-text keyword (matches game name).",
                        "default": "catan"
                    },
                    "gameIds": {
                        "title": "Game IDs (mode=byIds)",
                        "type": "array",
                        "description": "BGG game IDs (integers or `https://boardgamegeek.com/boardgame/<id>/<slug>` URLs).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "username": {
                        "title": "Username (mode=userProfile)",
                        "type": "string",
                        "description": "BGG username, e.g. `Aldie`, `tomvasel`. Lookup is public.",
                        "default": ""
                    },
                    "enrichHot": {
                        "title": "Enrich hot list with full details",
                        "type": "boolean",
                        "description": "When mode=hot, fetch full game details (ratings/mechanics/etc.) for each hot item. Slower but produces complete records.",
                        "default": true
                    },
                    "gameType": {
                        "title": "Game type filter",
                        "enum": [
                            "boardgame",
                            "boardgameexpansion",
                            "boardgameaccessory",
                            "videogame",
                            "rpgitem",
                            "rpgissue"
                        ],
                        "type": "string",
                        "description": "Restrict results to a specific BGG game type."
                    },
                    "minYear": {
                        "title": "Minimum year published",
                        "minimum": 1900,
                        "maximum": 2100,
                        "type": "integer",
                        "description": "Drop games published before this year."
                    },
                    "maxYear": {
                        "title": "Maximum year published",
                        "minimum": 1900,
                        "maximum": 2100,
                        "type": "integer",
                        "description": "Drop games published after this year."
                    },
                    "minRating": {
                        "title": "Minimum average rating (0–10)",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Drop games with average rating below this. BGG ratings are 0–10. Decimals may be entered as integers (e.g. enter 7 for >=7.0)."
                    },
                    "maxRating": {
                        "title": "Maximum average rating (0–10)",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Drop games with average rating above this."
                    },
                    "minPlayers": {
                        "title": "Minimum supported players",
                        "minimum": 1,
                        "maximum": 16,
                        "type": "integer",
                        "description": "Game must support at least this many players (no overlap with [min,max] excludes)."
                    },
                    "maxPlayers": {
                        "title": "Maximum supported players",
                        "minimum": 1,
                        "maximum": 16,
                        "type": "integer",
                        "description": "Game must support no more than this many players."
                    },
                    "minPlaytime": {
                        "title": "Minimum playing time (minutes)",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Drop games with playing time shorter than this."
                    },
                    "maxPlaytime": {
                        "title": "Maximum playing time (minutes)",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Drop games with playing time longer than this."
                    },
                    "minAge": {
                        "title": "Minimum recommended age",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Drop games with recommended age below this."
                    },
                    "categories": {
                        "title": "Categories (match any)",
                        "type": "array",
                        "description": "Restrict to games tagged with ANY of these categories. Common BGG categories listed. Note: BGG distinguishes Categories (genre tags like \"Wargame\", \"Abstract Strategy\", \"Card Game\") from Families (such as \"Strategy Games\", \"Card Drafting\", \"Cooperative Games\"). Use one of the canonical Categories from the dropdown above. To filter by Family-style genres, leave this empty and use `searchQuery` instead.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Abstract Strategy",
                                "Adventure",
                                "Age of Reason",
                                "American Civil War",
                                "American Indian Wars",
                                "American Revolutionary War",
                                "American West",
                                "Ancient",
                                "Animals",
                                "Arabian",
                                "Aviation / Flight",
                                "Bluffing",
                                "Book",
                                "Card Game",
                                "Children's Game",
                                "City Building",
                                "Civil War",
                                "Civilization",
                                "Collectible Components",
                                "Comic Book / Strip",
                                "Deduction",
                                "Dice",
                                "Economic",
                                "Educational",
                                "Electronic",
                                "Environmental",
                                "Expansion for Base-game",
                                "Exploration",
                                "Fantasy",
                                "Farming",
                                "Fighting",
                                "Game System",
                                "Horror",
                                "Humor",
                                "Industry / Manufacturing",
                                "Korean War",
                                "Mafia",
                                "Math",
                                "Mature / Adult",
                                "Maze",
                                "Medical",
                                "Medieval",
                                "Memory",
                                "Miniatures",
                                "Modern Warfare",
                                "Movies / TV / Radio theme",
                                "Murder/Mystery",
                                "Mythology",
                                "Napoleonic",
                                "Nautical",
                                "Negotiation",
                                "Novel-based",
                                "Number",
                                "Party Game",
                                "Pike and Shot",
                                "Pirates",
                                "Political",
                                "Post-Napoleonic",
                                "Prehistoric",
                                "Print & Play",
                                "Puzzle",
                                "Racing",
                                "Real-time",
                                "Religious",
                                "Renaissance",
                                "Science Fiction",
                                "Space Exploration",
                                "Spies/Secret Agents",
                                "Sports",
                                "Territory Building",
                                "Trains",
                                "Transportation",
                                "Travel",
                                "Trivia",
                                "Video Game Theme",
                                "Vietnam War",
                                "Wargame",
                                "Word Game",
                                "World War I",
                                "World War II",
                                "Zombies"
                            ]
                        }
                    },
                    "mechanics": {
                        "title": "Mechanics (match any)",
                        "type": "array",
                        "description": "Restrict to games with ANY of these mechanics. Common BGG mechanics listed.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Acting",
                                "Action Drafting",
                                "Action Points",
                                "Action Queue",
                                "Action Retrieval",
                                "Action Timer",
                                "Action/Event",
                                "Advantage Token",
                                "Area Majority / Influence",
                                "Area Movement",
                                "Area-Impulse",
                                "Auction/Bidding",
                                "Automatic Resource Growth",
                                "Betting and Bluffing",
                                "Bias",
                                "Bingo",
                                "Bribery",
                                "Campaign / Battle Card Driven",
                                "Card Drafting",
                                "Card Play Conflict Resolution",
                                "Catch the Leader",
                                "Chaining",
                                "Chit-Pull System",
                                "Closed Drafting",
                                "Closed Economy Auction",
                                "Commodity Speculation",
                                "Communication Limits",
                                "Connections",
                                "Constrained Bidding",
                                "Contracts",
                                "Cooperative Game",
                                "Crayon Rail System",
                                "Critical Hits and Failures",
                                "Cube Tower",
                                "Deck Construction",
                                "Deck, Bag, and Pool Building",
                                "Deduction",
                                "Delayed Purchase",
                                "Dice Rolling",
                                "Die Icon Resolution",
                                "Drafting",
                                "Drawing",
                                "Elapsed Real Time Ending",
                                "Enclosure",
                                "End Game Bonuses",
                                "Engine Building",
                                "Events",
                                "Finale Ending",
                                "Flicking",
                                "Force Commitment",
                                "Grid Coverage",
                                "Grid Movement",
                                "Hand Management",
                                "Hexagon Grid",
                                "Hidden Movement",
                                "Hidden Roles",
                                "Hidden Victory Points",
                                "Highest-Lowest Scoring",
                                "Hot Potato",
                                "I Cut, You Choose",
                                "Income",
                                "Increase Value of Unchosen Resources",
                                "Induction",
                                "Investment",
                                "Kill Steal",
                                "King of the Hill",
                                "Ladder Climbing",
                                "Layering",
                                "Legacy Game",
                                "Line Drawing",
                                "Line of Sight",
                                "Loans",
                                "Lose a Turn",
                                "Mancala",
                                "Map Addition",
                                "Map Deformation",
                                "Map Reduction",
                                "Market",
                                "Matching",
                                "Measurement Movement",
                                "Melding and Splaying",
                                "Memory",
                                "Minimap Resolution",
                                "Modular Board",
                                "Move Through Deck",
                                "Movement Points",
                                "Movement Template",
                                "Moving Multiple Units",
                                "Multi-Use Cards",
                                "Multiple Maps",
                                "Narrative Choice / Paragraph",
                                "Negotiation",
                                "Network and Route Building",
                                "Once-Per-Game Abilities",
                                "Open Drafting",
                                "Order Counters",
                                "Ownership",
                                "Paper-and-Pencil",
                                "Passed Action Token",
                                "Pattern Building",
                                "Pattern Movement",
                                "Pattern Recognition",
                                "Physical Removal",
                                "Pick-up and Deliver",
                                "Pieces as Map",
                                "Player Elimination",
                                "Player Judge",
                                "Point to Point Movement",
                                "Predictive Bid",
                                "Programmed Movement",
                                "Push Your Luck",
                                "Race",
                                "Random Production",
                                "Real-Time",
                                "Relative Movement",
                                "Re-rolling and Locking",
                                "Resource to Move",
                                "Rock-Paper-Scissors",
                                "Role Playing",
                                "Roles with Asymmetric Information",
                                "Roll / Spin and Move",
                                "Rondel",
                                "Scenario / Mission / Campaign Game",
                                "Score-and-Reset Game",
                                "Secret Unit Deployment",
                                "Selection Order Bid",
                                "Semi-Cooperative Game",
                                "Set Collection",
                                "Simulation",
                                "Simultaneous Action Selection",
                                "Singing",
                                "Single Loser Game",
                                "Slide/Push",
                                "Solo / Solitaire Game",
                                "Speed Matching",
                                "Spelling",
                                "Square Grid",
                                "Stacking and Balancing",
                                "Stat Check Resolution",
                                "Static Capture",
                                "Stock Holding",
                                "Storytelling",
                                "Sudden Death Ending",
                                "Take That",
                                "Targeted Clues",
                                "Team-Based Game",
                                "Tech Trees / Tech Tracks",
                                "Three Dimensional Movement",
                                "Tile Placement",
                                "Time Track",
                                "Track Movement",
                                "Trading",
                                "Traitor Game",
                                "Trick-taking",
                                "Tug of War",
                                "Turn Order: Auction",
                                "Turn Order: Claim Action",
                                "Turn Order: Pass Order",
                                "Turn Order: Progressive",
                                "Turn Order: Random",
                                "Turn Order: Role Order",
                                "Turn Order: Stat-Based",
                                "Turn Order: Time Track",
                                "Variable Phase Order",
                                "Variable Player Powers",
                                "Variable Set-up",
                                "Victory Points as a Resource",
                                "Voting",
                                "Worker Placement",
                                "Worker Placement with Dice Workers",
                                "Worker Placement, Different Worker Types",
                                "Zone of Control"
                            ]
                        }
                    },
                    "containsKeyword": {
                        "title": "Contains keyword",
                        "type": "string",
                        "description": "Drop games whose name, description, or alternate names do not contain this substring (case-insensitive)."
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
