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

# List available models

> Lists the currently available models, and provides basic information about each one such as the owner and availability.



## OpenAPI

````yaml /api-reference/corti-models/corti-models-openapi.yml get /v1/models
openapi: 3.0.3
info:
  title: Models API
  description: >-
    OpenAI-compatible and Anthropic-compatible API for Corti's LLM models.

    The models listing endpoint (`GET /v1/models`) returns the public
    AIGatewayRoute resources on the cluster this service runs on. Each model may
    carry extra metadata (capabilities, cost, effort, display name, token
    limits, ...) sourced from the llm.corti.ai/metadata annotation of the route.
    In US projects, these model IDs are served by Azure-hosted OpenAI models
    rather than Corti's own infrastructure — see
    [Regions](https://docs.corti.ai/models/regions).

    ## Available Models

    | Model | Description | |------|-------------| | `corti-s1` |
    Full-capability model | | `corti-s1-instant` | Fast variant of corti-s1 | |
    `corti-s1-mini` | Smaller model | | `corti-s1-mini-instant` | Fast variant
    of corti-s1-mini | | `corti-s1-embedding` | Embedding model |

    `-instant` variants are optimized for speed and lower token usage.

    ## Reasoning

    Some models return chain-of-thought reasoning in a `reasoning` field (chat
    completions) or as structured output items with `type: "reasoning"`
    (responses API). The `-instant` variants do not produce reasoning.

    | Model | Chat Completions | Anthropic Messages | |-------|:---:|:---:| |
    `corti-s1` | `reasoning` field present | Text content only | |
    `corti-s1-instant` | `reasoning: null` | Text content only | |
    `corti-s1-mini` | `reasoning` field present | Text content only | |
    `corti-s1-mini-instant` | `reasoning: null` | Text content only |

    ## Authentication

    All endpoints require a bearer token issued by Corti. Pass it in the
    `Authorization` header as `Bearer <token>`.
  version: 1.0.0
  contact:
    name: Corti AI
    url: https://corti.app
servers:
  - url: https://ai.{environment}.corti.app/
    variables:
      environment:
        default: eu
        enum:
          - eu
          - fr
          - us
security:
  - bearerAuth: []
paths:
  /v1/models:
    get:
      tags:
        - Models
      summary: List available models
      description: >-
        Lists the currently available models, and provides basic information
        about each one such as the owner and availability.
      operationId: listModels
      parameters:
        - name: experimental
          in: query
          required: false
          description: >-
            When true, experimental models (ids suffixed with -alpha or -beta)
            are included in the response. Defaults to false.
          schema:
            type: boolean
            default: false
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ModelList'
        '500':
          description: Models could not be listed
      security: []
components:
  schemas:
    ModelList:
      type: object
      required:
        - object
        - data
      properties:
        object:
          type: string
          enum:
            - list
        data:
          type: array
          items:
            $ref: '#/components/schemas/Model'
    Model:
      type: object
      required:
        - id
        - object
        - created
        - owned_by
      properties:
        id:
          type: string
          description: The model identifier, used in chat-completion requests.
        object:
          type: string
          enum:
            - model
        created:
          type: integer
          format: int64
          description: Unix timestamp (in seconds) of when the model route was created.
        owned_by:
          type: string
        display_name:
          type: string
          description: Human-readable name of the model.
        max_input_tokens:
          type: integer
          format: int64
          nullable: true
          description: Maximum number of input tokens supported by the model.
        max_output_tokens:
          type: integer
          format: int64
          nullable: true
          description: Maximum number of output tokens supported by the model.
        capabilities:
          $ref: '#/components/schemas/Capabilities'
        effort:
          $ref: '#/components/schemas/Effort'
        cost:
          $ref: '#/components/schemas/Cost'
      additionalProperties: true
    Capabilities:
      type: object
      description: Feature support flags of the model.
      properties:
        reasoning:
          $ref: '#/components/schemas/CapabilityProperties'
        tool_call:
          $ref: '#/components/schemas/CapabilityProperties'
        temperature:
          $ref: '#/components/schemas/CapabilityProperties'
        image_input:
          $ref: '#/components/schemas/CapabilityProperties'
      additionalProperties: true
    Effort:
      type: object
      description: Reasoning effort support of the model.
      required:
        - supported
        - levels
      properties:
        supported:
          type: boolean
        levels:
          type: array
          items:
            type: string
      additionalProperties: true
    Cost:
      type: object
      description: Cost per million tokens.
      properties:
        input:
          type: number
          nullable: true
        output:
          type: number
          nullable: true
        cache_read:
          type: number
          nullable: true
      additionalProperties: true
    CapabilityProperties:
      type: object
      required:
        - supported
      properties:
        supported:
          type: boolean
      additionalProperties: true
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      description: |
        Use a Corti-issued bearer token.

````