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

# API changelog: November 15, 2026

> 41 API, SDK, CLI, MCP, OAuth, and feed changes from November 15, 2026, newest first, each with its effect on clients. Newer changes are on the API changelog.

These are the API changelog entries from November 15, 2026, newest first. The newest changes are on the [API changelog](https://docs.0xinsider.com/changelog.md).

**November 15, 2026**

Pick of the Day: hit\_rate carries the implied win rate and the edge over it

[`GET /api/v1/pick-of-the-day/archive`](https://docs.0xinsider.com/api-reference/endpoint/get-pick-of-the-day-archive) and [`GET /api/v1/pick-of-the-day/stats`](https://docs.0xinsider.com/api-reference/endpoint/get-pick-of-the-day-stats) now send five fields on the record's `hit_rate`, the ones each stats bucket already carries:

* `priced_decided`: the settled picks with a recorded publication price.
* `priced_in_pct` and `priced_in_display`: the average midpoint price of those picks when published, read as a win rate.
* `edge_pp` and `edge_display`: the win rate over those picks minus `priced_in_pct`, in percentage points.

Before this change only the buckets carried the implied win rate, so the record's 57.1% win rate had nothing to be read against. On November 15 the record's 1,080 settled picks were all priced, at an implied 56.8%: the picks won about as often as their prices said, which is why the return on stake is near zero.

* The fields leave out void and pending picks, as `pct` does. `priced_in_pct`, `priced_in_display`, `edge_pp` and `edge_display` are absent when no settled pick is priced.
* The `get_pick_of_the_day_archive` and `get_pick_of_the_day_stats` tools on the remote [MCP endpoint](https://docs.0xinsider.com/integrations/mcp.md) return the same, and `@0xinsider/sdk` 0.102.0 adds the fields to its types.

**Backward compatible.** The fields are new and every existing field is unchanged.

**What to change:** Nothing. To show whether the picks beat their prices, read `edge_display` beside `win_rate_display`.

**November 15, 2026**

Game sharp money: since\_start counts from the first live score when the scheduled start is late

[`GET /api/v1/games/{event_slug}/sharp-money`](https://docs.0xinsider.com/api-reference/endpoint/get-game-sharp-money) and the `sharp_money` object on [`GET /api/v1/games?expand=sharp_money`](https://docs.0xinsider.com/api-reference/endpoint/list-games) now count `since_start` from the earlier of the game's `scheduled_at` and its first live score. Before, `since_start.since` was always `scheduled_at`.

A scheduled start can be hours late. On November 15, two women's college basketball games read `scheduled_at` 21:00 UTC and 00:00 UTC the next day, while both started at 19:00 UTC. While they were in play, `since_start.since` was later than `since_start.as_of`, so the reading covered no time and read `bought_usd` 0 with verdict `no_sharp_money`.

* `since_start.since` is never later than `since_start.as_of`. A game in play before its `scheduled_at` with no live score recorded has `since_start: null`, which claims nothing.
* `scheduled_at` is unchanged: it is still the provider's scheduled start.
* `@0xinsider/sdk` 0.101.0 carries the new description; its types are unchanged.

**Backward compatible.** The object's shape and every value it can carry are unchanged.

**What to change:** Nothing. If you compute the reading's window from `scheduled_at`, read `since_start.since` instead.

**November 15, 2026**

Games: women's college basketball periods read as quarters, never OT in regulation

[`GET /api/v1/games`](https://docs.0xinsider.com/api-reference/endpoint/list-games) and [`GET /api/v1/games/{event_slug}`](https://docs.0xinsider.com/api-reference/endpoint/get-game) now return a women's college basketball (`cwbb`) game's `status.period` as its quarter, and a new `status.provider_period` carries the feed's own period string on every game.

Before this change `status.period` was the feed's label, and the feed names a women's game's four quarters with the men's halves vocabulary. A game in its 3rd quarter read `OT`, and a game in its 4th read `End OT`. On November 15 at 20:59 UTC, 11 of 24 live games read `OT` or `End OT`, and none of them was in overtime.

| Feed label (`provider_period`) | `status.period` | The game is |
| - | - | - |
| `H1` | `Q1` | in the 1st quarter |
| `End H1` | `End Q1` | between the 1st and 2nd quarters |
| `H2` | `Q2` | in the 2nd quarter |
| `End H2` | `End Q2` | at halftime |
| `OT` | `Q3` | in the 3rd quarter |
| `End OT` | `End Q3` | in the 4th quarter, at the 3rd quarter's score |

* The feed sends no frame between the end of the 3rd quarter and the final, so `End Q3` stays through the 4th quarter and any overtime, with `scores_freshness` `unknown`.
* A frame whose status is final or stopped keeps the feed's label in `status.period`.
* Every other league's `status.period` is unchanged and equals `provider_period`.
* The `get_game` and `list_games` tools on the remote [MCP endpoint](https://docs.0xinsider.com/integrations/mcp.md) return the same, and `@0xinsider/sdk` 0.100.0 types `provider_period`.

**Backward compatible** for every league except `cwbb`. **Breaking** for a client that read `OT` or `End OT` in a `cwbb` `status.period` as overtime: that reading was wrong.

**What to change:** Nothing to show the right quarter. To keep the feed's raw label, read `status.provider_period`.

**November 15, 2026**

Game sharp money: since\_start states no buys with bought\_usd 0, so null claims nothing

[`GET /api/v1/games/{event_slug}/sharp-money`](https://docs.0xinsider.com/api-reference/endpoint/get-game-sharp-money) and the `sharp_money` object on [`GET /api/v1/games?expand=sharp_money`](https://docs.0xinsider.com/api-reference/endpoint/list-games) now send `since_start` on a binary game in play when no S, A or B grade wallet bought since the scheduled start: `bought_usd` `0`, `trader_count` `0`, `verdict.kind` `no_sharp_money`, `last_trade_at` `null`, and every outcome with `bought_usd` `0`, `pct` `0`, `avg_buy_price` `null` and `is_leader` `false`.

Before this change `since_start` was `null` both when none of those wallets bought and when the game had no reading at all, so a caller could not tell "nothing bought" from "not read". A soccer 1X2 game in play read `null`, the same as a binary game with no buys, while graded wallets had bought on it.

* `null` now claims nothing about what was bought: before the start, after the game, on a soccer 1X2 game, which the reading does not cover, and when no reading was available.
* `@0xinsider/sdk` 0.99.0 carries the new description; its types are unchanged.

**Backward compatible.** Every value is one the field already documents, and the object's shape is unchanged.

**What to change:** Treat `since_start: null` as "no reading", not as "no buys". To show that nothing was bought, read `since_start.bought_usd == 0`.

**November 15, 2026**

Traders: stale after a held market settles or a trade moves the open positions, and expand=trust agrees with data\_quality

[`GET /api/v1/trader/{address}`](https://docs.0xinsider.com/api-reference/endpoint/get-trader) and [`POST /api/v1/traders/batch`](https://docs.0xinsider.com/api-reference/endpoint/batch-get-traders) now report three cases as `stale` that read `fresh` before:

* `sports_record` reads `stale` when a market the wallet held settled after its last completed sync, even with no trade since. Settling removes the wallet's open row for that market, and the settled row arrives with the next read of the wallet's Polymarket positions, so until then `pnl.in_scope`, `stats.markets_traded` and `stats.win_rate` may leave that market out. The group's `owner` is `traders.last_synced`, its `as_of` is `synced_at`, and its `reason` starts `a market the wallet held settled after its last completed sync`. On November 15, 198 wallets with a record and no trade since their sync held a market that settled in one six-hour window.
* `positions` reads `stale` when the wallet traded after the positions clock (`last_active` later than the group's `as_of`): `pnl.unrealized` comes from the open positions read then, and a new fill changes none of them. On November 15, 17,347 of 174,272 wallets with stored positions were in this case.
* With `expand=trust`, a field served with a clock now takes its `data_quality` group's verdict: `freshness.status` is the group's `fresh` or `stale`, with the group's `as_of` and `max_age_s`. Before, every such field read `fresh` whenever a clock existed, so `trust.markets_traded` read `fresh` beside a `stale` `sports_record`, and `trust.synced_at` read `fresh` beside a `stale` `sync` group.
* `@0xinsider/sdk` 0.98.0 updates the descriptions.

**Backward compatible.** `stale` and every field are values these routes already document. A `max_age_s` request ceiling works as before. `trust.*.freshness` may now carry `max_age_s`, a key its schema already allows.

**What to change:** Nothing, if you already handle `stale`. If you show the record or `pnl.unrealized` as current whenever their group reads `fresh`, these wallets now read `stale`, with the figures as of `as_of`. If you read `trust.*.freshness.status`, it now matches `data_quality`.

**November 15, 2026**

Traders: last\_active counts trades seen on Polymarket's live trade stream

[`GET /api/v1/trader/{address}`](https://docs.0xinsider.com/api-reference/endpoint/get-trader) and [`POST /api/v1/traders/batch`](https://docs.0xinsider.com/api-reference/endpoint/batch-get-traders) now serve `last_active` as the later of the wallet's most recent recorded trade and its most recent trade seen on Polymarket's live trade stream. A trade later than `synced_at` marks the `sports_record` group of `data_quality.field_groups` `stale`, as before, so the group now reads `stale` within about two minutes of such a trade.

Before this change `last_active` was the most recent recorded trade only, and we record a small fill of many wallets only at their next sync. On November 15 a grade D wallet made 16 fills of $2.59 to $5.68 after its sync; none was recorded, so `last_active` stayed before `synced_at` and `sports_record` read `fresh` at -$686.38 while Polymarket showed -$180.12.

* The stream carries the taking side of each match. A wallet whose only trades since its sync filled resting orders is not seen there, and its `last_active` waits for the next sync, as before.
* The leaderboard entry's `last_active` still reads the recorded trade alone, re-read hourly, so a trader body's `last_active` can be later.
* `last_active` can now be sent for a wallet with no recorded trade, when the stream saw one.
* The `get_trader` tool on the remote [MCP endpoint](https://docs.0xinsider.com/integrations/mcp.md) returns the same, and `@0xinsider/sdk` 0.97.0 updates the field's description.

**Backward compatible.** The field keeps its type and format, and `stale` is a value the group already documents.

**What to change:** Nothing. If you compare a trader body's `last_active` with the leaderboard entry's, expect the trader body's to be later at times.

**November 15, 2026**

Game markets: sharp\_money fills the lines on your page first, and not\_computed holds between reads

[`GET /api/v1/games/{event_slug}/markets`](https://docs.0xinsider.com/api-reference/endpoint/list-game-markets) with `expand=sharp_money` changes in two ways. The `list_game_markets` tool on the remote [MCP endpoint](https://docs.0xinsider.com/integrations/mcp.md) reads the same route.

* A read now asks for the split lines on its own page, not every line of the game. On November 15, page 1 of `nfl-min-gb-2026-11-15` had 0 of its 27 split lines `computed` six minutes after the first read, while 27 lines on pages 2 to 5, which nobody had read, were.
* A line the game page does not split (a player prop, a line beyond the seven around its family's main line, a closed or settled line) now reads `not_computed` on every read. Before, a read that came more than about 2.5 minutes after the game's last read could report those lines `unavailable`: the same page read 100 of 100 `unavailable`, then 73 `not_computed` 29 seconds later.
* The `status` description gives each status one meaning, and says to read the same page again after the 30 seconds its `Cache-Control` `max-age` states.

**Backward compatible.** The field and its three values are unchanged. Fewer lines read `unavailable` when no read will compute them.

**What to change:** Nothing. A client that pages through a game gets each page's lines computed after it reads that page, not before.

**November 15, 2026**

Market close: every moneyline market gets its closing line, not only markets a tracked wallet bought

[`GET /api/v1/market/{condition_id}/close`](https://docs.0xinsider.com/api-reference/endpoint/get-market-close) and [`POST /api/v1/markets/close/batch`](https://docs.0xinsider.com/api-reference/endpoint/batch-get-market-close) now measure the close of every moneyline market, each leg of a soccer 1X2 included, whose game starts after this release. Before this change a market was measured only when a wallet we track had bought it before it settled. On November 15, 44,283 of the 46,336 moneylines that settled in the previous 30 days answered `unavailable` with `unavailable_reason` `not_captured`.

* A moneyline whose game started after this release answers `pending` until its close is measured, then `measured`, within the same 30-day window after kickoff as before.
* A market that is not a moneyline is measured as before: when a tracked wallet bought it before it settled.
* Moneylines whose game started before this release keep `not_captured`.
* The `get_market_close` tool on the remote [MCP endpoint](https://docs.0xinsider.com/integrations/mcp.md) returns the same. The `not_captured` description in the spec and in `@0xinsider/sdk` 0.96.0 now says which markets the capture reads.

**Backward compatible.** No field or value was added or removed; more markets reach `pending` and `measured`.

**What to change:** Nothing. A client that treated `not_captured` on a moneyline as final can read it again after kickoff.

**November 15, 2026**

Games: a finished game carries its traded volume

[`GET /api/v1/games/{event_slug}`](https://docs.0xinsider.com/api-reference/endpoint/get-game) and [`GET /api/v1/games`](https://docs.0xinsider.com/api-reference/endpoint/list-games) with `status=ended`, `cancelled` or `postponed` now return `volume` on a game read after it leaves the live board (`freshness.source` `stored`). The figure is the game volume summed from the stored volumes of the game's markets, by the same game-lines rule the game page uses: `basis` `game_lines`, `source` `gamma`, `unit` `taker_shares`, and no `observed_at`.

Before this change `volume` was omitted on every such game. On November 15 all 100 games of a `status=ended` page had none, while the game page for `nba-det-mia-2026-11-14` showed 1,774,869.

* The stored figure can trail Polymarket's final figure by a few shares until the next read of the closed markets.
* A match nobody traded has no volume on Polymarket and still omits `volume`.
* `@0xinsider/sdk` updates the field's description.

**Backward compatible.** The field keeps its type, and an omitted `volume` was already a documented state.

**What to change:** Nothing. A client that skipped finished games when ranking by `volume.value` can now include them.

**November 15, 2026**

Game sharp money adds since\_start: what graded wallets bought during a game

[`GET /api/v1/games/{event_slug}/sharp-money`](https://docs.0xinsider.com/api-reference/endpoint/get-game-sharp-money) and the `sharp_money` object on [`GET /api/v1/games?expand=sharp_money`](https://docs.0xinsider.com/api-reference/endpoint/list-games) now carry `since_start` on a binary game in play: what S, A and B grade wallets bought on its moneyline since the scheduled start, by side, in dollars put in.

* `since_start` holds `since` (the scheduled start), `as_of` (when the trades were read), `verdict`, `bought_usd`, `trader_count`, `last_trade_at`, and `outcomes[]` with `side`, `label`, `bought_usd`, `pct` (of `bought_usd`, summing to 100), `avg_buy_price` (0 to 1, `null` with no buy on that side) and `is_leader`.
* Its `verdict` is the share of those dollars alone, in the same vocabulary as the game's `verdict`: `all_on`, `leans`, `split`, `no_sharp_money` or `withheld`, and `withheld` when the side it would name holds too little money. It makes no claim against the price: in play, buys follow the score, so read each side's `avg_buy_price` beside it.
* It moves only when one of those wallets trades. `at_kickoff`, the split before the start, still never moves after the start.
* `null` before the start, after the game, on a soccer 1X2 game, and when none of those wallets bought since the start.
* The three verdicts share one schema, `GameSharpMoneyVerdict`, in the [OpenAPI document](https://0xinsider.com/api/v1/openapi.json). The `get_game_sharp_money`, `get_game` and `list_games` tools on the remote [MCP endpoint](https://docs.0xinsider.com/integrations/mcp.md) return the field, and `@0xinsider/sdk` 0.94.0 types it.

**Backward compatible.** The new key sits beside the old ones; a client that ignores it reads every game as before, `verdict.kind` `withheld` in play beside `at_kickoff`.

**What to change:** Nothing. To show what graded wallets did during a game, read `since_start.outcomes[]` and its `avg_buy_price`.

**November 15, 2026**

Traders: the sports record reads stale when the wallet traded after its last sync

[`GET /api/v1/trader/{address}`](https://docs.0xinsider.com/api-reference/endpoint/get-trader) and [`POST /api/v1/traders/batch`](https://docs.0xinsider.com/api-reference/endpoint/batch-get-traders) now mark the `sports_record` group of `data_quality.field_groups` as `stale` when the wallet traded after its last completed sync, that is, when `last_active` is later than `synced_at`. The group's `owner` is then `traders.last_synced`, its `as_of` is that sync, and its `reason` says what the figures leave out. The group covers `pnl.in_scope`, `stats.markets_traded` and `stats.win_rate`. The top-level `data_quality.status` follows, as for any stale group. The `get_trader` tool on the remote [MCP endpoint](https://docs.0xinsider.com/integrations/mcp.md) returns the same.

Before this change the group always read `fresh`. Its clock, `trader_product_scope_records.computed_at`, moves when a fill or a resolution makes us total the record again. The record's realized P\&L, cost basis and market counts come from the per-market values the sync reads from Polymarket, and a new fill changes none of them. On November 15 one wallet's record was timed 11:16 UTC and labeled `fresh` while it still showed the realized P\&L of its 04:06 sync: +$361.38, where Polymarket showed -$686.38. When we checked, about one wallet in nine with a record had traded after its last sync.

The definition of `stale` grows by one case. A group without `max_age_s` can now be `stale` when the source changed after `as_of`, and `reason` names the change. Until now such a group was never stale.

**Backward compatible.** `stale` and every field are values these routes already document. A `max_age_s` request ceiling works as before: it accepts a stale body whose oldest clock is inside the ceiling, and `data_quality.as_of` is unchanged, because the `sync` group already carries the same clock.

**What to change:** Nothing, if you already handle `stale`. If you show `pnl.in_scope` or the win rate as current whenever `sports_record` reads `fresh`, a wallet that traded since its sync now reads `stale`. Its figures are as of `synced_at` until the next sync, and opening the wallet's profile on 0xinsider requests one.

**November 15, 2026**

Edge Hunter: the one-way share leaves out wallets whose positions cannot be read

[`GET /api/v1/edge-hunter`](https://docs.0xinsider.com/api-reference/endpoint/get-edge-hunter), [`GET /api/v1/sports/pre-game-sides`](https://docs.0xinsider.com/api-reference/endpoint/get-pre-game-sides) and its alias [`GET /api/v1/sports-edge-signals`](https://docs.0xinsider.com/api-reference/endpoint/get-sports-edge-signals) now compute `directional_confidence` over the backed-side graded dollars whose wallets could be classified. Hedged and two-sided dollars still count against it, and dollars held by wallets no source could classify are left out of both sides. It is `null` when those wallets hold more than 10% of the backed-side graded dollars.

Before this change, unclassified dollars counted against the share, so it moved with whether a wallet's positions could be read on that compute. On November 15 one Jaguars vs. Titans side read 0.8682 and then 0.1114 two and a half minutes apart, with the same backed dollars and the same hedged holders.

* `one_way_holder_count`, `hedged_holder_count` and `one_way_graded_usd` are unchanged.
* `directional_rank_score` follows the new share. A `null` share ranks as it did before, as if it were 0.
* [`GET /api/v1/sports/pre-game-side-observations`](https://docs.0xinsider.com/api-reference/endpoint/get-pre-game-side-observations) records the new share on rows observed after this change; earlier rows keep the share they recorded.
* The `get_edge_hunter` tool on the remote [MCP endpoint](https://docs.0xinsider.com/integrations/mcp.md) returns the same value, and `@0xinsider/sdk` 0.92.0 updates the field's description.

**Backward compatible.** The field keeps its type and its range of 0 to 1, and `null` was already a documented value.

**What to change:** Nothing. A client that treats `null` as zero should treat it as unknown.

**November 15, 2026**

Holder edges count every settled market of every size, and say so in every\_size

`category_price_edge` and `category_scope_price_edge` on [`GET /api/v1/pick-of-the-day`](https://docs.0xinsider.com/api-reference/endpoint/get-pick-of-the-day) holders and on [`GET /api/v1/market/{condition_id}/top-holders`](https://docs.0xinsider.com/api-reference/endpoint/get-market-top-holders) now count every settled market of every size where the wallet's side and price are known. `markets`, `hit_rate` and `avg_price` describe that one set, and `edge` is still `hit_rate` minus `avg_price`.

Before this change the three figures counted only markets where the wallet put in $20 or more, and the site printed the rule as `$20+\`.

* A new boolean, `every_size`, is `true` on figures that count every size. It is `false`, or absent, on figures that still count markets of \$20 or more: holders frozen on a pick published before this change, and a wallet whose record the daily rebuild has not yet recounted.
* `sample=edge` on [`GET /api/v1/pick-of-the-day/picks/{pick_id}/wallets/{address}/markets`](https://docs.0xinsider.com/api-reference/endpoint/get-pick-of-the-day-wallet-markets) lists every settled market of every size behind the row's edge. On a pick frozen before this change, `listed` can differ from `printed`, and `matches_printed` is then `false`.
* The `get_pick_of_the_day_wallet_markets` tool on the remote [MCP endpoint](https://docs.0xinsider.com/integrations/mcp.md) and `@0xinsider/sdk` 0.91.0 describe the same rule and type `every_size`.
* A wallet's `markets` count usually grows, and its `hit_rate`, `avg_price` and `edge` can move either way. `category_avg_price`, the leaderboard's `price_edge`, and a profile's Edge still count markets of \$20 or more.

**Backward compatible.** No field was renamed or removed, and `every_size` is additive.

**What to change:** Nothing. If you print a holder's market count with a size rule, read `every_size` and print the rule only when it is not `true`.

**November 15, 2026**

Game sharp money: settled games withhold the verdict and carry the split before the start

[`GET /api/v1/games/{event_slug}/sharp-money`](https://docs.0xinsider.com/api-reference/endpoint/get-game-sharp-money#settled-games) now answers a `settled` game with `verdict.kind: "withheld"`, every `pct` at `0` and no `is_leader` side, and returns `at_kickoff`, the split as the site last recorded it before the scheduled start. The `get_game_sharp_money` tool on the remote MCP endpoint returns the same. [List games](https://docs.0xinsider.com/api-reference/endpoint/list-games.md) with `expand=sharp_money` is unchanged: it answers a settled game `not_computed`, as before.

Before this change every settled game answered `all_on` its winner with `pct` 100. A settled game's holders are the winning side's wallets that have redeemed in profit, so the losing side always read `0`: on November 15 all five settled NBA games of November 14 read that way, though graded wallets had held both sides before the start.

* `outcomes[].usd`, `outcomes[].wallets` and `trader_count` are unchanged: the winning side's realized profit and wallets.
* `at_kickoff` counts both sides' holders and has the same fields as on an `in_play` game. It is `null` when no split with graded money was recorded before the start.

**Backward compatible.** No field or value is added or removed. A settled game now answers values the route already documents. `@0xinsider/sdk` 0.90.0 carries the new descriptions in its types.

**What to change:** If you read a settled game's `verdict` or `pct` as where graded money stood, read `at_kickoff` instead.

**November 15, 2026**

Trading styles: two\_sided counts markets bought on both sides

The `two_sided` [trading style](https://docs.0xinsider.com/concepts/strategy-types.md) now counts the markets a wallet bought on both sides, as the page has always described it. Before this change it counted only the markets where the wallet still held shares of both outcomes. A settled market rarely holds both, so on November 15 no wallet carried `two_sided`, and a wallet that bought both sides in most of its markets still read 0%.

Styles are recomputed over the next hours. Some wallets move to `two_sided`, or gain it in their other qualifying patterns, so [`GET /api/v1/leaderboard`](https://docs.0xinsider.com/api-reference/endpoint/get-leaderboard) with `strategy=two_sided`, and every `strategy_type` field, can now return wallets where it returned none.

**Backward compatible.** The field names and the six style values do not change.

**What to change:** Nothing. A client that filtered on `two_sided` and read an empty list now gets wallets.

**November 15, 2026**

Max accounts get four times Pro's API rate, webhooks, integration keys and exports

A Max account's allowances on the API are now four times Pro's: 400 requests and 10,000 batch items a minute, 40 [webhook endpoints](https://docs.0xinsider.com/api-reference/endpoint/create-webhook.md), 40 named [integrations](https://docs.0xinsider.com/authentication.md), and 80 [exports](https://docs.0xinsider.com/api-reference/endpoint/submit-trader-export.md) a day with 20 per wallet an hour. Before this change Max had 200 requests and 5,000 batch items a minute, and the same 10 endpoints, 10 integrations, 20 exports a day and 5 an hour as Pro. Pro's allowances and both monthly quotas are unchanged.

* `RateLimit-Limit` and `X-RateLimit-Limit` read `400` on a Max key.
* The daily and hourly export counts are shared by [trader exports](https://docs.0xinsider.com/api-reference/endpoint/submit-trader-export.md) and [dataset jobs](https://docs.0xinsider.com/api-reference/endpoint/submit-whale-dataset.md), as before.
* `large_export_policy.rate_limit` on the [export snapshot](https://docs.0xinsider.com/api-reference/endpoint/get-trader-export-snapshot.md) now states the caller's plan: `80` and `20` on Max. It read `20` and `5` for every key.
* On Pro, the `400` at the endpoint limit now reads `maximum 10 webhook endpoints allowed on Pro; Max allows 40`, and the `409` at the integration limit reads `10 integrations are active, the Pro limit; Max holds 40. Revoke one before creating another.`
* `@0xinsider/sdk` 0.89.0 carries the new rates in its endpoint descriptions; its types are unchanged.

**Backward compatible.** Limits only rose, and every field and status code is the same.

**What to change:** Nothing. A client that hard-codes 200 a minute for Max can read `RateLimit-Limit` instead.

**November 15, 2026**

Games: an ITF singles match in play reads live with its score

[`GET /api/v1/games`](https://docs.0xinsider.com/api-reference/endpoint/list-games) and [`GET /api/v1/games/{event_slug}`](https://docs.0xinsider.com/api-reference/endpoint/get-game) now report an ITF singles match in play as `status.state` `live`, with each player's set score in `competitors[].score`, `coverage.scores` `available`, and `freshness.source` `live`. It is listed under `status=live`. The `get_game` and `list_games` tools on the remote [MCP endpoint](https://docs.0xinsider.com/integrations/mcp.md) return the same.

Polymarket's live data never marks an ITF singles match live, and we read its state from API-Tennis. Before this change that state did not reach these routes: on November 15 all four ITF matches in play read `scheduled` with no score, and `status=live&sport=tennis` listed only the one ATP match. For these matches `status.provider_status` is API-Tennis's own status, such as `Set 1`.

**Backward compatible.** Every value is one the routes already document.

**What to change:** Nothing. A client that skipped ITF games because they never read `live` can now follow them.

**November 15, 2026**

Market candles: 5m and 1h fill the newest buckets from Polymarket's 60-second prices

[`GET /api/v1/market/{condition_id}/candles`](https://docs.0xinsider.com/api-reference/endpoint/get-market-candles) at `resolution=5m` and `resolution=1h` now fills the buckets Polymarket has not published yet from its 60-second prices, which trail the clock by 4 to 11 minutes. Before this change the newest `5m` candle started 16 to 31 minutes before the read, and the newest `1h` candle started 1 to 2 hours before it, because Polymarket publishes those buckets in batches.

* Each `5m` and `1h` candle now carries `basis`. `provider_bucket` is Polymarket's own bucket price, so `o`, `h`, `l` and `c` are equal, as before.
* `provisional_minutes` marks a bucket after Polymarket's newest published one, in a window that ended under 3 hours ago. It is built from Polymarket's 60-second prices inside it: `o` is the first minute's price, `h` the highest, `l` the lowest, and `c` the last.
* A provisional candle changes. The bucket in progress gains minutes until it closes, and a later read replaces the candle with Polymarket's own bucket once it is published.
* A window that holds a provisional candle is re-read after at most 60 seconds. A read that is not cached of a window that ended under 3 hours ago spends 2 of your account's cold-read share, 6 a minute in bursts of up to 30.
* `1d` and `1w` candles have no `basis`, and their answers are unchanged. The `get_market_candles` tool on the remote [MCP endpoint](https://docs.0xinsider.com/integrations/mcp.md) returns the same field, and `@0xinsider/sdk` 0.88.0 types it as `"provider_bucket" | "provisional_minutes"`.

**Backward compatible.** `basis` is a new field, and every candle keeps `t`, `o`, `h`, `l` and `c`.

**What to change:** Nothing. To draw the newest candles differently, check `basis == "provisional_minutes"`, and replace candles by `t` on each read rather than appending.

**November 15, 2026**

Market candles add 5m and 1h resolutions from Polymarket's own price buckets

[`GET /api/v1/market/{condition_id}/candles`](https://docs.0xinsider.com/api-reference/endpoint/get-market-candles) now accepts `resolution=5m` and `resolution=1h`, read from Polymarket's price history at that bucket width. Before this change both values returned `400`, and the only resolutions were `1d` and `1w`, built from stored daily prices.

* Each `5m` or `1h` candle is one Polymarket bucket: one price, so `o`, `h`, `l` and `c` are equal, unrounded. A bucket Polymarket did not price has no candle.
* Without `from`, `5m` covers the last day and `1h` the last 7 days, ending now or when the market resolved. A window spans at most 15 days, `5m` reaches back 60 days and `1h` 90; a wider or older window returns `400`.
* `data.window_start`, `data.window_end` and `data.observed_at` appear only at `5m` and `1h`. A window that reaches the present is re-read after at most 60 seconds.
* Polymarket publishes these buckets in batches, so the newest candle trails the clock: on November 15 the newest `5m` candle started 16 to 31 minutes before the read, and the newest `1h` candle was the last completed hour. For the current price, read [`GET /api/v1/market/{condition_id}/snapshot`](https://docs.0xinsider.com/api-reference/endpoint/get-market-snapshot).
* A `5m` or `1h` read that is not cached spends your account's share of cold reads, 6 a minute in bursts of up to 30. Over it the answer is `429` with `error.reason` `cold_read_limited` and `Retry-After`; cached windows still answer. If Polymarket does not answer, the route returns `503` with reason `read_model_warming`.
* The `get_market_candles` tool on the remote [MCP endpoint](https://docs.0xinsider.com/integrations/mcp.md) accepts the same values, and `@0xinsider/sdk` 0.87.0 types them and the three new fields on `getMarketCandles`.

**Backward compatible.** `1d` stays the default, and `1d` and `1w` answers are unchanged. The new fields appear only at the new resolutions.

**What to change:** Nothing. To chart a game in play, request `resolution=5m`, pair it with the snapshot for the latest price, and handle `429` `cold_read_limited` by waiting for `Retry-After`.

**November 15, 2026**

Pick of the Day: each pick carries its market type, as the archive row does

[`GET /api/v1/pick-of-the-day`](https://docs.0xinsider.com/api-reference/endpoint/get-pick-of-the-day) now returns `sports_market_type` on each pick your key can open, in `view=full` and `view=summary`, with or without `pick_id`. It is the backed market's type, such as `moneyline`, `spreads` or `totals`, as recorded with the pick: the same value [`GET /api/v1/pick-of-the-day/archive`](https://docs.0xinsider.com/api-reference/endpoint/get-pick-of-the-day-archive) returns on that pick's row.

Before this change only the archive row carried the market type, so a client reading one pick could not tell a moneyline from a spread or a total.

* The field is omitted when the market states no type, and on a pick your key cannot open, which the read leaves out as before.
* The `get_pick_of_the_day` tool on the remote MCP endpoint returns it, and `@0xinsider/sdk` 0.86.0 adds it to `PickOfTheDay` and to the `view=summary` pick type. The tool's description drops the sentence that repeated what its `view` argument says; no argument changed.

**Backward compatible.** One optional field is added; no field was removed or changed.

**What to change:** Nothing. To label a pick's market, read `sports_market_type` from the pick instead of its archive row.

**November 15, 2026**

Market snapshot: the reference now says what a first-read cache\_miss means and when to read again

[`GET /api/v1/market/{condition_id}/snapshot`](https://docs.0xinsider.com/api-reference/endpoint/get-market-snapshot) reads top of book from our book cache. An open market that no reader holds has no cached book yet, so its first read answers `top_of_book.status` `unavailable` with `reason` `cache_miss` on each outcome. That same read starts the market's live book. In our reads on November 15 the book was served within 620 ms of the first read on 7 of 7 markets.

The OpenAPI document now describes each `top_of_book.reason` value, and the `get_market_snapshot` MCP tool description carries the same instruction: on `cache_miss` for an open market, read again after 1 second. A closed market starts no book, so its `cache_miss` stays.

**Backward compatible.** No field, value or status changes. Only the descriptions do. `@0xinsider/sdk` 0.85.0 carries the new description in its types.

**What to change:** If your client reads `cache_miss` as "this market has no book", read the snapshot once more after 1 second before you decide.

**November 15, 2026**

Remote MCP: list fewer tools with toolsets in the endpoint URL

The remote [MCP endpoint](https://docs.0xinsider.com/integrations/mcp.md#toolsets) takes a new optional query parameter, `toolsets`, on `POST /api/v1/mcp`. With it, `tools/list` answers only the tools you name, so a client that hands the list to a model can send it far less than the full 79 tools and 662 KB.

* `?toolsets=core` lists 16 tools, about 183 KB: account, the leaderboard and one trader, games and their sharp money, market search and one market, the day's picks and their record, large trades and flagged trades.
* `?toolsets=all` lists every current tool: 70, about 602 KB, the full list without the 9 deprecated aliases.
* A group name lists that group's current tools: `account`, `combos`, `content`, `games`, `large_trades`, `markets`, `picks`, `platforms`, `reports`, `suspicious_trades`, `traders` or `webhooks`. Separate several names with commas, as in `?toolsets=games,picks`, or repeat the parameter.
* A shortened list never holds a deprecated alias tool.
* `toolsets` changes `tools/list` only. `tools/call` still runs any tool by name, and `initialize` is the same for every URL.
* An unknown or empty name answers JSON-RPC error `-32602` with the valid names in its message.
* `@0xinsider/sdk` 0.84.0 sends it from `client.mcp(request, { toolsets: "core" })`; an array is joined with commas. The local `@0xinsider/mcp` package has no toolsets and lists its whole catalog.

**Backward compatible.** Without the parameter, `tools/list` answers the same full list as before, aliases included.

**What to change:** Nothing. To shorten the list, add `?toolsets=core`, or the groups you use, to the endpoint URL in your client's configuration. If your client signs in with OAuth and sends its own endpoint URL as the token `resource`, keep the URL without the query for that value.

**November 15, 2026**

Positions: a wallet's age and is\_new\_wallet now count from its first trade

[`GET /api/v1/positions`](https://docs.0xinsider.com/api-reference/endpoint/get-positions) now counts `trader.wallet_age_days` and `trader.is_new_wallet` from the wallet's first trade, the rule [large trades](https://docs.0xinsider.com/api-reference/endpoint/get-large-trades.md) and the site's New wallets view use, and each row carries that first trade as `trader.first_trade_at`. Before this change both fields counted from when 0xinsider first recorded the wallet, so a wallet that had traded for months could read as new: 98 of 4,822 wallets on the feed on November 15 did.

* `trader.first_trade_at`: the wallet's first trade 0xinsider recorded, the same value large trades return. `null` until the wallet has one.
* `trader.wallet_age_days`: days since `first_trade_at`. Absent when `first_trade_at` is `null`, as before when the age was unknown.
* `trader.is_new_wallet`: `true` when `first_trade_at` is under 30 days old. It stays a boolean and is `false` when `first_trade_at` is `null`, where large trades return `null`.
* The `get_positions` tool on the remote [MCP endpoint](https://docs.0xinsider.com/integrations/mcp.md) returns the same fields, and `@0xinsider/sdk` 0.83.0 types `trader.first_trade_at`.

**Backward compatible.** One field is added and no field, type or required field changed. The values change meaning: wallets 0xinsider recorded after their first trade now show a larger `wallet_age_days` and, if that trade is 30 or more days old, `is_new_wallet` `false`.

**What to change:** Nothing, unless you stored either field and compare it with older reads. To filter new wallets, keep reading `trader.is_new_wallet`; it now selects the same wallets as large trades.

**November 15, 2026**

Pick of the Day stats: the OpenAPI document and the MCP output schema name the row shapes they repeated

The schemas for [`GET /api/v1/pick-of-the-day/stats`](https://docs.0xinsider.com/api-reference/endpoint/get-pick-of-the-day-stats), `PickOfTheDayStats` and `PickOfTheDayStatsSections`, repeated the same row shapes inline 28 times. The [OpenAPI document](https://docs.0xinsider.com/api-reference/introduction.md) now defines each shape once and both schemas refer to it by name. No response changes.

* Eight new components, listed under [Objects](https://docs.0xinsider.com/api-reference/objects.md): `PickOfTheDayStatsBucket` (the rows of `categories`, `sports`, `tiers`, `months`, `price_bands`, `market_types` and `total_sides`), `PickOfTheDayStatsDay`, `PickOfTheDayStatsVoid`, `PickOfTheDayMarketExpectations`, `PickOfTheDayOutcomeStats`, `PickOfTheDayStatsRecords`, `PickOfTheDayStatsStreaks` and `PickOfTheDayAskComparison`.
* The `get_pick_of_the_day_stats` tool on the remote [MCP endpoint](https://docs.0xinsider.com/integrations/mcp.md) advertises an 18,599-byte `outputSchema`, down from 40,637, and `tools/list` is 662,236 bytes, down from 684,275. The schema's references stay inside the tool's own `$defs`.
* `@0xinsider/sdk` 0.82.0 exports the eight shapes as types.

**Backward compatible.** No field, type or required field changed, and a response that passed the old schema passes the new one.

**What to change:** Nothing. If you generate code from the OpenAPI document, your generator now emits these component names where it made up a name for each inline shape, so regenerate and update any reference to the old generated names.

**November 15, 2026**

Large trades: each row carries the wallet's age, and history takes new\_wallets

Every large trade on [`GET /api/v1/large-trades`](https://docs.0xinsider.com/api-reference/endpoint/get-large-trades), [`GET /api/v1/large-trades/history`](https://docs.0xinsider.com/api-reference/endpoint/get-large-trades-history) and [`GET /api/v1/large-trades/{id}`](https://docs.0xinsider.com/api-reference/endpoint/get-large-trade) now carries `trader.first_trade_at` and `trader.is_new_wallet`. History also takes `new_wallets=true`, which returns only trades by wallets whose first recorded trade is under 30 days old, the wallets the site's New wallets view shows.

* `trader.first_trade_at`: the wallet's first trade 0xinsider recorded. `null` until the wallet has one.
* `trader.is_new_wallet`: `true` when `first_trade_at` is under 30 days old, `false` when older, `null` when `first_trade_at` is `null`.
* With `new_wallets=true` the window starts 30 days back, because no older trade can belong to such a wallet. A `from` earlier than that is moved up to it.
* [`GET /api/v1/large-positions`](https://docs.0xinsider.com/api-reference/endpoint/list-large-positions) now fills `trader.username` the way the large-trade rows do: the wallet's username first, else its Polymarket pseudonym, and no name when the only one is the address. Before this change a wallet without a profile name could read as Polymarket's placeholder, its address followed by a number.
* The MCP tools follow the routes: the large-trade tools return both fields, `get_large_trades_history` and `get_whale_trades_history` take `new_wallets`, and `get_large_positions` names wallets the same way. The four large-trade list tools describe their arguments more briefly; no argument, type, default or bound changed. `@0xinsider/sdk` 0.82.0 types the fields and the parameter.
* A trade [`GET /api/v1/events/feed/since`](https://docs.0xinsider.com/api-reference/endpoint/get-event-replay-since) expands carries the same two fields.
* The deprecated `/api/v1/whale-trades` routes return the same fields and take the same parameter.

**Backward compatible.** Fields and a parameter were added. A position's `trader.username` can now differ from the value it had before for the same wallet.

**What to change:** Nothing. To follow new wallets, send `new_wallets=true` to large trades history, or read `trader.is_new_wallet` on any large-trade row.

**November 15, 2026**

Pick of the Day archive: each row carries the kickoff, market and backing figures the single pick returns

[`GET /api/v1/pick-of-the-day/archive`](https://docs.0xinsider.com/api-reference/endpoint/get-pick-of-the-day-archive) with `view=full` now returns, on each row whose backed side your key can open, the kickoff, the market and the backing figures [`GET /api/v1/pick-of-the-day?pick_id=`](https://docs.0xinsider.com/api-reference/endpoint/get-pick-of-the-day) returns for the same pick. Before this change those fields were only on the single pick, so reading them for the whole record took one request per pick, more than 1,000.

* `kickoff`: when the backed game starts, as recorded with the pick. The single pick states the new start when a game moved after publication.
* `condition_id`: the backed market, the value the single pick returns as `entry_authorization.condition_id`.
* `sports_market_type`: the market type, such as `moneyline`, `spreads` or `totals`, when the market states one.
* `backed_side_share`, `sharp_positioned_usd`, `sharp_wallet_count`, `side_graded_wallet_count` and `side_graded_usd`: the single pick's values for the same pick, omitted where it omits them.
* A row with `backed_side_locked` carries none of them, and `view=summary` rows are unchanged.
* The `get_pick_of_the_day_archive` tool on the remote MCP endpoint returns the same fields, and `@0xinsider/sdk` 0.81.0 adds them to `PickOfTheDayArchiveEntry`.

**Backward compatible.** Eight optional fields are added; no field was removed or changed.

**What to change:** Nothing. To group the record by game day or market type, or to read its backing figures, read the new fields from the archive instead of each pick.

**November 15, 2026**

@0xinsider/mcp 3.25.1: the stdio server carries the shorter tool descriptions

[`@0xinsider/mcp`](https://docs.0xinsider.com/integrations/mcp) 3.25.1 is on npm. Its stdio server now advertises the same tool descriptions as the remote MCP endpoint: no `Args:` or `Returns:` section, none over 1,500 characters, 49,725 bytes across the 79 tools where 3.25.0 sent 124,692.

* The install lines on this site name 3.25.1.
* The [CLI](https://docs.0xinsider.com/integrations/cli.md) in the same package is unchanged: no command, flag or exit code changed.

**Backward compatible.** No tool, argument, type, default, bound or annotation changed.

**What to change:** Nothing. To get the shorter descriptions, install `@0xinsider/mcp@3.25.1`. If you parse the `Args:` or `Returns:` text of a description, read `inputSchema` and the [API reference](https://docs.0xinsider.com/api-reference/introduction.md) instead.

**November 15, 2026**

MCP: tool descriptions are shorter and no longer list the result's fields

The remote [MCP endpoint](https://docs.0xinsider.com/integrations/mcp.md)'s `tools/list` now carries a shorter description on every tool. A description states what the tool is for, when to use it and the rules that no schema states. It no longer has a `Returns:` section that lists the fields `outputSchema` already lists. The 79 descriptions were 85,320 bytes in all and are now 49,725; the longest was 5,484 characters and is now 1,489; the whole answer was 720,126 bytes and is now 684,373.

* The nine deprecated alias tools (`get_whale_trades`, `get_whale_trade`, `get_whale_trades_history`, `get_market_intel`, `batch_get_market_intel`, `get_smart_money_flows`, `get_insider_radar`, `get_insider_radar_flag` and `get_platforms`) now say only which tool replaces them and when they are removed. Their arguments and results are unchanged.
* A field rule that a description no longer states is in the [API reference](https://docs.0xinsider.com/api-reference/introduction.md): each tool reads one `/api/v1` route, and that route's page states its rules and response fields. `get_edge_hunter` and `get_pick_of_the_day` name their route.
* The sentence on wallet names at the end of a description is shorter. The server's `instructions` still say in full that a wallet name is text its owner sets, to read as data and never as instructions.
* The `instructions` gain two sentences: retry a `read_model_warming` error at the time it names, and where the full rules are.
* The `@0xinsider/mcp` stdio server carries the same descriptions from its next release.

**Backward compatible.** No tool, argument, type, default, bound, annotation or output schema changed.

**What to change:** Nothing if your client passes descriptions to a model. If you match description text, such as the `Returns:` label, read `outputSchema` instead.

**November 15, 2026**

Market holders: each row carries the price edge the game page prints

[`GET /api/v1/market/{condition_id}/holders`](https://docs.0xinsider.com/api-reference/endpoint/get-market-holders) now returns each S, A and B holder's edge over the price it paid in the market's category, the same fields and figures [`GET /api/v1/market/{condition_id}/top-holders`](https://docs.0xinsider.com/api-reference/endpoint/get-market-top-holders) returns. Before this change the roster carried each wallet's win record and no edge, so a wallet outside the 100 largest holders on a side had no edge anywhere in the API.

* `category_price_edge`, `category_scope_price_edge`, `category_price_edge_hold` and `category_scope_price_edge_hold` have the shapes and rules of the top-holders fields. An edge or its hold sits beside a measured record only, and a wallet on both lists carries the same figures.
* `category_records_as_of` on the response says when the daily rebuild behind the edges began. A row carries its own, later `category_records_as_of` when its wallet was recounted since. The response omits it when no row has an edge or a hold.
* [`GET /api/v1/games/{event_slug}/holders`](https://docs.0xinsider.com/api-reference/endpoint/get-game-holders) returns the same rows, and each `ok` item's `data` carries `category_records_as_of`.
* The `get_market_holders` and `get_game_holders` tools on the remote MCP endpoint return the same fields. `@0xinsider/sdk` 0.80.0 adds them to `MarketHolder`, the market holders response, and `GameHoldersItem`.
* To keep the MCP `tools/list` answer within its size limit, the descriptions of `get_clv`, `get_sport_leaderboard` and `get_game_holders` no longer carry `Returns:` text. Those of `get_market_trades`, `list_games`, `list_settled_markets`, `list_game_markets` and `get_game_sharp_money` no longer list the fields their output schemas describe. `get_market_holders`, `get_market_top_holders` and `get_game_holders` say their other facts in fewer words.

**Backward compatible.** Optional fields are added; no field or tool argument was removed or changed.

**What to change:** Nothing. To show a holder's edge as the game page does, read `category_price_edge`, and its hold when it is absent. If you parse a tool's `Returns:` text, read its `outputSchema` instead.

**November 15, 2026**

MCP: tool descriptions no longer repeat the argument list

The remote [MCP endpoint](https://docs.0xinsider.com/integrations/mcp.md)'s `tools/list` no longer prints an `Args:` block in any tool description. Each argument is described once, in `inputSchema.properties.<name>.description`. Before this change, 73 of the 79 descriptions listed every argument a second time, and the answer was 752,842 bytes; it is now 720,327.

* 37 argument descriptions in 24 tools gained the facts that only the `Args:` block had stated, such as the `wth_` cursor prefix of the large-trade history tools.
* The rest of each description, its `Returns:` text included, is unchanged.
* The `@0xinsider/mcp` stdio server carries the same descriptions from its next release.

**Backward compatible.** No tool, argument, type, default, bound, annotation or output schema changed.

**What to change:** Nothing if your client reads arguments from `inputSchema`. If you parse the `Args:` text of a description, read `inputSchema.properties` instead.

**November 15, 2026**

Price moves: in-play and phase-unknown moves are kept 14 days

[`GET /api/v1/price-moves`](https://docs.0xinsider.com/api-reference/endpoint/list-price-moves) and [`GET /api/v1/market/{condition_id}/price-moves`](https://docs.0xinsider.com/api-reference/endpoint/list-market-price-moves) now keep a move by its `phase`: a `pre_game` move for 90 days, as before, and an `in_play` or `unknown` move for 14 days. Before this change every move was kept 90 days. In-play and unknown moves were 93% of the 427,438 moves stored on November 14.

* With `phase=in_play`, the walk ends 14 days back: `has_more` is `false` on the page that reaches it, whatever `since` says.
* Without `phase`, pages older than 14 days list `pre_game` moves only.
* The first moves past 14 days are deleted from November 27, 2026, 14 days after storing began.
* The `list_price_moves` tool on the remote MCP endpoint answers the same way. Its description no longer lists the arguments, which its input schema already describes. `@0xinsider/sdk` 0.79.0 updates the `listPriceMoves()` description only.

**Backward compatible.** No field, parameter or value changed.

**What to change:** If you study in-play or unknown moves over more than 14 days, read them within 14 days and keep your own copy.

**November 15, 2026**

Market top holders: each row carries the price edge the game page prints

[`GET /api/v1/market/{condition_id}/top-holders`](https://docs.0xinsider.com/api-reference/endpoint/get-market-top-holders) now returns each holder's edge over the price it paid in the market's category, the figure the game page's Top holders row prints beside the wallet, or the reason the page prints none. Before this change the row carried the wallet's win record in the category and no edge, so an agent could not read the figure the page shows.

* `category_price_edge`: `{ markets, hit_rate, avg_price, edge }`, the shape `display_holders[]` on Pick of the Day already uses. `hit_rate` is how often the side the wallet bought won and `avg_price` the average price it paid, over its settled markets in the category of \$20 or more at a known entry price; `edge` is `hit_rate` minus `avg_price`. All four are 0-1 probabilities at full precision: `edge` 0.022 is the page's +2.2 pp.
* `category_scope_price_edge`: the same edge over the game or league `category_win_rate_game` names, beside that record only.
* `category_price_edge_hold` and `category_scope_price_edge_hold`: `{ hold, record? }` when the page prints no edge beside a measured record, with `hold` one of `category_loss`, `too_few_markets`, `sample_mismatch` or `no_markets`.
* The edges are as of the row's `category_records_as_of`, or the response's when the row has none. The page's 95% range is 1.96 times the square root of `avg_price * (1 - avg_price) / markets`, either side of `edge`.
* The `get_market_top_holders` tool on the remote MCP endpoint returns the same fields, and `@0xinsider/sdk` 0.78.0 adds them to `MarketTopHolder`. [`GET /api/v1/market/{condition_id}/holders`](https://docs.0xinsider.com/api-reference/endpoint/get-market-holders) and the game holders batch carry no edge.

**Backward compatible.** Four optional fields are added; no field was removed or changed.

**What to change:** Nothing. To show a holder's edge as the page does, read `category_price_edge`, and its hold when it is absent.

**November 15, 2026**

Games: an ended game no longer reports an in-play match status

[`GET /api/v1/games`](https://docs.0xinsider.com/api-reference/endpoint/list-games) and [`GET /api/v1/games/{event_slug}`](https://docs.0xinsider.com/api-reference/endpoint/get-game) now omit `status.match_status` and `status.provider_status` on a game whose `status.state` is `ended` when the last status the live-score feed sent is one it sends only before the end. Before this change, a game we recorded as ended after its feed went quiet kept that status: on November 15, `itf-cross1-bulgar1-2026-11-14` read `state: ended` beside `match_status: in_progress` and `provider_status: Set 2`, and 53 ended games read `in_progress` or `scheduled`.

* The statuses omitted beside `ended` are `scheduled`, `in_progress`, `halftime`, `penalty_shootout` and `delayed`. A final, awarded, forfeit, postponed, cancelled, suspended or `unknown` status is still served.
* `freshness.scores_observed_at` is now when the score was last observed. Recording the end of such a game no longer moves it. A game ended that way before this change keeps the time of that write, because the earlier observation was not kept.
* The `list_games` and `get_game` tools on the remote MCP endpoint answer the same way. `@0xinsider/sdk` 0.77.1 updates the three field descriptions only.

**Backward compatible.** Both status fields were already optional; no field was added or removed.

**What to change:** Nothing if you read `status.state` for whether a game is over. If you read `match_status` alone, treat a missing value on an ended game as no status from the feed.

**November 15, 2026**

Games: a game held in play with no update for 3 hours reads suspended, in more sports

[`GET /api/v1/games`](https://docs.0xinsider.com/api-reference/endpoint/list-games) and [`GET /api/v1/games/{event_slug}`](https://docs.0xinsider.com/api-reference/endpoint/get-game) now report `status.state` `suspended` and `status.live` `false` for a soccer, hockey, basketball, American football or cricket game, or a series in one of eight esports titles, that Polymarket still lists in play when no live-score feed reports it and its period and score have not changed for 3 hours. Before this change only tennis had that rule, so a game whose feed had stopped read `live` for hours or days. On November 15 a Valorant series read `live` 16 hours after its kickoff, and two Sheffield Shield matches 4 days after theirs.

* The 3 hours start no sooner than 2 hours after kickoff, or 6 for esports, so a game reads `suspended` only after the longest game measured in its sport has ended. The esports titles are CS2, Dota 2, League of Legends, Valorant, Mobile Legends: Bang Bang, Rainbow Six Siege, Overwatch and Call of Duty.
* Cricket counts the 3 hours only after the match's scheduled days: 5 for a match with a draw market, 1 for a limited-overs match, and one fewer when the score shows runs. A multi-day match stays `live` through its overnight breaks.
* Every other sport or esports title, such as baseball, MMA, table tennis or StarCraft 2, keeps Polymarket's in-play flag.
* `window=now` leaves such a game out, as it does every suspended game whose kickoff is more than 3 hours old.
* The game reads `live` again when its period or score changes, or when a live-score feed reports it.
* The `list_games` and `get_game` tools on the remote MCP endpoint answer the same way. `@0xinsider/sdk` 0.77.0 updates the two field descriptions only.

**Backward compatible.** `suspended` was already a value of `status.state`; no field was added or removed.

**What to change:** Nothing if you already handle `suspended`. If you count every game Polymarket lists in play as live, read `status.state` instead.

**November 15, 2026**

Game sharp money: in-play and ended games carry the split before the start

[`GET /api/v1/games/{event_slug}/sharp-money`](https://docs.0xinsider.com/api-reference/endpoint/get-game-sharp-money#the-split-before-the-start) now returns `at_kickoff` on an `in_play` or `ended` game: the split as the site last recorded it before the scheduled start, valued at that moment's prices. The same object appears on [List games](https://docs.0xinsider.com/api-reference/endpoint/list-games.md) with `expand=sharp_money`, in the `get_game_sharp_money` and `list_games` tools on the remote MCP endpoint, and in `@0xinsider/sdk` 0.76.0 as `GameSharpMoney.at_kickoff`.

Before this change a game in play or waiting to settle showed `pct` 0 and no leader on every side, and nothing said where graded wallets stood when it began.

* `at_kickoff` has `as_of`, when the split was recorded, plus `verdict`, `total_usd`, `trader_count` and `outcomes[]` with `side`, `label`, `usd`, `pct` and `is_leader`.
* `outcomes[].pct` and `verdict` at the top level keep describing the game now, so they stay `0` and `withheld`.
* `at_kickoff` is `null` on a `live`, `settled` or `indeterminate` game, and when no split with graded money was recorded before the start. Soccer games have none more often.
* A postponed or cancelled game past its scheduled start answers `in_play`, as before, and its `at_kickoff` is the split before that start. The `lifecycle` descriptions in the OpenAPI spec and the MCP tools now say so.

**Backward compatible.** One field is added; no field was removed or changed.

**What to change:** Nothing. To show where graded money stood going into a game that has started, read `at_kickoff` and its `as_of`.

**November 15, 2026**

Suspicious trades take from and to, so one day's flags are one request

[`GET /api/v1/suspicious-trades`](https://docs.0xinsider.com/api-reference/endpoint/get-suspicious-trades) now takes `from` and `to`, bounds on the fill time `traded_at`, the same bounds [`GET /api/v1/large-trades/history`](https://docs.0xinsider.com/api-reference/endpoint/get-large-trades-history) takes. Before this change the list took no time window, so reading one day's flags meant paging `sort=recent` until `traded_at` passed the day.

* `from` is inclusive and `to` is exclusive, both RFC 3339. They apply in either `sort` and either `mode`, before the page is cut, so a bounded page is never short.
* A value that is not RFC 3339 returns `400` with `error.param` `from` or `to`. A `to` that is not after `from` returns `400` with `error.param` `to`.
* In `mode=stable` the cursor carries the window: change it while paging and the next page returns `400` with `error.reason` `cursor_expired`. Cursors issued before this change keep working.
* The deprecated alias `GET /api/v1/insider-radar` takes both parameters too.
* The `get_suspicious_trades` tool on the remote MCP endpoint and in `@0xinsider/mcp` 3.25.0 takes `from` and `to`, and `@0xinsider/sdk` 0.75.0 types them on `listSuspiciousTrades`.
* In the [CLI](https://docs.0xinsider.com/integrations/cli.md) from `3.25.0`, `0xinsider api call listSuspiciousTrades --query from=2026-11-12T00:00:00Z --query to=2026-11-13T00:00:00Z` reads one day's flags, and `api list` names both parameters.

**Backward compatible.** Two optional parameters are added; a request without them returns what it returned before.

**What to change:** Nothing. To read one day's flags, send `from` at 00:00 that day and `to` at 00:00 the next.

**November 15, 2026**

Get one game reads a started game Polymarket never finished, instead of 404

[`GET /api/v1/games/{event_slug}`](https://docs.0xinsider.com/api-reference/endpoint/get-game) now returns `200` for a game whose kickoff has passed and that Polymarket never reported in play or finished. Before this change it answered `404` "No covered game has that event\_slug", although [`GET /api/v1/markets/search`](https://docs.0xinsider.com/api-reference/endpoint/search-markets) listed the game's markets as active.

* The game comes from its stored record, with `freshness.source` `stored`, and has the same shape as a finished game read after it leaves the live board: no prices, `yes_quote`, volume, liquidity, title or tournament.
* `status.state` is `suspended` or `delayed` when that was the provider's last verdict, and `unknown` otherwise. `status.ended` is `false` and `status.ended_at` is `null`.
* [`GET /api/v1/games`](https://docs.0xinsider.com/api-reference/endpoint/list-games) does not list these games. A game whose kickoff is still ahead and that the board does not carry still answers `404`.
* While a board source is unavailable, such a slug still answers `503` `read_model_warming`, because the missing source could carry the game in play.
* The `404` message now reads "a game stays readable here by its slug once its kickoff has passed, finished or not". The `get_game` tool on the remote MCP endpoint answers the same way.

**Backward compatible.** `unknown`, `suspended` and `delayed` were already values of `status.state`; no field was added or removed.

**What to change:** If you treat a `404` from this route as "the game does not exist", nothing. If you treat every `200` as a game that is live, upcoming or finished, handle `status.state` `unknown` and read each market's current book from [Market snapshot](https://docs.0xinsider.com/api-reference/endpoint/get-market-snapshot.md).

**November 15, 2026**

Combo leg markets say whether the game has ended

Each leg market on [`GET /api/v1/combos/fills`](https://docs.0xinsider.com/api-reference/endpoint/list-combo-fills) and [`GET /api/v1/combos/{condition_id}`](https://docs.0xinsider.com/api-reference/endpoint/get-combo) now carries `game_ended`. Before this change a client could only read `kickoff_date_passed`, and a game that kicks off late in the UTC day is still in play after midnight UTC, so a past kickoff date did not say the game was over.

* `game_ended` is true when the game the market belongs to has ended, from the same stored game state [`GET /api/v1/games/{event_slug}`](https://docs.0xinsider.com/api-reference/endpoint/get-game) reads. A market in a child event, such as a soccer game's more-markets event, reads its parent game.
* It is false while the game is scheduled, in play or postponed.
* It is null when no state is stored for the game, when the leg has no local market, or when the market has no event. Some games have no live feed, so null means unknown, not in play.
* `kickoff_date_passed` keeps its meaning. Its description now says that true does not mean the game is over.
* The `get_combo_fills` and `get_combo` tools on the remote MCP endpoint return the field, and `@0xinsider/sdk` 0.74.0 types it on the leg market.

**Backward compatible.** One field is added to each leg market; no field was removed or changed.

**What to change:** If you read `kickoff_date_passed` as "the game is over", read `game_ended` instead. A pending leg with `game_ended` or `market_closed` true is waiting on its result. A pending leg with `game_ended` null is unknown, not finished.

**November 15, 2026**

Game market sharp money: a line with no trade keeps its figures for up to 15 minutes

[`GET /api/v1/games/{event_slug}/markets`](https://docs.0xinsider.com/api-reference/endpoint/list-game-markets) with `expand=sharp_money` now keeps a line `computed` for up to 15 minutes after its positions were read, as long as the line has not traded since that read. Before this change, every line turned `unavailable` 5 minutes after its read, traded or not, and at a busy hour many lines turned `unavailable` before they could be read again.

* `money_as_of` still dates the read, so on a `computed` line it can now be up to 15 minutes old.
* A line that trades is read again, or turns `unavailable`, within about 5 minutes of the trade.
* `usd` is valued at the price when the figures were computed, so on an older line it can differ from the line's price now.
* The `list_game_markets` tool on the remote MCP endpoint returns the same figures.

**Backward compatible.** No field was added, removed or renamed; more lines read `computed` where they read `unavailable` before.

**What to change:** Nothing. If you need a recent read, check `money_as_of` before you use a line's figures.

**November 15, 2026**

Combo leg markets carry the kickoff and whether that date has passed

Each leg market on [`GET /api/v1/combos/fills`](https://docs.0xinsider.com/api-reference/endpoint/list-combo-fills) and [`GET /api/v1/combos/{condition_id}`](https://docs.0xinsider.com/api-reference/endpoint/get-combo) now carries `game_start_time` and `kickoff_date_passed`. Before this change a client could not tell a pick whose kickoff date has passed from one that kicks off today, and a postponed game's question can still show the earlier date.

* `game_start_time` is the kickoff stored on the market, in UTC. It is null when the leg has no local market or the market has no kickoff.
* `kickoff_date_passed` is true only when that kickoff's calendar date is before today (UTC). It is false on the kickoff's own date, including while the game is in play, and false when there is no kickoff.
* `state` stays `pending` until the market resolves. `kickoff_date_passed` does not change the result.
* The `get_combo_fills` and `get_combo` tools on the remote MCP endpoint return both fields, and the next `@0xinsider/sdk` release types them on the leg market.

**Backward compatible.** Two fields are added to each leg market; no field was removed or changed.

**What to change:** Nothing. To tell a past-date open pick from one that kicks off today, read `kickoff_date_passed` and `game_start_time`, not the date in the question.

**November 15, 2026**

Game sharp money: a side with too little graded money before kickoff answers withheld

[`GET /api/v1/games/{event_slug}/sharp-money`](https://docs.0xinsider.com/api-reference/endpoint/get-game-sharp-money#verdict) now answers `verdict.kind: "withheld"` before kickoff when the side an `all_on` or `leans` verdict would name holds too little graded money to carry a claim. `outcomes[].usd`, `pct` and `is_leader` stay set, so the response still shows where the money is. The same verdict appears on [List games](https://docs.0xinsider.com/api-reference/endpoint/list-games.md) with `expand=sharp_money`, and in the `get_game_sharp_money` and `list_games` tools on the remote MCP endpoint and in `@0xinsider/mcp`.

Before this change, such a game answered `all_on` or `leans` on any amount of graded money. In games that kicked off from November 2 to 14, more than half the sides named before kickoff held that little, and those sides won about as often as their prices said.

* `lifecycle` stays `live`, and no other field changes.
* `leans_over_price` and `no_clear_lean` are unchanged.

**Backward compatible.** `withheld` is an existing value, and no field was added or removed.

**What to change:** Nothing. To show the leading side on these games yourself, read `is_leader` and `usd`.


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