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

# Get billing claims

> Returns the entitlements and usage limits for an organization. Users and API keys can read their own organization. Service tokens require `billing:read`.



## OpenAPI

````yaml /api-reference/billing.openapi.json get /v1/billing/organizations/{org_id}/claims
openapi: 3.1.0
info:
  title: billing
  description: ''
  license:
    name: ''
  version: 0.1.0
servers:
  - url: https://api.anthid.com
    description: Production
security: []
tags:
  - name: Billing
    description: Read organization billing access and open the customer portal
  - name: Billing
    description: Grant, change, or withdraw entitlements beyond an organization's plan
  - name: Billing
    description: Receive signed Stripe events for asynchronous processing
paths:
  /v1/billing/organizations/{org_id}/claims:
    get:
      tags:
        - Billing
      summary: Get billing claims
      description: >-
        Returns the entitlements and usage limits for an organization. Users and
        API keys can read their own organization. Service tokens require
        `billing:read`.
      operationId: getBillingClaims
      parameters:
        - name: org_id
          in: path
          description: Organization ID
          required: true
          schema:
            type: string
            format: uuid
          example: 11111111-2222-3333-4444-555555555555
      responses:
        '200':
          description: Billing claims resolved
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BillingClaims'
              example:
                entitlements:
                  controls: premium
                  support: premium
                  tier: professional
                  trading: live
                limits:
                  broker_connections: 10
                  requests_per_second: 100
                  retention_days: 365
                  stream_connections: 100
        '401':
          description: Missing or invalid authentication credentials
          content:
            text/plain:
              schema:
                type: string
        '403':
          description: >-
            Caller is authenticated but is not allowed to read billing claims
            for this organization
          content:
            text/plain:
              schema:
                type: string
        '404':
          description: No billing identity exists for the organization
          content:
            text/plain:
              schema:
                type: string
        '429':
          description: Caller exceeded the request rate limit
          content:
            text/plain:
              schema:
                type: string
        '500':
          description: Unexpected server error while resolving billing claims
          content:
            text/plain:
              schema:
                type: string
      security:
        - bearerAuth: []
        - clientCredentials: []
        - apiKeyAuth: []
components:
  schemas:
    BillingClaims:
      type: object
      required:
        - entitlements
        - limits
      properties:
        entitlements:
          $ref: '#/components/schemas/BillingEntitlements'
        limits:
          $ref: '#/components/schemas/BillingLimits'
    BillingEntitlements:
      type: object
      required:
        - controls
        - trading
        - support
      properties:
        controls:
          $ref: '#/components/schemas/ControlsEntitlement'
        support:
          $ref: '#/components/schemas/SupportEntitlement'
        tier:
          $ref: '#/components/schemas/BillingTier'
        trading:
          $ref: '#/components/schemas/TradingEntitlement'
    BillingLimits:
      type: object
      required:
        - requests_per_second
        - retention_days
        - broker_connections
        - stream_connections
      properties:
        broker_connections:
          type: integer
          format: int32
          minimum: 0
        requests_per_second:
          type: integer
          format: int32
          minimum: 0
        retention_days:
          type: integer
          format: int32
          minimum: 0
        stream_connections:
          type: integer
          format: int32
          minimum: 0
    ControlsEntitlement:
      type: string
      description: >-
        What scope of controls a plan may use.


        Ordered rather than binary. `Basic` covers the account-scoped controls
        that

        ship with any live plan, and `Premium` adds the organization and symbol

        scoped ones. The account-level breaker used to sit behind `Premium` with

        everything else, which put the guardrail out of reach of exactly the
        trader

        most likely to need it.


        Compare with [`ControlsEntitlement::allows`] rather than `==`. An
        equality

        check against `Premium` refuses `Basic`, which is the bug this ordering

        exists to prevent.
      enum:
        - premium
        - basic
        - none
    SupportEntitlement:
      type: string
      description: >-
        What level of support a plan carries.


        Ordered, so a plan holding `Premium` satisfies a surface asking for

        `Basic`. The variants are listed highest first to match the other

        entitlement enums, and the ordering lives in `rank` rather than in the

        declaration order so the two cannot drift.


        Nothing gates on this yet. It is resolved from Stripe, carried on the

        principal and recorded in the billing state projection, but no policy
        reads

        it, so treat it as a value the platform records rather than one it
        enforces.


        Compare with [`SupportEntitlement::allows`] rather than `==`, for the
        reason

        on [`crate::entitlements::controls::ControlsEntitlement`]: an equality
        check

        against one level silently refuses every level above it.
      enum:
        - premium
        - standard
        - basic
        - none
    BillingTier:
      type: string
      enum:
        - free
        - starter
        - professional
        - enterprise
    TradingEntitlement:
      type: string
      description: >-
        What a plan may trade against.


        Ordered, and the order is the point: `Live` includes `Paper`. A plan
        that

        can send real orders can obviously also send simulated ones, and the
        Stripe

        catalog says so by attaching `trading:paper` to Free and `trading:live`
        to

        every paid plan rather than attaching both.


        Compare with [`TradingEntitlement::allows`] rather than `==`. Equality
        reads

        as "is exactly this level", which is right for the live check today only

        because `Paper` happens to be the floor. The moment a level is added
        below

        `Paper` or between the two, every equality check silently starts
        refusing a

        caller who is entitled.
      enum:
        - paper
        - live
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      bearerFormat: JWT
    clientCredentials:
      type: http
      scheme: bearer
      bearerFormat: JWT
      description: Machine bearer token minted via the client_credentials grant.
    apiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key

````