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

# List models available to the current key



## OpenAPI

````yaml /api-reference/openapi.json get /models
openapi: 3.1.0
info:
  description: >-
    OpenAI-compatible hosted inference for Wally. Usage is billed against
    prepaid credits at the list prices shown in the RunAnywhere console.
  title: RunAnywhere Wally Public Inference API
  version: 2.0.0
servers:
  - description: Wally production inference gateway
    url: https://inference.runanywhere.ai/v1
security:
  - BearerAuth: []
paths:
  /models:
    get:
      summary: List models available to the current key
      operationId: listModels
      responses:
        '200':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ModelList'
          description: Available model aliases
        '401':
          $ref: '#/components/responses/Unauthorized'
        '429':
          $ref: '#/components/responses/RateLimited'
        default:
          $ref: '#/components/responses/Error'
components:
  schemas:
    ModelList:
      additionalProperties: false
      properties:
        data:
          items:
            $ref: '#/components/schemas/PublicModel'
          type: array
        object:
          const: list
      required:
        - object
        - data
      type: object
    PublicModel:
      additionalProperties: false
      properties:
        created:
          description: >-
            OpenAI-shaped creation timestamp (unix seconds) the gateway reports;
            informational.
          minimum: 0
          type: integer
        id:
          $ref: '#/components/schemas/PublicModelId'
        max_input_tokens:
          description: >-
            The advertised ceiling on input tokens for this model -- what an
            OpenAI-shaped coding agent reads to decide when to compact. It is
            the largest prompt the engine still answers with one output token,
            not the raw context length: a prompt longer than this is refused
            with 400 before it is billed. null means the deployment has not
            established one.
          minimum: 1
          type:
            - integer
            - 'null'
        max_output_tokens:
          description: >-
            The advertised ceiling on output tokens, when the deployment
            declares one separately from the context window. null means this
            model draws output from the single budget max_input_tokens already
            describes.
          minimum: 1
          type:
            - integer
            - 'null'
        mode:
          description: The gateway's model mode; every Wally model is a chat model.
          enum:
            - chat
          type: string
        object:
          const: model
        owned_by:
          $ref: '#/components/schemas/ModelOwner'
      required:
        - id
        - object
        - owned_by
      type: object
    OpenAIError:
      additionalProperties: false
      properties:
        error:
          $ref: '#/components/schemas/OpenAIErrorDetail'
      required:
        - error
      type: object
    RequestId:
      maxLength: 256
      minLength: 1
      type: string
    AccessControlExposeHeaders:
      description: >-
        The response headers a browser client may read, as a comma-separated
        list; it names x-request-id, Retry-After and Server-Timing when the
        response carries them.
      maxLength: 1024
      minLength: 1
      type: string
    RetryAfterSeconds:
      minimum: 0
      type: integer
    ServerTiming:
      description: >-
        W3C Server-Timing. As a HEADER it carries pre-stream phases only, for
        example the gateway's authorize call and the sidecar's ra-queue (time
        waiting for a seat) and ra-admit (the sidecar's own work before the
        request reached the model). Time to first token is never in the header,
        because it is not known when the headers are sent; on a streaming
        response it arrives as a Server-Timing TRAILER named ra-ttft, after the
        last SSE frame. Metric names are not a closed set: ignore a name you do
        not know, and treat the trailer as optional.
      maxLength: 1024
      minLength: 1
      type: string
    PublicModelId:
      maxLength: 128
      minLength: 1
      pattern: ^[A-Za-z0-9][A-Za-z0-9._:/-]*$
      type: string
    ModelOwner:
      maxLength: 128
      minLength: 1
      type: string
    OpenAIErrorDetail:
      additionalProperties: false
      properties:
        code:
          anyOf:
            - $ref: '#/components/schemas/ErrorCode'
            - type: 'null'
        message:
          $ref: '#/components/schemas/ErrorMessage'
        param:
          anyOf:
            - $ref: '#/components/schemas/ErrorParameter'
            - type: 'null'
        type:
          $ref: '#/components/schemas/ErrorType'
      required:
        - message
        - type
      type: object
    ErrorCode:
      enum:
        - bad_request
        - not_found
        - payload_too_large
        - unprocessable
        - invalid_api_key
        - expired_api_key
        - revoked_api_key
        - insufficient_credit
        - account_frozen
        - model_not_entitled
        - not_in_cohort
        - user_rate_limited
        - request_cancelled
        - quota_exceeded
        - capacity_exceeded
        - idempotency_key_reused
        - unsupported_endpoint
        - proxy_retired
        - gateway_unavailable
        - control_plane_overloaded
        - credit_gate_unavailable
        - upstream_contract_violation
        - unattributed_key
        - internal
        - bad_gateway
        - draining
        - spool_unhealthy
        - cold
        - timeout
      type: string
    ErrorMessage:
      maxLength: 2048
      minLength: 1
      type: string
    ErrorParameter:
      maxLength: 256
      minLength: 1
      type: string
    ErrorType:
      enum:
        - invalid_request_error
        - authentication_error
        - permission_error
        - rate_limit_error
        - quota
        - capacity
        - server_error
        - timeout
      type: string
  responses:
    Unauthorized:
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/OpenAIError'
      description: Missing, malformed, or unknown Cloud key
      headers:
        x-request-id:
          description: Request correlation id
          schema:
            $ref: '#/components/schemas/RequestId'
    RateLimited:
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/OpenAIError'
      description: Entitlement or GPU admission capacity limit
      headers:
        Access-Control-Expose-Headers:
          description: Response headers a browser client may read
          schema:
            $ref: '#/components/schemas/AccessControlExposeHeaders'
        Retry-After:
          description: Seconds before retrying when supplied
          schema:
            $ref: '#/components/schemas/RetryAfterSeconds'
        Server-Timing:
          description: Pre-stream phase timings when supplied
          schema:
            $ref: '#/components/schemas/ServerTiming'
        x-request-id:
          description: Request correlation id
          schema:
            $ref: '#/components/schemas/RequestId'
    Error:
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/OpenAIError'
      description: OpenAI-shaped error; raw upstream bodies are never returned
      headers:
        x-request-id:
          description: Request correlation id
          schema:
            $ref: '#/components/schemas/RequestId'
  securitySchemes:
    BearerAuth:
      bearerFormat: RunAnywhereCloudKey
      scheme: bearer
      type: http

````