> ## 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.

# Retrieve a model

> Retrieves one model, as OpenAI's model retrieve does, with the entry GET /v1/models lists for it to this caller. A model id, such as z-ai/glm-5.3, which holds a slash, answers its entry with its tiers; an alias, such as glm-5.3, answers its entry at its tier. The call is free, needs no balance, and shares the account's 60 model lists a minute.



## OpenAPI

````yaml /openapi.json get /v1/models/{id}
openapi: 3.1.1
info:
  title: Morse API
  version: '1'
  description: >-
    The Morse API serves chat 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/{id}:
    get:
      summary: Retrieve a model
      description: >-
        Retrieves one model, as OpenAI's model retrieve does, with the entry GET
        /v1/models lists for it to this caller. A model id, such as
        z-ai/glm-5.3, which holds a slash, answers its entry with its tiers; an
        alias, such as glm-5.3, answers its entry at its tier. The call is free,
        needs no balance, and shares the account's 60 model lists a minute.
      operationId: retrieveModel
      parameters:
        - name: id
          in: path
          required: true
          description: >-
            A model id or an alias from GET /v1/models. A model id's slash may
            be sent as it is or escaped as %2F.
          schema:
            type: string
      responses:
        '200':
          description: >-
            The model, as GET /v1/models lists it to this caller: a model id's
            entry with its tiers, or an alias's entry at its tier.
          headers:
            X-Morse-Version:
              $ref: '#/components/headers/X-Morse-Version'
          content:
            application/json:
              schema:
                oneOf:
                  - $ref: '#/components/schemas/ModelWithTiers'
                  - $ref: '#/components/schemas/Model'
              example:
                id: moonshotai/kimi-k3
                object: model
                created: 0
                owned_by: morse
                type: chat
                label: Kimi K3
                input_modalities:
                  - text
                  - image
                reasoning_efforts:
                  - none
                  - low
                  - high
                  - max
                tiers:
                  - tier: private
                    retention: zdr
                    quantizations:
                      - mxfp4
                      - fp8
                    context_tokens: 1048576
                    max_output_tokens: 1048576
                    compact_at_tokens: 838860
                    default_reasoning_effort: high
                    plan: pro
                    price:
                      prompt_micros_per_mtok: 3000000
                      completion_micros_per_mtok: 15000000
                      min_hold_micros: 15360
                  - tier: e2ee
                    retention: vendor
                    attesters:
                      - name: phala
                        sealed_model: moonshotai/kimi-k3
                    quantizations:
                      - unknown
                    context_tokens: 1048576
                    max_output_tokens: 1048576
                    compact_at_tokens: 838860
                    plan: pro
                    price:
                      prompt_micros_per_mtok: 3000000
                      completion_micros_per_mtok: 15000000
        '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, a token that starts with sk_ is not a whole
                sk_morse_ key, or the bearer is no Morse key or login token at
                all, such as another service's API key (sk-proj-...).
            - code: api_key_expired
              when: >-
                The key is past the expiry set on it. Make a new key, or set a
                later expiry before a key expires.
            - code: invalid_token
              when: >-
                The bearer is shaped as a Morse login token (a JWT) but its
                signature fails or it has expired. An API key sends 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.
            - code: ip_not_allowed
              when: >-
                The key allows requests only from its allowed IPs, and the
                request came from another address. The message names the address
                the proxy saw.
          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'
        '404':
          description: No model or alias of that name is listed to this caller.
          x-error-codes:
            - code: model_not_found
              when: >-
                The id names no model or alias that GET /v1/models lists to this
                caller, such as a model below the key's min_privacy or one only
                the Morse app may use.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
              example:
                error:
                  message: The requested model does not exist.
                  type: invalid_request_error
                  param: null
                  code: model_not_found
          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:
    ModelWithTiers:
      type: object
      required:
        - id
        - object
        - created
        - owned_by
        - type
        - tiers
      description: >-
        A model, listed once. The fields at the top describe the weights. Each
        row of tiers is the model at one privacy tier, with the price and limits
        it is sold at there. A tier with no price is not listed. The plan and
        included fields describe the Morse app. They do not apply to API keys,
        which always pay with credits.
      properties:
        id:
          type: string
          description: The model's id.
        object:
          const: model
        created:
          type: integer
          description: Always 0.
        owned_by:
          type: string
        type:
          type: string
          enum:
            - chat
            - image
            - video
            - search
            - fetch
            - research
            - transcription
          description: >-
            The endpoint that serves the model, as for a model in the aliases
            shape.
        label:
          type: string
        input_modalities:
          type: array
          items:
            type: string
          description: Absent when the model reads text only.
        reasoning_efforts:
          type: array
          items:
            type: string
            enum:
              - none
              - minimal
              - low
              - medium
              - high
              - xhigh
              - max
          description: >-
            On every chat model: the efforts it takes, lowest first. Empty when
            it takes none.
        tools:
          const: false
          description: >-
            False on a chat model served without tools. An API key's request
            that lets it call a tool (tools, or a tool_choice that calls one,
            with a tool_choice other than none) is refused with 400
            unsupported_parameter naming tools; any other request reaches the
            host with no tools, tool_choice, or parallel_tool_calls. Absent on
            every model that takes tools.
        characters:
          const: false
          description: >-
            False on a chat model kept out of character chats. A chat that plays
            a character on it, one that sends X-Character or a character's
            prompt, is refused with 400 model_unsupported_for_characters before
            Morse calls the model or holds any credit. Absent on every model
            that takes character chats.
        tiers:
          type: array
          description: >-
            The tiers the model is sold at, from the least private to the most.
            Each tier appears once, whichever providers serve it.
          items:
            $ref: '#/components/schemas/ModelTier'
    Model:
      type: object
      required:
        - id
        - object
        - created
        - owned_by
        - tier
        - type
        - plan
      description: >-
        A model in the aliases shape, which lists one entry per name. 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
            - transcription
          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, fetch models on /v1/fetch, and transcription
            models on /v1/audio/transcriptions.
        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.
        reasoning_efforts:
          type: array
          items:
            type: string
            enum:
              - none
              - minimal
              - low
              - medium
              - high
              - xhigh
              - max
          description: >-
            On every chat model: the efforts it takes, lowest first. Empty when
            it takes none.
        tools:
          const: false
          description: >-
            False on a chat model served without tools. An API key's request
            that lets it call a tool (tools, or a tool_choice that calls one,
            with a tool_choice other than none) is refused with 400
            unsupported_parameter naming tools; any other request reaches the
            host with no tools, tool_choice, or parallel_tool_calls. Absent on
            every model that takes tools.
        characters:
          const: false
          description: >-
            False on a chat model kept out of character chats. A chat that plays
            a character on it, one that sends X-Character or a character's
            prompt, is refused with 400 model_unsupported_for_characters before
            Morse calls the model or holds any credit. Absent on every model
            that takes character chats.
        quantizations:
          type: array
          items:
            type: string
            enum:
              - int4
              - int8
              - fp4
              - mxfp4
              - nvfp4
              - fp6
              - fp8
              - mxfp8
              - fp16
              - bf16
              - fp32
              - unknown
          description: >-
            On a chat model: the precisions the providers of the model at this
            entry's tier publish, as its tier row in the tiers shape lists them.
        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.
        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, fetch, and transcription models list no price,
            because each call costs a flat fee: 1,000 micros for a search or
            fetch, and 200 for a transcription.
          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
        unsealed:
          type: object
          description: >-
            On an e2ee model's own id, in an API key's list when its min_privacy
            is tee or lower, what a request without E2EE headers gets at a tee
            floor, and with no floor or a lower one when the model has no
            private or anon endpoint at or above it that the key admits. A login
            or guest token gets e2ee_header_missing instead. Morse seals its
            messages to a key the vendor's verified attestation lists, so the
            vendor's attested hardware reads them, and Morse reads them too: the
            request runs at tier tee, not e2ee, at the model's price, and holds
            what a plaintext chat holds.
          properties:
            tier:
              type: string
              enum:
                - tee
            min_hold_micros:
              type: integer
    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.
    ModelTier:
      type: object
      required:
        - tier
        - price
      description: >-
        A model at one privacy tier. Its limits are those a request at the tier
        is held to. A backup provider with a smaller window of its own serves
        only the chats that fit it and never changes them. Where the tier's main
        providers differ, a limit is the widest of theirs. Retention is the
        least private of the tier's providers. A row never names a provider.
      properties:
        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.
        retention:
          type: string
          enum:
            - vendor
            - zdr
        attesters:
          type: array
          description: >-
            On a tee or e2ee row: the vendors whose attestation proves the tier.
            On an e2ee row each also gives the model a sealed body carries.
          items:
            type: object
            required:
              - name
            properties:
              name:
                type: string
              sealed_model:
                type: string
        quantizations:
          type: array
          items:
            type: string
            enum:
              - int4
              - int8
              - fp4
              - mxfp4
              - nvfp4
              - fp6
              - fp8
              - mxfp8
              - fp16
              - bf16
              - fp32
              - unknown
          description: >-
            On a chat row: the precisions the tier's providers publish for the
            weights, in OpenRouter's names and order: integers, then floats,
            each fewest bits first, and unknown last. unknown is a provider that
            publishes none. The list counts every provider a chat at the tier
            may run on, backups and e2ee fallbacks included, and names none of
            them. provider.quantizations chooses among these.
        context_tokens:
          type: integer
        max_output_tokens:
          type: integer
          description: >-
            The most output tokens a request served at this tier may produce. A
            request asking more gets this many below e2ee and is refused with
            e2ee_output_limit_refused at e2ee.
        compact_at_tokens:
          type: integer
        default_reasoning_effort:
          type: string
          description: >-
            The effort a chat gets when it sets none. Absent when the vendor
            chooses.
        plan:
          type: string
          description: The lowest plan the Morse app lists the model under.
        requires_plan:
          type: string
          description: >-
            The lowest plan that may call the model in the Morse app. It does
            not apply to API keys.
        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 at this tier, in micro-dollars. 10,000 micros are one
            credit, which is $0.01. An API key pays the vendor's list price, and
            a Morse app login pays it at the model's markup. A chat model lists
            its prompt and completion price per million tokens, an image model
            its price per image and per reference image, and a search, fetch,
            research, or transcription model its flat price per call.
          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
            micros_per_call:
              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.