# BoardGameGeek Reviews Scraper (`thescrapelab/boardgamegeek-reviews-scraper`) Actor

Search BoardGameGeek by game name and extract public user reviews as clean, flat dataset rows. Choose the first best match or scrape all matching games, then collect recent or highest-rated reviews with an optional minimum rating filter.

- **URL**: https://apify.com/thescrapelab/boardgamegeek-reviews-scraper.md
- **Developed by:** [Inus Grobler](https://apify.com/thescrapelab) (community)
- **Categories:** Developer tools, Automation, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.49 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## BoardGameGeek Reviews Scraper

BoardGameGeek Reviews Scraper lets you search BoardGameGeek by game name and collect public user reviews as clean, structured dataset rows.

This Actor is designed for simple review collection:

- search by game name
- choose the first best match or all matches
- get one review per row
- keep output flat and easy to analyze
- collect recent or highest-rated reviews

### What It Does

Use this Actor when you want BoardGameGeek review data for research, analysis, monitoring, or enrichment.

You provide one or more game names, and the Actor returns public reviews for the matched BoardGameGeek titles.

### Why It Is Useful

- No BoardGameGeek IDs required
- Each review is returned as a separate row
- Good for sentiment analysis, review analysis, and market research
- Works well when you want review text for multiple games in one run

### Example Input

```json
{
  "gameNames": ["Gloomhaven"],
  "matchMode": "first",
  "maxReviewsPerGame": 50,
  "sortBy": "recent",
  "minRating": 7
}
````

### Input Fields

- `gameNames`: List of board game names to search on BoardGameGeek.
- `matchMode`: `first` or `all`.
- `maxReviewsPerGame`: Maximum number of reviews to return for each matched game.
- `sortBy`: `recent` or `highest`.
- `minRating`: Optional minimum rating filter from `0` to `10`.

### Match Mode

- `first`: Returns reviews for the single best BoardGameGeek match for each input name.
- `all`: Returns reviews for every matching BoardGameGeek title found for each input name.

Example:

- searching for `Catan` with `first` usually returns `Catan`
- searching for `Catan` with `all` may also return related titles such as `Catan Card Game` or `The Rivals for Catan`

### Output

Each review is returned as its own dataset row.

Example review row:

```json
{
  "type": "review",
  "source": "boardgamegeek",
  "scrapedAt": "2026-05-10T17:14:45.693Z",
  "gameId": 174430,
  "gameName": "Gloomhaven",
  "gameUrl": "https://boardgamegeek.com/boardgame/174430/gloomhaven",
  "reviewId": "145330938",
  "reviewUrl": null,
  "reviewerUsername": "Cdw165",
  "reviewerUrl": "https://boardgamegeek.com/user/Cdw165",
  "rating": 10,
  "ratingText": "10/10",
  "reviewTitle": null,
  "reviewText": "The game that got me interested in playing more board games. The strategy. The cooperation. This game is a masterpiece. Now if only I could finish the campaign!",
  "reviewDate": "2026-05-09",
  "language": null,
  "commentCount": null,
  "thumbsUp": null,
  "status": "ok",
  "errorMessage": null
}
```

Example error row:

```json
{
  "type": "error",
  "source": "boardgamegeek",
  "scrapedAt": "2026-05-10T17:14:45.693Z",
  "gameId": null,
  "gameName": "Unknown Game Name",
  "gameUrl": null,
  "status": "failed",
  "errorMessage": "No BoardGameGeek matches were found for \"Unknown Game Name\"."
}
```

### Good To Know

- `sortBy: "recent"` follows BoardGameGeek's recent review order.
- `sortBy: "highest"` follows BoardGameGeek's highest-rated review order.
- `matchMode: "all"` can return many matched games for broad search terms.
- Reviews without a visible rating are still returned unless you set `minRating`.
- Some fields such as `reviewTitle`, `reviewUrl`, `commentCount`, `thumbsUp`, and `language` may be `null` when they are not publicly available.

### Run With Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run_input = {
    "gameNames": ["Gloomhaven", "Catan"],
    "matchMode": "all",
    "maxReviewsPerGame": 10,
    "sortBy": "recent",
    "minRating": 7,
}

run = client.actor("thescrapelab/boardgamegeek-reviews-scraper").call(run_input=run_input)

items = client.dataset(run["defaultDatasetId"]).list_items().items

for item in items[:10]:
    print(item["type"], item.get("gameName"), item.get("reviewerUsername"))
    print(item.get("reviewText", "")[:200])
    print("---")
```

Install the client first:

```bash
pip install apify-client
```

### Compliance

- Scrapes only publicly available review data
- Does not access private content
- Does not require login
- Does not attempt to bypass restrictions

### Limitations

- BoardGameGeek may rate-limit or block some runs
- Broad names with `matchMode: "all"` can produce many matched games
- Public review quality varies from short opinions to long-form writeups

# Actor input Schema

## `gameNames` (type: `array`):

Board game names to search on BoardGameGeek. Each name is resolved to either the first best match or all matching games depending on Match mode.

## `matchMode` (type: `string`):

Choose whether each input name should scrape only the first best BoardGameGeek match or every matching game title found.

## `maxReviewsPerGame` (type: `integer`):

Hard limit for how many reviews to output for each matched game.

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

Review order as returned by BoardGameGeek. The Actor takes the first N reviews in that order.

## `minRating` (type: `number`):

Optional minimum numeric rating filter. Leave blank to disable filtering. Reviews without a rating are dropped when this is set.

## Actor input object example

```json
{
  "gameNames": [
    "Gloomhaven"
  ],
  "matchMode": "first",
  "maxReviewsPerGame": 50,
  "sortBy": "recent"
}
```

# Actor output Schema

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

Each item is a flat review row or an error row.

# 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 = {};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "BoardGameGeek Reviews Scraper",
        "description": "Search BoardGameGeek by game name and extract public user reviews as clean, flat dataset rows. Choose the first best match or scrape all matching games, then collect recent or highest-rated reviews with an optional minimum rating filter.",
        "version": "0.2",
        "x-build-id": "zYrxi8X5eLNL2JgV2"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/thescrapelab~boardgamegeek-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-thescrapelab-boardgamegeek-reviews-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/thescrapelab~boardgamegeek-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-thescrapelab-boardgamegeek-reviews-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/thescrapelab~boardgamegeek-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-thescrapelab-boardgamegeek-reviews-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",
                "properties": {
                    "gameNames": {
                        "title": "Game names",
                        "minItems": 1,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Board game names to search on BoardGameGeek. Each name is resolved to either the first best match or all matching games depending on Match mode.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        },
                        "default": [
                            "Gloomhaven"
                        ]
                    },
                    "matchMode": {
                        "title": "Match mode",
                        "enum": [
                            "first",
                            "all"
                        ],
                        "type": "string",
                        "description": "Choose whether each input name should scrape only the first best BoardGameGeek match or every matching game title found.",
                        "default": "first"
                    },
                    "maxReviewsPerGame": {
                        "title": "Max reviews per game",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard limit for how many reviews to output for each matched game.",
                        "default": 50
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "recent",
                            "highest"
                        ],
                        "type": "string",
                        "description": "Review order as returned by BoardGameGeek. The Actor takes the first N reviews in that order.",
                        "default": "recent"
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "number",
                        "description": "Optional minimum numeric rating filter. Leave blank to disable filtering. Reviews without a rating are dropped when this is set."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
