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

# Verify the invited maker's price-specific quote capacity

> Returns only the authenticated invitee's bounded capacity at the
proposed price across every frozen route. It exposes no raw portfolio,
other invitee, competing quote, venue-account, or control-group data
and creates no reservation or journal event. Quote submission repeats
the same calculation inside its serializable reservation transaction.
This call is not rate-limited and takes no idempotency key.




## OpenAPI

````yaml /openapi/agora.yaml post /v1/auctions/{auctionID}/quotes/preflight
openapi: 3.1.0
info:
  title: Agora Auction House API
  version: 1.0.0-pilot
  description: |
    Private first-price sealed auctions for venue-backed prediction contracts.
    Active auctions are never published through an unauthenticated or global
    feed. All price and quantity values are integer atoms.

    ## Authentication

    Every `/v1` operation requires a first-party Kairos session JWT
    (`Authorization: Bearer <jwt>`, RS256, `iss: kairos.trade`,
    `aud: kairos-api`, `ver: 1`, an expiry claim, and a subject enrolled in the
    Auction House). Any other credential shape — missing header, wrong
    audience, revoked session, unenrolled subject — is rejected with `401`
    before the handler runs. There is no API-key or anonymous tier. Browser
    WebSocket clients pass the same JWT as the `Sec-WebSocket-Protocol`
    subprotocol pair `authorization, Bearer.<base64url(jwt)>`.

    Every session is granted the `auction:create` and `auction:quote`
    capabilities; they only allow the request to reach the fail-closed
    Go-owned economic policy store, which remains the real authorization
    boundary.

    ## Errors

    Every error body is a flat JSON object: `{"error": "<code>"}`, plus a
    `"message"` field on rejections raised by the auction engine. Codes are
    stable; `message` is descriptive and must not be parsed. `422` rejections
    carry the durable auction reason code (for example `INVALID_PRICE_TICK`,
    `UNAUTHORIZED_SIZE`, `SERVICE_CAPACITY_EXCEEDED`) as the `error` value.

    ## Request limits

    Request bodies are capped at 1 MiB (`413 payload_too_large`). JSON is
    parsed strictly: no `null` values, no duplicate object keys, no unknown
    fields, no trailing data, and at most 64 levels of nesting. Owner-routing
    headers (`X-Service-Token`, `X-Agora-Peer`, `X-Agora-Active-Only`,
    `X-Agora-Owner-Read-Fallback`) are internal capabilities and are rejected
    with `403` on the public listener.

    ## Rate limiting

    Only state-changing operations are metered, by a per-account and
    per-auction token bucket owned by the authoritative shard, evaluated
    before any risk reservation or journal write. Exceeding a bucket returns
    `429 auction_mutation_rate_limited`. No `Retry-After` or `X-RateLimit-*`
    headers are emitted; back off and retry with the same idempotency key.
    Reads, both preflight calls, and the stream are not metered.
servers:
  - url: https://agora.kairos.trade
    description: >-
      Production. Agora is allow-listed RFQ and the production host is not
      currently enabled, so this base URL does not answer public requests yet.
  - url: https://staging-agora.kairos.trade
    description: Staging.
security:
  - bearerAuth: []
paths:
  /v1/auctions/{auctionID}/quotes/preflight:
    parameters:
      - $ref: '#/components/parameters/AuctionID'
    post:
      summary: Verify the invited maker's price-specific quote capacity
      description: |
        Returns only the authenticated invitee's bounded capacity at the
        proposed price across every frozen route. It exposes no raw portfolio,
        other invitee, competing quote, venue-account, or control-group data
        and creates no reservation or journal event. Quote submission repeats
        the same calculation inside its serializable reservation transaction.
        This call is not rate-limited and takes no idempotency key.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/QuotePreflightRequest'
      responses:
        '200':
          description: Current invitee quote-capacity evidence
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/QuotePreflight'
        '400':
          description: '`invalid_json`, `multiple_json_values`, or `invalid_auction_id`.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
        '401':
          $ref: '#/components/responses/Unauthorized'
        '403':
          description: |
            `forbidden` when the session lacks the `auction:quote` capability,
            or `internal_routing_headers_forbidden` when the request carries
            an owner-routing header.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
        '404':
          description: Auction absent or caller was not delivered an invitation
        '413':
          $ref: '#/components/responses/PayloadTooLarge'
        '422':
          description: |
            `auction_rejected` when the auction is no longer open or the
            auction reference is unbounded, otherwise the durable quote reason
            code (`INVALID_PRICE_RANGE`, `INVALID_PRICE_TICK`,
            `INVALID_QUANTITY_TICK`).
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
              example:
                error: auction_rejected
                message: auction is not open
        '500':
          description: >-
            `internal_error` — the admission authority returned capacity
            evidence that failed its own invariants. No 503 is emitted on this
            path.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
        '503':
          $ref: '#/components/responses/OwnerUnavailable'
components:
  parameters:
    AuctionID:
      name: auctionID
      in: path
      required: true
      description: Canonical UUID whose first character is the owner shard (0, 1, or 2).
      schema:
        type: string
        format: uuid
  schemas:
    QuotePreflightRequest:
      type: object
      required:
        - price_atoms
        - max_executable_quantity_atoms
      additionalProperties: false
      properties:
        price_atoms:
          $ref: '#/components/schemas/PriceAtoms'
        max_executable_quantity_atoms:
          type: integer
          format: int64
          minimum: 1
    QuotePreflight:
      type: object
      required:
        - status
        - requested_quantity_atoms
        - maximum_executable_quantity_atoms
        - checked_at
        - valid_until
        - routes
      properties:
        status:
          enum:
            - EXECUTABLE
            - INSUFFICIENT_CAPACITY
        requested_quantity_atoms:
          type: string
          pattern: ^[1-9]\d*$
        maximum_executable_quantity_atoms:
          type: string
          pattern: ^(0|[1-9]\d*)$
          description: Minimum price-specific capacity across all frozen routes.
        checked_at:
          type: string
          format: date-time
        valid_until:
          type: string
          format: date-time
        routes:
          type: array
          minItems: 1
          items:
            $ref: '#/components/schemas/QuoteRouteCapacity'
    Error:
      type: object
      required:
        - error
      description: |
        Flat error envelope used by every JSON error response. `message` is
        present on rejections raised by the auction engine and absent on
        transport-level rejections such as `invalid_list_page` or
        `payload_too_large`. Match on `error`; never parse `message`.
      properties:
        error:
          type: string
          description: Stable machine-readable code
          or the durable auction reason code on a 422/409 rejection.: null
        message:
          type: string
          description: Human-readable detail; not a stable contract.
    PriceAtoms:
      type: integer
      format: int64
      minimum: 0
      maximum: 10000
      description: One atom is 0.01 cent of probability-dollar price.
    QuoteRouteCapacity:
      type: object
      required:
        - venue
        - resource_type
        - maximum_executable_quantity_atoms
        - risk_source_sequence
        - risk_valid_until
        - authority_valid_until
      properties:
        venue:
          type: string
          maxLength: 64
        resource_type:
          enum:
            - COLLATERAL
            - POSITION
        maximum_executable_quantity_atoms:
          type: string
          pattern: ^(0|[1-9]\d*)$
        risk_source_sequence:
          type: string
          pattern: ^[1-9]\d*$
        risk_valid_until:
          type: string
          format: date-time
        authority_valid_until:
          type: string
          format: date-time
          description: Earliest frozen mapping
          route-rule: null
          fee: null
          reservation: null
          or execution-deadline expiry for this route.: null
  responses:
    Unauthorized:
      description: |
        The bearer session is absent, malformed, expired, revoked, signed by
        an unrecognized key, carries the wrong issuer, audience, or schema
        version, or its subject is not enrolled in the Auction House.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          example:
            error: unauthorized
            message: authentication required
    PayloadTooLarge:
      description: '`payload_too_large` — the request body exceeded 1 MiB.'
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          example:
            error: payload_too_large
    OwnerUnavailable:
      description: |
        The owning shard for this auction could not be reached or answered
        unusably: `auction_owner_unavailable`, `owner_routing_unavailable`, or
        `owner_response_invalid`.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          example:
            error: auction_owner_unavailable
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      bearerFormat: JWT

````

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