---
title: "Get today's Pick of the Day"
method: GET
path: "/api/v1/pick-of-the-day"
tags: ["Pick of the Day"]
---

# Get today's Pick of the Day

`GET /api/v1/pick-of-the-day`

One sourced sharp-money call a day (Pro-tier). Returns the published pick for the CURRENT product day: the backed side, the pre-game odds and $100 return, the proven sharp-money holders on that side, the grade, and a required truthful thesis. With proven holder backing the thesis uses the sharp-money grammar; without it the required string names the Pick of the Day without fabricating proof. The price is snapshotted before kickoff so it does not drift. It never serves a prior day's finished pick as today's, so an automated consumer never acts on a stale, already-settled game (a prior pick stays available through the archive endpoint). When no pick is published for the current product day it returns 404 with error.code="not_found" and error.reason="pick_not_released" -- branch on the reason, because error.code is a frozen contract and stays "not_found". That 404 is a schedule, not an outage: each selected pick normally releases one hour before its provider kickoff, within the 11:00-23:00 UTC operating window; a skipped day has no release. DO NOT POLL. error.retry_at (RFC3339, always in the future) and Retry-After give the recommended next attempt: the automatic release boundary before a selected pick; normally the persisted next automatic selector attempt (~15m) while no candidate exists; or a ~60s degradation when that schedule is absent, due, or a pick is overdue. Every value is advisory under supported operator actions: manual publication, release-time override, or admin generation can make a pick available first. Schedule one request rather than sleeping a worker thread.

## Headers

- `If-None-Match` string

## Response `200`

Today's Pick of the Day

- object
  - `object` 'pick_of_the_day', required
  - `data` PickOfTheDay, required
    - `state` 'full', required — Always 'full' for an authenticated Pro key.
    - `pick_date` string, date, required — The pick's local publication date (YYYY-MM-DD).
    - `pick_rank` integer — Stable 1-based slot within the product day's ranked picks.
    - `picks` PickOfTheDay[] — The complete ranked picks for this product day, ordered by pick_rank. Thin days contain fewer items; the selector never fabricates rows.
    - `pick_count` integer — Number of ranked picks.
    - `scheduled_picks` ScheduledPickSlot[] — Same-day picks selected but not yet released, ordered by pick_rank. Additive and optional: present only while at least one unreleased slot exists. Each slot exposes only its rank and schedule -- no market identity before release. Schedule the next read from the earliest release_at instead of polling.
      - `pick_rank` integer, required — Stable 1-based slot within the product day's ranked picks. The slot keeps this rank when it releases.
      - `release_at` string, date-time, required — The slot's scheduled release instant, normally the current provider kickoff minus one hour. The actual publish can trail it by bounded worker delay.
      - `kickoff` string, date-time, required — The backed game's current kickoff instant.
    - `matchup` string, required — Human-readable matchup (e.g. "Portugal vs. Uzbekistan").
    - `category` string, required — Frozen canonical calibration/report bucket (e.g. "Basketball", "MMA", or "Soccer"). Existing semantics are unchanged; presentation consumers should prefer display_category when present.
    - `display_category` string — Frozen public presentation category. For supported Polymarket sports this is the exact verified official event league (e.g. "WNBA" or "UFC"); otherwise it equals category. Additive and optional for mixed-version client compatibility.
    - `platform` string, required — Provider platform (e.g. "polymarket").
    - `release_at` string, date-time, required — The pick's stored release instant. Normally the current provider kickoff minus one hour; an operator may override it. The actual publish instant can trail it because of worker or claim delay.
    - `is_locked` boolean, required — 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` boolean — 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).
    - `outcome` 'pending' | 'win' | 'loss' | 'void', required — Settlement outcome of the backed side; 'pending' until the market resolves.
    - `outcome_display` string — 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` string, required — 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` string, nullable — The Polymarket CLOB token id (ERC1155 asset id, decimal string) for the backed outcome; null when unavailable (e.g. Kalshi markets, unsynced markets).
    - `position` string, required — The backed side phrased as a bet (e.g. "Portugal to win").
    - `side_summary` string, required — One-line summary of which side sharp money is backing. Any current-day published pick whose required holder proof is not safely readable returns 503 read_model_warming instead of a partial success shape.
    - `smart_wallet_count` integer, required — Public V1 compatibility count of S/A smart-money wallets on the backed side. The first-party/internal current policy counts S/A/B; historical rows retain their frozen policy's count. Any current-day published pick whose required holder proof is not safely readable returns 503 read_model_warming instead of fabricating zero or omitting this required field.
    - `top_grade` string, nullable — Best public V1-compatible S/A smart-money grade on the backed side. The first-party/internal current policy can select B, but a current B-only grade is omitted by the stable V1 adapter. Historical rows retain their frozen policy's grade. A current-day published pick with pending legacy proof, unknown-future proof, or structurally invalid current-policy proof returns 503 before this success schema is served. Resolved legacy proof remains readable on both current-day and archive/history responses.
    - `category_edge_pct` number, nullable — Deprecated (#7170): no longer populated for picks selected on/after the calibration-edge change; omitted (absent) for new picks (the field uses skip_serializing_if, so a null value is dropped from the JSON rather than serialized as null). Permanently frozen-legacy -- retained for historical picks, with no removal or replacement planned, so no v2 is implied. Historical picks may still carry a value. Legacy meaning: category win-rate edge as a fraction (the backed-side cohort's win rate in this category minus the non-market-maker category baseline, e.g. 0.09 = +9 points), paired with category_edge_sample.
    - `category_edge_sample` integer, nullable — Deprecated (#7170): no longer populated for picks selected on/after the calibration-edge change; omitted (absent) for new picks (the field uses skip_serializing_if, so a null value is dropped from the JSON rather than serialized as null). Permanently frozen-legacy -- retained for historical picks, with no removal or replacement planned, so no v2 is implied. Historical picks may still carry a value. Legacy meaning: pooled count of resolved markets behind category_edge_pct (the headline's n).
    - `smart_usd` number, nullable — Recency-weighted graded-flow magnitude in USD; omitted when <= 0.
    - `backed_price` number, nullable — Pre-game snapshot probability (0..1) for the backed side.
    - `odds_display` string, nullable — 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.
    - `return_per_100` number, nullable — Gross return on a $100 stake at the snapshotted price (100 / backed_price).
    - `payout_display` string, nullable — Pre-formatted return_per_100 as USD with cents and thousands separators: "$161.29" / "$1,250.00". The GROSS return (the $100 stake included), so it carries no sign. Convenience only; return_per_100 is the source value. Omitted when return_per_100 is.
    - `profit_display` string, nullable — Pre-formatted PROFIT on the $100 stake -- return_per_100 minus the 100 stake, i.e. the payout net of what you put in -- as a signed USD string: "+$61.29". Distinct from payout_display, which is gross. Omitted when return_per_100 is.
    - `clv_status` string, required — 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` string — 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` number — 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` string — Backend-formatted signed CLV percentage, present exactly when clv_pct is present.
    - `clv_explanation` string — Backend-owned CLV formula text with the entry probability, close probability, and rounded result. Provider timestamps remain private.
    - `unit_score` number — Net return for the pick in the existing $100 stake units. Omitted when the outcome is not valued.
    - `unit_score_display` string — Backend-formatted signed unit score, present exactly when unit_score is present.
    - `sharp_pct` number, nullable — First-party/internal backed-side sharp-money dollar consensus as a fraction 0..1: the share of current-policy sharp dollars on the backed side. Omitted on current public V1 rows when the B-inclusive value has no reconstructible S/A equivalent. A conviction signal, NOT a probability or expected-value claim. Frozen at generation.
    - `market_pct` number, nullable — Market-implied probability of the backed side as a fraction 0..1 (equals backed_price), re-exposed alongside sharp_pct for the WHY breakdown.
    - `consensus_edge_pct` number, nullable — First-party/internal consensus edge = sharp_pct - market_pct, the conviction-vs-price gap (how much more of the current-policy sharp money sits on this side than the price implies). Omitted on current public V1 rows when the B-inclusive value has no reconstructible S/A equivalent. This is NOT an expected-value or guaranteed edge. Null when either input is null.
    - `directional_confidence` number, nullable — First-party/internal team-directional commitment read at selection time: the fraction (0..1) of the backed side's current-policy graded sharp-money DOLLARS held by wallets that are genuinely one-way on this game, rather than hedged across its markets. Current public V1 rows omit this B-inclusive read because its historical S/A equivalent is not reconstructed. A high value means the graded pile is really committed to this side; a low one means much of it is hedged or unreadable. Omitted when the read was not computed (a pick selected before the field existed, an ungroupable game, or an empty graded pile) -- which is NOT the same as 0.0, a computed reading that nothing was confidently one-way.
    - `one_way_holder_count` integer, nullable — Graded backed-side holders read as one-way-committed on this game.
    - `hedged_holder_count` integer, nullable — Graded backed-side holders read as HEDGED across the game's markets.
    - `one_way_graded_usd` number, nullable — The one-way holders' share of the backed-side graded dollars (the confidence's numerator).
    - `total_graded_usd` number, nullable — Backed-side graded dollars the confidence is measured against (its denominator).
    - `qualifying_expert` object, nullable — The qualifying category expert whose sport-specific record and real position earned this pick its top selection tier. The first-party/internal current policy admits S/A/B; public V1 exposes a compatible S/A expert and omits a current-policy B-grade expert: a candidate backed by one outranks every candidate without one. Present only on the full payload. Omitted when no wallet qualified on the backed side, on picks generated before the field existed, and on the first-party web teaser, which withholds all backed-side evidence. Frozen at SELECTION time — the wallet's position can move before the pick renders.
      - `address` string, required — Wallet address of the qualifying expert.
      - `name` string, nullable — Provider display name, or null for an unnamed wallet.
      - `grade` string, nullable — 0xinsider grade letter. The first-party/internal current Pick of the Day policy counts S, A, and B; public V1 exposes only the compatible S/A expert.
      - `canonical_category` string, required — 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` number, required — Share of this wallet's resolved markets in canonical_category whose realized P&L came out positive, as a 0..1 fraction. Above 0.60 by construction. Deliberately NOT phrased as "closed profitable": the metric counts realized P&L above zero, so a resolved winner the wallet never redeemed sits at zero and counts against it.
      - `n_resolved` integer, required — Resolved markets in canonical_category behind win_rate. At least 10 by construction.
      - `position_usd` number, required — Polymarket's own currentValue for this wallet on the backed outcome, in USD, as of selection. At least 1000 by construction.
      - `stats_computed_at` string, date-time, required — When the category read model behind win_rate was last rebuilt.
    - `trust` PickTrust — Field-level trust metadata for the full Pick of the Day payload. Present on the full shape only (omitted on the teaser and the no-pick state, because whether a specialist backs the pick is itself backed-side evidence). Unlike TraderTrust it is not gated behind expand=trust: it carries one member on an endpoint that returns a single object per day.
      - `qualifying_expert` TrustMetadata, required — Shared source/freshness/reconciliation/completeness metadata for public API values that may be cached, stale, partial, computed, or provider-unavailable. Unavailable provider values must be represented with explicit metadata instead of fabricated zeros or empty arrays.
        - `source` TrustSource, required — Source metadata for a trust-critical value. Providers and DB/read models own business truth; clients should not infer missing provider facts from titles, slugs, zeros, or empty arrays.
          - `kind` 'provider' | 'database' | 'cache' | 'computed' | 'client_input' | 'unavailable', required
          - `owner` string, required — Provider, table/read-model, cache, or service that owns the value.
          - `field` string, nullable — Provider field, DB column, or computed field name when applicable.
        - `freshness` TrustFreshness, required — Freshness metadata for a trust-critical value. This is separate from transport cache fields in ResponseMeta.
          - `status` 'fresh' | 'refreshing' | 'stale' | 'not_live' | 'unknown' | 'unavailable', required
          - `as_of` string, date-time, nullable
          - `max_age_s` integer, nullable
        - `reconciliation` TrustReconciliation, required — How provider-owned facts were reconciled with stored/read-model values.
          - `status` 'provider_backed' | 'db_mirror' | 'computed' | 'partial' | 'not_applicable' | 'unavailable', required
          - `detail` string, nullable
        - `completeness` TrustCompleteness, required — Whether the described value or result set is complete for its stated contract.
          - `status` 'complete' | 'partial' | 'not_computed' | 'not_applicable' | 'unavailable', required
          - `detail` string, nullable
    - `traders` integer, nullable — Public V1 S/A compatibility count on the backed side (equals the adapted smart_wallet_count). The first-party/internal current policy counts S/A/B. Historical rows retain their frozen policy's count.
    - `backed_sharp_usd` number, nullable — Raw backed-side sharp-money USD frozen at generation. This is the Sharp USD value, not the recency-weighted smart_usd which decays. Omitted on current public V1 rows when the B-inclusive value has no reconstructible S/A equivalent.
    - `holders` PickHolder[], nullable — Bounded S/A compatibility projection of the frozen sharp-money holders on the backed side. Current full payloads expose the complete S/A/B roster in display_holders; historical rows can retain their earlier frozen shape.
      - `address` string, required
      - `name` string, nullable
      - `grade` string, nullable — All-time trader grade (S, A, B, C, D, F).
      - `shares` number, required
      - `category_win_rate` number, nullable — 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): 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_rate_status` 'measured' | 'not_enough_data' | 'unavailable' — 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.
    - `display_holders` PickHolder[], nullable — Full-only complete provider-confirmed S/A/B holder roster for the current Pick of the Day backing policy. Omitted for teaser, no-pick, and historical rows whose frozen holder proof predates this policy. Each entry may additionally carry `category_win_rate` / `category_win_rate_status`: the wallet's win rate in the pick's canonical `category`, stamped at serve time from the current category read model (the same annotation the sports sharp-money chips carry). The bounded `holders` compatibility projection never carries these fields.
      - `address` string, required
      - `name` string, nullable
      - `grade` string, nullable — All-time trader grade (S, A, B, C, D, F).
      - `shares` number, required
      - `category_win_rate` number, nullable — 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): 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_rate_status` 'measured' | 'not_enough_data' | 'unavailable' — 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.
    - `holder_count` integer, nullable — Exact S/A smart-money proof count on the backed side. The current display_holders roster can be longer because it also carries B-grade smart-money holders.
    - `editorial_note` string, nullable — Optional editorial note attached to the pick.
    - `thesis` string, required — Required truthful thesis. With at least one proven holder: Proven sharp money holds {pick_outcome_label}[, led by a grade-{top_grade} trader]. Without proven holder backing: 0xInsider's Pick of the Day is {pick_outcome_label}. Wallet counts are not appended.
    - `market_url` string, nullable — Canonical web market URL.
    - `event_slug` string, nullable — The canonical /event game-page slug (one neutral page per game), null when the game has no neutral event page.
    - `event_link_slug` string, nullable — Backend-resolved /event destination slug for this pick's source market; null is an authoritative no-link decision.
    - `sports_context` PickSportsContext — 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.
      - `league_name` string, nullable — League or competition display name (e.g. "Premier League").
      - `league_logo` string, nullable — League logo URL (provider-owned).
      - `yes_team` PickSportsTeam — 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`, `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.
        - `label` string, nullable — Team display label as it appears on the market outcome (e.g. "Portugal").
        - `short_label` string, nullable — Abbreviated team label (e.g. "POR").
        - `full_name` string, nullable — Full team or competitor name (e.g. "Portugal national football team").
        - `provider_id` integer, nullable — Provider team identifier (Polymarket /teams id).
        - `logo` string, nullable — Team crest or flag URL (provider-owned: Polymarket /teams crest for clubs, country flag for national teams and tennis players).
        - `color` string, nullable — Team brand color as a hex string (provider-owned).
        - `record` string, nullable — Win-loss record as a display string (e.g. "12-4").
        - `score` string, nullable — Live or final score as a display string when the game is in play or settled.
        - `headshot` string, nullable — 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` 'atp' | 'wta' | 'itf', nullable — 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` ScoreCell[] — 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.
          - `games` integer, required — Games won in this set.
          - `tiebreak` integer — Tiebreak points won in this set. Omitted when the set had no tiebreak; absence and zero are different.
        - `format` 'two_side' | 'multi_set' | 'esports_series' — 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.
        - `sets_won` integer, nullable — 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.
      - `no_team` PickSportsTeam — 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`, `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.
        - `label` string, nullable — Team display label as it appears on the market outcome (e.g. "Portugal").
        - `short_label` string, nullable — Abbreviated team label (e.g. "POR").
        - `full_name` string, nullable — Full team or competitor name (e.g. "Portugal national football team").
        - `provider_id` integer, nullable — Provider team identifier (Polymarket /teams id).
        - `logo` string, nullable — Team crest or flag URL (provider-owned: Polymarket /teams crest for clubs, country flag for national teams and tennis players).
        - `color` string, nullable — Team brand color as a hex string (provider-owned).
        - `record` string, nullable — Win-loss record as a display string (e.g. "12-4").
        - `score` string, nullable — Live or final score as a display string when the game is in play or settled.
        - `headshot` string, nullable — 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` 'atp' | 'wta' | 'itf', nullable — 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` ScoreCell[] — 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.
          - `games` integer, required — Games won in this set.
          - `tiebreak` integer — Tiebreak points won in this set. Omitted when the set had no tiebreak; absence and zero are different.
        - `format` 'two_side' | 'multi_set' | 'esports_series' — 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.
        - `sets_won` integer, nullable — 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.
      - `game_id` integer, nullable — Provider game identifier (Polymarket Gamma gameId); omitted when null.
      - `event_matchup` boolean, required — 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` PickSportsTeam — 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`, `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.
        - `label` string, nullable — Team display label as it appears on the market outcome (e.g. "Portugal").
        - `short_label` string, nullable — Abbreviated team label (e.g. "POR").
        - `full_name` string, nullable — Full team or competitor name (e.g. "Portugal national football team").
        - `provider_id` integer, nullable — Provider team identifier (Polymarket /teams id).
        - `logo` string, nullable — Team crest or flag URL (provider-owned: Polymarket /teams crest for clubs, country flag for national teams and tennis players).
        - `color` string, nullable — Team brand color as a hex string (provider-owned).
        - `record` string, nullable — Win-loss record as a display string (e.g. "12-4").
        - `score` string, nullable — Live or final score as a display string when the game is in play or settled.
        - `headshot` string, nullable — 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` 'atp' | 'wta' | 'itf', nullable — 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` ScoreCell[] — 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.
          - `games` integer, required — Games won in this set.
          - `tiebreak` integer — Tiebreak points won in this set. Omitted when the set had no tiebreak; absence and zero are different.
        - `format` 'two_side' | 'multi_set' | 'esports_series' — 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.
        - `sets_won` integer, nullable — 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.
      - `matchup_title` string, nullable — The two teams as a single whole-game label, joined "<home> – <away>" (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.
    - `disclaimer` string, required — Risk disclaimer shown with every pick.
  - `meta` ResponseMeta, required
    - `request_id` string, required — Unique request ID (req_ prefix).
    - `cached` boolean, required
    - `cache_age_s` integer, nullable — 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` integer, required — Advisory request weight (relative compute cost). 1 for simple reads; higher for heavier endpoints. Not a credit/price.
    - `directional_source` 'live' | 'degraded' — 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 smart-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` 'live' | 'db_only' — 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 smart-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` 'live' | 'partial' | 'degraded' | 'unavailable' — Whole filtered snapshot category-evidence status before pagination. Operational live always remains partial source coverage.
    - `category_skill_model_version` string
    - `category_skill_taxonomy_version` string
    - `category_skill_platform` 'polymarket'
    - `category_skill_scope` 'observed_goldsky_primary_taker_fill'
    - `category_skill_source_coverage` 'partial_whale_threshold_fills'
    - `category_skill_observation_started_at` string, date-time
    - `category_skill_model_operationally_degraded` boolean — 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` object
      - `live` integer, required
      - `insufficient` integer, required
      - `stale` integer, required
      - `unknown` integer, required
      - `degraded` integer, required
    - `category_skill_base_payload_hash` string — 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` string — 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.

## Other responses

- `304` — Not Modified. Returned when If-None-Match matches the current Pick of the Day payload.
- `401` — Missing or invalid API key
- `402` — Active Pro subscription required
- `403` — Account access denied
- `404` — No Pick of the Day is published for the current product day. This is expected before the selected pick's kickoff-relative release; each selected pick normally releases one hour before kickoff within the 11:00-23:00 UTC operating window, and on a skipped day no pick is published at all. 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.
- `408` — Request exceeded the server's 30-second transport timeout. The timeout response has an empty body because it is generated before handler-level JSON error shaping.
- `423` — Account is locked
- `429` — Rate limit exceeded. Two 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 before any item work is done.
- `503` — 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.

---

[API](https://skmtc.net/0xinsider/apis/0xinsider-api.md) · [All operations](https://skmtc.net/0xinsider/apis/0xinsider-api/llms.txt) · [OpenAPI document](https://skmtc-service-staging.skmtc.workers.dev/v1/apis/0xinsider/0xinsider-api/revisions/be0e25f93c7d/schema)