BoardGameGeek API Alternative: A JSON API With Pricing

The BGG API Is Great — and Stuck in 2010

BoardGameGeek is the canonical database of board games. If you've built anything in this space, you've probably used the BGG XMLAPI2. It works, it's free, and the data quality is excellent for the core fields — titles, designers, mechanics, ranks, ratings.

But it's also stuck in 2010. The format is XML only. Rate limits are real but undocumented (most developers learn them by getting 429'd at 3am). Average response times sit in the multi-second range during peak hours. There's no SLA, no status page beyond the BGG forum, no auth model beyond unauthenticated polling, and crucially — no pricing data of any kind. If you're building anything commercial or anything that needs to render in under 500ms, the XMLAPI is a bottleneck you'll spend weeks engineering around.

What Devs Actually Need in 2026

The board game tooling ecosystem has matured. Modern projects expect:

• JSON, not XML — the rest of the JavaScript and Python ecosystem hasn't shipped XML parsers as a default in years
• Predictable rate limits — clearly documented, tier-based, surfaced in response headers
• Pricing data — the missing piece for collection valuators, "where to buy" widgets, and trend tools
• Modern auth — a header-based API key, not unauthenticated scraping by user agent
• Structured pagination — limit and offset with count and total, not "scrape until you 404"
• An SLA — production traffic expects sub-second p95 and a status page

BGG was never designed for any of this. It was designed for forum widgets in the late 2000s, and that's still its primary integration model.

Why Pricing Matters Even for Non-Commercial Apps

A common reaction when we mention pricing: "I'm not selling games, I just want collection data." Pricing turns out to be useful even for purely non-commercial board game apps:

• Collection valuations — "Your shelf is worth $4,200" is a high-engagement feature for collection trackers
• "Where to buy" links — even if you don't take affiliate fees, surfacing the cheapest live listing is a kill feature
• Trend tracking — "Brass: Birmingham is up 14% this month" makes any BGG dashboard more interesting
• Trade fairness — collectors want a fair-value reference when swapping titles
• Insurance / inventory — collectors and retailers both need defensible per-title valuations

If your app already has the BGG ID for every game in a user's collection, layering prices is a one-call enhancement. Without an API like this, it's a multi-week scraping project.

Introducing the TCGAPIs Board Games API

The TCGAPIs Board Games API covers 175,000+ titles, keyed by BGG ID. You get the standard catalog fields — title, year published, designers, artists, publishers, mechanics, categories, families, ranks, ratings, weight, min/max players, playtime — alongside live marketplace pricing from the major board game retailers. JSON only, REST, header auth, documented rate limits.

The data overlap with BGG is intentional: every record carries the BGG ID, so existing collection databases keyed off BGG IDs work without any remapping. You don't migrate; you augment.

Quick Start

Sign up at /signup, grab your API key, and you're a single curl away from data. Brass: Birmingham is BGG ID 224517.

Title metadata:

curl 'https://api.tcgapis.com/api/v2/boardgames/title/224517' \
  -H 'x-api-key: tcg_live_a1b2c3d4e5f6'

Live marketplace pricing:

curl 'https://api.tcgapis.com/api/v2/boardgames/prices/224517' \
  -H 'x-api-key: tcg_live_a1b2c3d4e5f6'

In Node:

const bggId = 224517;
const headers = { 'x-api-key': process.env.TCGAPIS_KEY };
 
const [meta, prices] = await Promise.all([
  fetch(`https://api.tcgapis.com/api/v2/boardgames/title/${bggId}`, { headers })
    .then(r => r.json()),
  fetch(`https://api.tcgapis.com/api/v2/boardgames/prices/${bggId}`, { headers })
    .then(r => r.json()),
]);
 
console.log(`${meta.title} (${meta.yearPublished}) — cheapest: $${prices.lowest.price}`);

Migrating From BGG XML

A quick side-by-side. Here's a chunk of the BGG XMLAPI2 response for Brass: Birmingham:

<items>
  <item type="boardgame" id="224517">
    <thumbnail>https://cf.geekdo-images.com/.../brass-birmingham.jpg</thumbnail>
    <name type="primary" sortindex="1" value="Brass: Birmingham"/>
    <yearpublished value="2018"/>
    <minplayers value="2"/>
    <maxplayers value="4"/>
    <playingtime value="120"/>
    <statistics>
      <ratings>
        <average value="8.59"/>
        <bayesaverage value="8.41"/>
        <ranks>
          <rank type="subtype" id="1" name="boardgame" value="1"/>
        </ranks>
      </ratings>
    </statistics>
  </item>
</items>

And the equivalent JSON from TCGAPIs:

{
  "bggId": 224517,
  "title": "Brass: Birmingham",
  "yearPublished": 2018,
  "thumbnail": "https://cf.geekdo-images.com/.../brass-birmingham.jpg",
  "minPlayers": 2,
  "maxPlayers": 4,
  "playingTime": 120,
  "rating": {
    "average": 8.59,
    "bayesAverage": 8.41
  },
  "rank": {
    "boardgame": 1
  },
  "designers": ["Gavan Brown", "Matt Tolman"],
  "publishers": ["Roxley"],
  "mechanics": ["Hand Management", "Network and Route Building"]
}

No XML parser. No xml2js dependency. No regex over <value> attributes. Just await res.json().

The Data Overlap

The board game data sits alongside the TCG product catalog on the same infrastructure, but it's keyed off BGG IDs, not TCGPlayer product IDs. If your existing app stores BGG IDs (which most board game apps do), the migration is purely additive: keep BGG as a source of truth for whatever you trust it for, and call TCGAPIs for the data BGG doesn't provide.

A common pattern: continue scraping BGG occasionally for collection sync (your users' personal geeklists and collections), and use TCGAPIs for everything that needs to render fast — title pages, search, prices, dashboards.

What You Can Build

The pricing layer unlocks a category of apps the XML API can't support:

• Collection valuators — turn a user's BGG geeklist into a live portfolio value
• "Buy now" browser extensions — overlay current low prices on BGG title pages
• BGG dashboards with prices — modern frontends that show ratings, ranks, AND market pricing in one screen
• Retailer aggregators — "find the cheapest copy of [Ark Nova] across X retailers"
• Trend tools — "what's gone up the most this month?" leaderboards
• Trade-fairness calculators — auto-balance proposed trades by current market value
• Insurance/inventory exports — defensible per-title valuations for collectors

If you're new to TCGAPIs more broadly, our getting started guide covers the auth model and rate limit handling that applies across all endpoints.

FAQ

Is this a BGG mirror or independent data?

Both. The catalog metadata (titles, IDs, designers, mechanics, ranks) is synced from public BGG sources and enriched with our own corrections, normalized fields, and JSON-shaped output. The pricing data is fully independent — sourced directly from board game retailer feeds, not BGG. If a price changes at a retailer, it's reflected here regardless of BGG's state.

Do I need to authenticate?

Yes for most endpoints, but the free Hobby tier covers most personal projects (10,000 requests/month). The public games-list endpoint requires no key. Sign up here.

Can I look up by name, not just BGG ID?

Yes. The search endpoint (/api/v2/boardgames/search?q=brass) returns ranked title matches with BGG IDs. Useful for autocomplete and for backfilling BGG IDs into legacy databases that only stored title strings.

What's the rate limit story?

Documented, tier-based, surfaced in X-RateLimit-Remaining headers on every response. Hobby is 10,000 requests/month, Business is 50,000, Unlimited is uncapped. No undocumented per-second throttling.

How does pricing freshness compare to TCG card pricing?

Board game pricing updates less frequently than TCG card pricing — typically once per day per retailer rather than continuously — because retailer board game inventories don't churn at the same rate. For most use cases (collection valuations, "where to buy" widgets) this is well within useful tolerances.

Ready to Build?

If you've been working around the BGG XML API, this is the upgrade. Sign up, browse the Board Games API docs, and check pricing tiers — the free tier is enough to prototype most apps. For a related migration story on the TCG side, see Replace the TCGPlayer API in 10 Minutes.