How do I encode player count (min and max) for board games in schema?

Player count should be encoded as two separate numeric properties: minimum players and maximum players. The minimum/maximum distinction matters because many games have an officially supported range that differs from their playable range. For example, a game listed as '2–6 players' may be designed optimally for 3–5 players, with the 2-player experience being a noticeably different mode. Schema.org has specific properties for this: 'numberOfPlayers' with 'minValue' and 'maxValue' on a QuantitativeValue is the most accurate encoding. However, a simpler additionalProperty approach with separate min/max is more widely supported in Shopify contexts. Additionally, encode the 'best player count' as a third property — this is the sweet spot the designer intended: { '@type': 'PropertyValue', 'name': 'Player Count', 'value': '2–6 players', 'description': 'Supports 2 to 6 players. Minimum: 2 (game includes specific 2-player rules variant). Maximum: 6 (requires expansion for 7–8 players — sold separately). Best with: 4–5 players per designer recommendation and BGG community rating. At 6 players, player downtime between turns increases significantly. At 2 players, the game uses a modified automa (automated opponent) ruleset.' } Encoding best player count alongside min/max helps AI agents recommend the game for the buyer's specific group size rather than just whether their headcount falls within range.

What is BGG complexity weight and how should I encode it as a structured data property?

BoardGameGeek (BGG) complexity weight is a community-rated score from 1.0 to 5.0 that indicates how complex a game's rules and decision-making are. It is the most widely used single complexity metric in the hobby board game market. 1.0–1.5: Family/gateway (Ticket to Ride, Codenames, Dixit); rules learnable in under 10 minutes; accessible to non-gamers. 1.5–2.5: Medium-light (Catan, Pandemic, Carcassonne, 7 Wonders); some rules to learn but manageable. 2.5–3.5: Medium-heavy (Wingspan, Viticulture, Terraforming Mars, Agricola); several interlocking systems; 20–60 minute setup + rules learn. 3.5–4.5: Heavy (Gloomhaven, Twilight Imperium, Arkham Horror LCG); multiple rule books; significant learning investment; rewarding for dedicated gamers. 4.5–5.0: Very heavy (Hannibal & Hamilcar, wargames); extensive rulebooks; long play times; specialist audience. Encode: { '@type': 'PropertyValue', 'name': 'BGG Complexity Weight', 'value': '3.2', 'description': 'BoardGameGeek complexity weight: 3.2 out of 5.0 (as of 2026-06-20; BGG ID 233078). Medium-heavy complexity: multiple interlocking systems (engine building, action selection, card combo play). Estimated rules learning time: 45–90 minutes. Not suitable for casual or non-gamer audiences without a patient teacher. Compare: Catan (2.3), Terraforming Mars (3.2), Twilight Imperium 4th Ed (4.3). BGG weight is a community average — individual experience varies by prior gaming experience.' }

How do I encode game mechanics — what controlled vocabulary should I use?

Game mechanics are the core interaction systems that define how a game is played. Using BGG's mechanic taxonomy as a controlled vocabulary ensures AI agents can filter on widely-understood terms. Primary mechanics to encode: Worker Placement (place wooden workers on action spaces to take exclusive actions — Agricola, Viticulture, Lords of Waterdeep); Deck Building (players construct a personal card deck from a common pool — Dominion, Star Realms, Clank!); Deck Construction/Hand Management (players use a pre-built deck and manage their hand — most card games); Area Control (players control territories by having the most units — Risk, Scythe, Twilight Imperium); Engine Building (players build resource generation loops from cards/tiles — Wingspan, Race for the Galaxy); Roll-and-Write (players roll dice and write results on personal sheets — Yahtzee, Cartographers, Ganz Schön Clever); Cooperative (all players win or lose together — Pandemic, Arkham Horror, Spirit Island); Drafting (players pick cards/tiles from a rotating pool — 7 Wonders, Sushi Go, Wingspan); Push Your Luck (players choose when to stop taking risk — Can't Stop, Incan Gold); Social Deduction (hidden roles and bluffing — Werewolf, Secret Hitler, The Resistance). Encode: { '@type': 'PropertyValue', 'name': 'Game Mechanics', 'value': 'Worker Placement, Engine Building, Resource Management', 'description': 'Primary mechanics: (1) Worker Placement — place workers on action spaces to take exclusive actions; some spaces allow multiple workers, others are exclusive; workers returned at round end. (2) Engine Building — cards purchased become permanent engine components that generate resources each round; engine strength grows exponentially late-game. (3) Resource Management — 5 resource types (food, stone, wood, gold, knowledge) managed on a personal player board; scarcity drives worker placement competition.' }

How do I encode BGG ID and why should I include it in product schema?

BoardGameGeek ID (BGG ID) is a unique numeric identifier for every game in the BGG database — the canonical reference for hobby board games worldwide. BGG is the de facto authoritative database for board game information, ratings, reviews, rules, and expansions. Including the BGG ID in product schema allows AI shopping agents to cross-reference your product with BGG data for: user ratings (BGG score), number of ratings (confidence in score), player count recommendations from community, complexity weight, and related expansions and editions. The BGG ID is found in the game's BGG URL: boardgamegeek.com/boardgame/{ID}/game-name. Encode: { '@type': 'PropertyValue', 'name': 'BGG ID', 'value': '169786', 'description': 'BoardGameGeek game ID: 169786 (Scythe by Stonemaier Games). BGG URL: boardgamegeek.com/boardgame/169786/scythe. BGG rating: 8.2/10 (as of mid-2026, based on 80,000+ ratings). BGG complexity weight: 3.4/5. BGG rank: #5 Strategy, #8 Overall. The BGG ID is stable across editions — the 2nd edition and retail version share the same BGG ID; accessories and expansions have separate IDs. Buyers researching the game on BGG will find extended rules, FAQ, variants, and community review through this ID.' }

How do I encode language dependence and expansion compatibility for board games?

Language dependence measures how much text-reading is required to play the game. BGG uses a five-level scale that should be encoded: No necessary in-game text (abstract games — chess, Go, Azul — work in any language; no language dependence); Some necessary text (rules are translated but cards/tiles have minimal text; player aids exist); Moderate in-game text (some cards have unique text that affects play; moderate language barrier without translation); Extensive use of text (strategy card text, event cards, story text — game practically requires native language to play competitively); Unplayable in another language (heavy text games — Arkham Horror LCG, Gloomhaven — require translated edition). Encode: { '@type': 'PropertyValue', 'name': 'Language Dependence', 'value': 'Moderate — some card text requires reading', 'description': 'Language dependence: moderate. Player boards and resource tokens are iconic/symbolic (no text). Action cards have 2–4 lines of rules text each — a translated player aid or summary sheet makes the game playable in non-primary language. Rules book: available for download in French, German, Spanish, Japanese on publisher website. Cards: English only in this edition. A French-language edition exists (sold separately as a separate SKU).' } For expansion compatibility, encode the base game required and version compatibility: { '@type': 'PropertyValue', 'name': 'Expansion Compatibility', 'value': 'Requires base game: Wingspan (Stonemaier Games)', 'description': 'Standalone expansion — requires the Wingspan base game to play (sold separately). Compatible with: Wingspan (all editions including 2nd edition and Oceania edition). Compatible with all other Wingspan expansions simultaneously. Not backwards compatible with European Expansion rules variant 1 (rules errata card included for that variant). Box: standalone box, stores all expansion content plus base game cards in one box when NeoCon insert used (sold separately).' }

Optimization Guide

Shopify Board Game & Tabletop Game Schema — Player Count (Min/Max), Play Time (Minutes), BGG Complexity Weight (1–5), Minimum Age, Game Mechanic, BGG ID, Expansion Compatibility, Language Dependence, Structured Data

AI shopping agents answering queries like "cooperative board game 4 players under 60 minutes," "worker placement strategy game BGG weight above 3," or "expansion for Wingspan compatible with all editions" require player count, play time, complexity weight, mechanics, and expansion compatibility encoded as machine-readable structured data. Shopify's default JSON-LD outputs none of these tabletop game attributes — buyers comparing games on player count, complexity, or game mechanic cannot find the right product without explicit schema markup.

TL;DR Use Product @type with additionalProperty (or Schema.org's Game @type with native numberOfPlayers and characterAttribute) for: player count min/max, best player count, play time (minutes), BGG complexity weight (1.0–5.0), minimum age, game mechanics (controlled vocab list), product type (standalone / expansion / accessory), BGG ID, base game required (for expansions), and language dependence level. Store in a board_game.* metafield namespace.

Why Board Games Are Structurally Invisible to AI Shopping Agents

Board game purchase decisions cluster around three filter criteria that product titles rarely contain: player count ("I need something for 6 people"), play time ("under 45 minutes — we don't have all evening"), and complexity ("something a non-gamer can learn quickly"). A product titled "Catan — The Board Game" gives AI agents no signal on whether it plays 3–4 or 3–6, whether it takes 60 or 120 minutes, or whether it is gateway-complexity or heavy. Buyers asking ChatGPT or Perplexity Shopping for "board game for 5 people, 45-minute play time, not too complex" will not find Catan unless these attributes are explicitly encoded.

BGG complexity weight is the dominant complexity metric in the hobby board game space — it has no mainstream equivalent as well-calibrated. An AI agent that cannot access complexity weight cannot meaningfully distinguish a family game (Codenames, Ticket to Ride) from a gateway game (Catan, Pandemic) from a heavy strategy game (Gloomhaven, Twilight Imperium) — which are all sold in the same "board games" category on Shopify. Encoding the BGG weight as a numeric property creates the differentiating signal that AI agents need to match complexity-aware queries.

Expansion compatibility is a hard purchasing constraint — an expansion purchased for the wrong base game edition is useless. Buyers searching for "Wingspan Oceania expansion compatibility" need to know whether their first-edition base game is compatible before purchasing. Without explicit expansion compatibility attributes in schema, AI agents cannot answer this question from product data alone and will either refuse to answer or provide a generic response.

BGG Complexity Weight Reference Scale

Weight range	Category	Example games	Target audience
1.0–1.5	Family / gateway	Codenames (1.3), Dixit (1.1), Ticket to Ride (1.9)	Non-gamers, families, all ages
1.5–2.5	Medium-light	Catan (2.3), Pandemic (2.4), 7 Wonders (2.7)	Casual gamers, regular game nights
2.5–3.5	Medium-heavy	Wingspan (2.4), Viticulture (2.9), Terraforming Mars (3.2), Agricola (3.6)	Dedicated hobby gamers
3.5–4.5	Heavy	Gloomhaven (3.9), Spirit Island (4.0), Twilight Imperium 4 (4.3)	Experienced strategy gamers
4.5–5.0	Very heavy	Wargames, ASL, Campaign for North Africa (5.0)	Specialist wargame enthusiasts

Common Game Mechanic Controlled Vocabulary

Mechanic	Description	Example games
Worker Placement	Place workers on exclusive action spaces	Agricola, Viticulture, Everdell
Deck Building	Construct personal deck from shared pool during play	Dominion, Clank!, Star Realms
Area Control	Control territories with highest unit count	Scythe, Twilight Imperium, Risk
Engine Building	Build resource-generating loops from cards/tiles	Wingspan, Race for the Galaxy, Terraforming Mars
Cooperative	All players win or lose together	Pandemic, Arkham Horror, Spirit Island
Drafting	Pick cards from rotating pool	7 Wonders, Sushi Go!, Wingspan
Roll-and-Write	Roll dice and write results on personal sheet	Yahtzee, Cartographers, That's Pretty Clever
Social Deduction	Hidden roles with bluffing and voting	Werewolf, Secret Hitler, The Resistance
Push Your Luck	Player chooses when to stop taking risk	Can't Stop, Incan Gold, Zombie Dice
Legacy / Campaign	Permanent changes that persist across sessions	Pandemic Legacy, Gloomhaven, Betrayal Legacy

Complete Board Game Schema — Heavy Strategy Game

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Wingspan — Engine-Building Board Game, 1–5 Players, 40–70 Minutes, BGG Weight 2.4",
  "description": "Competitive engine-building board game about attracting birds to wildlife preserves. 1–5 players (also 1 player with automa solo opponent). Play time: 40–70 minutes. Complexity: BGG weight 2.4/5 (medium-light). Mechanics: Engine Building, Card Drafting, Hand Management, Set Collection. BGG ID: 266192. BGG rating: 8.0/10. Publisher: Stonemaier Games. Designer: Elizabeth Hargrave. Contents: 170 bird cards, food tokens, egg miniatures, bird trays, dice tower.",
  "sku": "STONEMAIER-WINGSPAN-RETAIL",
  "brand": { "@type": "Brand", "name": "Stonemaier Games" },
  "additionalProperty": [
    {
      "@type": "PropertyValue",
      "name": "Player Count",
      "value": "1–5 players (best 3–5)",
      "description": "Supported player count: 1 to 5. Best player count: 3–5 players per BGG community rating and designer intent. Solo mode: full automa (automated opponent) included in box — solo rules use a 'Automa' player deck that simulates a second player's board state and applies end-of-round pressure without requiring a human opponent. 2-player game: works well; direct competition for bird habitat spots is more visible at 2 players. 5-player game: longer play time (add 10–15 minutes per additional player); bird tray refills more frequently; slightly more player count scaling than some engine builders. Not suitable for 6+ players without expansion (Wingspan Asia adds 6–7 player mode)."
    },
    {
      "@type": "PropertyValue",
      "name": "Play Time",
      "value": "40–70 minutes",
      "description": "Estimated play time: 40 to 70 minutes. BGG listed play time: 40–70 minutes. Actual play time varies: first game (including rules teaching): 90–120 minutes. Experienced players (2–4 players who know the game): 45–60 minutes. Competitive 5-player: 70–90 minutes. Turn structure is simultaneously short (each player takes 1 of 4 actions per turn) and plays up to 26 total rounds per player — rounds are fast but the game plays all rounds. Solo automa play: typically 30–40 minutes once learned. Teaching time: 20–30 minutes for the basic rules; 45 minutes if reading the full rulebook with examples."
    },
    {
      "@type": "PropertyValue",
      "name": "BGG Complexity Weight",
      "value": "2.4",
      "description": "BoardGameGeek complexity weight: 2.4 out of 5.0 (medium-light). Rated by approximately 35,000 BGG users as of mid-2026 (BGG ID 266192). A 2.4 weight means: rules can be learned in 20–30 minutes by most adult gamers; suitable for regular game night groups with minimal prior experience; accessible to players who enjoy Catan (2.3) or Pandemic (2.4) but want more strategic depth than Ticket to Ride (1.9). The main complexity comes from bird cards (170 unique cards, each with a unique power) rather than the core rules (which are simple: choose 1 of 4 actions each turn). New players may feel overwhelmed by card variety initially."
    },
    {
      "@type": "PropertyValue",
      "name": "Minimum Age",
      "value": "10",
      "description": "Minimum recommended age: 10 years. Publisher age recommendation. Reading requirement: moderate — bird card powers involve text; a 10-year-old with adult guidance can play comfortably. Food tokens and egg miniatures present a potential choking hazard for children under 3. BGG community-rated 'suitable age': the BGG community rates Wingspan as appropriate for ages 10+, consistent with the publisher's rating. Note: the game contains themes (predator birds, food chain, nature) that are age-appropriate. No violent or mature content."
    },
    {
      "@type": "PropertyValue",
      "name": "Game Mechanics",
      "value": "Engine Building, Card Drafting, Hand Management, Set Collection",
      "description": "Primary mechanics: (1) Engine Building — each bird card played to a habitat (forest / grassland / wetland) generates resources or triggers powers when its habitat's action is activated; the more birds in a habitat, the more resources generated per action. Cards chain in egg-laying or food-collecting sequences, building exponentially powerful chains late-game. (2) Card Drafting — players choose bird cards from a rotating display of 3 face-up cards plus a blind draw from the deck; drafted cards go to hand. (3) Hand Management — players manage a hand of bird cards that they selectively play based on available food, habitat fit, and engine strategy. (4) Set Collection — end-game scoring cards (drawn at game start) reward specific sets (most birds in one habitat, birds with 'nocturnal' keyword, birds laid on eggs, etc.)."
    },
    {
      "@type": "PropertyValue",
      "name": "BGG ID",
      "value": "266192",
      "description": "BoardGameGeek ID: 266192. BGG URL: boardgamegeek.com/boardgame/266192/wingspan. BGG overall rating: 8.0/10 (approximately 110,000 ratings as of mid-2026). BGG rank: approximately #15 Overall, #7 Strategy. The BGG ID links to the base Wingspan game — expansions have separate IDs: European Expansion (BGG 285498), Oceania Expansion (BGG 300580), Asia Expansion (BGG 356658). Accessories and promo packs also have separate BGG IDs. Using the BGG ID allows AI agents to cross-reference ratings, rules FAQs, variant rules, and community reviews at BGG."
    },
    {
      "@type": "PropertyValue",
      "name": "Product Type",
      "value": "Standalone base game",
      "description": "Product type: standalone base game. No other purchase required to play. This is not an expansion — it contains all components needed for 1–5 players to play a complete game. Compatible expansions (sold separately, all require this base game): European Expansion (adds 81 European bird cards + new food token), Oceania Expansion (adds 95 Australasian birds + nectar food type), Asia Expansion (adds 65 Asian birds + 2-player variant rules + 6-7 player mode). All expansions are independently optional and fully combinable with each other."
    },
    {
      "@type": "PropertyValue",
      "name": "Language Dependence",
      "value": "Moderate — bird card text required for play",
      "description": "Language dependence: moderate (BGG scale 3/5 — moderate in-game text, not suitable for all audiences). Bird cards (170 unique cards) each have 1–3 lines of unique text describing their power — reading the text is required to use the power effectively. Rules reference: the rulebook (available as PDF on Stonemaier Games website) includes clarifications in English. Localized editions available: Spanish, French, German, Italian, Dutch, Portuguese, Polish, Czech, Korean, Japanese (sold as separate SKUs). This SKU is the English edition. A non-English-reading player may struggle to play competitively without the localized edition or a bilingual player to translate."
    }
  ]
}
</script>

Schema.org Game @type for Board Games

Schema.org has a dedicated Game @type with native properties for player count that can be used as an alternative to Product + additionalProperty:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": ["Product", "Game"],
  "name": "Wingspan — Engine-Building Board Game",
  "numberOfPlayers": {
    "@type": "QuantitativeValue",
    "minValue": 1,
    "maxValue": 5
  },
  "gameEdition": "Retail Edition (English)",
  "gameLocation": "Tabletop",
  "characterAttribute": [
    { "@type": "Thing", "name": "Engine Building" },
    { "@type": "Thing", "name": "Card Drafting" }
  ],
  "offers": {
    "@type": "Offer",
    "price": "60.00",
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock"
  }
}
</script>

Using ["Product", "Game"] as a dual type lets you combine the Game native player count properties with Product offers and pricing in one schema block. The additionalProperty approach in the previous section remains necessary for attributes not covered by the Game @type (BGG weight, complexity, mechanics controlled vocab).

Liquid Template — Board Game Metafields to JSON-LD

{% assign bg = product.metafields.board_game %}
{% if bg %}
<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": ["Product", "Game"],
  "name": {{ product.title | json }},
  "numberOfPlayers": {
    "@type": "QuantitativeValue",
    "minValue": {{ bg.players_min | json }},
    "maxValue": {{ bg.players_max | json }}
  },
  "additionalProperty": [
    { "@type": "PropertyValue", "name": "Best Player Count", "value": {{ bg.players_best | json }} },
    { "@type": "PropertyValue", "name": "Play Time", "value": {{ bg.play_time_minutes | json }}, "unitCode": "MIN" },
    { "@type": "PropertyValue", "name": "BGG Complexity Weight", "value": {{ bg.bgg_weight | json }} },
    { "@type": "PropertyValue", "name": "Minimum Age", "value": {{ bg.min_age | json }} },
    { "@type": "PropertyValue", "name": "Game Mechanics", "value": {{ bg.mechanics | json }} },
    { "@type": "PropertyValue", "name": "BGG ID", "value": {{ bg.bgg_id | json }} },
    { "@type": "PropertyValue", "name": "Product Type", "value": {{ bg.product_type | json }} },
    { "@type": "PropertyValue", "name": "Base Game Required", "value": {{ bg.base_game_required | json }} },
    { "@type": "PropertyValue", "name": "Language Dependence", "value": {{ bg.language_dependence | json }} },
    { "@type": "PropertyValue", "name": "Publisher", "value": {{ bg.publisher | json }} }
  ]
}
</script>
{% endif %}

Board Game Metafield Reference

Metafield key	Type	Example value	Priority
`board_game.players_min`	number_integer	1	Required
`board_game.players_max`	number_integer	5	Required
`board_game.players_best`	single_line_text_field	3–5 players	Recommended
`board_game.play_time_minutes`	single_line_text_field	40–70	Required
`board_game.bgg_weight`	number_decimal	2.4	Required
`board_game.min_age`	number_integer	10	Required
`board_game.mechanics`	list.single_line_text_field	Engine Building, Card Drafting	Required
`board_game.bgg_id`	single_line_text_field	266192	Recommended
`board_game.product_type`	single_line_text_field	Standalone base game	Required
`board_game.base_game_required`	single_line_text_field	Wingspan (BGG 266192)	Required (expansions)
`board_game.language_dependence`	single_line_text_field	Moderate — card text required	Recommended
`board_game.publisher`	single_line_text_field	Stonemaier Games	Recommended
`board_game.cooperative`	boolean	false	Recommended
`board_game.solo_mode`	boolean	true	Recommended

Five Common Board Game Schema Mistakes

Player count listed as a single number rather than min–max range. "Players: 4" is ambiguous — it could mean exactly 4 players (like some classic parlor games) or up to 4 players. Always encode both minimum and maximum: players_min and players_max as separate properties, and use Schema.org's QuantitativeValue with minValue and maxValue for the numberOfPlayers property. AI agents filtering on "board game for 3 people" need to check that 3 falls within the game's supported range.
Play time listed as a single static number rather than a range. "Play time: 60 minutes" is rarely accurate — most games have significant variability based on player count, player experience, and game state. A 2-player game may take 30 minutes; a 5-player game of the same title may take 90 minutes. Encode the range (40–70 minutes) and optionally note per-player-count estimates in the description. AI agents filtering on "under 45 minutes" should know whether your 60-minute listing is for max or average.
Complexity described vaguely as "easy" or "hard" without the BGG weight. "Easy to learn" is subjective; BGG complexity weight is a calibrated numeric scale with thousands of community raters. A 1.9-weight game (Ticket to Ride) is objectively more accessible than a 3.4-weight game (Scythe) — buyers and AI agents can act on numeric comparisons, not adjectives. Encode the numeric BGG weight and include the BGG ID so the weight can be verified and updated as community ratings evolve.
Expansions listed without the required base game SKU or name. An expansion without its base game requirement is incomplete product data. A buyer purchasing an expansion for a game they don't own (or the wrong edition) generates a guaranteed return. Always encode: product type (standalone / expansion), base game required (game name + BGG ID), and version compatibility notes if editions differ. Some expansions require specific editions or printing waves — encode this explicitly.
Language dependence omitted for text-heavy games. Board games are imported and sold globally. A buyer in France purchasing an English-language game with heavy card text (Arkham Horror LCG, Gloomhaven) will have a poor experience without a French edition. Encoding language dependence level — from "no text required" to "unplayable without translation" — allows AI agents to recommend localized editions when available and flag language barriers. Include links to the publisher's localized edition product pages if available.

FAQ

Should I use Schema.org's Game @type or Product @type for board games?

Use both via dual typing: "@type": ["Product", "Game"]. The Product @type handles pricing, availability, offers, and brand. The Game @type adds native numberOfPlayers (as QuantitativeValue with minValue/maxValue), gameEdition, and gameLocation. For attributes not in the Game schema (BGG weight, mechanics, language dependence), use additionalProperty. The dual-type approach lets you use the most semantically accurate properties from both types.

How do I encode a game that works differently at different player counts?

Encode the overall supported range (players_min, players_max) and add a description in the Player Count property noting any significant gameplay differences per count. For example: "2 players: uses automa rules; 4–5 players: optimal experience with full player interaction; 6 players (expansion required): longer play time, larger board." The "best player count" property is also useful — encode it separately and AI agents can recommend it specifically when buyers state their group size.

What BGG complexity weight threshold separates family from hobby games?

The BGG community broadly uses: under 2.0 = family/gateway (appropriate for anyone); 2.0–3.0 = medium weight (regular game night group); 3.0–4.0 = heavy (dedicated hobby gamer); above 4.0 = very heavy (specialist). Catan at 2.3 is the most cited gateway game. Wingspan at 2.4 is popular precisely because it sits at the light end of the hobby-gamer range. When encoding BGG weight, note the date of the rating — community weights change as more players rate the game.

How should I handle expansions that require a specific edition of the base game?

Encode the exact edition compatibility in the Base Game Required property: "Requires: Wingspan (English Retail Edition, 1st or 2nd printing — compatible with both; NOT compatible with Asia Expansion-only base box)." If there are multiple incompatible editions, list which are compatible and which are not. This level of detail prevents the most common return reason for tabletop expansions — an incompatible edition purchase.

Do cooperative games need any different schema properties than competitive games?

Add a boolean board_game.cooperative metafield (true/false) and encode it in schema. Cooperative vs competitive is a fundamental game type distinction — buyers searching for "cooperative board game for family" cannot filter on this without the boolean. Also flag partial co-op (one traitor/hidden role among cooperative players) separately, as it significantly changes the social dynamic of the game (some buyers specifically want or avoid traitor mechanics).

Does your Shopify store encode player count and BGG complexity weight in structured data?

Run a free CatalogScan to see which board game specifications are missing from your product JSON-LD — and which AI shopping agents can't see your player count range, play time, or game mechanics.

Run Free Scan