# BoardGameGeek Board Games Scraper (`parseforge/boardgamegeek-scraper`) Actor

Scrapes board game listings from BoardGameGeek by hot, search, or top-ranked mode. Returns each game as a flat row with rank, rating, player count, and metadata.

- **URL**: https://apify.com/parseforge/boardgamegeek-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Other, Social media, News
- **Stats:** 1 total users, 1 monthly users, 90.0% runs succeeded, 0 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

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

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

# README

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### BoardGameGeek Board Games Scraper

**Scrape board game data from BoardGameGeek hot lists, search results, or top-ranked charts, up to a million games per run.** Every game comes with its rank, rating, player count, and full metadata. No API key or XML parsing required. Export to CSV, JSON, Excel, or XML.

BoardGameGeek's XML API needs request queuing, rate-limit handling, and manual XML parsing. This reads the public game feeds directly, filtered by mode and search term, and returns each match in one fixed schema. You get the data you need without building a BGG API client.

| Who uses it | What they scrape BoardGameGeek for |
|---|---|
| Game publishers | Monitor which mechanics and themes are trending in the top-ranked games. |
| Market researchers | Track rating distributions and player counts across new hot releases. |
| Hobbyist developers | Build a personal board game database with current BGG rankings and metadata. |
| Content creators | Pull the latest hot games list for a weekly roundup article or video. |

### What it does

This Actor collects board game listings from BoardGameGeek by hot, search, or top-ranked mode, and returns each one as a flat row.

- 🔥 **Hot Games:** currently trending titles on BoardGameGeek, refreshed on each run.
- 🔍 **Search by Query:** find games matching a name or keyword like 'strategy' or 'catan'.
- 🏆 **Top Ranked:** the all-time highest-rated board games from the BGG database.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with BoardGameGeek data

**📈 Monitor hot game trends.**

A publisher runs the Actor in hot mode weekly to see which new titles are gaining traction and adjust their own release calendar.

**🔎 Research a niche genre.**

A blogger searches for 'dungeon crawler' to pull all matching games with their ratings and player counts for a comparison post.

**🏆 Audit the all-time greats.**

A game designer scrapes the top-ranked list to analyze common mechanics and themes among the highest-rated board games.

**📊 Feed a market analysis dashboard.**

A data analyst schedules daily runs of hot and top-ranked modes to populate a dashboard tracking rating shifts and new entries.

### Why choose this scraper

| | What you get |
|---|---|
| **No API key** | Reads public BoardGameGeek pages, no registration or OAuth. |
| **Flat output** | Every game is one row, ready for spreadsheets or databases. |
| **Three discovery modes** | Hot, search, and top-ranked cover trending, niche, and all-time best. |
| **Scalable runs** | Collect up to 1,000,000 games in a single run. |

### How it compares

This Actor focuses on fast, flat game listings from three discovery modes. Other BoardGameGeek scrapers on Apify add reviews, collection data, or XML API access.

| Feature | ParseForge | BoardGameGeek Scraper - Board Game Data & Ratings | BoardGameGeek (BGG) Board Game Reviews Scraper | BoardGameGeek (BGG) Board Game Reviews Scraper |
|---|---|---|---|---|
| Hot, search, and top-ranked modes | Yes | Yes | Yes | Not listed |
| Flat row output (no nested XML) | Yes | Not listed | Not listed | Not listed |
| Written reviews and reviewer profiles | Not listed | Not listed | Yes | Yes |
| Collection context and ownership data | Not listed | Not listed | Yes | Yes |
| BGG XML API2 integration | Not listed | Yes | Not listed | Not listed |

### Configure the run

Drive the Actor from hot, search, or top-ranked modes, and set a maximum number of games so only the top matches reach your dataset. The Input tab lists every parameter.

A first run with the defaults:

```json
{
 "maxItems": 10,
 "mode": "hot",
 "search": "strategy"
}
```

A larger pull:

```json
{
 "maxItems": 200,
 "mode": "hot",
 "search": "strategy"
}
```

### Pricing

Pay-per-result: **$0.021 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $2.10 |
| 1,000 results | $21.00 |
| 10,000 results | $210.00 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [BoardGameGeek Board Games Scraper](https://apify.com/parseforge/boardgamegeek-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to BoardGameGeek through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=parseforge/boardgamegeek-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting no results?**

Check that your search term is spelled correctly and is not too specific. Try a broader keyword. If using hot or top-ranked mode, BoardGameGeek may be temporarily slow; retry the run.

**The run is taking too long.**

Lower the maximum number of games. The Actor respects BoardGameGeek's rate limits, so large runs take time. For bulk data, consider splitting the work across multiple runs with different modes.

**Some games are missing data fields.**

BoardGameGeek pages vary. Some games may not have a player count or a rating yet. The Actor returns whatever is publicly listed; missing fields appear as empty in the output.

**I get an error when using search mode.**

Ensure you have filled in the 'Board game name' input field. If the field is empty, the Actor cannot run in search mode. Switch to hot or top-ranked mode if you do not have a search term.

### FAQ

| Question | Answer |
|---|---|
| Do I need a BoardGameGeek account or API key? | No. The Actor reads public BoardGameGeek pages directly. No login, API key, or XML parsing is required. |
| What data fields does the Actor return? | Each row includes the game name, rank, rating, number of voters, player count, and other metadata available on the listing page. The exact fields are shown in the sample output on the Actor's page. |
| Can I scrape both hot games and search results in one run? | You select one mode per run: hot, search, or top-ranked. To collect from multiple modes, run the Actor once per mode and merge the datasets. |
| How many board games can I scrape? | You set the maximum number of games per run, up to 1,000,000. The Actor stops when it reaches that count or runs out of matching games. |
| Does this Actor get game reviews or comments? | This Actor focuses on game listings and metadata. It does not collect written reviews or forum comments. For reviews, see the related Actors below. |
| What is the difference between hot and top-ranked modes? | Hot mode returns games currently trending on BoardGameGeek. Top-ranked mode returns the all-time highest-rated games based on BGG's ranking algorithm. |
| Can I search for a specific game by name? | Yes. Set the mode to 'Search by Query' and enter the game name or a keyword. The Actor returns matching games from BoardGameGeek's search results. |
| How do I export the scraped data? | The Actor outputs data in CSV, JSON, Excel, or XML. You can download the dataset from the run's storage tab or push it to an external service via an integration. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by BoardGameGeek, LLC. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

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

Maximum number of board games to collect per run.

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

How to discover games: hot (currently trending), search (by query), or top-ranked (BGG top games).

## `search` (type: `string`):

Search term to find board games (only used in search mode). Example: strategy, catan, dungeon.

## Actor input object example

```json
{
  "maxItems": 10,
  "mode": "hot",
  "search": "strategy"
}
```

# 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,
    "mode": "hot",
    "search": "strategy"
};

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

# Run the Actor and wait for it to finish
run = client.actor("parseforge/boardgamegeek-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "maxItems": 10,
  "mode": "hot",
  "search": "strategy"
}' |
apify call parseforge/boardgamegeek-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/boardgamegeek-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/a9sfyA9ix6MMPU9GV/builds/HhqchNm4GhacLeD5d/openapi.json