> ## 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. # Pick of the Day > Get the current day's published picks, their frozen prices, and modeled $1,000 returns. Use this endpoint to read picks as they are released. Automatic selections publish 30 to 45 minutes before their own kickoff, once qualification and final checks are complete, and a day can have up to 15 qualifying picks. One game can contribute up to 2 verified compatible selections. The supported pair combines a team's full-game moneyline and handicap selections; each selection still qualifies individually. Same-game picks share exposure and need not be independent. Retain each `pick_id` instead of deduplicating selections by game. Each pick keeps its own entry authorization and expiry. New selections use a neutral presentation order. `publication_order` gives their order within the date; it does not rank their quality. Selections retain their chosen market, side, and identity through release. An explicitly scheduled selection waits for its returned `release_at`. Cancelled or already-started games remain unavailable, and missing market data can delay publication. Later additions fill available slots. Historical order and proofs remain unchanged. Withdrawn picks are excluded from current and dated recommendations, the archive, and its statistics, even after market settlement. The public ledger retains their original identities and proof bytes. When no active pick is available, the endpoint returns `404` with a time for your next read; use that time to schedule a request. For past results, use [Pick of the Day archive](/api-reference/endpoint/get-pick-of-the-day-archive). To verify an unchanged settled pick, use [Pick of the Day ledger](/api-reference/endpoint/get-pick-of-the-day-ledger). ## Key response fields | Field | Meaning | | - | - | | `state` | `full` when entitled, proof-readable picks exist, or `none` when only locked ranks have published. | | `locked_picks[]` | Unauthorized unresolved published or scheduled ranks, containing only `pick_rank` and `required_tier: "max"`. | | `pick_id` | A positive decimal string that identifies this pick. Store it as a string, and use it when you need an identity that survives presentation changes. | | `publication_order` | The pick's neutral presentation slot, retained for the standing selection. It does not express quality or expected return. | | `is_free_selection` | Whether a signed-in free account can read this selection. Read this boolean instead of inferring access from a slot number. | | `supersedes_pick_id` | The stable ID of a replaced selection, or `null` when the pick replaces nothing. | | `pick_rank` | The existing compatibility slot, retained for old consumers. Use `pick_id` for identity and `publication_order` for order. | | `pick_outcome_label` | The backed selection label, ready to display. A total can say `Over 6.5` or `Under 5.5`, including the threshold recorded for that pick. Render the returned label without reconstructing it from the market title. | | `backed_price` | The Polymarket order book midpoint for the backed side at the moment the pick was published, written once. It is not an executed price: a buyer lifts the ask, so your own entry is usually a little worse. | | `stake_usd`, `return_usd` | `stake_usd` is the flat stake the record puts on every pick, `1000` since September 22, 2026. `return_usd` is the gross return of that stake at `backed_price`, so it is `stake_usd / backed_price`. `payout_display` and `profit_display` are formatted from `return_usd`. | | `return_per_100` | The same return on a literal \$100, so `100 / backed_price`. It predates `stake_usd` and is kept so a client that scales it to its own stake stays correct. | | `game_started` | `true` once the backed game's kickoff has passed, which means the frozen price is no longer actionable. The field is absent on an old pick with no stored kickoff, and absent should be read as not started. | | `game_ended` | `true` once the backed game is over by the live scoreboard, read on each request, so you can tell a finished game from one still in play before `outcome` settles. The field is absent when no scoreboard is available for the game; absent means unknown, not `false`. | | `sports_context.yes_team`, `sports_context.no_team` | These identify the game's participants and carry available scores. Settled picks retain a verified final score even after the live score expires. | | `sports_context.yes_team.ranking`, `sports_context.no_team.ranking` | Available ATP or WTA singles ranking, with its data source, retrieval time, and expiry. The field is optional. | | `polymarket_url` | The Polymarket page the pick links to, with the 0xinsider referral tag. The field is absent until that link is resolved; link the game's event page instead. | | `sharp_pct` | The share of graded-wallet dollars held on the backed side, when available. It describes measured backing, not a fair probability or expected value. | | `scheduled_picks[]` | Entitled selected slots that are not published yet. Public API rows retain `pick_rank`, `release_at`, and `kickoff`; unauthorized scheduled ranks appear only in `locked_picks`, without clocks. Schedule your next read from an available `release_at`. | | `proof_pending_picks[]` | Entitled published picks whose holder proof is not readable yet, with `pick_rank`, `release_at`, optional `kickoff`, and `retry_at`. Unauthorized ranks appear only in `locked_picks`. While this array is present, `picks` and `pick_count` cover only the picks whose proof is readable. Schedule your next read from the earliest `retry_at`. | | `entry_authorization.max_entry_price` | The maximum share price permitted for an automated entry. New policy 8 grants use the first fresh `reference_best_ask` plus `0.05`, capped at `0.85` and rounded down to the provider's price increment. Reference depth covers \$100 principal and the provider minimum order size; fees are additional. Honor the returned ceiling and original kickoff expiry. | | `entry_authorization.policy_version` | `8` on newly issued grants with the 5-cent allowance. Existing policy `7` grants retain their recorded 2-cent allowance, ceiling, and expiry. | The spec block below has every other field, including `holders`, `thesis`, and `disclaimer`. New execution permission is issued only while the pick remains eligible. An earlier selection alone does not grant entry permission. For a future automated entry, honor the returned authorization and its expiry. New preparation or refresh refuses an older authorization above `0.85`; an already issued private snapshot can retain its existing grant until refresh. A missing authorization means skip the automated entry, and the \$100 reference depth does not replace a current book check for your order size. ## Tennis rankings When a tennis participant has `ranking`, read `rank` with `tour` to display its ATP or WTA singles ranking. `source` is `api_tennis`. `observed_at` is the UTC retrieval time. Hide the rank after `expires_at`, including when you display a cached response. API-Tennis supplies no publication date; do not present `observed_at` as one. This is the latest retrieved ranking, not the player's ranking at match time. `ranking` is absent for unranked, ambiguous, doubles, expired, or unavailable participants. ## Sporting scores Read each participant's `score` in `sports_context.yes_team` and `sports_context.no_team`. For tennis, `sets_won` gives the match score, and `sets` carries the available set scores. Once a settled pick has a verified final score, that score remains available after the live feed stops publishing it. Only results verified for the same game are retained; this includes postponed games played on a later date. A settled market does not prove that the game has ended or supply its final score. If no verified final is available, the score remains unavailable. Do not infer it from `outcome`, the market price, or a different game between the same participants. ## Entry ceilings and actual prices The API ceiling is fixed when the grant is first issued; it does not follow later price changes or reset at publication. The reference ask can therefore predate the published midpoint in `backed_price`. Existing grants are not rewritten when the allowance changes. For a BUY, check the current executable order book price for your stake before submission and cap the order's share price at `max_entry_price`. Apply any stricter client limits too. The [auto-buy trader](/guides/auto-buy-the-pick#how-slippage-and-fill-prices-work) defaults to 3% above `backed_price`, so a 5-cent API allowance does not promise a 5-cent increase above the published price. The ceiling is not a quote, an order price, or a recorded fill. An actual order can fill at several prices at or below its submitted BUY limit, and its average fill price is known after execution. The API's modeled return still uses the frozen `backed_price`, not your account's fill price; fees are additional. ## Pick access Pro opens the designated free selection and the first 4 nonfree selections in publication order, for 5 daily picks in total. Max opens every available published pick up to 15 and includes all Pro features. A thin day has fewer picks; neither plan guarantees its full daily limit. A Pro response places other unresolved published and scheduled selections in `locked_picks`. Read the returned access fields instead of inferring access from a slot number. Each descriptor contains only `pick_rank` and `required_tier: "max"`; it reveals no game, market, participant, price, link, or identifying time. If only locked ranks have published, the endpoint succeeds with `state: "none"`, `picks: []`, and `pick_count: 0`, plus `locked_picks` and a message to upgrade. This is different from `pick_not_released` or a proof-warming error. Included resolved rows remain public, and the ledger retains every published commitment. The response schema has separate `full` and `none` branches. Full picks retain their existing selection fields and required nullable `supersedes_pick_id`. The empty entitlement branch omits selection IDs and game identity, and returns `supersedes_pick_id: null`. The website uses a different schedule projection: an unauthorized website slot can appear as a redacted descriptor with `required_tier` and no clocks. Do not parse the website response as the public API schedule. ## Recorded lead wallet A full newly certified pick can include `lead_backer`, the recorded lead wallet's identity, position, and directional category history. Legacy picks omit it and retain their recorded evidence. An omitted object also means the recorded lead facts are unavailable; do not invent a wallet or zero-valued record. | Field | Meaning | | - | - | | `address`, `name`, `grade`, `category` | These identify the wallet, its grade at publication, and the sport of its recorded history. | | `position_usd` | This is the provider-reported value held on the backed outcome at publication, in USD. It is the gross value on that outcome and does not subtract shares on the other outcome. It is not the entry cost or a live balance. | | `net_position_usd` | This is the wallet's net position toward the backed outcome at publication, in USD: its backed-outcome shares minus its shares on the other outcome of the same market, valued at the backed outcome's provider price. It is present only when the wallet also held the other outcome; a one-sided position omits it, because its net equals `position_usd`. | | `position_observed_at` | This is when the provider position fetch began. This conservative observation clock precedes completion; it does not make the position a live balance. | | `directional_event_count` | This counts distinct events in the wallet's recorded directional history for `category`. It is the total for the profit and ROI shown in this object. | | `profitable_event_count` | This counts events with positive realized P\&L in that same sample. Break-even events do not count as profitable. | | `realized_pnl_usd`, `entry_basis_usd`, `roi` | These describe that sample's realized profit, recorded entry basis, and their ratio. `roi` is a fraction, and the basis does not assert complete costs or fees. | | `max_realized_drawdown_usd` | This measures peak-to-trough realized P\&L after each event result in that sample. It excludes intragame, unrealized, and account equity drawdown. | | `recorded_at` | This is when the history evidence was recorded, separate from the position snapshot clock. | On newly certified picks, `display_holders` lists the lead first, then any verified supporters, then the other graded wallets that held the backed side at publication, ordered by shares. Only the lead and supporters are verified: the other rows are gross holdings on the backed side and may also hold the other side. The bounded S/A `holders` projection, `holder_count`, and the wallet counts cover only the certified wallets. `backed_sharp_usd`, when available, sums their recorded position values; gross flow and consensus fields are omitted, and `lead_backer` replaces the optional legacy `qualifying_expert` display. Show the event record as `profitable_event_count` out of `directional_event_count`, with `category` beside it. Multiple market positions in one event contribute one combined event result. Keep the profit and ROI with that record; a live wallet win rate uses a different sample and must not label this recorded history. An older server response can omit `profitable_event_count`. Treat a missing count as unavailable, not zero. Label both clocks when you render these facts. Positions can change afterward, and the wallet's history is not this pick's probability of winning. ## When a pick releases The day follows the `America/New_York` calendar. The daily release window runs from midnight to 23:30 US Eastern time. Automatic selections publish after qualification and final checks instead of waiting until 30 minutes before kickoff. An explicitly scheduled selection keeps its returned `release_at`; do not calculate it from kickoff. The chosen market and side remain fixed after selection. Actual publication can trail `release_at` while the record is prepared or provider facts are unavailable. Cancelled, closed, or invalid markets can prevent release. A day with no qualifying selections has no published picks. Until the first pick of the day is published, the route returns `404` with `error.code` `not_found` and `error.reason` `pick_not_released`. Branch on the reason, because `error.code` is a frozen contract. The `404` is a schedule, not an outage, and on a skipped day it lasts the whole day. 1. Read `Retry-After` (seconds) or `error.retry_at` (an RFC3339 instant). Both recommend the next moment to read; earlier publication remains possible. 2. Hand that instant to a cron job, a queue, or a timer, and end the request. 3. Do not sleep a worker on it and do not poll. The next selection may not be ready yet. ## Notification links New Pick of the Day email, Discord, and inbox notifications link to `https://0xinsider.com/pick-of-the-day/picks/{pick_id}`. This page opens the selection identified by `pick_id`, even when another selection is released later. A replacement has its own ID and page; the earlier ID continues to identify the earlier selection. Opening the page keeps the selection's Free, Pro, or Max access requirement. Earlier emails and messages keep their original URLs, and dated pick links continue to work. ## Example ```bash theme={null} curl -H "Authorization: Bearer $OXINSIDER_API_KEY" \ "https://api.0xinsider.com/api/v1/pick-of-the-day" ``` ## What it does not return * A prior day's pick. A settled game never appears as today's, so an automated client never acts on a finished market. Past picks and the running record are on [Pick of the Day archive](/api-reference/endpoint/get-pick-of-the-day-archive). * Game identity or clocks for an unauthorized unresolved rank. A locked descriptor is not a game you should enrich through another endpoint. * Extra picks to fill a daily target. A day with fewer qualifying markets returns fewer picks, and a skipped day returns none. * A price you can trade at. `backed_price` is the order book midpoint frozen at publication, and every pick carries a `disclaimer`. * A fair price or an expected value. `entry_authorization.max_entry_price` bounds how far the price may drift before an automated entry stops, and nothing more. The [auto-buy guide](/guides/auto-buy-the-pick) shows how one client uses it. * Proof that the pick was fixed before the game. That proof is the hash on [Pick of the Day ledger](/api-reference/endpoint/get-pick-of-the-day-ledger). ## Caching Save the response's `ETag` and send it in `If-None-Match` on your next request. If today's pick set has not changed, the server returns `304 Not Modified` with no body. ## OpenAPI ````yaml GET /api/v1/pick-of-the-day openapi: 3.1.0 info: x-generated-rate-limit-policy-from: web/src/lib/rate-limit-facts.ts via web/scripts/generate-api-policy.ts title: 0xinsider API description: >- Follow provider-exposed large-trade activity from Polymarket. Polymarket wallet-attributed trades can add grades, P&L, strategy, and diagnostic-score context when sufficient source data exists. Fields can be null or unavailable. Normal API requests use a 30-second server timeout that returns HTTP 408 Request Timeout with the standard error envelope (error.code request_timeout) when exceeded. Every /api/v1 failure answers that envelope, including a body that is not JSON or does not fit the request schema (400 invalid_body), a query or path value that does not parse (400 invalid_query, invalid_path), a missing Content-Type: application/json (415 unsupported_media_type), a body over 1048576 bytes (413 payload_too_large) and a method the path does not serve (405 method_not_allowed), each with error.param naming the field where one is known and meta.request_id equal to X-Request-Id. Unknown query names are ignored by default and reported in X-Query-Ignored, while X-Effective-Query lists the normalized names and values applied using form-urlencoded decoding, where + is a space; strict mode returns 400 bad_request with error.reason unknown_query_parameter before the handler runs, including for an unknown name with an incomplete percent escape. Every list operation clamps an out-of-range limit into its published minimum..maximum instead of refusing it (limit=0 reads one row, limit=500 reads the maximum), and X-Effective-Query reports the clamped value; only a limit that is not an integer is refused, with 400 invalid_query. Public REST /api/v1/* endpoints, excluding /api/v1/mcp, use Bearer-token based non-credentialed browser CORS: any Origin may call with Authorization, Content-Type, If-None-Match, Idempotency-Key, Mcp-Session-Id, Mcp-Protocol-Version, Last-Event-Id, and X-Query-Validation request headers. X-Query-Validation: strict opts into rejecting unknown query names; the default remains compatible. Remote MCP at /api/v1/mcp is non-credentialed, but still validates Origin against the 0xinsider/localhost allowlist per MCP Streamable HTTP DNS-rebinding guidance. Successful browser CORS preflight responses advertise Access-Control-Max-Age: 86400. Browser JavaScript may read RateLimit-Limit, RateLimit-Remaining, RateLimit-Reset, the legacy X-RateLimit-Limit, X-RateLimit-Remaining, X-RateLimit-Reset, Retry-After, ETag, X-Request-Id, X-Request-Cost, X-Usage-Accounting, X-Batch-RateLimit-Limit, X-Batch-RateLimit-Remaining, X-Batch-RateLimit-Reset, Mcp-Session-Id, X-Mcp-Error-Code, X-Query-Ignored, and X-Effective-Query response headers. Rate-limit headers describe the budget a request was counted against: the API key's per-minute window on an authenticated call, and the per-IP budget on a public route or on a refused credential (401, 402, 403, 423), so a client looping on a bad or lapsed key still sees how much room it has. Conditional GET: these operations return a weak ETag and answer If-None-Match with 304 Not Modified and an empty body: GET /api/v1/health, GET /api/v1/insider-radar, GET /api/v1/insider-radar/{id}, GET /api/v1/large-positions, GET /api/v1/leaderboard, GET /api/v1/leaderboard/trending, GET /api/v1/market/{condition_id}/candles, GET /api/v1/market/{condition_id}/flow, GET /api/v1/market/{condition_id}/intel, GET /api/v1/market/{condition_id}/snapshot, GET /api/v1/markets/explore, GET /api/v1/markets/sharp-money-flows, GET /api/v1/markets/smart-money-flows, GET /api/v1/pick-of-the-day, GET /api/v1/pick-of-the-day/archive, GET /api/v1/positions, GET /api/v1/sports-edge-observations, GET /api/v1/sports-edge-signals, GET /api/v1/trader/{address}, GET /api/v1/trader/{address}/context, GET /api/v1/trader/{address}/pnl, GET /api/v1/trader/{address}/position-timeline, GET /api/v1/traders/{trader}/position-timeline, GET /api/v1/large-trades, GET /api/v1/large-trades/history, GET /api/v1/large-trades/{id}, GET /api/v1/whale-trades, GET /api/v1/whale-trades/history, GET /api/v1/whale-trades/{id}, GET /api/v1/whale-trades/{id}/counterparties/executions, GET /api/v1/whale-trades/{id}/counterparties/executions/{execution_id}/makers. Credentialed first-party routes such as /api/keys, /api/billing, and auth endpoints remain restricted to configured 0xinsider origins. Protected V1 responses, except the zero-cost /api/v1/usage route, after handler execution carry X-Usage-Accounting: persisted, failed, or unknown. This reports the usage-record write; it does not change the handler result. Do not replay a successful mutation to repair an unknown usage record. Before execution, unavailable accounting capacity returns HTTP 503 with error.reason=request_accounting_unavailable; honor Retry-After. Public API responses add the browser-readable Server-Timing header: Processing time in milliseconds, for example api;dur=12.345. Includes API authentication, quota admission, handler work and response construction. Excludes network transit and streamed body or export-file transfer. The engineering budget is strictly below 250 ms; this header reports observations, not a latency guarantee or a new timeout. Requests through https://0xinsider.com/api/* append Server-Timing: web_api;dur= and X-Web-Request-Id for that web origin handler. The web clock includes upstream waiting and existing body construction, so do not add it to api;dur. It excludes platform routing, cold module initialization, CDN hits and later stream/file transfer. On a cache hit these headers describe the earlier origin fill, not the current request; static Markdown API routes have no fresh web clock. version: 1.0.0 contact: name: 0xinsider email: support@0xinsider.com url: https://0xinsider.com servers: - url: https://api.0xinsider.com description: >- Production (live data). Authenticate with a live key (oxi_sk_live_...); requires an active Pro subscription. A sandbox key (oxi_sk_test_...) is answered with 401 invalid_api_key and error.reason sandbox_api_key. - url: https://0xinsider.com/sandbox description: >- Sandbox. No credential required and no production data: every documented operation answers with its documented example or a deterministic sample of its response schema. GET /api/v1/stream is the one exclusion and answers 400 there, because a Server-Sent Events stream is a live connection rather than a body. Add ?sandbox_status= to receive one of the error responses the operation documents (for example 429 with Retry-After). Documented query parameters and JSON request bodies are checked against this document, the two context.md routes answer 200 text/markdown, GET /api/v1/trader/{address}/export/download answers its 302 with a Location the sandbox serves itself rather than an object store, and nothing is stored between requests. A sandbox key (oxi_sk_test_..., issued with no account by POST https://api.0xinsider.com/api/v1/agents/register) is optional: on an operation that requires a credential, a well-formed key is answered with X-Oxi-Sandbox-Key: valid and a malformed one with 401 invalid_api_key. security: - bearerAuth: [] - oauth2: - read tags: - name: Traders description: Traders, batch lookups, timelines, and export readiness. - name: Positions description: Current prediction-market position snapshots from backend-owned mirrors. - name: Large Positions description: Largest current open positions from graded traders (Polymarket-only). - name: Large trades description: Recent and historical large trades. - name: Leaderboard description: Ranked trader discovery and category/strategy leaderboards. - name: Pick of the Day description: >- One sourced sharp-money call a day: the side profitable wallets are backing, with pre-game odds, the holders, and the track record. - name: Games description: >- Sports and esports games: both sides, schedules, provider status and the Polymarket markets linked to each game. - name: Markets description: Market search, discovery, snapshots, and sharp-money flow. - name: Content description: Search across 0xinsider editorial content. - name: Suspicious trades description: Trades whose recorded suspicion score meets the live flag threshold. - name: Insider Radar description: >- Deprecated spelling of Suspicious trades; both operations stay live as aliases. - name: Events description: Durable public event replay streams. - name: Streaming description: Resumable real-time Server-Sent Events stream of live feed envelopes. - name: Webhooks description: Signed builder webhook destinations and delivery controls. - name: Usage description: Developer API budget and usage introspection. - name: Onboarding description: >- Self-serve agent registration: a sandbox key with no account, and the path to live access. - name: System description: Health and operational status checks. - name: MCP description: Remote Model Context Protocol transport. - name: Reports description: Daily, weekly, monthly, and trader export report snapshots. - name: Account description: Identify the account and credential authenticated for a paid API request. externalDocs: description: 0xinsider API docs url: https://docs.0xinsider.com paths: /api/v1/pick-of-the-day: get: tags: - Pick of the Day summary: Get today's Pick of the Day description: >- Returns entitled published picks for the current product day. Pro includes five selections in total: the designated free selection and the first four non-free selections in publication order. Max opens every available selection, up to fifteen. A day may contain up to two verified compatible selections per game: a team's full-game moneyline and handicap. Each selection retains its individual requirements. Same-game picks share exposure and need not be independent; retain each `pick_id` instead of deduplicating by game. Both read resolved picks. Publication prices and backing are frozen; a prior day never appears here, so use the archive. Stable `pick_id` values identify selections. `publication_order` describes presentation and `is_free_selection` describes access; neither is a quality rating. Standing selections retain their identity, slot, and release schedule. Later additions fill available slots. Historical IDs, order, and proof bytes remain unchanged. Unauthorized unresolved selections appear only as identity-free `locked_picks` containing `pick_rank` and `required_tier`. When only locked selections are published, HTTP 200 carries `state=none`, `picks=[]`, `pick_count=0`, and an Upgrade to Max message. Proof warming applies only to entitled picks. `scheduled_picks` contains only entitled slots and retains required `release_at` and `kickoff`. Unauthorized scheduled selections expose no game identity or release time. When no active pick is available, including after cancelled recommendations are withdrawn, HTTP 404 carries `error.code="not_found"` and `error.reason="pick_not_released"`. Branch on the reason and schedule one request using `Retry-After` or `error.retry_at` instead of polling. This advisory retry does not reveal an unauthorized game's release time. Final sporting scores are retained for resolved picks after the event is confirmed ended and both sides have verified scores. A result without a verified final stays unavailable; a win/loss outcome alone does not establish a sporting score. Existing sports_context fields and return calculations are unchanged. Withdrawn picks are excluded from current and dated recommendations, the archive, and its statistics, even after market settlement. The public ledger retains every published commitment under its original identity and proof bytes. Provider settlement still determines the recorded result. Request and response fields are unchanged. operationId: getPickOfTheDay parameters: - name: X-Query-Validation in: header required: false description: >- Opt into strict query-name validation. The default is compatible: unknown names are ignored and reported in X-Query-Ignored. With strict, an unknown name returns 400 bad_request with error.reason unknown_query_parameter before the handler runs, including when its percent escape is incomplete. schema: type: string enum: - strict - name: If-None-Match in: header required: false description: >- Conditional GET validator from a previous ETag. Matching values return 304 Not Modified with an empty body. schema: type: string responses: '200': description: >- Today's entitled Pick of the Day slate, or an identity-free locked response when no entitled picks are published. headers: X-Query-Ignored: $ref: '#/components/headers/X-Query-Ignored' X-Effective-Query: $ref: '#/components/headers/X-Effective-Query' ETag: description: >- Stable validator for the current Pick of the Day payload. Re-send it via If-None-Match for conditional GETs. schema: type: string RateLimit-Limit: $ref: '#/components/headers/RateLimit-Limit' RateLimit-Remaining: $ref: '#/components/headers/RateLimit-Remaining' RateLimit-Reset: $ref: '#/components/headers/RateLimit-Reset' X-RateLimit-Limit: $ref: '#/components/headers/X-RateLimit-Limit' X-RateLimit-Remaining: $ref: '#/components/headers/X-RateLimit-Remaining' X-RateLimit-Reset: $ref: '#/components/headers/X-RateLimit-Reset' X-Request-Id: $ref: '#/components/headers/X-Request-Id' X-Usage-Accounting: $ref: '#/components/headers/X-Usage-Accounting' Server-Timing: $ref: '#/components/headers/Server-Timing' content: application/json: schema: type: object required: - object - data - meta properties: object: type: string const: pick_of_the_day data: oneOf: - $ref: '#/components/schemas/PickOfTheDay' - $ref: '#/components/schemas/PickOfTheDayNoEntitledPicks' meta: $ref: '#/components/schemas/ResponseMeta' examples: success: summary: >- Published pick whose selector recorded no qualifying category expert -- a real negative, confirmed by trust value: object: pick_of_the_day data: state: full pick_date: '2026-06-23' matchup: Portugal vs. Uzbekistan category: Soccer display_category: Soccer platform: polymarket release_at: '2026-06-23T17:00:00Z' is_locked: false outcome: pending pick_outcome_label: Portugal position: Portugal to win side_summary: 1 profitable wallet on Portugal sharp_wallet_count: 1 smart_wallet_count: 1 top_grade: A sharp_usd: 48250 smart_usd: 48250 backed_price: 0.62 stake_usd: 1000 return_usd: 1612.9 return_per_100: 161.29 clv_status: pending market_pct: 0.62 traders: 1 holders: - address: '0x0000000000000000000000000000000000000000' name: swisstony grade: A last_traded_at: '2026-06-18T17:42:10Z' shares: 12500 display_holders: - address: '0x0000000000000000000000000000000000000000' name: swisstony grade: A last_traded_at: '2026-06-18T17:42:10Z' shares: 12500 category_win_rate: 0.64 category_win_record: wins: 16 decided: 25 category_win_rate_status: measured - address: '0x1111111111111111111111111111111111111111' name: marketmaker grade: B last_traded_at: '2026-06-18T17:42:10Z' shares: 9800 category_win_rate_status: not_enough_data holder_count: 1 thesis: >- Profitable wallets hold Portugal, led by a grade-A trader. market_url: https://0xinsider.com/event/portugal-vs-uzbekistan event_slug: portugal-vs-uzbekistan event_link_slug: portugal-vs-uzbekistan sports_context: league_name: FIFA World Cup league_logo: https://polymarket.com/leagues/fifa-world-cup.png yes_team: label: Portugal short_label: POR full_name: Portugal national football team provider_id: 1421 logo: https://polymarket.com/teams/portugal.png logo_mark_dark: false color: '#C8102E' record: null score: null no_team: label: Uzbekistan short_label: UZB full_name: Uzbekistan national football team provider_id: 1738 logo: https://polymarket.com/teams/uzbekistan.png logo_mark_dark: false color: '#1EB53A' record: null score: null game_id: 884213 event_matchup: false matchup_title: Portugal – Uzbekistan disclaimer: >- Not financial advice. Prediction markets carry risk; do your own research. pick_id: '1000' publication_order: 1 is_free_selection: true supersedes_pick_id: null meta: request_id: req_example cached: false cost: 1 '304': description: >- Not Modified. Returned when If-None-Match matches the current Pick of the Day payload. headers: X-Query-Ignored: $ref: '#/components/headers/X-Query-Ignored' X-Effective-Query: $ref: '#/components/headers/X-Effective-Query' ETag: description: Validator for the unchanged Pick of the Day payload. schema: type: string RateLimit-Limit: $ref: '#/components/headers/RateLimit-Limit' RateLimit-Remaining: $ref: '#/components/headers/RateLimit-Remaining' RateLimit-Reset: $ref: '#/components/headers/RateLimit-Reset' X-RateLimit-Limit: $ref: '#/components/headers/X-RateLimit-Limit' X-RateLimit-Remaining: $ref: '#/components/headers/X-RateLimit-Remaining' X-RateLimit-Reset: $ref: '#/components/headers/X-RateLimit-Reset' X-Request-Id: $ref: '#/components/headers/X-Request-Id' X-Usage-Accounting: $ref: '#/components/headers/X-Usage-Accounting' Server-Timing: $ref: '#/components/headers/Server-Timing' x-empty-body: true '401': description: Missing or invalid API key content: application/json: schema: $ref: '#/components/schemas/ApiError' '402': description: >- Active Pro subscription required. The key is valid but the account has no active Pro subscription; error.reason is subscription_inactive and error.message names the reactivation URL (https://0xinsider.com/billing). Permanent until a person reactivates: no Retry-After, never retry on a schedule. content: application/json: schema: $ref: '#/components/schemas/ApiError' '403': description: Account access denied content: application/json: schema: $ref: '#/components/schemas/ApiError' '404': description: >- No Pick of the Day is published for the current product day. Qualified automatic signals are due immediately after qualification and publish after final checks. Explicitly scheduled selections retain their stored release time. The product day uses America/New_York; a skipped day publishes nothing. The body carries error.code="not_found" with error.reason="pick_not_released" (branch on the reason -- the code stays "not_found" because error.code is a frozen contract) plus error.retry_at (RFC3339, always in the future), and the response sets Retry-After. Schedule against those instead of polling -- polling this window is what makes a schedule look like an outage. headers: Retry-After: description: >- Seconds until the recommended next retry. Before the operating-window start, before a selected pick's stored release, or after a skipped day it names the automatic system's next boundary. While no candidate exists it normally names the persisted next automatic selector attempt. New qualified signals or supported operator actions can make a pick available before any recommendation. An absent/due schedule or overdue pick degrades to ~60s. Always >= 1. Schedule one request (error.retry_at is its absolute RFC3339 twin); do not poll or block a worker thread. schema: type: integer content: application/json: schema: $ref: '#/components/schemas/ApiError' '408': description: >- The handler did not answer inside the server's 30-second timeout. error.code is request_timeout. On GET and HEAD the response carries Retry-After and error.retry_at; on a mutation it carries neither, because the request may have completed on the server: check its state before repeating it, and reuse its Idempotency-Key. content: application/json: schema: $ref: '#/components/schemas/ApiError' '423': description: Account is locked content: application/json: schema: $ref: '#/components/schemas/ApiError' '429': description: >- Rate limit exceeded. Three independent budgets. (1) 100 requests/minute per user (sliding window), on every authenticated route. (2) On the BATCH routes only: 2500 batch item units/minute per user, reserved before any item is executed. A batch with N requested items costs N item units, including duplicate and invalid items. 2500 = 100 requests x 25 items per batch, which is the most item work a key can buy through the request limiter at all: a caller may spend their entire 100-request minute on full 25-item batches without the item budget being what stops them. The REQUEST budget is the effective ceiling, and batching is never the more expensive choice. The item budget can still deny at a sliding-window boundary (both counters carry the previous window forward with a floor, and the item counter runs 25x the request counter), so honor a 429 from either. Over-quota batches return 429 with Retry-After plus RateLimit-Limit, RateLimit-Remaining, and RateLimit-Reset before any item work is done. (3) The monthly quota: Pro includes 500,000 and Max includes 2,000,000 authenticated requests per UTC calendar month. Over the plan's included requests: with pay as you go on, the excess bills at USD 0.20 per 1,000 on a monthly invoice, up to four times the included allowance (2,000,000 requests for Pro); without it, from October 1, 2026, the next request answers 429 rate_limited with error.reason monthly_quota_exceeded and a Retry-After to the month's reset. Pay-as-you-go accounts receive the same refusal at their ceiling. A refused request is not counted. Every authenticated response carries X-Monthly-Quota-Limit, X-Monthly-Quota-Remaining, and X-Monthly-Quota-Reset (unix seconds, the first of next month). (4) The per-address budget: 1200 requests/minute per IP, shared by every caller behind one address and counted before authentication, on every route. A 429 from it carries error.reason ip_rate_limited and describes that bucket in RateLimit-*; a throttled address (sustained over-limit traffic) carries error.reason ip_throttled with a Retry-After of minutes to days, and a request before it does not shorten the cooldown. Every 429 is the standard error envelope with meta.request_id equal to X-Request-Id. headers: Retry-After: description: Seconds until rate limit resets. schema: type: integer RateLimit-Limit: $ref: '#/components/headers/RateLimit-Limit' RateLimit-Remaining: $ref: '#/components/headers/RateLimit-Remaining' RateLimit-Reset: $ref: '#/components/headers/RateLimit-Reset' X-RateLimit-Limit: schema: type: integer X-RateLimit-Remaining: schema: type: integer X-RateLimit-Reset: schema: type: integer X-Request-Id: schema: type: string content: application/json: schema: $ref: '#/components/schemas/ApiError' '500': description: Unexpected server error content: application/json: schema: $ref: '#/components/schemas/ApiError' '503': description: >- Service unavailable. On this route a 503 has TWO distinct causes; branch on error.reason. (1) error.reason="read_model_warming": the requested endpoint cannot serve its read model yet. Exact causes are endpoint-specific and can include a cold or contended refresh or a dependency that prevented refresh; consult that endpoint's contract and do not infer dependency health from this shared reason. This is endpoint-local unavailability, not rate limiting: retry only this route after Retry-After (or error.retry_at), and do not feed it into a rate-limit backoff shared with other endpoints. (2) no error.reason: the Redis-backed authenticated rate limiter is unavailable and the middleware failed closed; Retry-After is the seconds until it probes Redis again. Both carry error.code="rate_limit_unavailable" (a FROZEN contract value, so it cannot be split per cause) and X-Request-Id -- which is why error.reason, not error.code, is the discriminator. headers: Retry-After: description: >- Seconds until retrying is worth doing. With error.reason="read_model_warming" this is the endpoint-local read-model retry interval; without a reason it is the rate-limiter outage cooldown. Always >= 1. schema: type: integer X-Request-Id: schema: type: string content: application/json: schema: $ref: '#/components/schemas/ApiError' x-codeSamples: - lang: curl label: cURL source: |- curl -sS \ -H "Authorization: Bearer $OXINSIDER_API_KEY" \ 'https://api.0xinsider.com/api/v1/pick-of-the-day' components: headers: X-Query-Ignored: description: >- Comma-separated, percent-encoded query names the operation did not publish and therefore ignored in compatible mode. Names are sorted and de-duplicated. schema: type: string X-Effective-Query: description: >- Normalized, percent-encoded query string containing only the recognized names and values applied by the operation. Query names and values use form-urlencoded decoding, where + is a space. Repeated names are retained and sorted by name. A limit outside the operation's published minimum..maximum is reported as the clamped value the page used, so the header states the page size served rather than the one requested. schema: type: string RateLimit-Limit: description: >- Request limit of the budget this request was counted against, for its current window: the API key's per-minute sliding window on an authenticated call; the per-IP budget on a public route and on a refused credential (401, 402, 403, 423), which never reaches the per-key limiter. Standard RateLimit header spelling. schema: type: integer example: 100 RateLimit-Remaining: description: >- Requests remaining in that budget's current window after this response. Standard RateLimit header spelling. schema: type: integer example: 84 RateLimit-Reset: description: >- Seconds until that budget's current window resets. Standard RateLimit header spelling. schema: type: integer example: 42 X-RateLimit-Limit: description: >- Request limit of the budget this request was counted against, for its current window: the API key's per-minute sliding window on an authenticated call; the per-IP budget on a public route and on a refused credential (401, 402, 403, 423). schema: type: integer example: 100 X-RateLimit-Remaining: description: Requests remaining in that budget's current window after this response. schema: type: integer example: 84 X-RateLimit-Reset: description: Unix timestamp when that budget's current window resets. schema: type: integer example: 1710772860 X-Request-Id: description: >- Server-generated request identifier for support and tracing. On every /api/v1 response, including 304, 408, CORS preflights and every error, and always equal to meta.request_id in the body. It is the key of the request's usage accounting row and of every log line the request emitted, so quote either form to support. A client-supplied X-Request-Id request header is ignored: the value is never adopted or echoed. schema: type: string example: req_550e8400 X-Usage-Accounting: description: >- Usage-record persistence for a protected V1 handler response. persisted: confirmed row; failed: write failed; unknown: completion could not be confirmed. Independent of handler success; do not replay successful mutations to repair accounting. Absent before accounting admission and on public routes. The zero-cost /api/v1/usage route also omits it. schema: type: string enum: - persisted - failed - unknown Server-Timing: description: >- Processing time in milliseconds, for example api;dur=12.345. Includes API authentication, quota admission, handler work and response construction. Excludes network transit and streamed body or export-file transfer. The engineering budget is strictly below 250 ms; this header reports observations, not a latency guarantee or a new timeout. schema: type: string example: api;dur=12.345 schemas: PickOfTheDay: type: object required: - state - supersedes_pick_id properties: state: type: string enum: - full description: Full success containing entitled proof-readable picks. pick_date: type: string format: date description: The pick's local publication date (YYYY-MM-DD). pick_rank: type: integer minimum: 1 maximum: 20 description: >- Deprecated compatibility daily release slot; use pick_id for identity and publication_order for scheduling. deprecated: true picks: type: array description: >- Published picks for this product day in the returned display order. Use pick_id for identity. items: $ref: '#/components/schemas/PickOfTheDay' pick_count: type: integer minimum: 0 maximum: 15 description: >- Number of items in `picks`: the proof-readable picks. Picks held in `proof_pending_picks` are not counted. scheduled_picks: type: array description: >- Rank-ordered entitled selections that have not released. Every row retains release_at and kickoff; unauthorized scheduled ranks appear only in identity-free locked_picks. items: $ref: '#/components/schemas/ScheduledPickSlot' matchup: type: string description: Human-readable matchup (e.g. "Portugal vs. Uzbekistan"). category: type: string description: >- Recorded canonical sport category. Prefer display_category for the public competition label. display_category: type: string description: >- Frozen public presentation category: the competition the Polymarket event belongs to. A curated label comes first -- an official league (e.g. "WNBA" or "UFC"), the esports title (e.g. "CS2", "LoL", "Dota 2" or "Valorant"), or a soccer competition (e.g. "LaLiga", "Premier League", "Serie A" or "UEFA Champions League"); any other competition carries the provider's own competition name without its season year (e.g. "UEFA Nations League", "ATP" or "Wimbledon"). It equals category only when the provider names no competition. An esports pick keeps the pooled "Esports" bucket in category, so a per-title label never implies a per-title measured cohort. Additive and optional for mixed-version client compatibility. platform: type: string enum: - polymarket description: Provider platform. Always polymarket. release_at: type: string format: date-time description: >- The pick's stored release instant. Qualified automatic selections are due immediately; explicitly scheduled selections retain their stored time. Final checks, worker or claim delay can make the actual publication later. is_locked: type: boolean description: >- True only before the pick's stored release instant (a pre-release embargo flag); effectively always false on a served, already-published pick. To detect that the backed game has kicked off, use `game_started`. game_started: type: boolean description: >- True once the backed game's kickoff has passed (kickoff <= now). When true the snapshotted pre-game price is no longer actionable. Absent for a legacy pick with no stored kickoff (treat as not-started). game_ended: type: boolean description: >- Whether the backed game is over according to the cached live scoreboard, read at serve time. Tells a finished game from one still in play before `outcome` settles. Omitted when the pick has no event slug or no scoreboard is cached for it; absence is unknown, never false. outcome: type: string enum: - pending - win - loss - void description: >- Settlement outcome of the backed side; 'pending' until the market resolves. outcome_display: type: string description: >- Pre-formatted SETTLEMENT STATUS for display: "Win" / "Loss" / "Void" / "Pending" -- the outcome enum above as a label. Convenience only; outcome is the source value. NOTE: this is the win/loss STATUS, not the backed side. The backed side is pick_outcome_label ("Belgium (-2.5)") -- a different field answering a different question. pick_outcome_label: type: string description: >- The backed side phrased as a bet: a team for a moneyline (e.g. "Portugal"), the handicap line for a spread (e.g. "Belgium (-2.5)"), or "{team} to advance" for a knockout advancement market (e.g. "Spain to advance"). token_id: type: string description: >- The Polymarket CLOB token id (ERC1155 asset id, decimal string) for the backed outcome; omitted when unavailable (e.g. unsynced markets). position: type: string description: The backed side phrased as a bet (e.g. "Portugal to win"). side_summary: type: string description: >- One-line summary of which side sharp money is backing. Required on every item in `picks`: a current-day published pick whose required holder proof is not safely readable is listed in `proof_pending_picks` instead of being served with a partial success shape or a synthetic zero, and the route returns 503 read_model_warming only when no published pick has readable proof. sharp_wallet_count: type: integer description: >- S/A wallet count on the backed side in the public V1 compatibility projection. smart_wallet_count: type: integer deprecated: true description: Deprecated spelling of sharp_wallet_count with the same value. top_grade: type: string description: Best recorded S/A grade in the public V1 compatibility projection. sharp_usd: type: number description: Recorded sharp-money magnitude in USD when available. smart_usd: type: number deprecated: true description: Deprecated spelling of sharp_usd with the same value. backed_price: type: number description: >- Frozen pre-game probability (0..1) for the backed side, written once at publication. It is the Polymarket CLOB order book midpoint at release, not an executed fill: a buyer lifts the ask, so a subscriber's own entry is usually a little worse than this price. entry_price_note: type: string description: >- Full-only disclosure when backed_price was recovered from provider history within 30 seconds before publication. Render beside the price. Absent for ordinary publication captures and teasers; this is a historical reference, not an executed fill. odds_display: type: string description: >- Pre-formatted backed_price as cents-on-the-dollar odds, to ONE decimal: "62.0c" / "99.9c". Never rounded to a whole cent -- a 99.9c favorite is not a 100c certainty. Convenience only; backed_price is the source value. Omitted when backed_price is. stake_usd: type: number description: >- The flat stake the published record puts on every pick, in USD: 1000 since 2026-09-22 (it was 100 before). Present exactly when return_usd is, so a reader never has to know the stake from anywhere else. return_usd: type: number description: >- Gross return of stake_usd at the frozen midpoint price (stake_usd / backed_price). A real fill pays the ask, so an executed stake usually returns a little less. Omitted with backed_price. return_per_100: type: number description: >- The same return on a literal $100 (100 / backed_price), kept for compatibility: the field predates stake_usd and its name promises the $100 basis, so a client that scales it to its own stake stays right. Present exactly when return_usd is. payout_display: type: string description: >- Pre-formatted return_usd as USD with cents and thousands separators: "$1,612.90" / "$12,500.00". The GROSS return (the stake included), so it carries no sign. Convenience only; return_usd is the source value. Omitted when return_usd is. profit_display: type: string description: >- Pre-formatted PROFIT on the stake -- return_usd minus stake_usd, i.e. the payout net of what you put in -- as a signed USD string: "+$612.90". Distinct from payout_display, which is gross. Omitted when return_usd is. clv_status: type: string description: >- Backend-owned CLV capture disposition. "pending" means no capture decision exists yet; terminal provider or quality statuses remain distinguishable. The raw close price and timestamp are never serialized. clv_basis: type: string description: >- Backend-owned CLV evidence basis. `frozen_displayed_entry` uses the persisted displayed entry. `historical_provider_entry` uses a known-CLOB point at or before publication. `historical_provider_price_match` requires the latest point in the prior hour to match. `historical_provider_nearby_price_match` requires a matching point within five minutes before publication. Source-null bases preserve unknown original provenance. clv_pct: type: number description: >- Closing-line value toward the backed side, computed as (close / entry - 1) * 100. The basis-specific provider p entry must match the stored display; historical_provider_price_match also requires source provenance to remain null and its latest entry to be within the one-hour window at or before publication. Every basis requires a later quality-checked p close from the same series in the bounded post-entry, pre-kickoff window. Omitted when not measured. clv_display: type: string description: >- Backend-formatted signed CLV percentage, present exactly when clv_pct is present. clv_explanation: type: string description: >- Backend-owned CLV formula text with the entry probability, close probability, and rounded result. Provider timestamps remain private. unit_score: type: number description: >- Net return for the pick in stake units (return_usd / stake_usd - 1); one unit is one stake_usd stake, and the figure is the same under any stake size. Omitted when the outcome is not valued. unit_score_display: type: string description: >- Backend-formatted signed unit score, present exactly when unit_score is present. sharp_pct: type: number description: >- Recorded sharp-money share as a 0..1 fraction when available. This is not a winning probability. market_pct: type: number description: >- Recorded market-implied probability as a 0..1 fraction when available. qualifying_expert: type: object description: >- Optional legacy recorded specialist facts. These describe the trader and do not disclose selection decisions. Present only on a full response when available; newly certified picks use lead_backer instead. properties: address: type: string description: Trader wallet address. name: type: string nullable: true description: Provider display name, or null for an unnamed wallet. grade: type: string nullable: true description: >- Recorded trader grade. Public V1 preserves its S/A compatibility projection. canonical_category: type: string description: >- The canonical sport bucket the win rate was measured over (for example Basketball). Can be BROADER than the pick's display_category, which names an exact league such as NBA — label the rate with this field, never with display_category. win_rate: type: number nullable: true description: >- Share of the trader’s resolved markets in canonical_category with positive realized P&L, as a 0..1 fraction. Null when not measured. This is a trader statistic, not the pick’s probability of winning. n_resolved: type: integer nullable: true description: >- Number of resolved markets behind win_rate; null when not measured. position_usd: type: number description: >- Recorded Polymarket position value on the backed outcome, in USD. It can change after this snapshot. opposite_position_usd: type: number description: >- Recorded position value on the other outcome of this market, in USD. Omitted when not recorded; zero is a measured value. stats_computed_at: type: string format: date-time description: Timestamp of the recorded trader statistics. required: - address - name - grade - canonical_category - win_rate - n_resolved - position_usd - stats_computed_at traders: type: integer description: >- Public V1 S/A wallet count on the backed side, equal to sharp_wallet_count. backed_sharp_usd: type: number description: >- Recorded backed-side position value in USD when available. Newly certified picks sum only publication-certified wallet positions; legacy rows retain their recorded value. holders: type: array description: >- Bounded S/A holder display projection. Newly certified picks include only publication-certified wallets; historical rows retain their recorded display shape. items: $ref: '#/components/schemas/PickHolder' display_holders: type: array description: >- Optional complete holder display roster. Newly certified picks list the recorded lead first, then any verified supporters, then the other graded wallets that held the backed side at publication, ordered by shares; only the lead and supporters are verified, the other rows are gross holdings that may also hold the other side and are not counted in the wallet counts, holder_count or backed_sharp_usd. Legacy rows retain their recorded display shape. items: $ref: '#/components/schemas/PickHolder' holder_count: type: integer description: >- S/A holder count for the public V1 compatibility projection. display_holders can include additional grades. editorial_note: type: string description: Optional editorial note attached to the pick. thesis: type: string description: >- Required truthful thesis. With at least one profitable-wallet holder: Profitable wallets hold {pick_outcome_label}[, led by a grade-{top_grade} trader]. Without holder backing: 0xInsider's Pick of the Day is {pick_outcome_label}. Wallet counts are not appended. market_url: type: string description: Canonical web market URL. polymarket_url: type: string description: >- Where this pick's outbound Polymarket link lands: Polymarket's own redirect answer for `/event/`, carrying the referral tag. Omitted until that redirect has been resolved; link to the event page instead when it is absent. event_slug: type: string description: >- The canonical /event game-page slug (one neutral page per game); omitted when the game has no neutral event page. event_link_slug: type: string description: >- Backend-resolved /event destination slug for the source market. Omitted outside full responses; null is an authoritative no-link decision. nullable: true sports_context: allOf: - $ref: '#/components/schemas/PickSportsContext' description: >- Provider-first sports context for the pick's market (team logos, league branding, live score). Full-state only; omitted when the pick is not a team-sports market. disclaimer: type: string description: Risk disclaimer shown with every pick. proof_pending_picks: type: array description: >- Entitled published picks whose holder proof is unreadable, ordered by rank. Unauthorized ranks appear only in locked_picks and cannot trigger proof warming. Read retry_at for the next read. items: $ref: '#/components/schemas/ProofPendingPickSlot' entry_authorization: $ref: '#/components/schemas/PotdEntryAuthorization' description: >- Optional full-response entry authorization. Missing or expired authorization cannot authorize an automated entry. locked_picks: type: array description: >- Unauthorized unresolved published or scheduled ranks. Contains no game, provider identity, price, or identifying clock. Pro may upgrade to Max to open these ranks. items: type: object required: - pick_rank - required_tier properties: pick_rank: type: integer minimum: 1 maximum: 20 required_tier: type: string enum: - max message: type: string description: >- Actionable status, including Upgrade to Max when only locked ranks are published. pick_id: type: string pattern: ^[1-9][0-9]*$ description: >- Stable pick row identity as decimal text. Never use a quality rank as identity. publication_order: type: integer description: >- Compatibility release slot. No quality claim; historic scheduling order is retained. is_free_selection: type: boolean description: >- Viewer-independent free selection designation. New rows store it explicitly; historic null storage uses the original free slot. supersedes_pick_id: type: string nullable: true pattern: ^[1-9][0-9]*$ description: Replacement predecessor stable id; null when no lineage is recorded. lead_backer: $ref: '#/components/schemas/PickLeadBacker' description: >- Optional full-only lead wallet publication facts. Omitted on legacy picks or when the recorded evidence is unavailable. PickOfTheDayNoEntitledPicks: type: object description: >- A successful current-day entitlement response when only unauthorized ranks have published. It carries an empty pick set, identity-free locked ranks and an upgrade message. Selection IDs, game identity, prices and unauthorized clocks are absent. Any scheduled or proof-pending rows are entitled rows. required: - state - pick_date - picks - pick_count - locked_picks - message - supersedes_pick_id properties: state: type: string enum: - none description: Only locked ranks are published for this account. pick_date: type: string format: date description: Current product date in America/New_York (YYYY-MM-DD). picks: type: array maxItems: 0 items: $ref: '#/components/schemas/PickOfTheDay' description: 'Empty: no entitled proof-readable picks are returned.' pick_count: type: integer const: 0 description: Zero entitled proof-readable picks. locked_picks: type: array description: >- Unauthorized unresolved published or scheduled ranks. Contains no game, provider identity, price, or identifying clock. Pro may upgrade to Max to open these ranks. items: type: object required: - pick_rank - required_tier properties: pick_rank: type: integer minimum: 1 maximum: 20 required_tier: type: string enum: - max minItems: 1 message: type: string description: >- Actionable status, including Upgrade to Max when only locked ranks are published. scheduled_picks: type: array description: >- Rank-ordered entitled selections that have not released. Every row retains release_at and kickoff; unauthorized scheduled ranks appear only in identity-free locked_picks. items: $ref: '#/components/schemas/ScheduledPickSlot' proof_pending_picks: type: array description: >- Entitled published picks whose holder proof is unreadable, ordered by rank. Unauthorized ranks appear only in locked_picks and cannot trigger proof warming. Read retry_at for the next read. items: $ref: '#/components/schemas/ProofPendingPickSlot' supersedes_pick_id: type: string nullable: true enum: - null description: 'Null: the empty entitlement envelope has no selection lineage.' ResponseMeta: type: object required: - request_id - cached - cost properties: request_id: type: string description: >- Unique request ID (req_ prefix). The same value as the X-Request-Id response header, the request's usage accounting row and its log lines. cached: type: boolean cache_age_s: type: integer description: >- Cache age in seconds. Omitted when the response was not cached, and also when it was cached but its age cannot be established (an entry stored before its cache carried a computed instant). Never a placeholder: an unknown age is reported as no value rather than as the cache TTL. cost: type: integer description: >- Advisory request weight (relative compute cost). 1 for simple reads; higher for heavier endpoints. Not a credit/price. ranking_generation: type: integer description: >- Committed PostgreSQL-owned leaderboard generation for the returned rows and cursor. Present on GET /api/v1/leaderboard; omitted on endpoints that do not read this ranking. ranking_as_of: type: string format: date-time description: >- Authoritative RFC3339 timestamp from cache_generations.updated_at for ranking_generation. It is read in the same repeatable-read snapshot as the leaderboard rows and is not request time, cache write time, or row insertion order. directional_source: type: string enum: - live - degraded description: >- Which path produced the team-directional read on this response. Only present on endpoints that compute one (today: GET /api/v1/sports-edge-signals). "live" means the read RAN. "degraded" means it FAILED, so nothing was measured and the ranking fell back to raw conviction. The flag describes the READ, not its consequence: a read that ran and found nothing groupable also leaves the directional fields null, and that is honestly "live" -- the per-signal nulls already say "nothing to enrich here", so this snapshot-level flag carries only what they cannot, namely whether the read ran at all. A degraded response is cached on the shorter degraded TTL so it self-heals. Reported SEPARATELY from ranking_source because the two degradations are independent -- a sharp-money DB miss weakens the ranking DATA, a directional failure removes a ranking WEIGHT -- and a consumer down-weighting a degraded response needs to know which input it lost. Omitted on endpoints that compute no directional read. ranking_source: type: string enum: - live - db_only description: >- Which ranking-data path produced this response. Only present on endpoints that can degrade a ranking (today: GET /api/v1/sports-edge-signals). "live" is the normal path (the current holder pile from the provider batch); "db_only" is the degraded fallback (a truthful but weaker trader_markets ranking) served when the live sharp-money ranking batch is unavailable (a sharp-money DB read failure, not a Polymarket outage) and cached on a shorter TTL, so a consumer can down-weight or skip it. Omitted on endpoints that never degrade. category_skill_source: type: string enum: - live - partial - degraded - unavailable description: >- Whole filtered snapshot category-evidence status before pagination. Operational live always remains partial source coverage. category_skill_model_version: type: string category_skill_taxonomy_version: type: string category_skill_platform: type: string const: polymarket category_skill_scope: type: string const: observed_goldsky_primary_taker_fill category_skill_source_coverage: type: string enum: - partial_whale_threshold_fills - graded_wallet_fills category_skill_observation_started_at: type: string format: date-time category_skill_model_operationally_degraded: type: boolean description: >- Whole-model operational readiness captured with the category model snapshot. Present on category-enriched responses even when the filtered signal list is empty. When true, category_skill_source is degraded and sports-edge-signals uses the shorter degraded cache TTL. category_skill_status_counts: type: object required: - live - insufficient - stale - unknown - degraded properties: live: type: integer minimum: 0 insufficient: type: integer minimum: 0 stale: type: integer minimum: 0 unknown: type: integer minimum: 0 degraded: type: integer minimum: 0 category_skill_base_payload_hash: type: string pattern: ^[0-9a-f]{64}$ description: >- SHA-256 of the funded signal membership/order/rank/cursor vector immediately before category-skill enrichment. Sports-edge-signals only. category_skill_enriched_base_payload_hash: type: string pattern: ^[0-9a-f]{64}$ description: >- Independent SHA-256 recomputation over the same base fields immediately after category-skill enrichment. Equality with category_skill_base_payload_hash proves shadow enrichment did not change funded inputs. Sports-edge-signals only. ApiError: type: object required: - object - error - meta properties: object: type: string const: error error: type: object required: - code - message properties: code: type: string description: >- FROZEN: an existing value never changes meaning. request_timeout (408, #16146) was added the way insufficient_scope was: the handler did not answer inside the server's 30-second timeout. Retry-After and retry_at ride on it only for a safe method (GET, HEAD); a timed-out mutation may have completed, so check its state and reuse its Idempotency-Key. enum: - bad_request - invalid_api_key - subscription_required - forbidden - insufficient_scope - not_found - account_locked - rate_limited - rate_limit_unavailable - internal_error - request_timeout message: type: string doc_url: type: string param: type: string retry_at: type: string format: date-time description: >- The recommended next request instant (RFC3339), always in the future. Present on every retryable error: `pick_not_released`, `rate_limited`, `rate_limit_unavailable`, and `read_model_warming`. Omitted otherwise. The absolute twin of `Retry-After`; prefer the header for the sleep duration. For `pick_not_released`, the earliest of the next scheduled release, the next automatic selector attempt, the operating-window start, or about 60 seconds. See that response. freshness: $ref: '#/components/schemas/FreshnessFailure' reason: type: string enum: - cursor_expired - unknown_endpoint - pick_not_released - trader_not_tracked - read_model_warming - database_unavailable - request_accounting_unavailable - idempotency_in_progress - webhook_delivery_in_progress - webhook_secret_rotation_not_prepared - webhook_secret_rotation_overlap_active - sandbox_api_key - api_key_in_query - subscription_inactive - monthly_quota_exceeded - invalid_query - unknown_query_parameter - invalid_path - invalid_body - unsupported_media_type - payload_too_large - method_not_allowed - ip_rate_limited - ip_throttled - export_expired - freshness_ceiling_unsatisfied description: >- ADDITIVE (#7209). The specific, actionable cause behind `code`, when there is one more specific than the code itself. `code` keeps its published values, so existing clients are unaffected; new clients branch on `reason`. Omitted when the code already says everything we know. pick_not_released: no Pick of the Day is published for the current product day; schedule one request against retry_at instead of polling. unknown_endpoint: the PATH is not a route on this API -- read GET /api/v1, do not retry. trader_not_tracked: the wallet is real and the URL is right, but the trader is outside the HOT/WARM sync tiers -- stop asking for this wallet. cursor_expired: pagination went stale mid-walk -- re-request the first page and continue. read_model_warming: the requested endpoint cannot serve its read model yet; exact causes are endpoint-specific and can include a cold or contended refresh or a dependency that prevented refresh. database_unavailable: the API's database or its connection pool is temporarily unreachable (a connection-class failure, not a query fault); code stays rate_limit_unavailable, nothing is rate-limited, retry after Retry-After / retry_at. idempotency_in_progress: retain the exact Idempotency-Key and request body, then retry shortly. webhook_delivery_in_progress: retry the URL or signing-secret configuration change after the destination's active request completes. request_accounting_unavailable: accounting capacity is unavailable before the handler executes; retry after Retry-After / retry_at. sandbox_api_key: the credential is a sandbox key (oxi_sk_test_) from POST /api/v1/agents/register, which only the sandbox server accepts -- call the sandbox base URL with it, or get a live key or OAuth access token; do not retry it here. api_key_in_query: the key was sent as a ?token= query parameter, which no route reads because URLs land in logs and history; the key itself was not checked -- resend it as Authorization: Bearer. subscription_inactive: the key is valid but the account's Pro subscription has lapsed (402 subscription_required); permanent until a person reactivates at https://0xinsider.com/billing, which the message names -- stop retrying on a schedule and surface the link. The key owner is emailed once per lapse. monthly_quota_exceeded: the account has used the requests Pro includes for the UTC calendar month (429 rate_limited); retry_at and Retry-After name the first of next month, the only retry that can succeed, and the message names https://0xinsider.com/developers, where pay as you go for requests over the quota is turned on. The X-Monthly-Quota-Limit, X-Monthly-Quota-Remaining and X-Monthly-Quota-Reset headers on every authenticated response say how close the account is. invalid_query, invalid_path, invalid_body (400 bad_request, #16146): a query parameter, a path segment or the JSON body did not parse or does not fit the route's schema, so no handler ran; param names the field when the parser named one (a query key, a path segment, a JSON path such as traders[0], or body); fix the request, never retry it as sent. unsupported_media_type (415 bad_request, param content-type): send the body with Content-Type: application/json. payload_too_large (413 bad_request, param body): the body is over 1048576 bytes. method_not_allowed (405 bad_request): the path is a route but not with this method; the Allow header names the methods it serves. ip_rate_limited (429 rate_limited, #16380): the per-address budget every caller behind one IP shares, counted before authentication, is spent; not the key's own window, and the RateLimit-* headers describe that bucket. ip_throttled (429 rate_limited): the address is in a cooldown after sustained over-limit traffic; Retry-After is minutes to days, and a request before it does not shorten the cooldown. meta: $ref: '#/components/schemas/ResponseMeta' ScheduledPickSlot: type: object description: >- An entitled same-day pick selected but not yet released: stable rank and backend-owned release/kickoff instants. No matchup, category, platform, side, price, or holder fields appear before release. Unauthorized scheduled ranks appear only in locked_picks. required: - pick_rank - release_at - kickoff - pick_id - publication_order - is_free_selection - supersedes_pick_id properties: pick_rank: type: integer minimum: 1 maximum: 20 description: >- Deprecated compatibility daily release slot; use pick_id for identity and publication_order for scheduling. deprecated: true release_at: type: string format: date-time description: >- The slot's stored release instant. Qualified automatic selections are due immediately; explicitly scheduled selections retain their stored time. The actual publication can follow final checks and worker delay. kickoff: type: string format: date-time description: The backed game's current kickoff instant. pick_id: type: string pattern: ^[1-9][0-9]*$ description: >- Stable pick row identity as decimal text. Never use a quality rank as identity. publication_order: type: integer description: >- Compatibility release slot. No quality claim; historic scheduling order is retained. is_free_selection: type: boolean description: >- Viewer-independent free selection designation. New rows store it explicitly; historic null storage uses the original free slot. supersedes_pick_id: type: string nullable: true pattern: ^[1-9][0-9]*$ description: Replacement predecessor stable id; null when no lineage is recorded. PickHolder: type: object required: - address - name - grade - last_traded_at - shares properties: address: type: string name: type: string nullable: true grade: type: string nullable: true description: All-time trader grade (S, A, B, C, D, F). last_traded_at: type: string format: date-time nullable: true description: >- The wallet's most recent recorded trade time, stamped at serve time from its current trader record rather than frozen with the pick. Always sent; null when no trade time is recorded. profile_segment: type: string description: >- 0xinsider profile path segment this wallet links to: `@` when that username resolves to this wallet alone, otherwise the lowercase wallet. Percent-encode the part after `@` and append to `https://0xinsider.com/profile/`. Stamped at serve time; absent on a body cached before the field shipped. shares: type: number entry_value_usd: type: number description: >- USD entry value of this wallet's position: `shares` times the pick's frozen `backed_price`. An entry valuation, never a live balance or the provider's current value. Omitted when the holder snapshot has no valid price. category_win_rate: type: number minimum: 0 maximum: 1 description: >- This wallet's win rate in the pick's canonical category bucket (the pick's `category` field, e.g. Basketball -- label the rate with it, never with the narrower `display_category` league, except when `category_win_rate_game` is present, in which case the rate is that game's and is labelled with it): the share of the wallet's resolved markets in that category whose realized P&L closed positive, as a 0..1 fraction. Present only with `category_win_rate_status` = `measured`, on `display_holders` entries, and only when the wallet clears the resolved-market floor; recomputed at serve time from the current category read model, not frozen with the pick. Absent on `holders` entries, legacy rows, and payloads predating the field. category_win_record: type: object required: - wins - decided properties: wins: type: integer minimum: 0 description: >- Resolved markets in the category that this wallet closed with a profit. decided: type: integer minimum: 0 description: >- Resolved markets in the category that this wallet closed with a profit or a loss. A market resolved at zero realized P&L is in neither count. description: >- The two counts `category_win_rate` is the ratio of, read from the same row: `wins / decided` equals the rate. Counts every resolved Polymarket market the wallet traded in the pick's canonical category (or in its game, when `category_win_rate_game` is present), at any position size; the counts are rebuilt daily. Present only with `category_win_rate_status` = `measured`; absent otherwise and on payloads predating the field. category_win_rate_game: type: string description: >- For an esports pick, the game `category_win_rate` and `category_win_record` were measured in, by the same name the pick's `display_category` uses for it: `LoL`, `CS2`, `Dota 2`, `Valorant`, `Call of Duty`, `Honor of Kings`, `Mobile Legends: Bang Bang`, `Overwatch`, `Rainbow Six Siege`, `Rocket League` or `StarCraft II`. Present only when the wallet's record in that game clears the 5-resolved-market floor, in which case the rate and record are the game's rather than the `Esports` bucket's. Absent when the rate is the bucket's (the wallet's game history is under the floor), on every non-esports pick, beside every non-measured status, and on payloads predating the field. Label the rate with this when present and with `category` otherwise. category_win_rate_status: type: string enum: - measured - not_enough_data - unavailable description: >- Why `category_win_rate` is present or absent on a `display_holders` entry: `measured` (rate present), `not_enough_data` (the wallet is below the resolved-market floor of 5 in the category), or `unavailable` (the annotation read failed; retry later). Absent entirely on `holders` entries, legacy rows, and payloads predating the field -- absence means the roster was never annotated, not a small sample. wallet_age_days: type: number nullable: true description: >- Days since this wallet's first trade. Stamped at serve time from the wallet's current trader record, never frozen with the pick. The five badge fields are present together, and only for a wallet that carries at least one badge; all absent means no badge, or a body cached before the fields shipped. is_new_wallet: type: boolean description: >- True when the wallet's first trade was under 30 days ago. Stamped at serve time from the wallet's current trader record, never frozen with the pick. The five badge fields are present together, and only for a wallet that carries at least one badge; all absent means no badge, or a body cached before the fields shipped. markets_traded: type: integer nullable: true description: >- Distinct markets this wallet has traded. Stamped at serve time from the wallet's current trader record, never frozen with the pick. The five badge fields are present together, and only for a wallet that carries at least one badge; all absent means no badge, or a body cached before the fields shipped. is_bot: type: boolean description: >- True when the wallet has traded 10,000 or more distinct markets, the breadth floor 0xinsider uses to mark automated wallets. It is a breadth rule, not proof of automation. Stamped at serve time from the wallet's current trader record, never frozen with the pick. The five badge fields are present together, and only for a wallet that carries at least one badge; all absent means no badge, or a body cached before the fields shipped. x_username: type: string nullable: true description: >- The wallet's X handle from its Polymarket profile, normalized to 1-15 characters of [A-Za-z0-9_] with no `@`. Link it as `https://x.com/`. Stamped at serve time from the wallet's current trader record, never frozen with the pick. The five badge fields are present together, and only for a wallet that carries at least one badge; all absent means no badge, or a body cached before the fields shipped. PickSportsContext: type: object required: - league_name - league_logo - yes_team - no_team - event_matchup description: >- Provider-first sports context for a Pick of the Day market: team crests, league branding, and live score. Team logos and league logo are provider-owned (Polymarket /teams crests for clubs, country flags for national teams and tennis players); no local derivation. properties: league_name: type: string nullable: true description: League or competition display name (e.g. "Premier League"). competition_label: type: string description: >- Provider-owned event taxonomy from Gamma eventMetadata, joined in league · serie · tournament order with blanks and case-insensitive duplicates removed. Separate from league_name; omitted when the provider does not supply the metadata. league_logo: type: string nullable: true description: League logo URL (provider-owned). yes_team: allOf: - $ref: '#/components/schemas/PickSportsTeam' nullable: true description: >- The team mapped to the market's YES outcome, or the parent-event home/first team when event_matchup is true. no_team: allOf: - $ref: '#/components/schemas/PickSportsTeam' nullable: true description: >- The team mapped to the market's NO outcome, or the parent-event away/second team when event_matchup is true. game_id: type: integer description: >- Provider game identifier (Polymarket Gamma gameId); omitted when the provider supplies none. event_matchup: type: boolean description: >- Always present. True when the two teams are the parent-event match identity for a teamless binary leg (e.g. a draw, totals, or prop market), not the market's own outcomes. event_subject_team: allOf: - $ref: '#/components/schemas/PickSportsTeam' description: >- Present only alongside event_matchup: the event team the binary leg is about (provider group_item_title matched to a matchup team, e.g. Belgium for "Will Belgium win?"), i.e. the winner on a Yes resolution. Omitted for teamless legs (draw, totals, prop). matchup_title: type: string description: >- The two teams as a single whole-game label, joined " – " (en-dash) in provider display order (e.g. "Portugal – Uzbekistan"). Composed server-side from the provider team names (no title/slug parsing). Present when both teams resolve a name; omitted for single-subject, teamless, or non-two-team contexts. ProofPendingPickSlot: type: object description: >- One PUBLISHED same-day pick whose holder proof is not readable yet: its stable slot rank, the release and kickoff instants, and the instant before which a retry cannot succeed. Every item in `picks` carries its full required shape, so a pick that cannot meet it is listed here instead of being served with missing fields or a synthetic zero. required: - pick_rank - release_at - retry_at - pick_id - publication_order - is_free_selection - supersedes_pick_id properties: pick_rank: type: integer minimum: 1 maximum: 20 description: >- Deprecated compatibility daily release slot; use pick_id for identity and publication_order for scheduling. deprecated: true release_at: type: string format: date-time description: The pick's stored release instant. kickoff: type: string format: date-time description: >- The backed game's frozen kickoff instant; absent for a legacy row without one. retry_at: type: string format: date-time description: >- Recommended next read: 30 seconds ahead while pre-game proof is warming, one hour ahead for a post-kickoff pending legacy row that only settlement can make readable. Schedule against it instead of polling. pick_id: type: string pattern: ^[1-9][0-9]*$ description: >- Stable pick row identity as decimal text. Never use a quality rank as identity. publication_order: type: integer description: >- Compatibility release slot. No quality claim; historic scheduling order is retained. is_free_selection: type: boolean description: >- Viewer-independent free selection designation. New rows store it explicitly; historic null storage uses the original free slot. supersedes_pick_id: type: string nullable: true pattern: ^[1-9][0-9]*$ description: Replacement predecessor stable id; null when no lineage is recorded. PotdEntryAuthorization: type: object required: - version - authorization_id - policy_version - condition_id - token_id - outcome_index - category - canonical_event_id - max_entry_price - reference_best_ask - reference_book_hash - reference_book_at - issued_at - expires_at properties: version: type: integer enum: - 1 authorization_id: type: string format: uuid policy_version: type: integer enum: - 7 - 8 description: >- Entry allowance policy, independent of selection or feed policy. Policy 8 issues new grants at the first reference ask plus 0.05, capped at 0.85 and floored to the provider tick. Policy 7 retains its original plus-0.02 grant. Existing grants never rise or extend. condition_id: type: string token_id: type: string outcome_index: type: integer enum: - 0 - 1 category: type: string description: Canonical sport bucket, not display_category. canonical_event_id: type: string description: >- Exact provider parent event ID, or provider event ID when no parent exists. max_entry_price: type: string description: >- Maximum authorized order price as an exact decimal string, excluding fees. Quote a current executable book for the actual stake and keep the submitted order price at or below this bound. Actual fills may be lower; this limit does not guarantee a fill or define fair probability. reference_best_ask: type: string description: >- Selected-token best ask at first issuance. The entry allowance uses this immutable reference, not the published pick price or a later quote. reference_book_hash: type: string reference_book_at: type: string format: date-time issued_at: type: string format: date-time expires_at: type: string format: date-time description: >- Original authorization expiry at the earlier requested or provider kickoff; never extended. An expired authorization cannot authorize a new automated entry. description: >- Returned entry permission bound to the named market, token and outcome. New policy-8 grants allow five cents above the first reference ask, capped at 85 cents and floored to the provider tick; policy-7 grants retain their original two-cent allowance. Honor the immutable max_entry_price and expires_at, and quote a current executable book for the actual stake. The submitted order price must remain within the limit; fills may be lower. Fees are separate, and this grant does not guarantee liquidity, execution or positive expected value. PickLeadBacker: type: object description: >- Recorded lead wallet facts, available only on full newly certified picks. Position and category history are frozen at publication; they are not live balances or pick win probabilities. properties: address: type: string description: Lead trader wallet address. name: type: string nullable: true description: Recorded provider display name. grade: type: string description: Trader grade recorded at publication. category: type: string description: Canonical sport of the recorded directional history. position_usd: type: number description: >- Provider-reported position value on the backed outcome at publication, in USD. It is the gross value on that outcome and does not subtract shares the wallet held on the other outcome; see net_position_usd. It is not the entry cost or a live balance. net_position_usd: type: number description: >- Net value of the lead's position toward the backed outcome at publication, in USD: shares held on the backed outcome minus shares held on the other outcome of the same market, valued at the backed outcome's provider price at publication. Present only when the wallet also held the other outcome; absent for a one-sided position, whose net equals position_usd. It is not a live balance. position_observed_at: type: string format: date-time description: >- Start time of the provider position fetch used at publication. This conservative observation clock precedes completion; the position is not a live balance. directional_event_count: type: integer description: Distinct directional events in the recorded category history. profitable_event_count: type: integer minimum: 0 maximum: 4294967295 description: >- Events with strictly positive native terminal P&L in the same frozen category sample as directional_event_count, realized_pnl_usd and roi. Multiple market positions in one event contribute one combined event result. Zero-profit events remain in directional_event_count but do not increase this count. This is a recorded wallet result, not a market win rate or the pick's win probability. realized_pnl_usd: type: number description: >- Realized P&L over the recorded directional category sample, in USD. Excludes open positions and later changes. entry_basis_usd: type: number description: >- Recorded entry basis of that directional sample, in USD; not a claim of complete trading costs or fees. roi: type: number description: >- Realized P&L divided by recorded entry basis, as a fraction: 0.10 means 10%. This is a wallet statistic, not a pick win probability. max_realized_drawdown_usd: type: number description: >- Peak-to-trough realized P&L drawdown after each event result in the recorded sample, in USD. Excludes intragame, unrealized, and account equity drawdown. recorded_at: type: string format: date-time description: >- Timestamp when the directional history evidence was recorded, separate from the provider position snapshot clock. required: - address - name - grade - category - position_usd - position_observed_at - directional_event_count - profitable_event_count - realized_pnl_usd - entry_basis_usd - roi - max_realized_drawdown_usd - recorded_at FreshnessFailure: type: object required: - max_age_s - data_quality_status properties: max_age_s: type: integer format: int64 minimum: 0 description: The caller's requested whole-response freshness ceiling in seconds. actual_age_s: type: integer format: int64 minimum: 0 description: >- Age in seconds of the oldest stored data_quality.as_of clock, when one is available. as_of: type: string format: date-time description: >- The oldest stored data-quality clock used to calculate actual_age_s, when one is available. data_quality_status: type: string enum: - fresh - partial - unknown - untracked - unavailable description: >- The trader body's whole-response data-quality status. Only fresh can satisfy max_age_s. PickSportsTeam: type: object description: >- A single sports team or competitor in a Pick of the Day market's sports context. Identity and score fields are provider-owned and nullable. The structured score fields (`sets`, `format`, `sets_won`) and the tennis fields (`headshot`, `headshot_revision`, `tour`) are backend-owned and are OMITTED rather than null when they do not apply, so a consumer must treat an absent key and a null the same way. required: - label - short_label - full_name - provider_id - logo - logo_mark_dark - color - record - score properties: label: type: string nullable: true description: >- Team display label as it appears on the market outcome (e.g. "Portugal"). short_label: type: string nullable: true description: Abbreviated team label (e.g. "POR"). full_name: type: string nullable: true description: >- Full team or competitor name (e.g. "Portugal national football team"). provider_id: type: integer nullable: true description: Provider team identifier (Polymarket /teams id). logo: type: string nullable: true description: >- Team crest or flag URL. Official NFL (32), WNBA (15), NBA (30), NHL (32), and MLB (30) club crests use same-origin relative paths (`/api/sports/team-logos/{league}/{abbr}.svg?v=`); resolve relative URLs against the API origin. Vendored soccer club crests use the same path with `.png`. Other teams use provider artwork, including country flags for national teams and tennis players. Novelty and national-team rows outside the vendored club sets retain provider artwork. logo_mark_dark: type: boolean description: >- True when artwork measurements show that the team mark needs a light plate on a dark background. Vendored crest verdicts are tied to the exact asset bytes; provider artwork is measured by the teams sync. Always sent; false when no current measurement marks the logo dark. color: type: string nullable: true description: Team brand color as a hex string (provider-owned). record: type: string nullable: true description: Win-loss record as a display string (e.g. "12-4"). score: type: string nullable: true description: >- Live or final score as a display string when the game is in play or settled. headshot: type: string description: >- Tennis player headshot URL, served same-origin. Present only for a tennis competitor the headshot resolver matched; absent for team sports and for unmatched players, where `logo` stays the fallback. tour: type: string enum: - atp - wta - itf description: >- Tennis tour this competitor belongs to. Present for every tennis entry whether or not `headshot` resolved, so a consumer can tell a tennis player with no photo from a non-tennis team. Absent for every other sport. Only `atp` and `wta` name a gender; the ITF World Tennis Tour runs men's and women's events and the provider does not say which, so `itf` means tennis with gender unknown. sets: type: array items: $ref: '#/components/schemas/ScoreCell' description: >- Per-set score cells for this side, in set order. Backend-owned: render these rather than parsing `score`. Omitted entirely when the provider score is not a structured multi-set match or could not be parsed, so an absent array and an empty one carry the same meaning. format: $ref: '#/components/schemas/ScoreFormat' sets_won: type: integer description: >- Completed sets won by this side. Present only when both sides expose the same set columns, so a partially parsed scoreline reports no tally rather than a misleading one. headshot_revision: type: integer format: int64 minimum: 0 description: >- Optional monotonic photo revision for this tennis player, independent of the sports score revision. Legacy stored photos start at zero. Successful new or changed image bytes advance it; source checks and attribution changes do not. Compare only for the same tour and provider_id: a higher revision replaces the portrait, an equal revision may fill a missing portrait, and a lower revision must not replace a newer one. Absent when no photo resolved. ranking: allOf: - $ref: '#/components/schemas/TennisRanking' description: >- Optional latest retrieved ATP/WTA singles rank for this player. Absent for unranked, ambiguous, doubles, expired, or unavailable identities. This is not rank at match time. ScoreCell: type: object description: >- One side's score in a single set. The verbatim provider text stays on the team's `score` string; this is the parsed form. required: - games properties: games: type: integer description: Games won in this set. tiebreak: type: integer description: >- Tiebreak points won in this set. Omitted when the set had no tiebreak; absence and zero are different. ScoreFormat: type: string enum: - two_side - multi_set - esports_series description: >- Shape the provider score string was parsed into. `two_side` is one aggregate per side (basketball `105-98`), `multi_set` is per-set columns (tennis `6-7(5-7), 6-0, 1-0`), `esports_series` is a maps/sets/format triplet (`000-000|2-0|Bo3`). Omitted when the score could not be parsed. TennisRanking: type: object description: >- A provider-reported ATP/WTA singles rank with independent retrieval and expiry clocks. API-Tennis provides no ranking publication date. Retrieval time does not establish when the tour published the ranking. required: - rank - tour - source - observed_at - expires_at additionalProperties: false properties: rank: type: integer minimum: 1 maximum: 4294967295 description: Provider-reported singles rank. tour: type: string enum: - atp - wta description: The player ranking tour. source: type: string enum: - api_tennis description: The standings provider. observed_at: type: string format: date-time description: >- Successful snapshot retrieval time in UTC, not ranking publication date. expires_at: type: string format: date-time description: >- UTC deadline after which clients must hide this rank, including when an older game or pick response remains cached. securitySchemes: bearerAuth: type: http scheme: bearer description: >- Legacy default or named integration API key, or OAuth 2.1 access token, in the Authorization header as `Bearer oxi_sk_live_...` or `Bearer oxi_at_...`. Default keys retain full access; integration keys are limited to their approved read, webhooks, export and usage scopes and expire within 90 days. All credentials share the owner's account limits. Data calls require an active Pro subscription and return live data. A 401 carries WWW-Authenticate: Bearer resource_metadata="https://api.0xinsider.com/.well-known/oauth-protected-resource" (RFC 6750 section 3, RFC 9728). oauth2: type: oauth2 description: >- OAuth 2.1 authorization code flow with PKCE S256 for apps and MCP clients acting for a user. Public clients only (no client secret): register with RFC 7591 at https://api.0xinsider.com/oauth/register or present an https client ID metadata document URL as client_id. Authorization server metadata: https://api.0xinsider.com/.well-known/oauth-authorization-server. The access token (oxi_at_..., one hour) is sent as `Authorization: Bearer`; refresh tokens rotate on every use. A route outside the token's scopes answers 403 insufficient_scope. Walkthrough: https://0xinsider.com/auth.md. flows: authorizationCode: authorizationUrl: https://0xinsider.com/oauth/authorize tokenUrl: https://api.0xinsider.com/oauth/token refreshUrl: https://api.0xinsider.com/oauth/token scopes: read: >- Read markets, traders, large trades, positions, reports, search, the event stream and every MCP tool webhooks: Create, list, verify, rotate and delete webhook endpoints export: Start, poll and download trader exports usage: Read the caller's API usage counters ```` This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.