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

# Edge Hunter

> Get the Max-only Edge Hunter board with ranked sports markets, backing data, and current quotes.

Use the experimental Edge Hunter endpoint to read the ranked sports markets shown on [the Edge Hunter page](https://0xinsider.com/sports/edge). Each row includes its game and market identity, the side backed by graded wallets, the measured backing, and current outcome quotes when available.

This endpoint requires Max. A valid Pro credential returns `403 forbidden` with `error.reason: max_plan_required`. It replaces the retired sports signals and observations endpoints; it is a different response contract.

## Parameters

| Parameter | Meaning |
| - | - |
| `horizon_hours` | Includes kickoffs after the snapshot's `as_of` and up to this many hours later. It defaults to 48 and is clamped to 1 through 48. |

The board covers all sports with a fixed `B` grade floor, including `S`, `A`, and `B` wallets. It returns the first 30 ranked rows after the horizon filter. `total` counts the matching rows before that cap.

## Key response fields

The response uses `object: "edge_hunter"`. Read the board from `data`, and the request metadata from `meta`.

| Field | Meaning |
| - | - |
| `data.as_of` | The time the ranking snapshot was computed. |
| `data.horizon_hours`, `data.min_grade` | The applied kickoff window and fixed `B` grade floor. |
| `data.ranking_source` | `live` uses the current holder backing; `db_only` reports a fallback ranking from stored wallet positions. |
| `data.directional_source` | `live` means the directional read ran; `degraded` means it failed. |
| `data.cached_age_seconds` | The ranking snapshot's cache age, or `null` when computed for this request. |
| `data.viewer` | Always `max` on this API endpoint. |
| `data.free_rank` | Always `null`; there is no free signal row. |
| `data.total` | The matching row count before the 30-row cap. |
| `data.rows[].state`, `data.rows[].free` | Always `full` and `false`. |
| `data.rows[].rank` | The row's rank within the returned window, starting at 1. |
| `data.rows[].condition_id`, `event_slug`, `title` | The market and event identity. Optional identities can be `null`. |
| `data.rows[].category`, `raw_category` | The canonical sport and provider category, such as `Soccer` and `EPL`. |
| `data.rows[].game_start_time` | The known kickoff time. |
| `data.rows[].volume` | The provider's cumulative traded volume in shares, not cash traded. |
| `data.rows[].participants` | Participant names and available provider IDs, logos, colors, or headshots. |
| `data.rows[].outcomes` | Both outcomes in provider order, with labels and current quotes when available. |
| `data.rows[].signal` | The backed side, graded-wallet counts, backed dollars, backing share, ranking scores, and current quote. |

`signal.sharp_pct` is a fraction, not a percentage: `0.81` means 81%. `signal.s_count`, `a_count`, and `b_count` count the backing wallets by grade; `graded_holders` is their combined count.

## Ranking and quote clocks

A ranking snapshot and a current quote measure different things. `as_of` dates the ranking; each available `current_price` has its own `price`, `basis`, and `ts`. A kickoff can have passed by the time you receive a cached snapshot, so compare `game_start_time` with the current time before using the row.

`price` is a decimal string. `basis` is `midpoint` or `last_trade`, and `ts` is an epoch-millisecond string for the observed quote state. `validated_at`, when present, is a separate epoch-millisecond string for the validation time.

A missing quote is `null`. Do not substitute zero or treat the quote as the wallets' entry price. Read `ranking_source` and `directional_source` before presenting a fallback as current evidence.

## Example

```bash theme={null}
curl -sS \
  -H "Authorization: Bearer $OXINSIDER_API_KEY" \
  "https://api.0xinsider.com/api/v1/edge-hunter?horizon_hours=24"
```

Use a Max API key or an authorized OAuth token. See [Authentication](/authentication).

## What it does not return

* Observation cohorts, their funnel, or holder-arrival history.
* Cursor pagination, a category filter, or a configurable grade floor.
* Backed token IDs or category-skill evidence.
* A guaranteed return, an executed entry price, or an order instruction.

The retired paths are `/api/v1/sports-edge-signals`, `/api/v1/sports-edge-observations`, `/api/v1/sports/pre-game-sides`, and `/api/v1/sports/pre-game-side-observations`. All 4 return `410 endpoint_retired`. Update the response parser when migrating.


## OpenAPI

````yaml GET /api/v1/edge-hunter
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,
    X-Effective-Query, Deprecation, Sunset, and Link 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=<milliseconds> 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=<code> 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.
  - name: Combos
    description: Polymarket multi-leg combo fills, details, and live counts.
externalDocs:
  description: 0xinsider API docs
  url: https://docs.0xinsider.com
paths:
  /api/v1/edge-hunter:
    get:
      tags:
        - Markets
      summary: Get Edge Hunter
      description: >-
        Read the full experimental Edge Hunter board at
        https://0xinsider.com/sports/edge. Max only: a Pro credential returns
        403 forbidden with reason max_plan_required. Across all sports and
        esports, the board uses a fixed B grade floor, reports total before its
        30-row cap, and includes provider participants, both outcome quotes, and
        backed-side analytics. horizon_hours defaults to 48 and is clamped to
        1..48. Snapshot and quote clocks are independent. There is no category,
        cohort, cursor, limit, or min_grade parameter. This is analytics, not an
        order instruction.
      operationId: getEdgeHunter
      parameters:
        - name: X-Query-Validation
          in: header
          required: false
          description: >-
            Set to strict to reject unsupported query names. By default, unknown
            query names are ignored and reported in X-Query-Ignored.
          schema:
            type: string
            enum:
              - strict
        - name: horizon_hours
          in: query
          required: false
          description: >-
            Kickoff window in hours from the snapshot anchor. Defaults to 48;
            integer values below 1 or above 48 are clamped to 1 or 48.
          schema:
            type: integer
            default: 48
      responses:
        '200':
          description: >-
            The full Max-only Edge Hunter board. No ETag or pagination is
            provided.
          headers:
            X-Query-Ignored:
              $ref: '#/components/headers/X-Query-Ignored'
            X-Effective-Query:
              $ref: '#/components/headers/X-Effective-Query'
            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: edge_hunter
                  data:
                    $ref: '#/components/schemas/EdgeHunterBoard'
                  meta:
                    $ref: '#/components/schemas/ResponseMeta'
              example:
                object: edge_hunter
                data:
                  as_of: '2026-10-11T18:00:00Z'
                  horizon_hours: 48
                  min_grade: B
                  ranking_source: live
                  directional_source: live
                  cached_age_seconds: null
                  viewer: max
                  free_rank: null
                  total: 0
                  rows: []
                meta:
                  request_id: req_example
                  cached: false
                  cost: 5
        '400':
          description: >-
            Invalid horizon_hours: send an integer. With X-Query-Validation:
            strict, an unsupported query name is rejected with reason
            unknown_query_parameter. No cursor or pagination parameter is
            accepted.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ApiError'
        '401':
          description: Missing or invalid API key
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ApiError'
        '402':
          description: >-
            Active Pro or Max subscription required for paid data. Edge Hunter
            additionally requires Max; an active Pro credential receives 403
            max_plan_required.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ApiError'
        '403':
          description: >-
            Forbidden. error.reason max_plan_required: the key is valid and its
            account is on Pro, but this route is part of Max; every Pro route
            keeps working with the same key, and error.message names the upgrade
            URL (https://0xinsider.com/pricing). Without a reason, the account
            was deleted.
          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: >-
            Redis-backed authenticated rate limiter unavailable; retry after the
            per-process outage cooldown
          headers:
            Retry-After:
              description: >-
                Seconds until the middleware will probe the Redis-backed rate
                limiter again.
              schema:
                type: integer
            X-Request-Id:
              schema:
                type: string
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ApiError'
      security:
        - bearerAuth: []
        - oauth2:
            - read
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:
    EdgeHunterBoard:
      type: object
      required:
        - as_of
        - horizon_hours
        - min_grade
        - ranking_source
        - directional_source
        - cached_age_seconds
        - viewer
        - free_rank
        - total
        - rows
      properties:
        as_of:
          type: string
          format: date-time
          description: >-
            When the ranked snapshot was computed. Date current quotes with
            their own ts values.
        horizon_hours:
          type: integer
          minimum: 1
          maximum: 48
        min_grade:
          type: string
          const: B
        ranking_source:
          type: string
          enum:
            - live
            - db_only
          description: >-
            live uses the current graded holder pile; db_only is a weaker
            stored-data fallback.
        directional_source:
          type: string
          enum:
            - live
            - degraded
          description: degraded means directional enrichment was unavailable.
        cached_age_seconds:
          type: integer
          nullable: true
          minimum: 0
        viewer:
          type: string
          const: max
        free_rank:
          type: integer
          nullable: true
          description: 'Always null: Edge Hunter has no free signal slot.'
        total:
          type: integer
          minimum: 0
          description: Ranked rows in this window before the 30-row cap.
        rows:
          type: array
          maxItems: 30
          items:
            $ref: '#/components/schemas/EdgeHunterRow'
      description: >-
        The full Edge Hunter board shown at https://0xinsider.com/sports/edge,
        for Max credentials. It covers all sports and esports with a fixed B
        grade floor and returns the first 30 ranked rows. No cursor or
        observation cohorts are exposed.
    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/edge-hunter). "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/edge-hunter). "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 the ranked sports snapshot 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 category-skill 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
                - endpoint_retired
            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
                - max_plan_required
                - endpoint_retired
              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 not on the warm sync tier (the wallets we sync
                most often) -- 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 its plan 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.
                max_plan_required (403 forbidden, #23085): the key is valid and
                its account is on Pro, but the route is part of Max (GET
                /api/v1/edge-hunter); every Pro route keeps working with the
                same key, so do not disable it. The message names
                https://0xinsider.com/pricing, where the account upgrades; a
                retry never clears it. endpoint_retired (410): this legacy
                sports endpoint no longer serves data. Migrate to GET
                /api/v1/edge-hunter; retrying the retired path cannot succeed.
        meta:
          $ref: '#/components/schemas/ResponseMeta'
    EdgeHunterRow:
      type: object
      required:
        - rank
        - state
        - free
        - condition_id
        - event_slug
        - title
        - category
        - raw_category
        - game_start_time
        - volume
        - participants
        - image
        - outcomes
        - signal
      properties:
        rank:
          type: integer
          minimum: 1
        state:
          type: string
          const: full
        free:
          type: boolean
          const: false
        condition_id:
          type: string
        event_slug:
          type: string
          nullable: true
        title:
          type: string
          nullable: true
        category:
          type: string
          nullable: true
          enum:
            - Basketball
            - Football
            - Baseball
            - Hockey
            - MMA
            - Boxing
            - Soccer
            - Cricket
            - Golf
            - Tennis
            - Esports
            - Racing
            - Table Tennis
            - Pickleball
        raw_category:
          type: string
          nullable: true
        game_start_time:
          type: string
          format: date-time
          nullable: true
        volume:
          type: number
          nullable: true
          description: >-
            Cumulative provider taker volume in shares, not cash in USD. Null
            when unavailable.
        participants:
          type: array
          items:
            $ref: '#/components/schemas/EdgeHunterParticipant'
        image:
          type: string
          nullable: true
        outcomes:
          type: array
          minItems: 2
          maxItems: 2
          items:
            $ref: '#/components/schemas/EdgeHunterOutcome'
        signal:
          $ref: '#/components/schemas/EdgeHunterSignal'
          nullable: true
      description: >-
        One full Max row from Edge Hunter. signal is populated on every row this
        endpoint returns. Identity and quotes preserve provider values; unknown
        values stay null.
    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.
    EdgeHunterParticipant:
      type: object
      required:
        - name
      properties:
        provider_id:
          type: integer
          format: int64
        logo:
          type: string
        logo_mark_dark:
          type: boolean
        color:
          type: string
        headshot:
          type: string
        headshot_revision:
          type: integer
          format: int64
        tour:
          type: string
        name:
          type: string
    EdgeHunterOutcome:
      type: object
      required:
        - index
        - label
        - provider_id
        - current_price
      properties:
        index:
          type: integer
          enum:
            - 0
            - 1
        label:
          type: string
          nullable: true
        provider_id:
          type: integer
          format: int64
          nullable: true
        current_price:
          $ref: '#/components/schemas/EdgeHunterPrice'
          nullable: true
      description: >-
        One provider outcome in YES/NO order. Null current_price means no
        verified current quote is available.
    EdgeHunterSignal:
      type: object
      required:
        - piled_side
        - piled_outcome_index
        - sharp_pct
        - backed_sharp_usd
        - s_count
        - a_count
        - b_count
        - graded_holders
        - top_grade
        - smart_score
        - net_side
        - conviction_score
        - one_way_holder_count
        - hedged_holder_count
        - one_way_graded_usd
        - directional_confidence
        - directional_rank_score
        - current_price
      properties:
        piled_side:
          type: string
          nullable: true
        piled_outcome_index:
          type: integer
          enum:
            - 0
            - 1
        sharp_pct:
          type: number
          nullable: true
          minimum: 0
          maximum: 1
          description: >-
            Fraction of graded money on the backed side, not a percentage from 0
            to 100.
        backed_sharp_usd:
          type: number
        s_count:
          type: integer
        a_count:
          type: integer
        b_count:
          type: integer
        graded_holders:
          type: integer
        top_grade:
          type: string
          nullable: true
          enum:
            - S
            - A
            - B
        smart_score:
          type: number
          nullable: true
        net_side:
          type: string
          nullable: true
        conviction_score:
          type: number
        one_way_holder_count:
          type: integer
          nullable: true
        hedged_holder_count:
          type: integer
          nullable: true
        one_way_graded_usd:
          type: number
          nullable: true
        directional_confidence:
          type: number
          nullable: true
        directional_rank_score:
          type: number
        current_price:
          $ref: '#/components/schemas/EdgeHunterPrice'
          nullable: true
      description: >-
        Backed-side analytics from the ranked snapshot, plus a separately dated
        current quote. Scores rank attention; they are not probabilities or
        order instructions.
    EdgeHunterPrice:
      type: object
      required:
        - price
        - basis
        - ts
      properties:
        price:
          type: string
          description: >-
            Provider probability as a decimal string. Keep its precision until
            display.
        basis:
          type: string
          enum:
            - midpoint
            - last_trade
        ts:
          type: string
          description: >-
            Source observation clock in epoch milliseconds, represented as a
            string.
        validated_at:
          type: string
          description: >-
            Backend validation clock in epoch milliseconds. Omitted when no
            current-source validation is available.
  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.