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

# List models

> Lists every model, with its type, privacy tier, limits, and prices. The call is free and needs no balance. It does not count toward the account's requests per minute. Each account may list the models 60 times a minute, on every plan.



## OpenAPI

````yaml /openapi.json get /v1/models
openapi: 3.1.1
info:
  title: Morse API
  version: '1'
  description: >-
    The Morse API serves chat, image, web search, and page-reading models
    through an OpenAI-compatible interface. Each request pays with your Morse
    account's credits.


    Send an API key from the Morse app with every request, in the Authorization
    header as Bearer sk_morse_.... A key acts for its account and always pays
    with credits, never with a plan's included use. One credit is $0.01. GET
    /v1/models lists prices in micro-dollars, 10,000 to the credit. Keep keys on
    your server. Browsers on other sites cannot call the API.


    All of an account's keys and its owner's use of the Morse app share one
    budget of requests per minute and one limit on requests in flight. The
    account's plan sets both. A request refused for either limit carries
    Retry-After, the number of seconds to wait. A retried POST is a new request,
    and the API charges it again.


    An error reply is JSON in the Error shape, with a stable code. A path the
    API does not serve returns 404 as plain text, and a wrong method returns 405
    as plain text.
servers:
  - url: https://api.trymorse.ai
security:
  - apiKey: []
paths:
  /v1/models:
    get:
      summary: List models
      description: >-
        Lists every model, with its type, privacy tier, limits, and prices. The
        call is free and needs no balance. It does not count toward the
        account's requests per minute. Each account may list the models 60 times
        a minute, on every plan.
      operationId: listModels
      responses:
        '200':
          description: The models.
          headers:
            X-Morse-Version:
              $ref: '#/components/headers/X-Morse-Version'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ModelList'
              example:
                object: list
                data:
                  - id: flux-2-max
                    object: model
                    created: 0
                    owned_by: Black Forest Labs
                    tier: anon
                    type: image
                    label: FLUX.2 [max]
                    plan: plus
                    price:
                      micros_per_image: 192000
                      micros_per_reference: 144000
                  - id: kimi-k3
                    object: model
                    created: 0
                    owned_by: Moonshot
                    tier: private
                    type: chat
                    label: Kimi K3
                    retention: zdr
                    input_modalities:
                      - text
                      - image
                    context_tokens: 1048576
                    max_output_tokens: 1048576
                    compact_at_tokens: 900000
                    plan: plus
                    price:
                      prompt_micros_per_mtok: 3600000
                      completion_micros_per_mtok: 18000000
                      min_hold_micros: 18432
                  - id: parallel-search
                    object: model
                    created: 0
                    owned_by: Parallel
                    tier: anon
                    type: search
                    label: Parallel Search
                    plan: free
                    included:
                      from: free
                      quota: web_calls
        '401':
          description: The key is missing or wrong.
          x-error-codes:
            - code: invalid_api_key
              when: >-
                The Authorization header is missing or not Bearer, the key is
                unknown or revoked, or a token that starts with sk_ is not a
                whole sk_morse_ key.
            - code: invalid_token
              when: >-
                The bearer token is not a Morse API key. Send the whole
                sk_morse_ key.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
              example:
                error:
                  message: Incorrect API key provided.
                  type: invalid_request_error
                  param: null
                  code: invalid_api_key
          headers:
            X-Morse-Version:
              $ref: '#/components/headers/X-Morse-Version'
        '403':
          description: The key's account may not make this request.
          x-error-codes:
            - code: account_disabled
              when: Morse has disabled the key's account.
            - code: account_deleted
              when: The key's account has been deleted.
            - code: account_under_18
              when: The account's owner said they are under 18.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
              example:
                error:
                  message: This account has been disabled. Contact support.
                  type: invalid_request_error
                  param: null
                  code: account_disabled
          headers:
            X-Morse-Version:
              $ref: '#/components/headers/X-Morse-Version'
        '429':
          description: >-
            The account listed the models too often. Wait the number of seconds
            in Retry-After, then retry.
          x-error-codes:
            - code: rate_limit_exceeded
              when: >-
                The account used up its 60 model lists a minute. All of the
                account's keys and its owner's use of the Morse app share them.
                Up to 7 lists can go at once, then one each second.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
              example:
                error:
                  message: >-
                    Rate limit reached for this account. Retry after the time in
                    the Retry-After header.
                  type: requests
                  param: null
                  code: rate_limit_exceeded
          headers:
            X-Morse-Version:
              $ref: '#/components/headers/X-Morse-Version'
            Retry-After:
              $ref: '#/components/headers/Retry-After'
        '503':
          description: >-
            Morse or the provider is busy or unavailable. Retry the request
            later.
          x-error-codes:
            - code: service_unavailable
              when: Morse could not start the request. Retry it.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
              example:
                error:
                  message: >-
                    The service is temporarily unable to authorize requests. Try
                    again shortly.
                  type: server_error
                  param: null
                  code: service_unavailable
          headers:
            X-Morse-Version:
              $ref: '#/components/headers/X-Morse-Version'
            Retry-After:
              $ref: '#/components/headers/Retry-After'
components:
  headers:
    X-Morse-Version:
      description: The running build. Every reply carries it.
      schema:
        type: string
    Retry-After:
      description: Whole seconds to wait before retrying, at least 1.
      schema:
        type: integer
        minimum: 1
  schemas:
    ModelList:
      type: object
      required:
        - object
        - data
      properties:
        object:
          const: list
        data:
          type: array
          items:
            $ref: '#/components/schemas/Model'
    Error:
      type: object
      description: >-
        Every JSON error reply has this shape. Branch on code, which is stable.
        The message is for people and can change.
      additionalProperties: false
      required:
        - error
      properties:
        error:
          type: object
          additionalProperties: false
          required:
            - message
            - type
            - param
            - code
          properties:
            message:
              type: string
              description: A sentence that says what went wrong and what to do.
            type:
              type: string
              description: >-
                The error's family, such as invalid_request_error,
                insufficient_balance, plan, requests, upstream_error, or
                server_error. plan means the account's plan does not allow the
                model, even when credits pay for the request.
            param:
              type:
                - string
                - 'null'
              description: Always null on the endpoints documented here.
            code:
              type: string
              description: >-
                The specific error. Each operation lists the codes it can
                return.
    Model:
      type: object
      required:
        - id
        - object
        - created
        - owned_by
        - tier
        - type
        - plan
      description: >-
        A model. The list sorts models by id. The included field describes what
        each plan includes in the Morse app. It does not apply to API keys,
        which always pay with credits.
      properties:
        id:
          type: string
          description: The name to send as model.
        object:
          const: model
        created:
          type: integer
          description: Always 0.
        owned_by:
          type: string
        tier:
          type: string
          enum:
            - anon
            - private
            - tee
            - e2ee
          description: >-
            The privacy tier. anon reaches the vendor without your identity,
            private runs on a provider with zero data retention, tee runs on
            attested hardware, and e2ee also encrypts the messages to that
            hardware.
        type:
          type: string
          enum:
            - chat
            - image
            - video
            - search
            - fetch
            - research
          description: >-
            The endpoint that serves the model. chat models run on
            /v1/chat/completions, image models on /v1/images/generations, search
            models on /v1/search, and fetch models on /v1/fetch.
        label:
          type: string
        retention:
          type: string
          enum:
            - vendor
            - zdr
        attester:
          type: string
        fallback_attesters:
          type: array
          items:
            type: string
        input_modalities:
          type: array
          items:
            type: string
          description: Absent when the model reads text only.
        context_tokens:
          type: integer
        max_output_tokens:
          type: integer
        compact_at_tokens:
          type: integer
        plan:
          type: string
          description: The lowest plan the Morse app lists the model under.
        requires_plan:
          type: string
          description: >-
            Present when only accounts on that plan or above may use the model,
            from the app or with a key. Other accounts get model_requires_plan.
        included:
          type: object
          description: What plans include in the Morse app. It does not apply to API keys.
        price:
          type: object
          description: >-
            What you pay, in micro-dollars. 10,000 micros are one credit, which
            is $0.01. Search and fetch models list no price, because each call
            costs a flat 1,000 micros.
          properties:
            prompt_micros_per_mtok:
              type: integer
            completion_micros_per_mtok:
              type: integer
            min_hold_micros:
              type: integer
            micros_per_image:
              type: integer
            micros_per_reference:
              type: integer
            micros_per_second:
              type: integer
  securitySchemes:
    apiKey:
      type: http
      scheme: bearer
      bearerFormat: sk_morse_...
      description: An API key from the Morse app. It starts with sk_morse_.

````

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