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

# Weekly report snapshot

> Get a weekly or custom date-range summary of large trades, with up to 100 top trades.

Use this endpoint for a weekly summary of large Polymarket trades recorded by 0xinsider. Select an ISO week or a date range, and read `snapshot.status` before treating the figures as final.

For a view that switches between days, weeks, and months, use [Reports](/api-reference/endpoint/get-reports).

## Parameters

Send either `week`, or both `from` and `to`. If you send none of them, you get `400` with `error.param` `from`. If you send all three, `from` and `to` decide the range.

| Parameter | Description |
| - | - |
| `week` | An ISO week, written as `YYYY-WW`. The range runs Monday to Sunday and is kept as a durable snapshot. A week number of `00`, or above `53`, returns `400` with `error.param` `week`. |
| `from`, `to` | A UTC date range, both written as `YYYY-MM-DD` and sent together. The range includes both dates and can be at most 31 days wide. |

A range wider than 31 inclusive days returns `400` with `error.reason` `invalid_query` and `error.param` `from`. A `from` later than `to` returns `400` with `error.param` `from`. Neither case is trimmed to fit.

## When the numbers stop changing

A report is `final` only once its body is built after the range has closed and after the trades from those dates have had time to arrive. That cutoff is `snapshot.final_after`: the UTC close of `end_date` plus the 7,530-second ingestion budget.

Until that instant `snapshot.status` is `rolling` and every number can still move. A closed range refreshes every 5 minutes until `final_after`, is rebuilt once after it, and is then frozen.

## Key response fields

| Field | Meaning |
| - | - |
| `source_range.start_date`, `end_date` | The first and last UTC date the report covers. Read them back when you sent a `week`. |
| `snapshot.storage` | `durable` for an ISO week, which is stored and versioned. `ephemeral` for a `from` and `to` range, which is computed for your request and not stored. |
| `snapshot.status` | `final` for a frozen body, `rolling` while the numbers can still change. |
| `snapshot.period_closed` | `true` once `end_date` has ended on the UTC calendar. A closed range is not yet a final one. |
| `snapshot.mutable_until` | On a `rolling` body, the UTC date that `final_after` falls on. `null` once the body is `final`. |
| `snapshot.version` | The content version of a durable ISO week. An `ephemeral` range always reports `0`, because it is never stored under an identity of its own. |
| `completeness.status` | `empty` when the range has no large trades, `partial` while the body is `rolling`, and `complete` once it is `final`. |
| `report.top_whale_trades` | At most 100 trades for a weekly report, whichever range you asked for. |
| `report.total_whale_volume` | The USD size of the large trades 0xinsider recorded in the range. It is not Polymarket's lifetime volume for those wallets. |

## Example

```bash theme={null}
curl -H "Authorization: Bearer $OXINSIDER_API_KEY" \
  "https://api.0xinsider.com/api/v1/reports/weekly?week=2026-19"
```

## What it does not return

* A `404` for a quiet week. A range with no large trades returns `200` with `completeness.status` `empty`.
* A trimmed range. A `from` and `to` range wider than 31 inclusive UTC days answers `400 invalid_query` instead of being cut down to fit.
* A settled figure while the range includes today, or in the 7,530 seconds after it ends. Wait for `snapshot.status` `final`.
* A `from` and `to` range on every request. When too many custom ranges are being computed at once, you get `503` with `error.reason` `read_model_warming` and a `Retry-After` of 5 seconds.


## OpenAPI

````yaml GET /api/v1/reports/weekly
openapi: 3.1.0
info:
  x-generated-rate-limit-policy-from: web/src/lib/rate-limit-facts.ts via web/scripts/generate-api-policy.ts
  title: 0xinsider API
  description: >-
    Follow provider-exposed large-trade activity from Polymarket. Polymarket
    wallet-attributed trades can add grades, P&L, strategy, and diagnostic-score
    context when sufficient source data exists. Fields can be null or
    unavailable. Normal API requests use a 30-second server timeout that returns
    HTTP 408 Request Timeout with the standard error envelope (error.code
    request_timeout) when exceeded. Every /api/v1 failure answers that envelope,
    including a body that is not JSON or does not fit the request schema (400
    invalid_body), a query or path value that does not parse (400 invalid_query,
    invalid_path), a missing Content-Type: application/json (415
    unsupported_media_type), a body over 1048576 bytes (413 payload_too_large)
    and a method the path does not serve (405 method_not_allowed), each with
    error.param naming the field where one is known and meta.request_id equal to
    X-Request-Id. Unknown query names are ignored by default and reported in
    X-Query-Ignored, while X-Effective-Query lists the normalized names and
    values applied using form-urlencoded decoding, where + is a space; strict
    mode returns 400 bad_request with error.reason unknown_query_parameter
    before the handler runs, including for an unknown name with an incomplete
    percent escape. Every list operation clamps an out-of-range limit into its
    published minimum..maximum instead of refusing it (limit=0 reads one row,
    limit=500 reads the maximum), and X-Effective-Query reports the clamped
    value; only a limit that is not an integer is refused, with 400
    invalid_query. Public REST /api/v1/* endpoints, excluding /api/v1/mcp, use
    Bearer-token based non-credentialed browser CORS: any Origin may call with
    Authorization, Content-Type, If-None-Match, Idempotency-Key, Mcp-Session-Id,
    Mcp-Protocol-Version, Last-Event-Id, and X-Query-Validation request headers.
    X-Query-Validation: strict opts into rejecting unknown query names; the
    default remains compatible. Remote MCP at /api/v1/mcp is non-credentialed,
    but still validates Origin against the 0xinsider/localhost allowlist per MCP
    Streamable HTTP DNS-rebinding guidance. Successful browser CORS preflight
    responses advertise Access-Control-Max-Age: 86400. Browser JavaScript may
    read RateLimit-Limit, RateLimit-Remaining, RateLimit-Reset, the legacy
    X-RateLimit-Limit, X-RateLimit-Remaining, X-RateLimit-Reset, Retry-After,
    ETag, X-Request-Id, X-Request-Cost, X-Usage-Accounting,
    X-Batch-RateLimit-Limit, X-Batch-RateLimit-Remaining,
    X-Batch-RateLimit-Reset, Mcp-Session-Id, X-Mcp-Error-Code, X-Query-Ignored,
    and X-Effective-Query response headers. Rate-limit headers describe the
    budget a request was counted against: the API key's per-minute window on an
    authenticated call, and the per-IP budget on a public route or on a refused
    credential (401, 402, 403, 423), so a client looping on a bad or lapsed key
    still sees how much room it has. Conditional GET: these operations return a
    weak ETag and answer If-None-Match with 304 Not Modified and an empty body:
    GET /api/v1/health, GET /api/v1/insider-radar, GET
    /api/v1/insider-radar/{id}, GET /api/v1/large-positions, GET
    /api/v1/leaderboard, GET /api/v1/leaderboard/trending, GET
    /api/v1/market/{condition_id}/candles, GET
    /api/v1/market/{condition_id}/flow, GET /api/v1/market/{condition_id}/intel,
    GET /api/v1/market/{condition_id}/snapshot, GET /api/v1/markets/explore, GET
    /api/v1/markets/sharp-money-flows, GET /api/v1/markets/smart-money-flows,
    GET /api/v1/pick-of-the-day, GET /api/v1/pick-of-the-day/archive, GET
    /api/v1/positions, GET /api/v1/sports-edge-observations, GET
    /api/v1/sports-edge-signals, GET /api/v1/trader/{address}, GET
    /api/v1/trader/{address}/context, GET /api/v1/trader/{address}/pnl, GET
    /api/v1/trader/{address}/position-timeline, GET
    /api/v1/traders/{trader}/position-timeline, GET /api/v1/large-trades, GET
    /api/v1/large-trades/history, GET /api/v1/large-trades/{id}, GET
    /api/v1/whale-trades, GET /api/v1/whale-trades/history, GET
    /api/v1/whale-trades/{id}, GET
    /api/v1/whale-trades/{id}/counterparties/executions, GET
    /api/v1/whale-trades/{id}/counterparties/executions/{execution_id}/makers.
    Credentialed first-party routes such as /api/keys, /api/billing, and auth
    endpoints remain restricted to configured 0xinsider origins. Protected V1
    responses, except the zero-cost /api/v1/usage route, after handler execution
    carry X-Usage-Accounting: persisted, failed, or unknown. This reports the
    usage-record write; it does not change the handler result. Do not replay a
    successful mutation to repair an unknown usage record. Before execution,
    unavailable accounting capacity returns HTTP 503 with
    error.reason=request_accounting_unavailable; honor Retry-After. Public API
    responses add the browser-readable Server-Timing header: Processing time in
    milliseconds, for example api;dur=12.345. Includes API authentication, quota
    admission, handler work and response construction. Excludes network transit
    and streamed body or export-file transfer. The engineering budget is
    strictly below 250 ms; this header reports observations, not a latency
    guarantee or a new timeout. Requests through https://0xinsider.com/api/*
    append Server-Timing: web_api;dur=<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.
externalDocs:
  description: 0xinsider API docs
  url: https://docs.0xinsider.com
paths:
  /api/v1/reports/weekly:
    get:
      tags:
        - Reports
      summary: Weekly report snapshot
      description: >-
        Returns a weekly whale-activity report snapshot. Pass an ISO YYYY-WW
        token for a durable canonical snapshot, or an exact from/to UTC range of
        at most 31 inclusive days for an ephemeral response. The response
        identifies closed ranges as final and current ranges as rolling.
      operationId: getWeeklyReportSnapshot
      parameters:
        - name: X-Query-Validation
          in: header
          required: false
          description: >-
            Opt into strict query-name validation. The default is compatible:
            unknown names are ignored and reported in X-Query-Ignored. With
            strict, an unknown name returns 400 bad_request with error.reason
            unknown_query_parameter before the handler runs, including when its
            percent escape is incomplete.
          schema:
            type: string
            enum:
              - strict
        - name: from
          in: query
          required: false
          description: >-
            UTC source-range start in YYYY-MM-DD format; required with to.
            Together with to, selects an exact ephemeral range of at most 31
            inclusive UTC days. A start after tomorrow UTC returns 400
            bad_request with error.param=from.
          schema:
            type: string
            pattern: ^\d{4}-\d{2}-\d{2}$
        - name: to
          in: query
          required: false
          description: >-
            UTC source-range end in YYYY-MM-DD format; required with from.
            Together with from, selects an exact ephemeral range of at most 31
            inclusive UTC days. An end before 2024-03-01, the first day report
            data covers, returns 400 bad_request with error.param=to.
          schema:
            type: string
            pattern: ^\d{4}-\d{2}-\d{2}$
        - name: week
          in: query
          required: false
          description: >-
            ISO week selector in YYYY-WW format; alternative to from/to. Selects
            a durable canonical snapshot. A week that ends before 2024-03-01,
            the first day report data covers, or starts after tomorrow UTC
            returns 400 bad_request with error.param=week.
          schema:
            type: string
            pattern: ^\d{4}-\d{2}$
      responses:
        '200':
          description: Weekly report snapshot
          content:
            application/json:
              schema:
                type: object
                required:
                  - object
                  - data
                  - meta
                properties:
                  object:
                    type: string
                    const: report_snapshot
                  data:
                    $ref: '#/components/schemas/ReportSnapshot'
                  meta:
                    $ref: '#/components/schemas/ResponseMeta'
              examples:
                success:
                  summary: Successful response
                  value:
                    object: report_snapshot
                    data:
                      kind: weekly
                      generated_at: '2026-09-21T11:45:11.573440+00:00'
                      source_range:
                        start_date: '2026-09-07'
                        end_date: '2026-09-13'
                        timezone: UTC
                      snapshot:
                        version: 41
                        storage: durable
                        status: final
                        generated_at: '2026-09-21T11:45:11.573440+00:00'
                        mutable_until: null
                        period_closed: true
                        final_after: '2026-09-14T02:05:30Z'
                        source_read_started_at: null
                      completeness:
                        status: complete
                        reason: >-
                          the requested source range is closed and this body was
                          read after the whale-trade ingestion budget elapsed;
                          zero-activity dates are represented by absence of
                          whale rows
                        expected_days: 7
                        covered_days_with_whale_activity: 7
                      reconciliation:
                        volume_kind: local_whale_activity_volume
                        whale_volume_source: >-
                          whale_alerts.usdc_notional_num (provider usdcSize when
                          supplied; size*price fallback when the WS/REST payload
                          omits it, until reconciled, #5430)
                        notes: >-
                          Report whale volume is a source-range snapshot over
                          local whale-alert activity, not provider lifetime
                          trader volume.
                      report:
                        total_whale_trades: 370
                        total_large_trades: 370
                        total_whale_volume: 11017645.500849
                        total_large_trade_volume: 11017645.500849
                        biggest_trade_size: 491236.3567
                        active_traders: 153
                        top_whale_trades:
                          - id: 12130
                            trade_time: '2026-09-09T23:21:04+00:00'
                            side: BUY
                            title: >-
                              US Open ATP: Alexander Zverev vs Botic van de
                              Zandschulp
                            outcome: Alexander Zverev
                            token_id: >-
                              9158437108174135547239483835198621883927847537872618727943792296109949759031
                            size: 491236.3567
                            price: 0.88
                            market_category: Tennis
                            platform: polymarket
                            name: Noprajsk
                            pseudonym: null
                            trader_grade: null
                          - id: 12127
                            trade_time: '2026-09-09T23:19:42+00:00'
                            side: BUY
                            title: >-
                              US Open ATP: Alexander Zverev vs Botic van de
                              Zandschulp
                            outcome: Alexander Zverev
                            token_id: >-
                              9158437108174135547239483835198621883927847537872618727943792296109949759031
                            size: 378649.17296
                            price: 0.88
                            market_category: Tennis
                            platform: polymarket
                            name: Noprajsk
                            pseudonym: null
                            trader_grade: null
                        top_large_trades:
                          - id: 12130
                            trade_time: '2026-09-09T23:21:04+00:00'
                            side: BUY
                            title: >-
                              US Open ATP: Alexander Zverev vs Botic van de
                              Zandschulp
                            outcome: Alexander Zverev
                            token_id: >-
                              9158437108174135547239483835198621883927847537872618727943792296109949759031
                            size: 491236.3567
                            price: 0.88
                            market_category: Tennis
                            platform: polymarket
                            name: Noprajsk
                            pseudonym: null
                            trader_grade: null
                          - id: 12127
                            trade_time: '2026-09-09T23:19:42+00:00'
                            side: BUY
                            title: >-
                              US Open ATP: Alexander Zverev vs Botic van de
                              Zandschulp
                            outcome: Alexander Zverev
                            token_id: >-
                              9158437108174135547239483835198621883927847537872618727943792296109949759031
                            size: 378649.17296
                            price: 0.88
                            market_category: Tennis
                            platform: polymarket
                            name: Noprajsk
                            pseudonym: null
                            trader_grade: null
                        categories:
                          - category: Soccer
                            whale_trade_count: 120
                            category_volume: 3618430.255359
                          - category: Tennis
                            whale_trade_count: 65
                            category_volume: 2751098.843941
                        grade_distribution: []
                    meta:
                      request_id: req_example
                      cached: false
                      cost: 1
          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'
        '400':
          description: >-
            Invalid request parameter. A weekly explicit from/to range wider
            than 31 inclusive UTC days returns 400 with
            error.reason=invalid_query. A period that ends before 2024-03-01,
            the first day report data covers, returns 400 bad_request with
            error.param=week or to; one that starts after tomorrow UTC, with
            error.param=week or from.
          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 subscription required. The key is valid but the account
            has no active Pro subscription; error.reason is
            subscription_inactive and error.message names the reactivation URL
            (https://0xinsider.com/billing). Permanent until a person
            reactivates: no Retry-After, never retry on a schedule.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ApiError'
        '403':
          description: Account access denied
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ApiError'
        '408':
          description: >-
            The handler did not answer inside the server's 30-second timeout.
            error.code is request_timeout. On GET and HEAD the response carries
            Retry-After and error.retry_at; on a mutation it carries neither,
            because the request may have completed on the server: check its
            state before repeating it, and reuse its Idempotency-Key.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ApiError'
        '423':
          description: Account is locked
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ApiError'
        '429':
          description: >-
            Rate limit exceeded. Three independent budgets. (1) 100
            requests/minute per user (sliding window), on every authenticated
            route. (2) On the BATCH routes only: 2500 batch item units/minute
            per user, reserved before any item is executed. A batch with N
            requested items costs N item units, including duplicate and invalid
            items. 2500 = 100 requests x 25 items per batch, which is the most
            item work a key can buy through the request limiter at all: a caller
            may spend their entire 100-request minute on full 25-item batches
            without the item budget being what stops them. The REQUEST budget is
            the effective ceiling, and batching is never the more expensive
            choice. The item budget can still deny at a sliding-window boundary
            (both counters carry the previous window forward with a floor, and
            the item counter runs 25x the request counter), so honor a 429 from
            either. Over-quota batches return 429 with Retry-After plus
            RateLimit-Limit, RateLimit-Remaining, and RateLimit-Reset before any
            item work is done. (3) The monthly quota: Pro includes 500,000 and
            Max includes 2,000,000 authenticated requests per UTC calendar
            month. Over the plan's included requests: with pay as you go on, the
            excess bills at USD 0.20 per 1,000 on a monthly invoice, up to four
            times the included allowance (2,000,000 requests for Pro); without
            it, from October 1, 2026, the next request answers 429 rate_limited
            with error.reason monthly_quota_exceeded and a Retry-After to the
            month's reset. Pay-as-you-go accounts receive the same refusal at
            their ceiling. A refused request is not counted. Every authenticated
            response carries X-Monthly-Quota-Limit, X-Monthly-Quota-Remaining,
            and X-Monthly-Quota-Reset (unix seconds, the first of next month).
            (4) The per-address budget: 1200 requests/minute per IP, shared by
            every caller behind one address and counted before authentication,
            on every route. A 429 from it carries error.reason ip_rate_limited
            and describes that bucket in RateLimit-*; a throttled address
            (sustained over-limit traffic) carries error.reason ip_throttled
            with a Retry-After of minutes to days, and a request before it does
            not shorten the cooldown. Every 429 is the standard error envelope
            with meta.request_id equal to X-Request-Id.
          headers:
            Retry-After:
              description: Seconds until rate limit resets.
              schema:
                type: integer
            RateLimit-Limit:
              $ref: '#/components/headers/RateLimit-Limit'
            RateLimit-Remaining:
              $ref: '#/components/headers/RateLimit-Remaining'
            RateLimit-Reset:
              $ref: '#/components/headers/RateLimit-Reset'
            X-RateLimit-Limit:
              schema:
                type: integer
            X-RateLimit-Remaining:
              schema:
                type: integer
            X-RateLimit-Reset:
              schema:
                type: integer
            X-Request-Id:
              schema:
                type: string
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ApiError'
        '500':
          description: Unexpected server error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ApiError'
        '503':
          description: >-
            Service unavailable. A weekly explicit range can return
            error.reason=read_model_warming when bounded custom-range admission
            is full and should be retried after Retry-After; the other 503 cause
            is the Redis-backed authenticated rate limiter 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'
      x-codeSamples:
        - lang: curl
          label: cURL
          source: |-
            curl -sS \
              -H "Authorization: Bearer $OXINSIDER_API_KEY" \
              'https://api.0xinsider.com/api/v1/reports/weekly'
components:
  schemas:
    ReportSnapshot:
      type: object
      required:
        - kind
        - generated_at
        - source_range
        - snapshot
        - completeness
        - reconciliation
        - report
      properties:
        kind:
          type: string
          enum:
            - daily
            - weekly
            - monthly
        generated_at:
          type: string
          format: date-time
        source_range:
          $ref: '#/components/schemas/ReportSourceRange'
        snapshot:
          $ref: '#/components/schemas/SnapshotState'
        completeness:
          $ref: '#/components/schemas/SnapshotCompleteness'
        reconciliation:
          $ref: '#/components/schemas/ReportReconciliation'
        report:
          $ref: '#/components/schemas/ReportPayload'
    ResponseMeta:
      type: object
      required:
        - request_id
        - cached
        - cost
      properties:
        request_id:
          type: string
          description: >-
            Unique request ID (req_ prefix). The same value as the X-Request-Id
            response header, the request's usage accounting row and its log
            lines.
        cached:
          type: boolean
        cache_age_s:
          type: integer
          description: >-
            Cache age in seconds. Omitted when the response was not cached, and
            also when it was cached but its age cannot be established (an entry
            stored before its cache carried a computed instant). Never a
            placeholder: an unknown age is reported as no value rather than as
            the cache TTL.
        cost:
          type: integer
          description: >-
            Advisory request weight (relative compute cost). 1 for simple reads;
            higher for heavier endpoints. Not a credit/price.
        ranking_generation:
          type: integer
          description: >-
            Committed PostgreSQL-owned leaderboard generation for the returned
            rows and cursor. Present on GET /api/v1/leaderboard; omitted on
            endpoints that do not read this ranking.
        ranking_as_of:
          type: string
          format: date-time
          description: >-
            Authoritative RFC3339 timestamp from cache_generations.updated_at
            for ranking_generation. It is read in the same repeatable-read
            snapshot as the leaderboard rows and is not request time, cache
            write time, or row insertion order.
        directional_source:
          type: string
          enum:
            - live
            - degraded
          description: >-
            Which path produced the team-directional read on this response. Only
            present on endpoints that compute one (today: GET
            /api/v1/sports-edge-signals). "live" means the read RAN. "degraded"
            means it FAILED, so nothing was measured and the ranking fell back
            to raw conviction. The flag describes the READ, not its consequence:
            a read that ran and found nothing groupable also leaves the
            directional fields null, and that is honestly "live" -- the
            per-signal nulls already say "nothing to enrich here", so this
            snapshot-level flag carries only what they cannot, namely whether
            the read ran at all. A degraded response is cached on the shorter
            degraded TTL so it self-heals. Reported SEPARATELY from
            ranking_source because the two degradations are independent -- a
            sharp-money DB miss weakens the ranking DATA, a directional failure
            removes a ranking WEIGHT -- and a consumer down-weighting a degraded
            response needs to know which input it lost. Omitted on endpoints
            that compute no directional read.
        ranking_source:
          type: string
          enum:
            - live
            - db_only
          description: >-
            Which ranking-data path produced this response. Only present on
            endpoints that can degrade a ranking (today: GET
            /api/v1/sports-edge-signals). "live" is the normal path (the current
            holder pile from the provider batch); "db_only" is the degraded
            fallback (a truthful but weaker trader_markets ranking) served when
            the live sharp-money ranking batch is unavailable (a sharp-money DB
            read failure, not a Polymarket outage) and cached on a shorter TTL,
            so a consumer can down-weight or skip it. Omitted on endpoints that
            never degrade.
        category_skill_source:
          type: string
          enum:
            - live
            - partial
            - degraded
            - unavailable
          description: >-
            Whole filtered snapshot category-evidence status before pagination.
            Operational live always remains partial source coverage.
        category_skill_model_version:
          type: string
        category_skill_taxonomy_version:
          type: string
        category_skill_platform:
          type: string
          const: polymarket
        category_skill_scope:
          type: string
          const: observed_goldsky_primary_taker_fill
        category_skill_source_coverage:
          type: string
          enum:
            - partial_whale_threshold_fills
            - graded_wallet_fills
        category_skill_observation_started_at:
          type: string
          format: date-time
        category_skill_model_operationally_degraded:
          type: boolean
          description: >-
            Whole-model operational readiness captured with the category model
            snapshot. Present on category-enriched responses even when the
            filtered signal list is empty. When true, category_skill_source is
            degraded and sports-edge-signals uses the shorter degraded cache
            TTL.
        category_skill_status_counts:
          type: object
          required:
            - live
            - insufficient
            - stale
            - unknown
            - degraded
          properties:
            live:
              type: integer
              minimum: 0
            insufficient:
              type: integer
              minimum: 0
            stale:
              type: integer
              minimum: 0
            unknown:
              type: integer
              minimum: 0
            degraded:
              type: integer
              minimum: 0
        category_skill_base_payload_hash:
          type: string
          pattern: ^[0-9a-f]{64}$
          description: >-
            SHA-256 of the funded signal membership/order/rank/cursor vector
            immediately before category-skill enrichment. Sports-edge-signals
            only.
        category_skill_enriched_base_payload_hash:
          type: string
          pattern: ^[0-9a-f]{64}$
          description: >-
            Independent SHA-256 recomputation over the same base fields
            immediately after category-skill enrichment. Equality with
            category_skill_base_payload_hash proves shadow enrichment did not
            change funded inputs. Sports-edge-signals only.
    ApiError:
      type: object
      required:
        - object
        - error
        - meta
      properties:
        object:
          type: string
          const: error
        error:
          type: object
          required:
            - code
            - message
          properties:
            code:
              type: string
              description: >-
                FROZEN: an existing value never changes meaning. request_timeout
                (408, #16146) was added the way insufficient_scope was: the
                handler did not answer inside the server's 30-second timeout.
                Retry-After and retry_at ride on it only for a safe method (GET,
                HEAD); a timed-out mutation may have completed, so check its
                state and reuse its Idempotency-Key.
              enum:
                - bad_request
                - invalid_api_key
                - subscription_required
                - forbidden
                - insufficient_scope
                - not_found
                - account_locked
                - rate_limited
                - rate_limit_unavailable
                - internal_error
                - request_timeout
            message:
              type: string
            doc_url:
              type: string
            param:
              type: string
            retry_at:
              type: string
              format: date-time
              description: >-
                The recommended next request instant (RFC3339), always in the
                future. Present on every retryable error: `pick_not_released`,
                `rate_limited`, `rate_limit_unavailable`, and
                `read_model_warming`. Omitted otherwise. The absolute twin of
                `Retry-After`; prefer the header for the sleep duration. For
                `pick_not_released`, the earliest of the next scheduled release,
                the next automatic selector attempt, the operating-window start,
                or about 60 seconds. See that response.
            freshness:
              $ref: '#/components/schemas/FreshnessFailure'
            reason:
              type: string
              enum:
                - cursor_expired
                - unknown_endpoint
                - pick_not_released
                - trader_not_tracked
                - read_model_warming
                - database_unavailable
                - request_accounting_unavailable
                - idempotency_in_progress
                - webhook_delivery_in_progress
                - webhook_secret_rotation_not_prepared
                - webhook_secret_rotation_overlap_active
                - sandbox_api_key
                - api_key_in_query
                - subscription_inactive
                - monthly_quota_exceeded
                - invalid_query
                - unknown_query_parameter
                - invalid_path
                - invalid_body
                - unsupported_media_type
                - payload_too_large
                - method_not_allowed
                - ip_rate_limited
                - ip_throttled
                - export_expired
                - freshness_ceiling_unsatisfied
              description: >-
                ADDITIVE (#7209). The specific, actionable cause behind `code`,
                when there is one more specific than the code itself. `code`
                keeps its published values, so existing clients are unaffected;
                new clients branch on `reason`. Omitted when the code already
                says everything we know. pick_not_released: no Pick of the Day
                is published for the current product day; schedule one request
                against retry_at instead of polling. unknown_endpoint: the PATH
                is not a route on this API -- read GET /api/v1, do not retry.
                trader_not_tracked: the wallet is real and the URL is right, but
                the trader is outside the HOT/WARM sync tiers -- stop asking for
                this wallet. cursor_expired: pagination went stale mid-walk --
                re-request the first page and continue. read_model_warming: the
                requested endpoint cannot serve its read model yet; exact causes
                are endpoint-specific and can include a cold or contended
                refresh or a dependency that prevented refresh.
                database_unavailable: the API's database or its connection pool
                is temporarily unreachable (a connection-class failure, not a
                query fault); code stays rate_limit_unavailable, nothing is
                rate-limited, retry after Retry-After / retry_at.
                idempotency_in_progress: retain the exact Idempotency-Key and
                request body, then retry shortly. webhook_delivery_in_progress:
                retry the URL or signing-secret configuration change after the
                destination's active request completes.
                request_accounting_unavailable: accounting capacity is
                unavailable before the handler executes; retry after Retry-After
                / retry_at. sandbox_api_key: the credential is a sandbox key
                (oxi_sk_test_) from POST /api/v1/agents/register, which only the
                sandbox server accepts -- call the sandbox base URL with it, or
                get a live key or OAuth access token; do not retry it here.
                api_key_in_query: the key was sent as a ?token= query parameter,
                which no route reads because URLs land in logs and history; the
                key itself was not checked -- resend it as Authorization:
                Bearer. subscription_inactive: the key is valid but the
                account's Pro subscription has lapsed (402
                subscription_required); permanent until a person reactivates at
                https://0xinsider.com/billing, which the message names -- stop
                retrying on a schedule and surface the link. The key owner is
                emailed once per lapse. monthly_quota_exceeded: the account has
                used the requests Pro includes for the UTC calendar month (429
                rate_limited); retry_at and Retry-After name the first of next
                month, the only retry that can succeed, and the message names
                https://0xinsider.com/developers, where pay as you go for
                requests over the quota is turned on. The X-Monthly-Quota-Limit,
                X-Monthly-Quota-Remaining and X-Monthly-Quota-Reset headers on
                every authenticated response say how close the account is.
                invalid_query, invalid_path, invalid_body (400 bad_request,
                #16146): a query parameter, a path segment or the JSON body did
                not parse or does not fit the route's schema, so no handler ran;
                param names the field when the parser named one (a query key, a
                path segment, a JSON path such as traders[0], or body); fix the
                request, never retry it as sent. unsupported_media_type (415
                bad_request, param content-type): send the body with
                Content-Type: application/json. payload_too_large (413
                bad_request, param body): the body is over 1048576 bytes.
                method_not_allowed (405 bad_request): the path is a route but
                not with this method; the Allow header names the methods it
                serves. ip_rate_limited (429 rate_limited, #16380): the
                per-address budget every caller behind one IP shares, counted
                before authentication, is spent; not the key's own window, and
                the RateLimit-* headers describe that bucket. ip_throttled (429
                rate_limited): the address is in a cooldown after sustained
                over-limit traffic; Retry-After is minutes to days, and a
                request before it does not shorten the cooldown.
        meta:
          $ref: '#/components/schemas/ResponseMeta'
    ReportSourceRange:
      type: object
      required:
        - start_date
        - end_date
        - timezone
      properties:
        start_date:
          type: string
          format: date
        end_date:
          type: string
          format: date
        timezone:
          type: string
          const: UTC
    SnapshotState:
      type: object
      required:
        - version
        - storage
        - status
        - generated_at
        - mutable_until
        - period_closed
        - final_after
        - source_read_started_at
      properties:
        version:
          type: integer
          format: int64
          description: >-
            Immutable content version for a durable report identity; 0 for an
            ephemeral explicit weekly from/to range.
        storage:
          type: string
          enum:
            - durable
            - ephemeral
          description: >-
            durable for canonical daily, ISO-week, and monthly snapshot
            identities; ephemeral for explicit weekly from/to ranges, which are
            recomputed within a bounded 31-day window and never persisted.
        status:
          type: string
          enum:
            - final
            - rolling
          description: >-
            final only for a body whose source read started at or after
            final_after (the UTC close of the range plus the whale-trade
            ingestion budget). rolling for a live range and for a closed range
            still inside that budget: such a body refreshes every five minutes,
            is rebuilt once after final_after, and is then frozen. Before
            2026-09-22 a closed range read final from the calendar alone, even
            for a body built before the range ended (#16225).
        generated_at:
          type: string
          format: date-time
        mutable_until:
          type: string
          format: date
          nullable: true
          description: >-
            For a rolling body, the UTC date on which a final body can first be
            built (the date of final_after); null once final.
        period_closed:
          type: boolean
          description: >-
            Whether the source range has ended on the UTC calendar. Closing is
            not finality: a closed range is rolling until final_after.
        final_after:
          type: string
          format: date-time
          description: >-
            The instant a source read must start at or after to produce a final
            body: the range's UTC close plus 7,530 s, the whale-trade ingestion
            budget (p95 block lag gate plus the projection retry budget).
        source_read_started_at:
          type: string
          format: date-time
          nullable: true
          description: >-
            When this body's source read started, the clock finality is judged
            on. null for a body stored before that clock was recorded.
    SnapshotCompleteness:
      type: object
      required:
        - status
        - reason
        - expected_days
        - covered_days_with_whale_activity
      properties:
        status:
          type: string
          enum:
            - complete
            - partial
            - empty
          description: >-
            complete only on a final body (snapshot.status final). partial for a
            live range and for a closed range whose body was read before
            final_after; reason says which. empty when the range has no whale
            activity.
        reason:
          type: string
        expected_days:
          type: integer
        covered_days_with_large_trade_activity:
          description: >-
            Canonical key since #16304; covered_days_with_whale_activity is its
            deprecated spelling, emitted beside it with the same value.
          type: integer
        covered_days_with_whale_activity:
          type: integer
    ReportReconciliation:
      type: object
      required:
        - volume_kind
        - whale_volume_source
        - notes
      properties:
        volume_kind:
          type: string
          const: local_whale_activity_volume
        whale_volume_source:
          type: string
          description: >-
            Where the whale volume in this report is read from: the column name
            `whale_alerts.usdc_notional_num`, followed in parentheses by the
            reconciliation note the server attaches to it. The server has always
            sent the note with the name, so this is not a bare constant; match
            on the prefix, not the whole string.
        notes:
          type: string
    ReportPayload:
      type: object
      required:
        - total_large_trades
        - total_whale_trades
        - total_large_trade_volume
        - total_whale_volume
        - biggest_trade_size
        - active_traders
        - top_large_trades
        - top_whale_trades
        - categories
        - grade_distribution
      properties:
        total_large_trades:
          description: >-
            Canonical key since #16304; total_whale_trades is its deprecated
            spelling, emitted beside it with the same value.
          type: integer
          nullable: true
        total_whale_trades:
          type: integer
          nullable: true
        total_large_trade_volume:
          description: >-
            Canonical key since #16304; total_whale_volume is its deprecated
            spelling, emitted beside it with the same value.
          type: number
          nullable: true
        total_whale_volume:
          type: number
          nullable: true
        biggest_trade_size:
          type: number
          nullable: true
        active_traders:
          type: integer
          nullable: true
        top_large_trades:
          description: >-
            Canonical key since #16304; top_whale_trades is its deprecated
            spelling, emitted beside it with the same value.
          type: array
          items:
            type: object
            required:
              - outcome
              - side
              - title
              - size
              - price
              - token_id
              - id
              - trade_time
              - market_category
              - platform
              - name
              - pseudonym
              - trader_grade
            properties:
              outcome:
                type: string
                nullable: true
                description: Provider outcome label for the traded side.
              side:
                type: string
                nullable: true
                description: Trade direction (BUY or SELL), not the outcome side.
              title:
                type: string
                nullable: true
                description: Market title.
              size:
                type: number
                nullable: true
                description: Trade size in USD.
              price:
                type: number
                nullable: true
                description: Trade price in provider [0, 1] units.
              token_id:
                type: string
                nullable: true
                description: >-
                  The Polymarket CLOB token id (ERC1155 asset id, decimal
                  string) for the traded outcome; null when unavailable (e.g.
                  unsynced markets).
              id:
                type: integer
                format: int64
                nullable: true
                description: Whale trade id.
              trade_time:
                type: string
                format: date-time
                nullable: true
                description: Trade timestamp (UTC).
              market_category:
                type: string
                nullable: true
                description: Provider market category.
              platform:
                type: string
                enum:
                  - polymarket
                nullable: true
                description: >-
                  Always polymarket, or null when the row carries no stored
                  value.
              name:
                type: string
                nullable: true
                description: Trader display name, when known.
              pseudonym:
                type: string
                nullable: true
                description: Trader pseudonym, when no display name is known.
              trader_grade:
                type: string
                nullable: true
                description: Trader grade (S-F) at snapshot time.
          nullable: true
        top_whale_trades:
          type: array
          items:
            type: object
            required:
              - outcome
              - side
              - title
              - size
              - price
              - token_id
              - id
              - trade_time
              - market_category
              - platform
              - name
              - pseudonym
              - trader_grade
            properties:
              outcome:
                type: string
                nullable: true
                description: Provider outcome label for the traded side.
              side:
                type: string
                nullable: true
                description: Trade direction (BUY or SELL), not the outcome side.
              title:
                type: string
                nullable: true
                description: Market title.
              size:
                type: number
                nullable: true
                description: Trade size in USD.
              price:
                type: number
                nullable: true
                description: Trade price in provider [0, 1] units.
              token_id:
                type: string
                nullable: true
                description: >-
                  The Polymarket CLOB token id (ERC1155 asset id, decimal
                  string) for the traded outcome; null when unavailable (e.g.
                  unsynced markets).
              id:
                type: integer
                format: int64
                nullable: true
                description: Whale trade id.
              trade_time:
                type: string
                format: date-time
                nullable: true
                description: Trade timestamp (UTC).
              market_category:
                type: string
                nullable: true
                description: Provider market category.
              platform:
                type: string
                enum:
                  - polymarket
                nullable: true
                description: >-
                  Always polymarket, or null when the row carries no stored
                  value.
              name:
                type: string
                nullable: true
                description: Trader display name, when known.
              pseudonym:
                type: string
                nullable: true
                description: Trader pseudonym, when no display name is known.
              trader_grade:
                type: string
                nullable: true
                description: Trader grade (S-F) at snapshot time.
          nullable: true
        categories:
          type: array
          items:
            type: object
          nullable: true
        grade_distribution:
          type: array
          items:
            type: object
          nullable: true
          description: >-
            Counts of current grades for distinct Polymarket traders with at
            least one whale alert in the report's source date range. The grade
            is the current projection at snapshot materialization time, not a
            historical grade at trade time. Traders without a current ranking
            projection are omitted; a null grade entry means the active trader's
            current grade is unavailable.
    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.
  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
  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.