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

# Your balance and limits

> The calling key's account: status, balance (credits and US dollars at
$0.001 per credit), whether usage is unlimited, and the limits that
apply. Free.




## OpenAPI

````yaml /openapi.yaml get /v1/account
openapi: 3.1.0
info:
  title: Skylit Public API
  version: 1.0.0
  summary: Options-Greeks heatmaps as a public HTTP API.
  description: |
    Skylit exposes its real-time options-Greeks (gamma / vanna) heatmaps as a
    versioned public HTTP API, per strike, with the live velocity metric and
    Skylit's node classification (King / Gatekeeper / etc.).

    **Authentication.** Send your Skylit API key as a bearer token:

        Authorization: Bearer <key>

    A request without an `Authorization` header gets `401`; an invalid,
    revoked or expired key gets `403`.

    **Credit metering.** Every chargeable request debits a fixed cost from
    your credit balance:

    | Endpoint        | Cost |
    |-----------------|-----:|
    | `/v1/heatmap`    | 1   |
    | `/v1/historical` | 5   |
    | `/v1/stream`     | 1 per minute open |
    | `/v1/openapi.json` | 0 |

    New customers are seeded with 5,000 credits. Every chargeable response
    carries `X-Credits-Remaining: <balance>`. Out of credits → `402`
    `insufficient_credits`; an admin-suspended account → `403`
    `account_suspended`. Top up via your account console.

    **Rate limits.** A safety ceiling of 600 requests / minute is enforced
    by the Skylit gateway and surfaced via `X-RateLimit-Limit`,
    `X-RateLimit-Remaining`, and `X-RateLimit-Reset`. `429` includes
    `Retry-After`. This is a runaway-protection ceiling, not a quota —
    credit metering does the per-customer accounting.

    Live streams (`/v1/stream`) cost 1 credit to open plus 1 per minute
    connected, and close after one hour.

    **Resolution.** The heatmap is a 1-second time series. Endpoints return the
    single snapshot nearest the requested instant — poll `/v1/heatmap` every
    60-90s for live, or query `/v1/historical` at any minute boundary for a
    1-minute replay grid (no server-side downsampling needed).

    **Velocity is live-only.** The `velocityPct` field is present on
    `/v1/heatmap` (live) and absent on `/v1/historical` (replay).

    **Response shape.** Success → `{ "data": ..., "meta": { ... } }`; errors →
    `{ "error": { "code": "...", "message": "..." } }`. camelCase throughout.
    `data.symbols` is always an array (one element per requested symbol), so a
    single-symbol call and a multi-symbol "Trinity" call share one shape.
servers:
  - url: https://api.skylit.ai
    description: Production
security:
  - bearerApiKey: []
tags:
  - name: Heatmap
  - name: Meta
paths:
  /v1/account:
    get:
      tags:
        - Account
      summary: Your balance and limits
      description: |
        The calling key's account: status, balance (credits and US dollars at
        $0.001 per credit), whether usage is unlimited, and the limits that
        apply. Free.
      operationId: getAccount
      responses:
        '200':
          description: Account.
          content:
            application/json:
              schema:
                type: object
                properties:
                  data:
                    type: object
                    properties:
                      customerId:
                        type: string
                      status:
                        type: string
                        enum:
                          - active
                          - suspended
                      apiEligible:
                        type: boolean
                      unlimited:
                        type: boolean
                      creditsBalance:
                        type: integer
                      balanceUsd:
                        type: number
                      limits:
                        type: object
                        properties:
                          requestsPerMinute:
                            type: integer
                          symbolsPerHeatmapCall:
                            type: integer
                          symbolsPerStream:
                            type: integer
                          historicalInFlight:
                            type: integer
                          activeKeys:
                            type: integer
                          streamMaxDurationMinutes:
                            type: integer
        '401':
          $ref: '#/components/responses/Unauthorized'
        '404':
          $ref: '#/components/responses/NotFound'
components:
  responses:
    Unauthorized:
      description: Missing or invalid API key.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
    NotFound:
      description: |
        Unknown symbol, no data available, or none of the requested
        `expirations` exist for the symbol (`code: expiration_not_found`).
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
  schemas:
    Error:
      type: object
      required:
        - error
      properties:
        error:
          type: object
          required:
            - code
            - message
          properties:
            code:
              type: string
              description: Stable, machine-readable error code.
              example: no_data
            message:
              type: string
              description: Human-readable explanation.
  securitySchemes:
    bearerApiKey:
      type: http
      scheme: bearer
      description: |
        Skylit API key in the `Authorization` header
        (`Authorization: Bearer <key>`).

````