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

# Edge Hunter

> Select Max-only Edge Hunter markets by sport, league, type, and identity across the board, signals, and observations.

Edge Hunter combines the quoted sports board, ranked signals, and observation cohorts under one endpoint. Every view requires Max. A valid Pro credential returns `403 forbidden` with `error.reason: max_plan_required`.

## Choose a view

| `view` | Response | Use it for |
| - | - | - |
| `board` (default) | `object: "edge_hunter"`, rows in `data.rows` | The full quoted board shown on [Edge Hunter](https://0xinsider.com/sports/edge): up to 30 globally ranked pre-game markets, with optional selection and grade filters. |
| `signals` | `object: "list"`, `view: "signals"`, rows in `data` | Ranked pre-game records with token IDs, category-skill evidence, filters, and cursor pagination. |
| `observations` | `object: "list"`, `view: "observations"`, rows in `data` | Wider-holder, in-play, or emerging-pile measurements with token IDs, price marks, freshness, and funnel evidence. |

Every row of every view carries `protocol_version`: `v1` (CTF) or `v2` (Protocol V2), read from the row's `condition_id`. On a `v2` market the row's token ids are Protocol V2 position ids: sign their orders for ExchangeV3 and read their balance as `CONDITIONAL-V2`.

Omitting `view` keeps the board envelope. Advanced views return a different envelope; select the view before reading the response. Every returned row adds provider identity under `market_context`.

To read the website's Max board, use `view=board`, the same kickoff horizon, the default `B` floor and 30-row limit, and no selection filters. Website `horizon=24` maps to API `horizon_hours=24`. The website's Cards and Table choices change layout; they are not API data views.

The website and API share the full board projection. Read the returned ranking and quote clocks when comparing separate requests; independently refreshed quotes need not have identical values. The API requires a ready snapshot and can return a warming response while the website's session route refreshes its data.

The board maintains bounded live quote coverage for its default ranked markets. Requests with selection filters also renew coverage for the rows they return, within the shared subscription limits and expiry.

The board reads quotes from verified display-price and websocket caches without making inline CLOB REST requests. A market's first quote can still be `current_price: null` while an order-book update is pending. Retained quotes keep their original observation clock and retention limit.

## Parameters

| Parameter | Board | Signals | Observations |
| - | - | - | - |
| `horizon_hours` | Default 48; integer values clamp to 1 to 48. | Default 12; integer values clamp to 1 to 48. | Rejected. The pre-game universe is fixed at 48 hours; in-play uses a 12-hour kickoff lookback. |
| `category` | Optional canonical sport or provider alias. | Optional canonical sport or provider alias. | Optional canonical sport or provider alias. |
| `min_grade` | `S`, `A`, or `B`; default `B`. | `S`, `A`, or `B`; default `B`. | Rejected. |
| `cohort` | Rejected. | Rejected. | Required: `wider_holder`, `in_play`, or `emerging_pile`. |
| `admission` | Rejected. | Rejected. | Optional, with `cohort=wider_holder` only: `most_held_48h`, `most_held_48h_by_type` with `market_types`, or `most_held_48h_min_25_usd`. See [Most-held selection](#most-held-selection), [Most-held selection by market type](#most-held-selection-by-market-type) and [Most-held selection above a position floor](#most-held-selection-above-a-position-floor). |
| `limit` | Default 30; integer values clamp to 1 to 30. | Default 20; integer values clamp to 1 to 100. | Default 20; integer values clamp to 1 to 100. |
| `cursor` | Rejected. | Returned `next_cursor`. | Returned `next_cursor`. |

A parameter belonging to another view returns `400`. Unknown query names use the API's normal compatible validation: they are ignored and reported in `X-Query-Ignored`. Send `X-Query-Validation: strict` to reject unknown names.

Raw provider categories resolve to canonical sports; a non-sport category returns an empty collection. In the board and signals views, `min_grade=S` requires at least one S holder on the backed side, and `A` requires an S or A holder. This filter does not remove lower-grade holders from the recorded pile or recompute its backing share.

## Shared market selection

These optional selectors apply to all three views. Omit them to keep the existing scope.

| Selector | Meaning |
| - | - |
| `kind` | Select `sports` or `esports`. Omit it for both. |
| `sports` | Select canonical sport buckets such as `Football`, `Soccer`, or `Esports`, ignoring case. Unknown names and league aliases such as `NFL` return `400`. |
| `leagues` | Select normalized league identities such as `nfl` or `cs2`. Copy authoritative values from `market_context.league`. |
| `market_types` | Select provider market types, such as `moneyline`, using metadata rather than words in a title. |
| `condition_ids` | Select specific markets by raw provider `condition_id` or an existing `mkt_` market ID. Market IDs normalize to raw condition IDs. |
| `event_slugs` | Select provider event identities returned by the game catalog or market discovery. |
| `series_slugs` | Select provider series identities. A display label is not a series key. |

Repeat a list parameter or put comma-separated values inside it. Each list accepts 1 to 100 values before duplicate removal. Omit an axis to leave it unselected; SDK empty arrays fail before a request is sent.

Use bare names such as `sports=Football&sports=Basketball`; bracket notation such as `sports[]=Football` returns `400`.

Lists are normalized, deduplicated, and sorted. Sport, kind, and league matching ignores case; event, series, and market-type identities match case-sensitively. A row must match any value within each supplied list and every supplied selector across lists.

Unknown well-formed market IDs or provider identities return an empty result. An empty list, unsupported canonical sport, or ID for another entity type returns `400`. Omit an axis to leave it unselected.

For example, `sports=Football&sports=Basketball` selects either sport. Adding `leagues=nfl` also requires that league. Only records matching the combined selection are returned. Do not interpret an empty selected result as proof that no backing exists.

The legacy `category` parameter keeps its canonical bucket meaning. `category=NFL` reaches `Football`, including other football leagues; use `leagues=nfl` for league selection. Esports aliases similarly reach the whole `Esports` bucket; select a verified title identity when you need one title.

## Discover games and market identities

Use [List games](https://docs.0xinsider.com/api-reference/endpoint/list-games.md) to discover the deployment's covered sports and league values. Use those published values rather than guessing from a league display name. They describe that catalog and do not guarantee a matching Edge Hunter record.

Each game's `markets` contains provider `condition_id` values and `mkt_` market IDs. Use [Search markets](https://docs.0xinsider.com/api-reference/endpoint/search-markets.md) when you need a market ID from a title. Copy selector values from Edge Hunter's returned `market_context` for league, series, and market type; the game catalog supplies coverage and game/market identities.

## Provider market context

Every row exposes `market_context` in all three views. An older cached snapshot can have a `null` object; when present, its four fields are required and nullable. These are provider-backed identities, with `null` for unavailable values.

| Field | Meaning |
| - | - |
| `market_context.league` | The normalized league identity to use in `leagues`. |
| `market_context.series_slug` | The exact provider series identity to use in `series_slugs`. |
| `market_context.market_type` | The exact provider market type to use in `market_types`. |
| `market_context.metadata_updated_at` | When 0xinsider's stored market metadata was updated. It is not a provider observation time or a ranking, price, observation, or holder clock. |

A league display name, a title keyword, or an event-slug prefix does not establish membership. Copy the returned identities instead of inferring a selector value. Missing identity stays unknown and cannot satisfy a selection on that axis.

For sports, a recognized provider season series can identify the league when explicit league metadata is absent. The series must belong to the row's canonical sport, and an explicit league identity takes precedence. Without explicit league metadata, an unrecognized or sport-inconsistent series leaves `league` as `null`.

For esports, a recognized game series determines the game identity even when the provider's league metadata names a tournament. The Counter-Strike match series reports `cs2`; a title keyword or unrelated series does not establish that identity.

If the snapshot lacks ready selection metadata, an explicitly selected request returns `503 read_model_warming` until a refreshed snapshot is available.

A selected response adds a top-level `selection` echo with the normalized requested axes: `kind`, `category`, `sports`, `leagues`, `market_types`, `condition_ids`, `event_slugs`, and `series_slugs`. Unrequested axes are omitted. An unselected default response omits `selection`.

## Default board

By default, the board keeps its existing sports scope and `B` grade floor. It returns up to `limit` ranked rows after the requested selection, grade, and horizon filters. `data.total` counts matching rows before the cap.

`data.unranked` counts the markets the board looked at for your window and selection that got no row, and says why. A market is looked at when an S, A or B wallet made a large trade in it in the last 24 hours, the same way every row was found. `data.total` plus the three counts is every market looked at, so `total: 0` with three zeros means no game in the window drew that trading.

| `data.unranked` field | Meaning |
| - | - |
| `split_holder_pile` | S, A and B money on the two sides is too even to back either side. |
| `no_graded_holders` | No S, A or B wallet holds either side now. |
| `below_grade_floor` | One side is backed, but no wallet on it is at or above `min_grade`. |

`data.unranked` is `null` only on a snapshot built before the counts existed, which the board can serve for a few minutes after the November 2026 release that added them.

`data.viewer` is `max`, `data.free_rank` is `null`, and every returned row has `state: "full"` and `free: false`.

Read `data.as_of` for the ranking clock, `ranking_source` for a live or stored-position fallback, and `directional_source` for the directional read's state. Each row includes market and event identity, participants, outcomes, and backed-side analytics under `signal`. Available `current_price` quotes carry a decimal-string `price`, `basis`, epoch-millisecond string `ts`, and optional `validated_at`.

| Board field | Meaning |
| - | - |
| `outcomes[].token_id` | The nullable provider token ID for that outcome. Outcomes stay in provider order; they are not reordered around the backed side. |
| `signal.token_id` | The nullable token ID for the backed outcome. You can use it without another market-snapshot request. |
| `signal.ranked_at` | The frozen ranking timestamp for this row. It does not become the time of a refreshed quote or your API request. |
| `signal.category_skill` | The existing aggregate category evidence for the backed holders. Read its status and coverage before interpreting its nullable measurements. |

These fields are required when their containing outcome or full signal is present. A missing token ID remains `null`; it is not an empty or invented identifier. `category_skill.as_of` dates category evidence separately from `signal.ranked_at` and quote `ts`.

The category object includes coverage counts, covered backing, aggregate category measurements, and concentration evidence. It adds context without changing which markets qualify, their order, or the grade floor. It contains aggregate evidence rather than a list of holder identities.

Read `canonical_category` and `source_coverage` for the evidence's scope. A league filter selects rows; it does not redefine or recompute their category evidence.

`signal.sharp_pct` is a fraction: `0.81` means 81%. `graded_holders` combines the S/A/B holder counts. `volume` is provider taker volume in shares, not cash traded.

## Ranked signals

Use `view=signals` to retain the old ranked-feed capabilities. Rows include `condition_id`, the backed outcome's nullable `token_id`, `side`, `ranked_at`, holder counts and dollars, backing scores, directional measurements, and `category_skill` evidence.

The signals view adds ranking and directional provenance under `meta.ranking_source` and `meta.directional_source`.

Directional measurements recognize a fresh complete position observation even when position balances did not change, provided that observation covers the positions. Missing, stale, or unclassifiable evidence can still leave the measurements unknown; `null` does not mean zero. A snapshot's `directional_source` reports whether its read succeeded, not whether every row has a directional measurement.

Read `data` in server order. Use `has_more` and `next_cursor` to continue, keeping the same view and normalized selectors and filters. The cursor binds the source snapshot, normalized selection, and row ordering. An expired or replaced snapshot requires restarting from page one; cursors from the retired routes must also be replaced.

The compatibility fields `piled_side`, `signal_created_at`, and `smart_score` remain on the wire alongside their canonical names `side`, `ranked_at`, and `side_share`. `piled_outcome_index` selects the provider's binary outcome column; it does not identify a home/away team. Use the market title and event context with the side label.

## Observation cohorts

| `cohort` | Meaning |
| - | - |
| `wider_holder` | Pre-game holder piles that `view=signals` does not list at its widest request (`horizon_hours=48`, `min_grade=B`, no selector). A market `view=signals` lists leaves `wider_holder`, and becomes a `wider_holder` market again in the first snapshot after `view=signals` stops listing it, so until kickoff you can read a market in one of the two views. Directional evidence can be unavailable; read its status. |
| `in_play` | Provider-confirmed live games whose original live source is no more than 30 seconds old. Snapshot reuse cannot extend that source limit (see [Snapshot availability](#snapshot-availability)). Unavailable provider-live, holder, or directional evidence fails closed. |
| `emerging_pile` | A projection of `wider_holder` with finite `sharp_pct` in `[0.75, 0.85)`, complete holder scans, and a kickoff after the pinned projection cutoff. It overlaps `wider_holder`; it is not a separate population or holder-arrival history. |

Each snapshot evaluates at most 8 markets per sport and cohort, 4 per event, and 168 in all. `wider_holder` adds a second group of up to 8 markets per sport, under the same per-event and overall limits. Markets beyond these limits count in `coverage.capacity_limited_markets`.

* The first `wider_holder` group takes the soonest kickoffs, and among markets with the same kickoff, the most graded holders first. A market in this group stays evaluated until its game starts, unless `view=signals` lists it.
* The second `wider_holder` group takes the markets with the most graded holders among the rest that kick off within 24 hours, so these markets show up to a day before kickoff. A market in this group keeps its place in later snapshots until its game starts, so a market with more graded holders waits for a free place. It gives its place up when its holder read shows no observation: its graded holders split, no current graded holder is found, or its price is unavailable. A holder read that does not finish in time does not cost it its place.
* `in_play` takes the markets with the most graded holders first.

Each row's `admitted_by` names the group that evaluated it: `most_held` for the second `wider_holder` group and for every `in_play` row, `soonest_kickoff` for the first `wider_holder` group. An `emerging_pile` row carries the value of the `wider_holder` row it projects. Filter on `most_held` to keep the most-held selection.

### Most-held selection

Add `admission=most_held_48h` to a `cohort=wider_holder` request to get a different selection instead of the default one. Per sport, it takes up to 8 `wider_holder` markets that kick off within 48 hours, ordered by the most `indexed_graded_holders`, then the most volume, then the soonest kickoff, with at most 4 per event. Every market type ranks in the same queue; [How far a market was from a most-held place](#how-far-a-market-was-from-a-most-held-place) gives the full order and the fields that show each row's place in it. This is the selection the observations view used before October 17, 2026.

Every row carries `indexed_graded_holders`: the S, A, and B graded wallets in the 0xinsider index that hold either outcome of the market. That is the count the selection ranks by, so check the selection against it. `graded_holders` counts the S, A, and B holders of the row's `side` only, from Polymarket's holder list, and can be larger or smaller.

`rank` does not follow either count. It orders the selected rows by `directional_rank_score`, highest first, as in the default selection.

The selection is made again on every snapshot and keeps no places, so a market with more graded holders takes the place of one with fewer. The default response does not change when you use it. Each sport keeps its 8 places however many markets the default selection takes.

The selection skips markets that are no longer a contest. When Polymarket's live sports data marks a game postponed, cancelled, suspended, or final, every market of that game is skipped, including its exact score, half-time, and other side markets. A market on the game's main Polymarket event, such as a team-win market, is also skipped when its Yes price is 0.02 or lower, or 0.98 or higher.

A skipped market counts as `provider_excluded`, not `capacity_limited`. A lopsided market priced between those bounds, such as a 0.04 underdog, still ranks by its graded holders.

| Field | With `admission=most_held_48h` |
| - | - |
| `data` | Only the selection's rows. Every row has `admitted_by: "most_held_48h"`, also when the default selection evaluates the same market. |
| `admission` | `most_held_48h`, echoed at the top level. A default response has no `admission` field. |
| `indexed_graded_holders` | The count the selection ranks by, on every row. `rank` orders rows by `directional_rank_score` instead. |
| `funnel`, `coverage`, `degraded`, `degradation_reasons` | Describe this selection. A `wider_holder` market it does not take counts as `capacity_limited`, or as `provider_excluded` when the selection skips it. |
| `holder_snapshot_at` | Up to 15 minutes old, or up to 30 minutes for a market more than an hour before kickoff that has had no trade since that read. A market only this selection takes is read at most once every 10 minutes. One with no holder read to serve is read right after every default market with none, before default markets whose last read still serves. |

Any other view or cohort returns `400` with `error.param: "admission"`. Cursors and `ETag` values bind `admission`, so keep it on every page and conditional read.

### Most-held selection by market type

`admission=most_held_48h` ranks every market type together, and `market_types` filters the rows afterwards. A type whose markets hold fewer wallets than the team-win markets of the same games can then return no rows: on November 3, 2026, Soccer had 286 `totals` candidates, and none made the 8 places.

Add `admission=most_held_48h_by_type` with `market_types` to run the same rule within each type you name. Per sport and per `market_context.market_type`, it takes up to 8 `wider_holder` markets that kick off within 48 hours, ordered by the most `indexed_graded_holders`, then the most volume, then the soonest kickoff, with at most 4 per event. Soccer totals: `admission=most_held_48h_by_type&market_types=totals&category=Soccer`.

| Field | With `admission=most_held_48h_by_type` |
| - | - |
| `data` | Only the selection's rows. Every row has `admitted_by: "most_held_48h_by_type"`. |
| `admission` | `most_held_48h_by_type`, echoed at the top level. |
| `departures` | Not included. |
| `funnel`, `coverage`, `degraded`, `degradation_reasons` | Describe this selection. A `wider_holder` market it does not take counts as `capacity_limited`, or as `provider_excluded` when the selection skips it, on the same rule as `admission=most_held_48h`. |
| `holder_snapshot_at` | Up to 15 minutes old, or up to 30 minutes for a market more than an hour before kickoff that has had no trade since that read. A market only this selection takes is read at most once every 10 minutes, in the same order, taking turns with the markets only `admission=most_held_48h` takes. |

`market_types` is required, and each value is 1 to 64 lowercase letters, digits or underscores, as `market_context.market_type` returns them. A missing or malformed value returns `400` with `error.param: "market_types"`. The snapshot computes only the sport and type pairs someone asked for in the last 30 minutes. The first request for a new pair returns `503` with `error.reason: "read_model_warming"` and `Retry-After: 45`; retry after that wait. A request with no category needs its own pairs, so it can also wait once. Neither the default response nor `admission=most_held_48h` changes.

### Most-held selection above a position floor

`indexed_graded_holders` counts every S, A and B graded wallet holding the market, so a wallet with $2 in it counts the same as one with $10,000. Add `admission=most_held_48h_min_25_usd` to run the `admission=most_held_48h` rule counting only the graded wallets whose position in the market is worth \$25 or more, both outcomes together, at the value the 0xinsider index last read for the wallet. Per sport, it takes up to 8 `wider_holder` markets that kick off within 48 hours, ordered by the most `indexed_graded_holders_min_25_usd`, then the most volume, then the soonest kickoff, then the lowest `condition_id`, with at most 4 per event. Soccer: `admission=most_held_48h_min_25_usd&category=Soccer`.

| Field | With `admission=most_held_48h_min_25_usd` |
| - | - |
| `data` | Only the selection's rows. Every row has `admitted_by: "most_held_48h_min_25_usd"`. |
| `indexed_graded_holders_min_25_usd` | On each row: the count the row was ranked by, never more than its `indexed_graded_holders`. Only this admission returns it. |
| `admission` | `most_held_48h_min_25_usd`, echoed at the top level. |
| `most_held_48h_position`, `most_held_48h_cutoffs` | This selection's own places and last markets, ranked by `indexed_graded_holders_min_25_usd`; each cutoff also carries `indexed_graded_holders_min_25_usd`. |
| `departures` | Not included. |
| `funnel`, `coverage`, `degraded`, `degradation_reasons` | Describe this selection, on the same rule as `admission=most_held_48h`. |
| `holder_snapshot_at` | As for `admission=most_held_48h_by_type`. A market only this selection takes is read at most once every 10 minutes, after the markets only the other two selections take. |

The snapshot computes this selection only for the sports, and the no-category scope, someone asked for with it in the last 30 minutes. The first request for a new one returns `503` with `error.reason: "read_model_warming"` and `Retry-After: 45`; retry after that wait. The floor is part of the value: a different floor would be a new `admission` value, so a recorded row always says which rule took it. Neither the default response, `admission=most_held_48h` nor `admission=most_held_48h_by_type` changes.

### How far a market was from a most-held place

`admission=most_held_48h` puts every `wider_holder` market of a sport in one queue, whatever its market type. No type is weighted, and none is dropped before ranking. The queue is ordered by these values, each one breaking ties in the one before:

1. The most `indexed_graded_holders`.
2. The most `volume`.
3. The soonest `game_start_time`.
4. The lowest `condition_id`.

A market is skipped when its event already holds 4 markets of the queue. Side markets such as totals and exact score count toward the event of their main game, so a soccer game's team-win markets often fill most of its 4. The first 8 markets of the queue are the selection, and `market_types` only filters them afterwards.

Both `admission=most_held_48h` and `admission=most_held_48h_by_type` responses tell you where each row stands in that queue:

| Field | Meaning |
| - | - |
| `most_held_48h_position` | On each row: the market's place in its sport's queue, counted from 1, from the same snapshot that selected it. Places 1 to 8 are `admission=most_held_48h` markets. A place of 14 means the sport would need 14 places for this market to get one. `null` means the market has no place, because its event already held 4 markets ranked above it. |
| `most_held_48h_cutoffs` | At the top level: one entry for each sport the response covers, which is the one sport `category` names or every sport without it. Each entry names the last market `admission=most_held_48h` took, the 8th when it takes 8, with its `position`, `condition_id`, `indexed_graded_holders`, `volume`, and `game_start_time`. |

A `totals` row with `most_held_48h_position: 14` and 11 `indexed_graded_holders`, against a Soccer cutoff with `position: 8` and 15 `indexed_graded_holders`, needed 6 more places, or at least 4 more graded holders to rank level with the last market in. A market whose holder read ended without a card, such as a split holder pile, keeps its place, so the places on `admission=most_held_48h` rows can skip numbers, and the cutoff market can be missing from `data`. A default response has neither field, and a snapshot from before November 13, 2026 omits both until the next refresh.

### Departures

A `cohort=wider_holder` response, with or without `admission=most_held_48h`, includes `departures`. It lists each market whose `wider_holder` card was in an earlier snapshot of the same selection, is not in this one, and whose game has not started. Use it to learn why a card you saw is gone.

| Field | Meaning |
| - | - |
| `condition_id` | The market's Polymarket condition id. |
| `event_slug` | The event's slug, or `null`. |
| `category` | The sport the departed card carried. |
| `admitted_by` | The departed card's `admitted_by`. On an `admission=most_held_48h` response it is `most_held_48h`. |
| `game_start_time` | The kickoff the departed card carried. The entry leaves the list once this time passes. |
| `last_observed_at` | The departed card's `observed_at`: when the card was last evaluated. |
| `departed_at` | The `snapshot_as_of` of the first snapshot without the card. |
| `reason` | Why that snapshot had no card for the market, as an `EdgeHunterObservationTerminalReason`. |

| `reason` | What happened to the market |
| - | - |
| `primary_slate_candidate` | `view=signals` lists it at its widest request. Read it there. |
| `split_holder_pile` | Its graded holders split between the sides. |
| `no_current_graded_holder` | Its holder read found no current graded holder. |
| `capacity_limited` | It lost its evaluation place without another outcome, for example to a market with more graded holders under `admission=most_held_48h`. |
| `holder_deadline_unavailable` | Its holder read did not finish in time. The card often comes back in a later snapshot; if it does not, a later answer replaces this reason. |
| `provider_excluded` | Polymarket excluded the market. Under `admission=most_held_48h`, it can also mean that its game is postponed, cancelled, suspended, or final, or that its Yes price is 0.02 or lower, or 0.98 or higher. See [Most-held selection](#most-held-selection). |
| `resolved`, `provider_closed`, `outside_horizon` | The market resolved or closed, or its kickoff moved outside the 48-hour window. |
| `missing_stored_market` | 0xinsider no longer has a record of the market. |

Only `reason` can change while an entry stays in the list, in two cases:

* From a read that did not finish to an answer. If an entry departed with `holder_deadline_unavailable`, `provider_unavailable`, `holder_computation_unavailable` or `internal_unclassified`, a later snapshot replaces that reason with the market's actual outcome, for example `split_holder_pile`.
* To or from `primary_slate_candidate`, as `view=signals` starts or stops listing the market. A later snapshot that excludes the market sets `primary_slate_candidate`; one that no longer excludes it sets that snapshot's outcome for the market. A snapshot whose `signals_as_of` is `null` changes neither.

Any other reason stays. `departed_at` and the other fields never change. The entry leaves at its `game_start_time`, or as soon as the market has a card again. If the card leaves again later, that is a new entry.

The list is ordered newest `departed_at` first and holds at most 336 entries; when more are open, the oldest leave first. It follows the same `category` and selectors as `data`, is the same on every page of one snapshot, and is part of the `ETag`.

`departures` is omitted on `in_play` and `emerging_pile`, and on a snapshot that could not establish its departures. Treat a missing field as unknown and an empty array as no departed cards. If 0xinsider loses its record of earlier snapshots, the list starts empty again.

### Which signals snapshot a response excluded

Every observations response carries `signals_as_of`: the `ranked_at` of the `view=signals` snapshot whose listed markets this snapshot excluded from `wider_holder` as `primary_slate_candidate`. Each snapshot reads it when it starts, so for up to one snapshot after `view=signals` refreshes, `signals_as_of` can be older than the `ranked_at` you read from `view=signals`. To compare the two views, read both and keep the pair whose times match.

`signals_as_of` is `null` when no `view=signals` snapshot could be read, the same outage in which `view=signals` returns `503 read_model_warming`. That snapshot excluded no market: every market is a `wider_holder` candidate, and the funnel counts no `primary_slate_candidate`. The field is omitted on an unmappable legacy `category`.

The response includes `snapshot_as_of`, snapshot-wide `degraded`, and per-sport `funnel` diagnostics alongside the paginated `data`. The funnel accounts for the source generation and category scope; it is not a count of records after league, type, or identity selection. An empty collection and the funnel explain the measured result; missing coverage is not evidence that no market or backing exists.

Rows retain `token_id`, `event_id`, `parent_event_id`, `observed_at`, `backed_price`, provider-read source, `holder_scan_complete`, `holder_snapshot_at`, directional status, and the underlying holder and directional measurements. `observation_only` is always `true`.

Observation `meta` contains standard request and cache metadata. Use `snapshot_as_of`, row `observed_at`, `holder_snapshot_at`, and `provider_read_source` for observation clocks and provenance. Ranked-source fields are not required on observations.

An incomplete holder scan gives a positive lower bound. `holder_snapshot_at` is the original provider completion time, including on a cache hit; it is not the time your request read the cache. Observation cursors also bind the cohort, `admission`, and, for `emerging_pile`, the first page's projection cutoff.

A row can carry an older holder read when the latest refresh could not finish a new read for its market, or the new read failed. A `wider_holder` or `emerging_pile` row can carry a read up to 15 minutes old. An `in_play` row can carry a read up to 10 minutes old, and that older read is always one taken after the game went live and after that market's own kickoff. Both limits are counted when the snapshot is computed. The row then keeps the older read's `holder_snapshot_at`, and `provider_read_source` is `cached`. Once a market's own kickoff has passed, no `in_play` row with `provider_read_source: "cached"`, older or recent, carries a holder read taken before it.

A `wider_holder` or `emerging_pile` market that kicks off more than an hour later is read again only when its last read is 10 minutes old. Until then its row carries that read, with the read's own `holder_snapshot_at` and `provider_read_source: "cached"`. While the market has had no trade since that read, the row keeps carrying it, with no new read, until the read is 30 minutes old. This applies to the default selection and to both most-held selections.

A `wider_holder` market in the default selection that kicks off within the hour is read again about every three minutes while it trades. While it has had no trade since its last read, its row keeps carrying that read, with the read's own `holder_snapshot_at` and `provider_read_source: "cached"`, until the read is 10 minutes old; then it is read again. The 15-minute limit above does not change.

An `in_play` market is read again about every three minutes while it trades. While it has had no trade since its last read, its row keeps carrying that read, with the read's own `holder_snapshot_at` and `provider_read_source: "cached"`, until the read is 5 minutes old; then it is read again. The 10-minute limit above does not change.

On an incomplete scan, `sharp_pct` describes the observed holder population. It is not a lower bound on the complete population's backing share; holders missing from either side can move that fraction.

## Snapshot quality and coverage

Every observation response includes `degradation_reasons` and `coverage`. Read them before interpreting a small or empty page.

`degraded` describes the shared all-sports snapshot. Category, cohort, league, and market selectors preserve that flag and its reasons, including causes outside your selected records.

Each `degradation_reasons[]` item has a typed `reason` and a canonical `sport`, or `null` when the cause applies to the whole snapshot. The list is empty when the snapshot is not degraded. A clean selected funnel does not clear a reason recorded elsewhere in the snapshot, and one terminal per input cannot represent every incomplete read.

For example, `holder_deadline_unavailable` can remain recorded for one sport while your selected sport's funnel is clean. An emitted `wider_holder` row can also retain `directional_status: "unavailable"` while its terminal remains `wider_holder_emitted`.

| `coverage` field | Scope and meaning |
| - | - |
| `input_markets` | Counts measured source inputs across all sports before category, cohort, or market selection. |
| `capacity_limited_markets` | Counts source inputs outside the bounded holder-work admission. |
| `emitted_observations` | Counts all source `wider_holder` and `in_play` emissions before selection. `emerging_pile` overlaps those records and does not add source emissions. |
| `incomplete_holder_markets` | Counts source markets with incomplete holder scans, including scans that did not produce an observation. Each market's holders come from 1 page of up to 100 per outcome token, so a market with more holders counts here by design. |
| `selected_observations` | Counts records matching your cohort, category, selectors, and applicable projection cutoff before pagination. |
| `returned_observations` | Counts this page's rows and equals `data.length`. |

The first 4 counts stay attached to the whole source snapshot. They are not a census of every provider market or a count of successfully evaluated holders.

A legacy `category` value that cannot resolve to a sport returns an empty result without reading a sports snapshot. All 6 counts are zero and the reason list is empty; those values do not establish the actual all-sports snapshot's health.

`capacity_limited` is intentional admission and does not itself set `degraded`. Pagination returns admitted snapshot records; it cannot recover markets excluded by admission. These limits are unchanged.

The 100-holder page is also an intentional bound and does not set `degraded`. Such a market shows `holder_scan_complete: false` on its row and counts in `incomplete_holder_markets`. The `holder_scan_incomplete` reason is retired and no longer appears in `degradation_reasons`; it remains a funnel terminal.

`board_upcoming_status: "not_configured"` means no upcoming source applies to that sport, not that the provider failed. For configured upcoming supply, read `board_upcoming_status` and `board_upcoming_unavailable_scopes`; live-market failure terminals do not describe the upcoming source.

Each observation reads 1 page of up to 100 holders for each outcome token. A token with more holders leaves `holder_scan_complete` as `false`. The API does not fill the gap from a different position population or describe the scan as complete.

Holder collection has bounded priority and rotates markets awaiting evidence across refreshes. It retains cached observations with their original holder clocks; it does not guarantee that every admitted market has current or complete evidence in each snapshot. Ranked views keep their existing rules.

A market before kickoff whose new holder read does not finish serves its last read for up to 15 minutes, or up to 30 minutes when it kicks off more than an hour later and has had no trade since that read. After that without a new read, it ends as `holder_deadline_unavailable`. A provider error is never covered by an older read.

A complete holder scan does not clear unrelated snapshot degradation reasons.

## Cursor recovery

Both advanced views return `400` with `error.reason: cursor_expired` when a valid cursor's selection or filters no longer match, or its snapshot has been replaced. Discard the old cursor and collected rows, and restart from page one. Selected cursors issued before the league identity correction must also be restarted.

A malformed or invalidly signed cursor returns a generic `400 bad_request`. Read `error.param` and `error.message`; waiting will not repair the cursor.

Cursor pagination follows one current snapshot; it is not a historical archive. Save response bodies you need to retain after that snapshot expires.

## Price and freshness clocks

`backed_price` is the aggregate backed-side market midpoint recorded at `observed_at`, not the wallets' executed entry price. The board's current quotes are separate price observations. A missing board quote is `null`; do not substitute zero.

Keep the clocks separate: board `data.as_of` and `signal.ranked_at`, or a ranked-feed row's `ranked_at`, date the ranking snapshot; `category_skill.as_of` dates category evidence. Observation `snapshot_as_of` dates snapshot completion, `observed_at` dates row evaluation, and `holder_snapshot_at` dates the provider holder read. Quote `ts` and optional `validated_at` describe quote state and validation; a cached pre-game ranking can contain a kickoff that has since passed.

## Snapshot availability

All three public API views read warmed snapshots. If the snapshot is unavailable or cannot pass fresh readiness checks, the API returns `503` with `error.reason: read_model_warming` and a 5-second `Retry-After`. Wait before requesting the same view again; a warming response is not an empty complete result.

The `observations` view can keep serving its last snapshot when one scheduled refresh misses its deadline, for up to 45 seconds past its usual snapshot age limit. `meta.cache_age_s` gives the snapshot's age in seconds and `snapshot_as_of` gives its completion time, so check them if you need fresher data. A second missed refresh in a row returns the `503` above.

The snapshot reads a sport's pre-game `wider_holder` holders only while someone asks for them. That means a `wider_holder` or `emerging_pile` request named the sport, or named no category, in the last 30 minutes. The default selection and `admission=most_held_48h` are counted apart, and in-play reads never stop.

If nobody asked for a sport in that time, a request for it returns `503 read_model_warming` with a 45-second `Retry-After`. The same happens to a request without a category while any sport is in that state. The request restarts that sport's holder reads, and the retry returns the same rows as before. A client that reads a sport at least every 30 minutes never gets this `503`. While a sport's holders are not read, its admitted markets count in `coverage.capacity_limited_markets`.

In-play rows additionally require coherent provider-live evidence no more than 30 seconds old, measured from the original source observation. The website's 2-second refresh marker can expire while that evidence remains usable; refreshing the snapshot or reading it from cache does not renew the source clock.

Provider-confirmed live membership is observed independently of rendered scores, quotes, and holder enrichment. A UI score invalidation or refresh becoming due does not invalidate that separate membership evidence. It still requires a complete provider observation with a valid original clock; a complete observation with no matching live game is an observed absence, not an unavailable read.

Invalidated provider sources, incomplete or invalid observations, and missing, future-dated, or expired source clocks are not accepted. These checks use existing background observations; API requests do not start another provider collection.

The source limit applies during computation and every cached in-play read, including the missed-refresh grace period. If a cached in-play snapshot's live source has expired, the API returns `503 read_model_warming` until a fresh snapshot is available. The grace period never extends the live source's 30-second limit.

## Conditional reads

`signals` and `observations` return an `ETag`. Reuse it in `If-None-Match` for the same view, normalized selection, and filters; a semantic match returns `304` with no body. Both advanced views use `Cache-Control: private, no-cache`, so stored responses must be revalidated before reuse. The default board has no `ETag`, pagination, or `304` response.

## Examples

```bash theme={null}
# Quoted 24-hour board, matching the website's 24-hour horizon
curl -sS -H "Authorization: Bearer $OXINSIDER_API_KEY" \
  "https://api.0xinsider.com/api/v1/edge-hunter?horizon_hours=24"

# NFL board with a narrower grade floor
curl -sS -G -H "Authorization: Bearer $OXINSIDER_API_KEY" \
  "https://api.0xinsider.com/api/v1/edge-hunter" \
  --data-urlencode "sports=Football" --data-urlencode "leagues=nfl" \
  --data-urlencode "min_grade=A" --data-urlencode "limit=10"

# Ranked esports signals
curl -sS -G -H "Authorization: Bearer $OXINSIDER_API_KEY" \
  "https://api.0xinsider.com/api/v1/edge-hunter" \
  --data-urlencode "view=signals" --data-urlencode "kind=esports" \
  --data-urlencode "leagues=cs2" --data-urlencode "market_types=moneyline"

# Ranked Soccer signals
curl -sS -H "Authorization: Bearer $OXINSIDER_API_KEY" \
  "https://api.0xinsider.com/api/v1/edge-hunter?view=signals&category=Soccer&min_grade=A&horizon_hours=24&limit=20"

# Wider-holder Soccer observations
curl -sS -H "Authorization: Bearer $OXINSIDER_API_KEY" \
  "https://api.0xinsider.com/api/v1/edge-hunter?view=observations&cohort=wider_holder&category=Soccer&limit=20"

# The most-held Soccer selection over 48 hours
curl -sS -H "Authorization: Bearer $OXINSIDER_API_KEY" \
  "https://api.0xinsider.com/api/v1/edge-hunter?view=observations&cohort=wider_holder&admission=most_held_48h&category=Soccer&limit=20"
```

To select a specific market, copy its `condition_id` or `mkt_` market ID from discovery and send it in `condition_ids`. The response echoes raw condition IDs. Keep the same selection on every cursor page and conditional read.

Use a Max API key or an authorized OAuth token. See [Authentication](https://docs.0xinsider.com/authentication.md).

## Migrate from retired endpoints

| Retired route | Replacement |
| - | - |
| `/api/v1/sports-edge-signals` or `/api/v1/sports/pre-game-sides` | `/api/v1/edge-hunter?view=signals`, preserving supported filters. |
| `/api/v1/sports-edge-observations` or `/api/v1/sports/pre-game-side-observations` | `/api/v1/edge-hunter?view=observations&cohort=…`, preserving supported filters. |

All four old paths return `410 Gone` with `error.code` and `error.reason` set to `endpoint_retired`. Start a fresh pagination sequence on the new route. The default board remains available with no view parameter; use the advanced views for the former feed capabilities.


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