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

# Get futures for a sport

> Returns futures/outright **competition events** (e.g. tournament winner) for a sport, with future-class markets in the standard V2 market → participants → lines → prices shape and per-market settlement state. Competition events are excluded from the dated game endpoints and served only here. **Early access — requires an Ultra plan or higher.**

A competition is an **interval**, not an instant: `event_date` is when it starts and `settle_by` is when it must have graded. Futures events carry no `teams` array and no score — the human-readable identity is `schedule.event_name`.

**Date filtering uses interval overlap.** An event is returned when its `[event_date, settle_by]` span intersects the requested window — `settle_by >= from` and `event_date <= to`. So the default `from=now` means "in flight right now" and matches a season future that started months ago.

**Paging is keyset-based** (no skip parameter). When more results exist the response carries `meta.next_cursor`; pass it back verbatim as `cursor`. Ordering is soonest-to-resolve first: `settle_by`, then `event_date`, then `event_id`. `meta.count` is the number of events on the page, `meta.has_more` says whether another page exists, and `meta.total` is the number of events matching your filters across all pages, so a single call tells you the size of the listing.

**Default visibility:** settled markets are removed per market, an event is hidden once every requested future-class market on it has settled, and terminal (final/canceled/abandoned) events are excluded. `include_settled=true` lifts all of those **and** the default `from=now`, so settled history is reachable.

**Delta bootstrap:** On known zero-delay access, `meta.delta_last_id` can seed `GET /api/v2/markets/delta` only when this snapshot explicitly reports `X-Data-Delay-Seconds: 0`; it is a positive whole-integer cursor. With a positive, absent, or invalid delay header, keep using scoped snapshots and do not substitute `0`. Futures market IDs are **not** in the delta feed's default set — pass them explicitly (e.g. `market_ids=1141`) when polling. See the [Futures guide](/guides/futures) for the full integration recipe.




## OpenAPI

````yaml get /api/v2/sports/{sportID}/futures
openapi: 3.1.0
info:
  title: TheRundown Sports API
  version: 2.0.0
  description: >
    **Resolve the event first.** Ambiguous date, team, player, or timezone? The
    agent asks instead of guessing.


    **Every price carries evidence.** Event, market, affiliate ID, line, and the
    price update time. A fetch time is not freshness.


    **Missing stays missing.** No remembered odds, no synthetic prices, no
    filled gaps.


    **IDs come from the API.** Sports, markets, and affiliates are discovered at
    runtime. Retired affiliates stay out.


    Real-time and historical sports betting data, odds, lines, and statistics
    across major North American and international sports leagues.


    ## Authentication

    All endpoints (except `/sports` and `/affiliates`) require authentication.
    Send your API key from a private server-side environment variable in the
    `X-TheRundown-Key` header.

    The query-key security scheme is retained for compatibility with existing
    integrations and deprecated for new integrations; do not put keys in URLs,
    prompts, browser bundles, or public code.

    ## Off-the-Board Sentinel Value

    The value **0.0001** indicates a line is "off the board" — the sportsbook
    has temporarily removed pricing (e.g., pending injury news). This is NOT an
    error. Display as "Off Board" or "N/A" in your UI.


    ## Rate Limiting

    Requests are rate-limited per API key tier. Check response headers for
    current limits.


    ## Data Updates

    - Live odds update in real-time during games

    - Use delta endpoints for efficient polling of changes

    - WebSocket connections available for streaming updates


    ## V1 vs V2

    V2 endpoints use market-based data structures (market_id, participants, line
    prices). V1 endpoints use legacy line-based structures (moneyline, spread,
    total objects). V2 is recommended for new integrations.
  contact:
    name: TheRundown API Support
    url: https://therundown.io
    email: support@therundown.io
  termsOfService: https://therundown.io/terms
servers:
  - url: https://therundown.io
    description: Production
security:
  - ApiKeyHeader: []
tags:
  - name: V2 Sports
    description: Sport listings, dates, and teams (V2)
  - name: V2 Events
    description: Events with market-based odds (V2)
  - name: V2 Markets
    description: Market definitions, odds, deltas, and history (V2)
  - name: V2 Futures
    description: >-
      Futures/outright competition events — championship and tournament-winner
      boards (V2, early access)
  - name: V2 Teams
    description: Team data, players, and stats (V2)
  - name: V2 Players
    description: Player data (V2)
  - name: V2 Stats
    description: Team and player statistics (V2)
  - name: V2 WebSocket
    description: Real-time streaming via WebSocket (V2)
  - name: V2 Reference
    description: Reference data — affiliates, sportsbooks, season types (V2)
  - name: V1 Events
    description: Events with line-based odds (V1 legacy)
  - name: V1 Lines
    description: Moneyline, spread, total, best-line endpoints (V1 legacy)
  - name: V1 Sports
    description: Sport listings, dates, events, schedules (V1 legacy)
  - name: V1 Delta
    description: Delta/change feeds (V1 legacy)
  - name: V1 Reference
    description: Reference data (V1 legacy)
  - name: V1 WebSocket
    description: Real-time streaming via WebSocket (V1 legacy)
externalDocs:
  description: Build with AI guide
  url: https://therundown.io/build-with-ai
paths:
  /api/v2/sports/{sportID}/futures:
    get:
      tags:
        - V2 Futures
      summary: Get futures for a sport
      description: >
        Returns futures/outright **competition events** (e.g. tournament winner)
        for a sport, with future-class markets in the standard V2 market →
        participants → lines → prices shape and per-market settlement state.
        Competition events are excluded from the dated game endpoints and served
        only here. **Early access — requires an Ultra plan or higher.**


        A competition is an **interval**, not an instant: `event_date` is when
        it starts and `settle_by` is when it must have graded. Futures events
        carry no `teams` array and no score — the human-readable identity is
        `schedule.event_name`.


        **Date filtering uses interval overlap.** An event is returned when its
        `[event_date, settle_by]` span intersects the requested window —
        `settle_by >= from` and `event_date <= to`. So the default `from=now`
        means "in flight right now" and matches a season future that started
        months ago.


        **Paging is keyset-based** (no skip parameter). When more results exist
        the response carries `meta.next_cursor`; pass it back verbatim as
        `cursor`. Ordering is soonest-to-resolve first: `settle_by`, then
        `event_date`, then `event_id`. `meta.count` is the number of events on
        the page, `meta.has_more` says whether another page exists, and
        `meta.total` is the number of events matching your filters across all
        pages, so a single call tells you the size of the listing.


        **Default visibility:** settled markets are removed per market, an event
        is hidden once every requested future-class market on it has settled,
        and terminal (final/canceled/abandoned) events are excluded.
        `include_settled=true` lifts all of those **and** the default
        `from=now`, so settled history is reachable.


        **Delta bootstrap:** On known zero-delay access, `meta.delta_last_id`
        can seed `GET /api/v2/markets/delta` only when this snapshot explicitly
        reports `X-Data-Delay-Seconds: 0`; it is a positive whole-integer
        cursor. With a positive, absent, or invalid delay header, keep using
        scoped snapshots and do not substitute `0`. Futures market IDs are
        **not** in the delta feed's default set — pass them explicitly (e.g.
        `market_ids=1141`) when polling. See the [Futures
        guide](/guides/futures) for the full integration recipe.
      operationId: v2GetFuturesForSport
      parameters:
        - $ref: '#/components/parameters/SportIDPath'
        - name: from
          in: query
          schema:
            type: string
          description: >-
            Start of the window. A competition is returned when its `settle_by`
            is at or after this — i.e. it has not finished yet. RFC3339
            timestamp or `YYYY-MM-DD`; date-only values use the `offset`
            timezone. Defaults to **now**, with two exceptions where it is left
            unbounded instead: when `include_settled=true` (so settled history,
            whose intervals ended in the past, stays reachable), and when an
            explicit `to` is itself already in the past (defaulting `from` to
            now would describe an inverted, always-empty window).
          example: '2026-08-01'
        - name: to
          in: query
          schema:
            type: string
          description: >-
            End of the window. A competition is returned when its `event_date`
            (start) is at or before this. RFC3339 timestamp or `YYYY-MM-DD`,
            inclusive; date-only values use the `offset` timezone. Unbounded
            when omitted.
          example: '2026-08-31'
        - $ref: '#/components/parameters/OffsetQuery'
        - name: limit
          in: query
          schema:
            type: integer
            default: 50
            maximum: 200
          description: >-
            Maximum events returned per page (values above 200 are clamped to
            200).
        - name: cursor
          in: query
          schema:
            type: string
          description: >-
            Opaque keyset page token. Pass `meta.next_cursor` from the previous
            response verbatim; omit for the first page. Do not parse or
            construct the token.
        - name: include_settled
          in: query
          schema:
            type: boolean
            default: false
          description: >-
            Set to `true` to include settled markets (with their graded
            `settlement` entries) and terminal (finished/canceled) competition
            events. Also lifts the default `from=now`, so settled history is
            reachable — add explicit `from`/`to` bounds to scope it.
        - name: market_ids
          in: query
          schema:
            type: string
          description: >-
            Comma-separated market IDs, intersected with the future-class market
            set (1141 = Tournament Winner on every futures sport; golf adds
            1392–1396). When omitted, all future-class markets are returned.
            Game-market IDs match no markets here (events still return, with
            empty markets arrays).
          example: '1141'
        - $ref: '#/components/parameters/AffiliateIDsQuery'
      responses:
        '200':
          description: Futures events retrieved successfully
          headers:
            X-Data-Delay-Seconds:
              description: >-
                Optional data-delay entitlement value in whole seconds. Only an
                explicit value of `0` confirms zero-delay access for
                market-delta bootstrap; a positive or missing value means use
                scoped snapshots.
              schema:
                type: integer
                minimum: 0
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/FuturesEventsResponse'
              example:
                meta:
                  delta_last_id: '1595215769'
                  next_cursor: >-
                    MTc4NTY0MzIwMDAwMDAwMDAwMHwxNzg1Mzg0MDAwMDAwMDAwMDAwfDc2ODVhMzJkYTYyOGM3N2UwMzFhMmQ5NzAxMTI4ODgy
                  count: 50
                  has_more: true
                  total: 73
                events:
                  - event_id: a3d1f9f94f220a45cfd944181569cc46
                    sport_id: 2
                    event_date: '2026-09-10T00:00:00Z'
                    settle_by: '2027-02-21T00:00:00Z'
                    event_status: STATUS_SCHEDULED
                    settlement: {}
                    schedule:
                      event_name: NFL Super Bowl Winner (2026 Season)
                      season_year: 2026
                    markets:
                      - id: 4967891
                        market_id: 1141
                        period_id: 0
                        name: tournament_winner
                        market_description: Tournament Winner
                        participants:
                          - id: 61
                            type: TYPE_TEAM
                            name: Buffalo Bills
                            lines:
                              - id: 8155509548895b87157633c87df81b3e
                                prices:
                                  '22':
                                    id: '665502535'
                                    price: 1000
                                    is_main_line: true
                                    updated_at: '2026-07-29T17:01:46Z'
                                  '25':
                                    id: '665857721'
                                    price: 1074
                                    is_main_line: true
                                    updated_at: '2026-07-29T18:30:25Z'
                          - id: 63
                            type: TYPE_TEAM
                            name: New England Patriots
                            lines:
                              - id: b1d9b8b548f232cc35ea2a3995449d3c
                                prices:
                                  '22':
                                    id: '665502553'
                                    price: 2000
                                    is_main_line: true
                                    updated_at: '2026-07-29T17:01:46Z'
        '400':
          description: Invalid parameter (malformed date, cursor, or ID list)
          content:
            application/json:
              schema:
                type: object
                properties:
                  error:
                    type: string
        '403':
          description: Plan does not include futures markets
          content:
            application/json:
              schema:
                type: object
                properties:
                  error:
                    type: string
                  upgrade_url:
                    type: string
              example:
                error: Futures markets require Ultra plan or higher
                upgrade_url: /pricing/api
components:
  parameters:
    SportIDPath:
      name: sportID
      in: path
      required: true
      schema:
        type: integer
      description: >
        Sport ID. Common values: 1=NCAAF, 2=NFL, 3=MLB, 4=NBA, 5=NCAAB, 6=NHL,
        7=UFC, 8=WNBA, 9=CFL, 10=MLS, 11=EPL, 16=UEFA Champions League, 33=UEFA
        Europa League, 38=ATP Tennis, 39=WTA Tennis, 40=PGA Tour Golf,
        41=Formula 1
    OffsetQuery:
      name: offset
      in: query
      schema:
        type: integer
        default: 0
        example: 300
      description: >-
        UTC offset in **minutes** for the date boundary. Use `300` for US
        Central, `240` for Eastern, `360` for Mountain, `420` for Pacific.
        Without this, the API day boundary is midnight UTC.
    AffiliateIDsQuery:
      name: affiliate_ids
      in: query
      schema:
        type: string
      description: >
        Comma-separated sportsbook/affiliate IDs to filter. Common values
        include DraftKings (19), FanDuel (23), BetMGM (22), BookMaker (7),
        BetCRIS (9), Pinnacle (3), Polymarket US (31), Circa Sports (32), Bet105
        (33), and Heritage Sports (34). Availability varies by sport and market.

        On V2 event endpoints (`/api/v2/sports/{sportID}/events/{date}`,
        `/api/v2/events/{eventID}`, and their openers/closing siblings),
        `affiliate_ids=0` is a scores-only sentinel: the response keeps events,
        scores, and status and omits markets and price objects. Other endpoints
        that share this parameter treat `affiliate_ids` as a sportsbook filter
        only.
  schemas:
    FuturesEventsResponse:
      type: object
      properties:
        meta:
          $ref: '#/components/schemas/FuturesMeta'
        events:
          type: array
          items:
            $ref: '#/components/schemas/FuturesEvent'
    FuturesMeta:
      type: object
      properties:
        delta_last_id:
          $ref: '#/components/schemas/MarketDeltaCursor'
          example: '1595215769'
        next_cursor:
          type: string
          description: >-
            Opaque keyset token for the next page. Present only while more rows
            exist; absent on the last page. Pass back verbatim as `cursor`.
        count:
          type: integer
          description: >-
            Number of events on this page (the length of `events`). Always
            present.
          example: 50
        has_more:
          type: boolean
          description: >-
            `true` while more pages exist (the same signal as `next_cursor`, as
            a boolean). `false` on the last page. Always present.
          example: true
        total:
          type: integer
          description: >-
            Number of events matching your filters across ALL pages, so you can
            size a listing without walking every page. Counts events, not
            markets; the keyset cursor does not affect it. Always present.
          example: 73
    FuturesEvent:
      type: object
      description: >-
        One competition event. Competitions are intervals — `event_date` is the
        start and `settle_by` the settlement horizon. Futures events have no
        `teams` array and no score block.
      properties:
        event_id:
          type: string
          description: >-
            Opaque hash identifying the competition. Stable for the life of the
            competition — the public handle across snapshots and the delta feed.
          example: a3d1f9f94f220a45cfd944181569cc46
        sport_id:
          type: integer
          example: 2
        event_date:
          type: string
          format: date-time
          description: When the competition starts (interval start).
        settle_by:
          type: string
          format: date-time
          description: >-
            Settlement horizon — when the competition must have graded (interval
            end).
        event_status:
          type: string
          description: >-
            Event status. Season-long team competitions currently remain
            `STATUS_SCHEDULED` for the life of the board (live in-progress
            status for team seasons is not yet populated); short competitions
            like golf tournaments do transition to `STATUS_IN_PROGRESS` and
            `STATUS_FINAL`.
          example: STATUS_SCHEDULED
        settlement:
          type: object
          description: >-
            Per-market settlement state, keyed by market ID. Empty (`{}`) until
            grading begins — a market with no entry has not entered grading.
          additionalProperties:
            $ref: '#/components/schemas/FuturesSettlement'
        schedule:
          $ref: '#/components/schemas/FuturesSchedule'
        markets:
          type: array
          description: >-
            Future-class markets in the standard V2
            market/participant/line/price shape.
          items:
            $ref: '#/components/schemas/MarketResponse'
    MarketDeltaCursor:
      description: >-
        Positive whole-integer cursor for `/api/v2/markets/delta`. The API may
        return it as an integer or a numeric string. Use a snapshot value to
        begin market-delta polling only for known zero-delay access when that
        snapshot explicitly reports `X-Data-Delay-Seconds: 0`; otherwise use
        scoped snapshots and never substitute `0`.
      oneOf:
        - type: integer
          format: int64
          minimum: 1
        - type: string
          pattern: ^[1-9][0-9]*$
    FuturesSettlement:
      type: object
      description: Per-market settlement state for a competition event.
      properties:
        status:
          type: string
          description: >-
            Settlement state. A market with no `settlement` entry at all has not
            entered grading; entries appear with a pre-grading status (e.g.
            `pending`) as the competition nears resolution, and become `settled`
            once graded. `settled` is the only terminal value — treat anything
            else as grading in progress; the vocabulary may grow.
          example: settled
        winning_line:
          type: string
          description: >-
            Canonical name of the winning participant. Present once settled, for
            winner-shaped markets only — entry markets (Top 10, Make The Cut)
            grade per participant and settle without a single winner.
          example: Jackson Koivun
        winning_participant_id:
          type: integer
          format: int64
          description: >-
            Participant ID of the winner, matching
            `markets[].participants[].id`. Present once settled, for
            winner-shaped markets only.
          example: 139644
        settled_at:
          type: string
          format: date-time
          description: When the market graded. Present once settled.
    FuturesSchedule:
      type: object
      description: Trimmed schedule block for a competition event.
      properties:
        event_name:
          type: string
          description: Human-readable competition name — the display identity of the event.
          example: NFL Super Bowl Winner (2026 Season)
        season_year:
          type: integer
          example: 2026
        league_name:
          type: string
          description: >-
            League or tour label, when applicable (e.g. `PGA Tour`). Omitted
            otherwise.
          example: PGA Tour
    MarketResponse:
      type: object
      description: Market with participants and prices for a specific event
      properties:
        id:
          type: integer
          format: int64
        market_id:
          type: integer
          example: 1
        period_id:
          type: integer
        name:
          type: string
          example: Money Line
        market_description:
          type: string
        participants:
          type: array
          items:
            $ref: '#/components/schemas/MarketParticipantResponse'
    MarketParticipantResponse:
      type: object
      properties:
        id:
          type: integer
          description: >-
            Stable, joinable participant identifier. Join on this field rather
            than name to avoid shared-name collisions. Its meaning depends on
            `type`: for `TYPE_TEAM` it is the normalized team ID (stable across
            seasons, matches `event.teams[].team_id`; full record at GET
            /api/v2/teams/{team_id}); for `TYPE_PLAYER` it is the player ID
            (full record at GET /api/v2/players/{player_id}); for `TYPE_RESULT`
            it is a small outcome index (e.g. 0/1 for Over/Under) and is not a
            team or player resource key.
          example: 51
        type:
          type: string
          description: >-
            Kind of participant. Determines what `id` points to (team, player,
            or result outcome).
          enum:
            - TYPE_TEAM
            - TYPE_PLAYER
            - TYPE_RESULT
        name:
          type: string
          description: >-
            Display name. Not guaranteed unique across participants — join on
            `id`, not `name`.
          example: New England Patriots
        lines:
          type: array
          items:
            $ref: '#/components/schemas/MarketLinesResponse'
    MarketLinesResponse:
      type: object
      properties:
        id:
          type: string
        value:
          type: string
          description: >-
            Line value. For spreads/totals this is numeric; for some prop and
            special markets it can be a method, round, threshold, or other
            display value. When `line_value_is_participant` is true, the
            participant usually carries the selection.
        selection:
          type: string
        handicap:
          type: string
        prices:
          type: object
          description: Prices keyed by affiliate ID
          additionalProperties:
            $ref: '#/components/schemas/MarketLinePriceResponse'
    MarketLinePriceResponse:
      type: object
      properties:
        id:
          type: string
        price:
          type: number
          description: American odds price. Value of 0.0001 means "off the board".
          example: -110
        price_delta:
          type: number
          nullable: true
          description: Change from previous price
        is_main_line:
          type: boolean
          description: Whether this is the primary/main line
        source_id:
          type: string
          description: >-
            The sportsbook's own identifier for this price/selection, when
            available. Omitted when the book does not expose one. For Polymarket
            (affiliate 26) this encodes
            `<event-slug>-<gamma-market-id>-<clob-token-id>` (parse from the
            right; the two trailing fields are numeric) — see the Source
            identifiers section of the Sportsbook reference for the full mapping
            recipe.
        liquidity_usd:
          type: number
          description: >-
            USD reading for this price. On Kalshi (affiliate 25) and Polymarket
            (affiliate 26) this is approximate resting order-book depth
            (Polymarket reports its own figure alongside the price; Kalshi's is
            derived from its order book on a separate refresh cadence). On
            Pinnacle (affiliate 3) this is the book's max stake. Omitted
            entirely, never null and never a fabricated 0, when a current
            reading is not available. See the docs FAQ for details.
          example: 4210.5
        updated_at:
          type: string
          format: date-time
        closed_at:
          type: string
          format: date-time
          description: Closing timestamp for this price; omitted if no recorded closure.
  securitySchemes:
    ApiKeyHeader:
      type: apiKey
      in: header
      name: X-TheRundown-Key
      description: Recommended API key request header for new integrations

````

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