> ## 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.

# Game sharp money

> Get where graded wallets' money sits across a whole game, per outcome, in one read.

Read how much S, A and B grade money backs each side of one game, and the verdict the game page shows for it. Use it instead of paging [Market holders](https://docs.0xinsider.com/api-reference/endpoint/get-market-holders.md) for every market and adding the rows yourself.

To read the same object for every game on a page of [List games](https://docs.0xinsider.com/api-reference/endpoint/list-games.md), send `expand=sharp_money` there. This endpoint needs a Pro or Max key.

## Parameters

| Parameter | Meaning |
| - | - |
| `event_slug` | Required. The game ID from [List games](https://docs.0xinsider.com/api-reference/endpoint/list-games.md). Matching is case-insensitive. |

## Key response fields

| Field | Meaning |
| - | - |
| `data.status` | `computed` when the object carries the game's money. `not_computed` when the game was not evaluated, or is live and its holders could not be read, which says nothing about whether graded money exists. `unavailable` appears only on a `list_games` expansion, when the sport's money could not be read for that request. |
| `data.lifecycle` | `live` before the game starts. `in_play` from the scheduled start, or once the provider reports the game live, until the game is over. See [In-play games](#in-play-games). `ended` when the game is over and its markets have not settled. See [Ended games](#ended-games). `settled` when the game is resolved and the money is the settled recap. See [Settled games](#settled-games). `indeterminate` when the outcome facts are void, partial or contradictory. |
| `data.verdict` | The verdict the game page shows, keyed by `kind`. See [Verdict](#verdict). |
| `data.outcomes[]` | One entry per side: `side` (`home`, `draw` or `away`), `label`, `usd`, `pct`, `is_leader`, and `wallets` with the S, A and B wallet counts. A game with no draw has 2 entries. |
| `data.total_usd` | Every graded dollar on the game. |
| `data.allocation`, `data.unallocated_usd` | `exact` when every dollar is attributed to a side, so `outcomes[].usd` sums to `total_usd`. `degraded` when some money could not be attributed, so the sides carry less than `total_usd` by exactly `unallocated_usd`, and `pct` and `is_leader` are not set. |
| `data.trader_count` | Distinct S, A and B wallets on the game. A wallet on 2 sides counts once. |
| `data.holders_partial` | `true` when a market's holder list was a capped page rather than a complete list, so the dollars and counts cover part of the holders. |
| `data.computed_at`, `data.money_as_of` | When the money was added up, and when the holder positions behind it were observed (the oldest across the game's markets). A `null` `money_as_of` means the age is unknown, not that it is fresh. |
| `data.at_kickoff` | On an `in_play`, `ended` or `settled` game, the split as the site last recorded it before the game started. See [The split before the start](#the-split-before-the-start). `null` on every other lifecycle. |

Every money field is `null`, and `outcomes` is empty, unless `status` is `computed`. `lifecycle` and `at_kickoff` describe the game, so they can be set when it is not. A `null` means the value is not known. It never means zero.

## Verdict

| `kind` | Meaning |
| - | - |
| `no_sharp_money` | No graded money is on the game. A live game answers it only after its holders were read, so `money_as_of` is set. |
| `all_on` | Every graded dollar is on the outcome in `label`. |
| `leans` | The outcome in `label` leads the runner-up clearly, with `pct` percent of the graded dollars. |
| `split` | One outcome leads, but too narrowly to call. |
| `leans_over_price` | Graded money sits further onto the outcome in `label` than its price does, by `divergence_pts` probability points. |
| `no_clear_lean` | The money was compared with the price and no outcome stood apart. |
| `unavailable` | Graded money exists but could not be attributed to sides. |
| `withheld` | The money is in `outcomes`, but no directional claim is made for this game in its current state. A `live` game answers it when the side the money would name holds too little graded money to carry a claim, with `pct` and `is_leader` still set. An `in_play` game answers it, an `ended` game answers it until its markets settle, and a `settled` game answers it. |

`is_leader` and the verdict describe where the money is. They are not a recommendation.

`pct`, `is_leader` and a directional verdict are published only while `lifecycle` is `live`, before the game starts, and inside `at_kickoff` after it. They value each side's holdings at current prices.

## In-play games

Once a game starts, its prices follow the score. Holdings valued at those prices move toward whichever side is ahead, and graded wallets keep buying during play. A share computed then shows who is winning, not where the wallets stood before the game. So while a game is in play, the endpoint reports who holds each side and makes no claim about direction.

| Field | On an `in_play` game |
| - | - |
| `data.verdict` | `withheld`, or `no_sharp_money` when no graded money is on the game. |
| `data.outcomes[].pct` | `0` on every side. |
| `data.outcomes[].is_leader` | `false` on every side. |
| `data.outcomes[].usd`, `data.outcomes[].wallets` | Still set. `usd` values each side's holdings at in-game prices, so it moves with the score. |
| `data.at_kickoff` | The split before the game started, or `null` when none was recorded. See [The split before the start](#the-split-before-the-start). |

`in_play` means the scheduled start has passed, or the provider reports the game live, and the game is not over. It is not proof that play is under way: a suspended, postponed or cancelled game past its scheduled start answers `in_play` too, and so does a game with no live score feed. [Get game](https://docs.0xinsider.com/api-reference/endpoint/get-game.md)'s `status` says whether the game is being played. A postponed or cancelled game's `at_kickoff` is still the split before its scheduled start.

When the game is over, `lifecycle` becomes `ended`.

## Ended games

Once a game is over, its prices move to the result. Holdings valued at those prices put nearly every dollar on the winner, whether a wallet held its side before the game or bought it after the result was clear. So until the markets settle, the endpoint reports who holds each side and makes no claim about direction.

| Field | On an `ended` game |
| - | - |
| `data.verdict` | `withheld`, or `no_sharp_money` when no graded money is on the game. |
| `data.outcomes[].pct` | `0` on every side. |
| `data.outcomes[].is_leader` | `false` on every side. |
| `data.outcomes[].usd`, `data.outcomes[].wallets` | Still set. `usd` values each side's holdings at current prices, which already reflect the result. |
| `data.at_kickoff` | The split before the game started, or `null` when none was recorded. See [The split before the start](#the-split-before-the-start). |

When the markets settle, `lifecycle` becomes `settled`, or `indeterminate` when the outcome facts are void, partial or contradictory. A game Polymarket reports as ended without a result, such as a cancelled one, answers `ended` until then too.

## Settled games

Once the markets settle, the only holders the endpoint can read are the winning side's wallets that have redeemed in profit. The losing side's holders are not in that list, so a share computed from it would put every dollar on the winner. So a settled game reports the winners' profit and makes no claim about direction.

| Field | On a `settled` game |
| - | - |
| `data.verdict` | `withheld`, also when no graded wallet has redeemed the winning side in profit, because that says nothing about who held the game. `unavailable` when the money could not be attributed to sides. |
| `data.outcomes[].pct` | `0` on every side. |
| `data.outcomes[].is_leader` | `false` on every side. |
| `data.outcomes[].usd` | The realized profit of the winning side's S, A and B wallets that have redeemed. The losing side reads `0`. |
| `data.outcomes[].wallets`, `data.trader_count` | Those winning wallets. The losing side counts `0`. A winning wallet that has not redeemed yet is not counted. |
| `data.at_kickoff` | The split before the game started, which counts both sides' holders, or `null` when none was recorded. See [The split before the start](#the-split-before-the-start). |

## The split before the start

While a game is `in_play`, `ended` or `settled`, `at_kickoff` shows where the graded money stood going into it: the split as the site last recorded it before the game started, which is before its scheduled start and before the provider reported it live. Prices then carried no score and no result. The top-level `outcomes[].pct` and `verdict` keep describing the game now, so they stay `0` and `withheld`.

| Field | Meaning |
| - | - |
| `at_kickoff.as_of` | When the site recorded the split, before the game started. |
| `at_kickoff.outcomes[]` | One entry per side: `side`, `label`, `usd`, `pct` and `is_leader`, as recorded then. `usd` values each side's holdings at that moment's prices. |
| `at_kickoff.total_usd`, `at_kickoff.trader_count` | The graded dollars on the game then, and the S, A and B wallets that held them. |
| `at_kickoff.verdict` | The verdict as recorded then, keyed by `kind` as in [Verdict](#verdict). A side holding too little graded money to carry a claim answers `withheld`, as a `live` game does now. |

`at_kickoff` is `null` when no split with graded money was recorded before the start, when the money then could not all be attributed to sides, or when the recorded sides no longer match the game's. Soccer games have none more often than other games.

## 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/sharp-money'
```

The first read of a game that is not on the current board, or of a live game whose holders have not been read yet, can answer `503` with `read_model_warming` while the money is added up. A few games are added up at a time, and the rest wait their turn. `Retry-After` is the number of seconds until this game should be ready, from 3 to 90. Read again after that delay.

To read many games, send `expand=sharp_money` on [List games](https://docs.0xinsider.com/api-reference/endpoint/list-games.md) first. Call this endpoint only for the games that come back `not_computed`.

## What it does not return

* Holder identity. Read wallets per market with [Market holders](https://docs.0xinsider.com/api-reference/endpoint/get-market-holders.md).
* Per-market or per-line money. The object covers the game's sides.
* A slug that names no sports game. That is a `404`.

## Caching

The response carries a weak `ETag`. Send it back as `If-None-Match` for a `304` with an empty body. `meta` is excluded from the validator.


## 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.