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

# List Models

> The catalog of models your account can call, with each model's current per-token prices, context limit and supported parameters. Prices change over time; poll this endpoint to track them. Entries are OpenAI model objects (`object: "model"`, `owned_by: "relace"`), so `client.models.list()` in any OpenAI SDK pointed at `https://models.relace.ai/v1` works.

The catalog of every model your account can call -- the open-weight models and the Relace models alike -- with the current price of each. Use the `id` field as the `model` parameter in [Chat Completions](/api-reference/open-models/chat-completions) and [Messages](/api-reference/open-models/messages) requests.

Entries are OpenAI model objects (`object: "model"`, `owned_by: "relace"`) with the model's context limit, modalities, prices and supported parameters added, so `client.models.list()` in any OpenAI SDK pointed at `https://models.relace.ai/v1` works unchanged.

## Tracking prices

Prices are subject to change, and this endpoint is the source of truth: the tables in these docs are updated by hand and can lag. Each entry carries its per-token prices as decimal dollar strings:

* `input_modalities[].pricing` (on the `text` entry): `prompt` for input tokens and, where the model has a prefix cache, `cached_prompt` for input tokens served from it.
* `output_modalities[].pricing`: `completion` for output tokens.


## OpenAPI

````yaml GET /v1/models
openapi: 3.0.1
info:
  title: Relace API
  description: API for accessing Relace code generation models.
  version: 1.0.0
  license:
    name: MIT
servers:
  - url: https://models.relace.ai
    description: Server for model API endpoints
  - url: https://api.relace.run
    description: Server for general infrastructure
security:
  - bearerAuth: []
paths:
  /v1/models:
    get:
      description: >-
        The catalog of models your account can call, with each model's current
        per-token prices, context limit and supported parameters. Prices change
        over time; poll this endpoint to track them. Entries are OpenAI model
        objects (`object: "model"`, `owned_by: "relace"`), so
        `client.models.list()` in any OpenAI SDK pointed at
        `https://models.relace.ai/v1` works.
      responses:
        '200':
          description: The hosted model catalog
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ModelsResponse'
        '401':
          description: Unauthorized
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error401'
      servers:
        - url: https://models.relace.ai
components:
  schemas:
    ModelsResponse:
      type: object
      properties:
        object:
          type: string
          description: Always `list`
        data:
          type: array
          description: Every model your account can call
          items:
            type: object
            properties:
              id:
                type: string
                description: >-
                  Model ID to pass as `model` in Chat Completions and Messages
                  requests
              object:
                type: string
                description: Always `model`
              owned_by:
                type: string
                description: Always `relace`
              name:
                type: string
                description: Human-readable model name
              description:
                type: string
                description: What the model is and how to use it
              created:
                type: integer
                description: Unix timestamp of when the model was listed
              quantization:
                type: string
                nullable: true
                description: Quantization the model is served at, e.g. `fp4`, `fp8`, `bf16`
              hugging_face_id:
                type: string
                description: Hugging Face repository of the weights, for open-weight models
              input_modalities:
                type: array
                description: >-
                  Accepted inputs. The `text` entry carries the context limit
                  and the prompt prices; an `image` entry means images are
                  accepted and billed as prompt tokens.
                items:
                  type: object
                  properties:
                    type:
                      type: string
                      enum:
                        - text
                        - image
                    supported_inputs:
                      type: object
                      properties:
                        max_context_length:
                          $ref: '#/components/schemas/TokenQuantity'
                      description: '`text` only'
                    pricing:
                      type: array
                      items:
                        $ref: '#/components/schemas/TokenPrice'
                      description: >-
                        `text` only: the `prompt` price, plus a `cached_prompt`
                        price when the model has a prefix cache
              output_modalities:
                type: array
                items:
                  type: object
                  properties:
                    type:
                      type: string
                      enum:
                        - text
                    max_length:
                      $ref: '#/components/schemas/TokenQuantity'
                    streaming:
                      type: boolean
                    supported_parameters:
                      type: object
                      additionalProperties:
                        type: object
                        properties:
                          type:
                            type: string
                            description: '`unknown`, `boolean`, `array`, or `integer`'
                          min:
                            type: integer
                          max:
                            type: integer
                          unit:
                            type: string
                      description: >-
                        Request parameters the model accepts, keyed by name:
                        sampling parameters (`temperature`, `top_p`,
                        `max_tokens`, `stop`, ...) and features (`reasoning`,
                        `tools`, `json_mode`, `structured_outputs`). A parameter
                        that is absent here is stripped from requests.
                    pricing:
                      type: array
                      items:
                        $ref: '#/components/schemas/TokenPrice'
                      description: The `completion` price
      example:
        object: list
        data:
          - id: deepseek-ai/DeepSeek-V4.1-Flash
            object: model
            owned_by: relace
            name: 'DeepSeek: DeepSeek V4.1 Flash'
            description: >-
              DeepSeek V4.1 Flash is a sparse mixture-of-experts model from
              DeepSeek with 552B total parameters (8B active per input token),
              Engram conditional memory, and a 1M-token context window.
            created: 1789006620
            quantization: fp4
            input_modalities:
              - type: text
                supported_inputs:
                  max_context_length:
                    value: 1048576
                    unit: token
                pricing:
                  - type: prompt
                    unit: token
                    cost_usd: '0.00000013'
                  - type: cached_prompt
                    unit: token
                    cost_usd: '0.00000001'
            output_modalities:
              - type: text
                max_length:
                  value: 1048576
                  unit: token
                streaming: true
                supported_parameters:
                  temperature:
                    type: unknown
                  max_tokens:
                    type: integer
                    min: 1
                    max: 1048576
                    unit: token
                  reasoning:
                    type: boolean
                  tools:
                    type: boolean
                pricing:
                  - type: completion
                    unit: token
                    cost_usd: '0.00000052'
    Error401:
      type: object
      properties:
        error:
          type: string
          description: Error message
          example: >-
            Invalid API key. Check the key, or create one at
            https://app.relace.ai.
    TokenQuantity:
      type: object
      properties:
        value:
          type: integer
        unit:
          type: string
          description: Always `token`
    TokenPrice:
      type: object
      properties:
        type:
          type: string
          enum:
            - prompt
            - cached_prompt
            - completion
          description: >-
            `prompt` = input tokens, `cached_prompt` = input tokens served from
            the prefix cache, `completion` = output tokens
        unit:
          type: string
          description: Always `token`
        cost_usd:
          type: string
          description: Price per token in dollars, as a decimal string.
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      description: Relace API key Authorization header using the Bearer scheme.

````

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