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

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

# List settled markets

> List the sports and esports game markets that settled since a time, oldest first, each row the object the market_settled webhook sends.

Use this endpoint to catch up on settlements after your server was down, or to poll for them instead of receiving the [`market_settled`](https://docs.0xinsider.com/api-reference/webhooks/market-settled) webhook. Each row is the `data` object that webhook sends. To read one game's markets and their current settlement, use [List game markets](https://docs.0xinsider.com/api-reference/endpoint/list-game-markets.md).

Every plan with an API key can read it. The webhook, which pushes the same rows to your server, is Pro and Max only.

## Parameters

| Parameter | Meaning |
| - | - |
| `since` | Required without `cursor`. An RFC 3339 time. The list starts with the first settlement we recorded at or after it. A missing or unreadable value is a `400` with `error.reason` `invalid_query` and `error.param` `since`. |
| `sports_market_type` | Optional. A comma-separated list of Polymarket market types to keep, such as `moneyline`, `spreads`, or `totals`, at most 64. Matching is case-insensitive. The default is `moneyline`, or every type when you send `condition_id`. `*` keeps every type, including markets with no type. |
| `league` | Optional. A comma-separated list of leagues to keep, as the rows' `league` spells them, such as `nba`, `epl`, or `pga`, at most 32. Each starts with a letter and holds no hyphen; any other value is a `400` with `error.param` `league`. The default is every league. |
| `condition_id` | Optional. A comma-separated list of market condition ids to keep, at most 20. Each is `0x` and 64 hex digits, matched case-insensitively. Use it to check whether one market settled. Any other value, or a 21st id, is a `400` with `error.param` `condition_id`. |
| `event_slug` | Optional. A comma-separated list of event slugs to keep, at most 10, matched exactly. Use it to read every settled market of one game. An 11th slug is a `400` with `error.param` `event_slug`. |
| `limit` | Optional. How many rows to return, from 1 to 100. The default is 20, and a value outside the range is clamped. |
| `cursor` | Optional. The `next_cursor` value from an earlier response. It replaces `since` and keeps the filters it was issued with. You can leave the filters out; if you send them, they must match the cursor's, or the read is a `400` with `error.reason` `cursor_expired`. |

The filters work like the webhook's `settlement_filters`: `condition_id` and `event_slug` are its `condition_ids` and `event_slugs`. When you send both, a row must match both. A Polymarket `polyv2` copy of a game has its own condition ids and its own slug, such as `polyv2-nba-phi-chi-2026-11-08`. Name one of those to list the copy; naming the original game's slug does not list it. A PGA Tour event slug starts with a year, such as `2026-world-wide-technology-championship`, so its markets have the league `pga`. A row whose `league` is `null` never matches a `league` filter.

## Key response fields

| Field | Meaning |
| - | - |
| `data[]` | The settlements, oldest first by `settlement.observed_at`, then `settlement_id`. Each row has the same fields as the `market_settled` webhook's `data`. |
| `data[].condition_id`, `settlement_id` | The market, and the id of this settled state. A market can appear more than once, as a resolved question with no winner yet, with the winner Polymarket's ConditionalTokens contract paid, and as Polymarket's row with payouts, each with its own `settlement_id`. The list includes two states the webhook does not send: one we first saw more than 6 hours after the market resolved, and one that names a winner an earlier state already named. |
| `data[].event_slug`, `game_id`, `league`, `sports_market_type` | The game the market belongs to, its league (the first part of its event slug, or `pga` for a PGA Tour market), and Polymarket's market type, as they stood when we recorded the settlement. They stay on the row after the market closes. A settlement recorded before November 8, 2026 reads them from the market as it stands now, and reads `null` where we no longer hold that market. |
| `data[].outcomes` | Each outcome name at its index, recorded with the other market fields. `outcomes[settlement.winning_outcome_index]` names the winner. Empty on an older settlement whose market we no longer hold. |
| `data[].settlement` | The same object [List game markets](https://docs.0xinsider.com/api-reference/endpoint/list-game-markets.md) serves: `payouts` per share in micro-USDC in outcome order (`1000000` is \$1), `result` (`outcome`, or `split` for a 50-50), `winning_outcome_index`, `was_disputed`, `resolved_at` (`null` on a resolved oracle question), `oracle_updated_at` (when Polymarket last changed the oracle state; on an oracle question, when its answer settled it), and `observed_at`, when we first saw this state. |
| `data[].copy_of_event_slug` | On a Polymarket `polyv2` copy of a game, the original game's event slug. Without `condition_id` or `event_slug`, a copy whose original has a moneyline market is left out, as the webhook leaves it out of a filter that does not name it, so this is `null`. A copy you name is listed with it. |
| `data[].protocol_version` | The Polymarket protocol the market settles and redeems on: `v1`, or `v2` for the Protocol V2 markets: any market whose Gamma version reads `v2`, the `polyv2` copies included. The `market_settled` webhook and the `MarketSettled` stream frame carry the same value. |
| `complete_through` | The newest time the list covers, 2 minutes before the read. We record a settlement a few seconds after we observe it, so the list holds back the last 2 minutes. A row observed at or before this time is never added behind your cursor later. |
| `has_more` | `true` when more rows up to `complete_through` remain: read `next_cursor` now. `false` when you have read up to `complete_through`. |
| `next_cursor` | Always present. When `has_more` is `false`, keep it and read it again later: it returns only what we record after this page. |

A page can hold fewer than `limit` rows, or none, while `has_more` is `true`: a page that has not filled up after about 120 ms of reading stops and continues on the next page. Keep reading `next_cursor` until `has_more` is `false`.

If the first read of a page misses our 200 ms read deadline, the response is a `503` with `error.reason` `read_model_warming` and `Retry-After: 1`. Send the same request again after it.

## Example

Every moneyline that settled in the NBA or the Premier League since 18:00 UTC on November 7, 2026:

```bash theme={null}
curl -sS \
  -H "Authorization: Bearer $OXINSIDER_API_KEY" \
  'https://api.0xinsider.com/api/v1/markets/settled?since=2026-11-07T18:00:00Z&league=nba,epl&limit=100'
```

Whether one market settled, at every market type:

```bash theme={null}
curl -sS \
  -H "Authorization: Bearer $OXINSIDER_API_KEY" \
  'https://api.0xinsider.com/api/v1/markets/settled?since=2026-11-09T00:00:00Z&condition_id=0x01540d2cdf1385a16149e77cc33b73ba8d000000000000000000000000000000'
```

Then read the next page with the cursor alone:

```bash theme={null}
curl -sS \
  -H "Authorization: Bearer $OXINSIDER_API_KEY" \
  "https://api.0xinsider.com/api/v1/markets/settled?cursor=$NEXT_CURSOR"
```

The `list_settled_markets` MCP tool calls this endpoint with the same parameters, and so does the TypeScript SDK's `listSettledMarkets()`, from `@0xinsider/sdk` 0.44.0. The [settlement notifier recipe](https://docs.0xinsider.com/recipes/settlement-notifier.md) uses this endpoint to catch up after downtime.

## What it does not return

* Markets that are not part of a sports or esports game. The list holds the game markets we record settlements for.
* Settlements before November 7, 2026, 16:48 UTC, when we started recording them. A market that settled earlier appears only if a later read recorded it, with that read's time as `observed_at`.
* The market's question or label. Read it from [List game markets](https://docs.0xinsider.com/api-reference/endpoint/list-game-markets.md) by `event_slug`.
* Settlements newer than `complete_through`. Read `next_cursor` again later for them.

## Caching

The response carries a weak semantic `ETag`. Send it back as `If-None-Match` for a `304` with an empty body. `request_id` and `cost` are excluded from the validator.


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