> ## Documentation Index
> Fetch the complete documentation index at: https://docs.0xinsider.com/llms.txt
> Use this file to discover all available pages before exploring further.

> ## Agent Instructions
> The Markdown of an API reference page leaves out the OpenAPI schema.
> Every object an endpoint returns or a webhook carries, with each field's type, presence and meaning, is on https://docs.0xinsider.com/api-reference/objects.md.
> The full OpenAPI 3.1 spec names each operation's and each webhook's exact parameters, request body and response schema: https://docs.0xinsider.com/api-reference/openapi.json.

# List game markets

> List every Polymarket market of one game, from the moneyline to each player prop.

Use this endpoint to find a game's spreads, totals, team totals, period lines and player props. [List games](https://docs.0xinsider.com/api-reference/endpoint/list-games.md) and [Game](https://docs.0xinsider.com/api-reference/endpoint/get-game.md) carry only the winner markets, and [Search markets](https://docs.0xinsider.com/api-reference/endpoint/search-markets.md) returns one market per game.

Each row has the `condition_id` and both outcome token ids. Send `expand=quotes` to get each outcome's current price, best bid and best ask on the same page, and `expand=trading_terms` to get each market's fees, liquidity rewards, order delay, tick and minimum order size, or pass a `condition_id` to [Market holders](https://docs.0xinsider.com/api-reference/endpoint/get-market-holders.md) and [Market snapshot](https://docs.0xinsider.com/api-reference/endpoint/get-market-snapshot.md).

Polymarket files some markets of a game under child events. A soccer game's exact score, halftime result and "more markets" events are examples. This endpoint returns those markets too, and each row's `event_slug` names the event it belongs to.

## Parameters

| Parameter | Meaning |
| - | - |
| `event_slug` | Required. The game's event slug from [List games](https://docs.0xinsider.com/api-reference/endpoint/list-games.md) or a [Search markets](https://docs.0xinsider.com/api-reference/endpoint/search-markets.md) result, for example `nba-bos-orl-2026-11-01`. Matching is case-insensitive. |
| `sports_market_type` | Optional. A comma-separated list of Polymarket market types to keep, such as `spreads,totals` or `points`. Matching is case-insensitive. An unknown type returns an empty page, not an error. |
| `status` | Optional. `active`, `closed`, or `all`. A market is `closed` once Polymarket has closed trading or it has resolved. The default is `all`. |
| `protocol_version` | Optional. `v1` keeps the markets that trade on Polymarket's CTF exchanges, and `v2` keeps the ones on Protocol V2. Leave it out to get both. Any other value returns `400`. |
| `limit` | Optional. How many markets to return, from 1 to 100. The default is 20, and a value outside the range is clamped. |
| `cursor` | Optional. The `next_cursor` value from the previous response. Send it with the same filters. |
| `expand` | Optional. `sharp_money` adds each row's `sharp_money` object: how much S, A, and B wallet money holds each side of that line, the split the game page shows. `quotes` adds each outcome's `quote`: its current price, best bid and best ask, each with the time it was observed. `trading_terms` adds each row's `trading_terms`: the market's fee schedule, liquidity reward settings, order delay, tick and minimum order size, from Polymarket's market record. `quotes` and `trading_terms` work on every plan, and each adds 1 to the request cost. Repeat `expand` to send several, for example `expand=quotes&expand=trading_terms`. |

## Key response fields

| Field | Meaning |
| - | - |
| `event_slug` | The slug you asked for, lowercased. |
| `data[].condition_id` | Polymarket's id for the market. |
| `data[].event_slug` | The event the market belongs to. A child event's market carries the child's own slug. |
| `data[].sports_market_type` | Polymarket's market type, for example `moneyline`, `spreads`, `totals` or `points`. It is omitted when Polymarket gives none. |
| `data[].group_item_title` | Polymarket's short label for the market, for example `Spread -7.5` or `O/U 222.5`. |
| `data[].line` | The line as a number, for example `-7.5` for a spread or `222.5` for a total. It is omitted when the market has no line. |
| `data[].line_outcome_index` | The index of the outcome the line belongs to, when Polymarket states it. For a spread, it is the side the line is quoted for. |
| `data[].outcomes` | Both outcomes in Polymarket's index order, each with its `label` and CLOB `token_id`, and its `quote` with `expand=quotes`. |
| `data[].outcomes[].quote.status` | Only with `expand=quotes`. `observed` when we hold the outcome's price, its book, or both; a `null` figure beside it is one we do not hold, except that a `null` `best_bid` or `best_ask` beside a `book_observed_at` is a side of the book with no orders. A book with one side, or no orders at all, is `observed` too. `no_orderbook` when Polymarket confirmed the outcome has no order book and we hold no price. `unavailable` when we hold no figure for it, or could not read it from our cache: every figure is `null`, and `book_unavailable_reason` says whether reading again helps. |
| `data[].outcomes[].quote.price` | The price Polymarket shows for the outcome, from 0 to 1. `price_basis` says which it is: `midpoint` when the best bid and ask are at most \$0.10 apart, otherwise `last_trade`. `price_observed_at` is when the quote and trades behind it were observed. |
| `data[].outcomes[].quote.best_bid`, `best_ask` | The outcome's best bid and best ask on Polymarket's order book, from 0 to 1. `book_observed_at` is when Polymarket's book update behind them was observed. With `book_observed_at` set, a `null` side holds no orders: a book with only bids has a `null` `best_ask`, and an empty book has both `null`. |
| `data[].outcomes[].quote.book_source` | Only with `expand=quotes`. Who read the book: `clob_stream` (Polymarket's live market feed) or `clob_rest` (a fetch of Polymarket's order books). `null` when `book_observed_at` is. For a book that has not changed for a while, `book_observed_at` is when it last changed, whichever source read it. |
| `data[].outcomes[].quote.book_depth_within_2c` | Only with `expand=quotes`. How much money rests near the price on each side of the book: `bid_usd` is the dollar value (price times size) of bids at or above the midpoint minus 2 cents, and `ask_usd` of asks at or below the midpoint plus 2 cents. It covers every level of the book, not only the top ones. It is the measure the `market_price_moved` webhook calls `book_depth_within_2c`, served here as numbers. `null` when we hold no depth for the book, for example in the seconds after a price change on a streamed market; read again after a few seconds. On a book more than 4 cents wide, no order is within 2 cents of the midpoint, so both sides read 0. |
| `data[].outcomes[].quote.book_unavailable_reason` | Only with `expand=quotes`. `null` when `book_observed_at` is set. Otherwise, why we hold no book: `cache_miss` (none yet; the request starts covering the page's open markets, so read again after a few seconds), `cache_unavailable` (we could not read the book from our cache, so nothing is known about it; read again after a few seconds), `stream_capacity` (we are not streaming this market, and API reads already hold every live book they can open; reading again does not help until fewer markets are read), `no_orderbook` (Polymarket confirmed the outcome has no order book) or `missing_provider_token_id`. |
| `data[].protocol_version` | The Polymarket protocol the market trades on: `v1` (CTF) or `v2` (Protocol V2). On a `v2` market, each outcome's `token_id` is its Protocol V2 position id, so sign its orders for ExchangeV3 and read its balance as `CONDITIONAL-V2`. A market never changes protocol. |
| `data[].status` | `active` or `closed`, by the same rule as the `status` filter. |
| `data[].settlement.status` | How Polymarket's oracle settled, or is settling, the market. `observed` means Polymarket's resolution row fills the fields below. `not_posed` means no oracle request exists yet, and `settled` is `false`. `unavailable` means no read is in hand and no settlement of the market is recorded: every other field is `null`, so ask again shortly and never treat it as unsettled. |
| `data[].settlement.oracle_status` | Polymarket's oracle state as Polymarket writes it: `posed`, `proposed`, `challenged`, `reproposed`, `disputed`, `arbitration` or `resolved`. `settled` is `true` once it is `resolved`. |
| `data[].settlement.payouts` | What one share of each outcome pays, in micro-USDC (`1000000` is \$1), in outcome index order. It is set only on a resolved row that carries payouts. A resolved oracle question carries none, so it stays `null` there. |
| `data[].settlement.result` | `outcome` when one side paid in full, and `winning_outcome_index` names that side. `split` is Polymarket's 50-50. Both are read from `payouts`, or, on a resolved oracle question, which has none, from the payout Polymarket's ConditionalTokens contract recorded on Polygon. Both stay `null` until that contract has paid and we have read it, which we do once per market. |
| `data[].settlement.proposed_answer` | The newest proposal of a pending round: `outcome_0`, `outcome_1`, `split` or `too_early`. A proposal is not a result. |
| `data[].settlement.expected_settlement_time` | Polymarket's estimate of the earliest time a pending market settles, with its `settlement_time_basis`. It is an estimate, not a deadline. |
| `data[].settlement.was_disputed`, `resolved_at`, `observed_at` | Whether a proposal was disputed, when the market resolved, and when we saw it. On a settled market, `observed_at` is when we first saw the settlement, and it never changes: usually about 12 seconds after `resolved_at`, within about 25 seconds for 95 in 100, and up to about 5 minutes for a market our resolution scan misses. On any other market, it is when Polymarket last answered. Once the game has kicked off or one of its markets has closed, that is at most once a minute while the game is read, and less often when many games are read at once. The first read of a game nobody has read for a while can carry a block up to an hour old, and starts a new read for the next request. Past that hour with no read, the block is `unavailable` until that read lands. Before kickoff, while none of the game's markets has closed, nothing can have settled and the block is not refreshed: it keeps its `observed_at` until kickoff and can be up to 6 hours old. Past 6 hours it is `unavailable` until a new read lands. The first read after kickoff, or after one of the game's markets closes, refreshes it. Once a block is 15 minutes old, a market we have since seen settle carries its settled block instead. Read the age from `observed_at`. Every key is always present, and `null` means unknown. A resolved oracle question carries no `resolved_at`, so it stays `null` there; read `oracle_updated_at`. |
| `data[].settlement.oracle_updated_at` | When Polymarket last changed the market's oracle state, which Polymarket calls its latest lifecycle change. It is not a resolution time and never fills in for `resolved_at`. On a resolved oracle question, it is when the answer settled the question: Polymarket's ConditionalTokens contract pays at the same second or up to about 85 minutes later. On a settled market, it is the value we recorded with the settlement, and it never changes. `null` when we hold none, as on a settlement we recorded before November 8, 2026. |
| `data[].trading_terms.status` | Only with `expand=trading_terms`. `observed` when Polymarket's market record was read at `observed_at`; a `null` figure is one the record does not carry. `not_listed` when Polymarket's market list returned no record for the market. `unavailable` when no read is in hand yet: every figure is `null`, so read again after a few seconds. |
| `data[].trading_terms.fees_enabled`, `fee_schedule` | Whether fees are active, and the fee curve Polymarket charges by: `rate`, `exponent`, `taker_only` (`true` when only the taker pays) and `rebate_rate`, the fraction of taker fees rebated to the resting maker (`0.25` is 25%). `fee_schedule` is `null` when the record carries none. |
| `data[].trading_terms.rewards_min_size`, `rewards_max_spread` | The smallest order, in shares, that can earn liquidity rewards, and how far from the midpoint, in cents, a resting order can sit and still qualify. |
| `data[].trading_terms.reward_allocations` | The market's dated reward allocations, each with `rewards_amount` (the total), `rewards_daily_rate` (the amount per day), and `start_date` and `end_date` as Polymarket writes them. `null` when the record carries none. |
| `data[].trading_terms.seconds_delay` | How many seconds a newly placed marketable order waits before it can match. Polymarket sets this delay on sports markets around live play, so it can change during a game. |
| `data[].trading_terms.tick_size`, `observed_at` | The smallest price step a limit order can use, and when Polymarket's record was read. Each market's read is refreshed about once a minute. |
| `data[].trading_terms.min_order_size_shares` | The smallest order Polymarket's order book accepts, in shares. Compare it with your order's share count, not its dollar cost: a buy of 5 shares at $0.40 costs $2.00 and meets a minimum of 5. Polymarket's market reference calls this figure USDC, but its order book enforces it on shares. |
| `data[].trading_terms.trading` | Only with `expand=trading_terms`. Where an order on this market is signed, from its `protocol_version` and `negative_risk`, by Polymarket's order-signing table, whatever `status` says: `exchange` (`ctf_exchange_v2`, `neg_risk_ctf_exchange_v2` or `exchange_v3`), `eip712_domain_version` (`"2"` on a `v1` market, `"3"` on a `v2` market), `verifying_contract` (the exchange's Polygon address) and `balance_asset_type` (`CONDITIONAL` or `CONDITIONAL-V2`). The domain name is `Polymarket CTF Exchange` and the chain id is 137 on both protocols. It is omitted on a `v1` market whose `negative_risk` we do not hold. |
| `data[].sharp_money.status` | Only with `expand=sharp_money`. Each status means one thing. `computed`: the figures below are present, dated by `money_as_of`, also while the game's lines are being listed. `not_computed`: the line is not one the game page splits, as last listed (a player prop, a line beyond the seven around its family's main line, or a closed or settled line). No read computes it, and it turns `unavailable` only when a later listing splits it, as when its family's main line moves. `unavailable`: the line is one the game page splits, or the game's lines could not be listed, and no figure is held: the line has not been read yet, or its last read is over 5 minutes old (15 minutes for a line with no trade since). Each read asks for the split lines on its own page for 2 minutes, and a line reads `computed` once it has been read. Read the same page again after the 30 seconds its `Cache-Control` `max-age` states. A game read alone has about 35 lines in about a minute. A game with 100 or more lines, or any game at a busy hour when many games are read at once, can take several minutes. |
| `data[].sharp_money.trader_count` | How many S, A, and B wallets hold either side of the line. A computed line no S, A, or B wallet holds reads 0, with 0 on both sides. |
| `data[].sharp_money.outcomes` | Both sides in Polymarket's index order, each with `index` (matching `data[].outcomes[].index`), `usd` (the S, A, and B wallet money on that side), and `wallets` (the `s`, `a`, and `b` counts). `usd` values each side's holdings at the price when the figures were computed, at most 15 minutes ago, so once the game starts it follows the score: on November 14, 2026, with Tennessee up 19-7 on Texas A\&M in the fourth quarter, Tennessee -2.5 read $23,359 against $60. The game page names no side on a line while the game's [sharp money](https://docs.0xinsider.com/api-reference/endpoint/get-game-sharp-money.md) reads `lifecycle` `in_play` or `ended`; check it before you read a side from these figures. |
| `data[].sharp_money.money_as_of` | When the positions behind the figures were read. On a line with no trade since that read, it can be up to 15 minutes old. A line that trades is read again, or turns `unavailable`, within about 5 minutes of the trade. `null` means the age is unknown. |
| `families` | Every market type the event holds, with its `markets` count and how many are `active`. It ignores the filters, so one call tells you which types exist. |
| `has_more`, `next_cursor` | Whether another page exists, and the cursor that reads it. |

Rows are ordered by `sports_market_type`, then `line`, then `condition_id`. Markets with no type come last.

## Example

```bash theme={null}
curl -sS \
  -H "Authorization: Bearer $OXINSIDER_API_KEY" \
  'https://api.0xinsider.com/api/v1/games/nba-bos-orl-2026-11-01/markets?sports_market_type=spreads,totals&status=active&expand=quotes'
```

The `list_game_markets` MCP tool calls this endpoint with the same parameters. Pass `expand` as an array, for example `["quotes", "trading_terms"]`.

## Conditional reads

The response carries a weak semantic `ETag`. Send it back as `If-None-Match` for a `304` with an empty body. `request_id` and `cost` are excluded from the validator. With `expand=quotes`, the `ETag` changes whenever a quote does. With `expand=trading_terms`, it changes each time a market's terms are read again, about once a minute.

## What it does not return

* Prices, unless you send `expand=quotes`. Liquidity is on [Market snapshot](https://docs.0xinsider.com/api-reference/endpoint/get-market-snapshot.md), one market per request.
* Holder identity. Use [Game holders](https://docs.0xinsider.com/api-reference/endpoint/get-game-holders.md) to read the holders of several of the game's markets in one request.
* Fees, liquidity rewards, the order delay, the tick or the minimum order size, unless you send `expand=trading_terms`.
* A sharp-money split, unless you send `expand=sharp_money`. It needs a Pro or Max key; any other key gets `402` `subscription_required`.
* A slug with no stored market. That is a `404` with `error.code` `not_found`.
* An event outside sports and esports. That is a `404` with `error.reason` `market_out_of_scope`. Stop requesting it.


## API Specification

The full API specification for this endpoint is available in the [documentation index](https://docs.0xinsider.com/llms.txt).


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.