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

# Aggregate trade volume/pressure metrics for a contract window

> Returns aggregated volume and buy-pressure metrics for a (provider, contract_id) over
a trailing window, computed from the same deduplicated trade data as `/v1/trades`.

**Two query shapes depending on provider**, because the platform cannot generically
infer which side of a market is "Yes":
- **Kalshi**: `outcome_0` is the side where `outcome` or `token_id`
  (case-insensitive) equals `"yes"`, `outcome_1` is `"no"`.
- **All other providers**: volumes are grouped by `token_id` and the **top 2 tokens by
  volume** are reported as `outcome_0`/`outcome_1` — a volume ranking, not a
  guaranteed Yes/No mapping.

USD volume is always `size * price / 100` (price is cents 0–100 for every provider).
`outcome_0_volume_share_pct` defaults to 50.0 when both outcome volumes are zero.
`coverage_pct` measures how much of the requested window is actually backed by data
and is 0 when no trades are found in the window.

**Rate-limit cost (LIGHT bucket)**: flat 1 unit per request.

**Caching**: responses are cached for 10s per replica (with singleflight coalescing) to
absorb duplicate concurrent requests. `Cache-Control: private, max-age=5`, no ETag —
this route never returns 304.




## OpenAPI

````yaml /openapi/market-data-api.yaml get /v1/trades/metrics
openapi: 3.1.0
info:
  title: Kairos Market Data API
  version: 1.2.0
  summary: Read-only prediction and perpetual market data across venues.
  description: >
    The Kairos Market Data API provides read-only access

    to normalized prediction-market data across every venue Kairos integrates:

    OHLCV candles, the trade tape, market metadata, resolution lifecycles, and

    latest mark prices.


    ## No signup required


    Every endpoint works **without credentials** on the anonymous free tier,

    rate-limited per source IP (120 light units/min, 20 heavy units/min). Try
    any

    request from the interactive docs at

    [app.kairos.trade/docs/market-data](https://app.kairos.trade/docs/market-data)

    or straight from curl. For production budgets (1,200 light and 150 heavy

    units/min by default, raisable per credential), request an API key from the

    Kairos team.


    ## Authentication


    Three modes, resolved per request:


    - **Anonymous** — no credential headers at all. Free tier, IP-keyed limits.

    - **API key** — `X-Client-Id` + `X-Api-Key` + `X-Api-Secret` headers
      (all three; partial header sets are rejected with 401 rather than
      degrading to anonymous).
    - **First-party session** — `Authorization: Bearer` JWT (Kairos web app
      sessions only; not offered to API consumers).

    Resolution order is fixed: an `Authorization` header takes the bearer

    path, any of the three API-key headers takes the API-key path, and only

    a request carrying neither is eligible for the anonymous tier.


    On the API-key path, an unreachable credential store surfaces on **any**

    endpoint as `500` with `code: internal` and the message

    `authentication backend unavailable`. A source IP outside a credential's

    whitelist is `403 ip_not_whitelisted`; that is the only 403 this service

    emits.


    ## Rate limiting


    Weighted sliding-window budgets over one minute, in **units**, across two

    independent buckets: light (candles, metadata, resolutions, trade

    metrics) and heavy (trade history, marks, perpetual snapshots). Most

    requests cost 1 unit; larger requests may consume more of your quota —

    each operation's `x-kairos-rate-limit` states its exact cost model.

    Every admitted response carries `X-RateLimit-Bucket`, `X-RateLimit-Tier`,

    `X-RateLimit-Remaining`, and `X-RateLimit-Reset`; 429s add `Retry-After`.


    A separate per-IP admission gate runs *before* authentication to keep a

    flood off shared infrastructure. It also answers 429 `rate_limited`, but

    with `Retry-After: 60` and no `X-RateLimit-*` headers.


    Redis backs the weighted limiter and it fails **closed**: if it is

    unreachable the request is rejected with 503 `rate_limiter_unavailable`

    rather than let through unmetered.


    ## Conventions


    - **Prediction-market prices** are on the 0–100 scale (implied probability
      × 100) in the prediction candle, trade, and mark endpoints. Prediction
      USD notional = `size × price / 100`.
    - **Perpetual prices are direct venue prices**, not probabilities and not
      0–100 values. Perpetual quantities retain their declared native unit
      (`base_asset` or `contracts`). Never divide a perpetual price by 100 or
      compute contract notional without the instrument's authoritative contract
      multiplier; the snapshot does not synthesize a cross-venue notional.
    - **Hyperliquid is two products on one venue.** Its HIP-4 outcome markets
      are prediction markets, read with `provider=hyperliquid` on the
      prediction endpoints; its perpetuals are bare coins read under
      `/v1/perpetuals/hyperliquid/{instrument}/snapshot`, where the instrument
      is the canonical id `hl-mainnet-<symbol>-<quote>` (e.g.
      `hl-mainnet-btc-usdt`). Different id schemes, different price semantics;
      they are never interchangeable.
    - **Errors** all use one envelope:
      `{"error": {"code": "...", "message": "..."}}`.
    - **Providers** are case-insensitive; `kalshi_offchain` aliases `kalshi`,
      `dome` aliases `polymarket`, and `opinion` is resolvable for historic
      reads only.
  contact:
    name: Kairos
    url: https://app.kairos.trade/docs/market-data
  termsOfService: https://kairos.trade/terms
servers:
  - url: https://md.kairos.trade
    description: Production
  - url: https://staging-md.kairos.trade
    description: Staging
security:
  - {}
  - apiKeyClientId: []
    apiKeyKey: []
    apiKeySecret: []
tags:
  - name: Candles
    description: OHLCV candle series (1s → 1d), JSON or compact columnar binary.
  - name: Trades
    description: Trade tape and aggregate volume metrics.
  - name: Markets
    description: Market metadata, batch lookup, identifier resolution, and enumeration.
  - name: Resolutions
    description: Resolution outcomes and UMA-style lifecycle state/timelines.
  - name: Marks
    description: Latest mark (last trade price) per outcome token.
  - name: Perpetuals
    description: Live perpetual books, trades, candles, funding, and market state. Beta.
  - name: Status
    description: Health and readiness probes.
paths:
  /v1/trades/metrics:
    get:
      tags:
        - Trades
      summary: Aggregate trade volume/pressure metrics for a contract window
      description: >
        Returns aggregated volume and buy-pressure metrics for a (provider,
        contract_id) over

        a trailing window, computed from the same deduplicated trade data as
        `/v1/trades`.


        **Two query shapes depending on provider**, because the platform cannot
        generically

        infer which side of a market is "Yes":

        - **Kalshi**: `outcome_0` is the side where `outcome` or `token_id`
          (case-insensitive) equals `"yes"`, `outcome_1` is `"no"`.
        - **All other providers**: volumes are grouped by `token_id` and the
        **top 2 tokens by
          volume** are reported as `outcome_0`/`outcome_1` — a volume ranking, not a
          guaranteed Yes/No mapping.

        USD volume is always `size * price / 100` (price is cents 0–100 for
        every provider).

        `outcome_0_volume_share_pct` defaults to 50.0 when both outcome volumes
        are zero.

        `coverage_pct` measures how much of the requested window is actually
        backed by data

        and is 0 when no trades are found in the window.


        **Rate-limit cost (LIGHT bucket)**: flat 1 unit per request.


        **Caching**: responses are cached for 10s per replica (with singleflight
        coalescing) to

        absorb duplicate concurrent requests. `Cache-Control: private,
        max-age=5`, no ETag —

        this route never returns 304.
      operationId: getTradeMetrics
      parameters:
        - name: provider
          in: query
          required: true
          description: >
            Venue identifier, case-insensitive. `kalshi_offchain` aliases
            `kalshi`; `dome` aliases `polymarket`. Whether `provider` resolves
            to Kalshi determines which aggregation query runs — see the
            operation description.
          schema:
            type: string
            enum:
              - kalshi
              - kalshi_offchain
              - polymarket
              - dome
              - opinion
              - predictfun
              - hyperliquid
          example: polymarket
        - name: contract_id
          in: query
          required: true
          description: Venue-scoped contract/token identifier to compute metrics for.
          schema:
            type: string
          example: '0x8b1c119419f622e21fc576ec8e9c2c07b2c1b09babf0e1f3d1cb9bfc1a8f9c2'
        - name: window_seconds
          in: query
          required: false
          description: >
            Trailing window, in seconds, measured back from the current server
            time. Valid range [3600, 86400]; out-of-range or non-integer values
            are rejected with 400.
          schema:
            type: integer
            minimum: 3600
            maximum: 86400
            default: 86400
          example: 3600
      responses:
        '200':
          description: >
            Aggregated metrics for the window. Present with all-zero volumes
            (and `coverage_pct: 0`) rather than a 404 when no trades exist.
          headers:
            X-RateLimit-Bucket:
              schema:
                type: string
                example: light
            X-RateLimit-Tier:
              schema:
                type: string
                example: api-key
            X-RateLimit-Remaining:
              schema:
                type: integer
            X-RateLimit-Reset:
              schema:
                type: integer
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/TradeMetricsResponse'
              example:
                metrics:
                  volume_usd: 184032.55
                  outcome_0_volume_usd: 121004.1
                  outcome_1_volume_usd: 63028.45
                  outcome_0_volume_share_pct: 65.8
                  trade_count: 5123
                  window_seconds: 3600
                  coverage_pct: 97.2
        '400':
          description: >
            Validation failure: missing `provider`, unrecognized `provider`,
            missing `contract_id`, or `window_seconds` outside [3600, 86400].
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                error:
                  code: invalid_request
                  message: window_seconds must be an integer in [3600, 86400]
        '401':
          $ref: '#/components/responses/Unauthorized'
        '403':
          $ref: '#/components/responses/IPNotWhitelisted'
        '429':
          $ref: '#/components/responses/RateLimited'
        '500':
          description: The trade-metrics query failed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '503':
          $ref: '#/components/responses/RateLimiterUnavailable'
components:
  schemas:
    TradeMetricsResponse:
      type: object
      required:
        - metrics
      properties:
        metrics:
          $ref: '#/components/schemas/TradeMetrics'
    ErrorResponse:
      type: object
      description: Canonical error envelope emitted by every Market Data API endpoint.
      required:
        - error
      properties:
        error:
          type: object
          required:
            - code
            - message
          properties:
            code:
              type: string
              description: Machine-readable error code.
              example: invalid_request
            message:
              type: string
              description: Human-readable detail.
              example: market_ids exceeds maximum 200
    TradeMetrics:
      type: object
      required:
        - volume_usd
        - outcome_0_volume_usd
        - outcome_1_volume_usd
        - outcome_0_volume_share_pct
        - trade_count
        - window_seconds
        - coverage_pct
      properties:
        volume_usd:
          type: number
          description: >-
            Total USD notional traded in the window (size * price / 100,
            summed), rounded to 2 decimals.
          example: 184032.55
        outcome_0_volume_usd:
          type: number
          description: >
            USD volume attributed to "outcome 0". For Kalshi this is the "yes"
            side; for all other providers it is whichever token had the highest
            volume in the window (not guaranteed to be "Yes"). Rounded to 2
            decimals.
          example: 121004.1
        outcome_1_volume_usd:
          type: number
          description: >
            USD volume attributed to "outcome 1". For Kalshi this is the "no"
            side; for all other providers it is the second-highest-volume token
            in the window. Rounded to 2 decimals.
          example: 63028.45
        outcome_0_volume_share_pct:
          type: number
          description: >
            outcome_0_volume_usd as a percentage of (outcome_0 + outcome_1)
            volume, rounded to 1 decimal. Defaults to 50.0 when both outcome
            volumes are zero.
          minimum: 0
          maximum: 100
          example: 65.8
        trade_count:
          type: integer
          format: int64
          description: Number of deduplicated trades in the window.
          example: 5123
        window_seconds:
          type: integer
          description: Echoes the effective `window_seconds` request parameter.
          example: 3600
        coverage_pct:
          type: number
          description: >
            Percentage of the requested window actually covered by data, clamped
            to [0, 100]. 0 when no trades are found. Rounded to 1 decimal.
          example: 97.2
  responses:
    Unauthorized:
      description: >
        No valid credential presented. Every path returns `code: unauthorized`;
        the triggers differ:


        - An `Authorization` header on a deployment where bearer auth is not
        enabled (`bearer authentication is not enabled`).

        - A bearer token that fails verification (`invalid or expired session`),
        or whose token/session has been revoked (`session has been revoked`).

        - An incomplete or wrong API-key header set. Sending *any* of
        `X-Client-Id`, `X-Api-Key`, `X-Api-Secret` commits the request to the
        API-key path, so a partial set is rejected rather than silently
        degrading to anonymous limits (`valid X-Client-Id, X-Api-Key, and
        X-Api-Secret headers are required`).

        - No credential material at all while the anonymous free tier is
        unavailable — switched off for the deployment, forced off through the
        runtime kill switch, or not yet resolvable on a replica that has never
        read the flag (it fails closed).
      headers:
        WWW-Authenticate:
          schema:
            type: string
          description: >-
            `Bearer realm="market-data-api"` on bearer-verification failure,
            `APIKey realm="market-data-api", header="X-Client-Id, X-Api-Key,
            X-Api-Secret"` on missing/invalid API-key credentials. Absent on the
            revoked-session and bearer-disabled paths.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorResponse'
          example:
            error:
              code: unauthorized
              message: >-
                valid X-Client-Id, X-Api-Key, and X-Api-Secret headers are
                required
    IPNotWhitelisted:
      description: API key presented from a source IP not in that credential's whitelist.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorResponse'
          example:
            error:
              code: ip_not_whitelisted
              message: source IP not in credential whitelist
    RateLimited:
      description: >
        Two different gates return this status, both with `code: rate_limited`:


        - **Per-credential (or per-IP, when anonymous) weighted budget
        exhausted.** The message is `rate limit exceeded`, or, for anonymous
        callers, `anonymous rate limit exceeded — request an API key for higher
        limits (…)`. `Retry-After` is the whole number of seconds until the
        current one-minute window rolls over, floored at 1. All four
        `X-RateLimit-*` headers are present.

        - **Per-IP admission gate.** An in-process, pre-authentication guard
        that keeps a flood off the shared credential cache and database. The
        message is `too many requests from this address` and `Retry-After` is a
        flat `60`. Because this fires *before* authentication, the response
        carries **no** `X-RateLimit-*` headers at all.
      headers:
        Retry-After:
          schema:
            type: integer
          description: >-
            Seconds until the caller may retry — window-rollover seconds for the
            weighted limiter, a flat 60 for the IP admission gate.
        X-RateLimit-Bucket:
          schema:
            type: string
            enum:
              - light
              - heavy
        X-RateLimit-Tier:
          schema:
            type: string
            enum:
              - anonymous
              - api-key
              - user
        X-RateLimit-Remaining:
          schema:
            type: integer
        X-RateLimit-Reset:
          schema:
            type: integer
            description: Unix timestamp (seconds) when the current window resets.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorResponse'
          example:
            error:
              code: rate_limited
              message: rate limit exceeded
    RateLimiterUnavailable:
      description: >
        The rate limiter is unreachable. Fails CLOSED — the request is rejected
        rather than let through unmetered.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorResponse'
          example:
            error:
              code: rate_limiter_unavailable
              message: rate limiter temporarily unavailable
  securitySchemes:
    apiKeyClientId:
      type: apiKey
      in: header
      name: X-Client-Id
      description: >-
        Credential client id (`kairos_ck_...`). Must be sent together with
        X-Api-Key and X-Api-Secret.
    apiKeyKey:
      type: apiKey
      in: header
      name: X-Api-Key
      description: >-
        64-char hex API key. Must be sent together with X-Client-Id and
        X-Api-Secret.
    apiKeySecret:
      type: apiKey
      in: header
      name: X-Api-Secret
      description: >-
        64-char hex API secret. Must be sent together with X-Client-Id and
        X-Api-Key.

````

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