# List models

Every offering this deployment serves, one type at a time, with what it can do and what it costs. Public: no key needed, so you can read the catalog before you have one.

`GET https://api.momor.ai/models/chat`

`/models/decision` lists the decision models and `/models/transcribe` the transcription models; `/models` and `/models/two` answer as `/models/chat` does. All take the same parameters. Read the catalog at runtime and fill a model picker from it rather than hardcoding names: offerings change with the deployment. The answer may be up to five minutes old.

## Query

- `select` (string): A comma-separated list of the fields each entry carries, such as id,provider,pricing. Fields are selected whole, so capabilities arrives with everything under it. A field no entry carries is refused with 400.

## Response

A list, `{ "object": "list", "data": [ … ] }`, with one entry per offering: several entries can share one `id` while naming different providers. A field with no value, such as `quantization` where the provider declares none, is left out.

- `id` (string): The model’s id: publisher/name in lowercase, with spaces as hyphens. Send it as model.
- `object` (string): model
- `name` (string): The name the model is shown under, such as Claude Sonnet 5.
- `description` (string): What the model is and what it is for, in a sentence.
- `ownedBy` (string): The model’s publisher. Send it as model.publisher to constrain by publisher.
- `provider` (string): The service hosting this offering. Send it as model.provider to pin the serving provider.
- `resale` (boolean): Whether Momor resells the offering on its own key. A Gateway call runs on Momor’s key only where it is true; elsewhere it needs your own key.
- `type` (string): The model’s type, which decides the route that reaches it. Values: `chat`, `decision`, `transcribe`.
- `tier` (string): The model’s tier. A request may spell it in any case. An unknown model is listed but never served. Values: `unknown`, `free`, `low`, `medium`, `high`, `xHigh`, `tierless`.
- `contextLength` (integer): The total context window, in tokens.
- `quantization` (string): The precision the provider serves the model at, where it declares one.
- `releasedAt` (string): The day the model was released, as yyyy-mm-dd.
- `capabilities` (object): What the offering can be sent. Momor does not paper over provider requirements: this is where you learn that a model can’t call tools, be held to a schema, or take the file you were about to send.
  - `toolUse` (boolean): Whether tools may be sent.
  - `structuredOutput` (string): responseSchema needs jsonSchema. Values: `none`, `jsonObject`, `jsonSchema`.
  - `streaming` (boolean): Whether streaming is accepted.
  - `caching` (boolean): Whether the provider offers prefix caching for the model.
  - `contentTypes` (string[]): What the model reads natively. A type absent here may still reach it through a converter.
  - `stop` (boolean): Whether the offering honours stop; likewise seed, frequencyPenalty, presencePenalty, topK, serviceTier, user, metadata and logprobs. An offering that does not is still sent the call, without it.
  - `parallelToolCalls` (boolean): Whether the offering can hold the model to one tool call a turn.
  - `reasoning` (boolean): Whether the offering reasons at all. One that does not is sent no reasoning depth.
- `pricing` (object): The price the provider publishes, which is what a call is charged. See Credits and pricing.
  - `promptTokens` (number): US dollars per million input tokens.
  - `completionTokens` (number): US dollars per million output tokens.
  - `cacheReadMultiplier` (number): Cache reads, as a multiple of promptTokens.
  - `cacheWriteMultiplier` (number): Cache writes, as a multiple of promptTokens.
  - `thoughtTokens` (number): US dollars per million reasoning tokens counted apart from the output.
  - `perUnit` (object): Sent only for a model priced by the unit rather than the token: an OCR model by the page it read, a transcription model by the minute of the recording.
    - `unit` (string): The unit the price is for. Values: `page`, `minute`.
    - `price` (number): US dollars for one unit.

The provider’s own model identifier is deliberately absent: it is used only when Momor sends the call to that provider.

## Errors

| Status | Code | What happened |
| --- | --- | --- |
| `400` | `—` | select names a field a catalog entry does not carry. |

## For OpenAI SDKs

`GET https://api.momor.ai/v1/models`

The chat models [Create a chat completion](/docs/gateway/reference/chat-completions/) can call, in OpenAI’s model-list shape, one entry per model, for an SDK’s model listing. Public, and cached for up to five minutes like the catalogs.

- `id` (string): The model’s id, publisher/name.
- `object` (string): model
- `owned_by` (string): The model’s publisher.
- `resale` (boolean): Whether a key Momor resells runs any of the model’s offerings, as resale above.

```bash title="Request"
curl "https://api.momor.ai/models/chat?select=id,ownedBy,provider,pricing"
```

```python
import requests

catalog = requests.get("https://api.momor.ai/models/chat").json()
for entry in catalog["data"]:
    print(entry["id"], entry["provider"], entry["pricing"]["promptTokens"])
```

```typescript
const catalog = await (await fetch("https://api.momor.ai/models/chat")).json();
for (const entry of catalog.data) {
  console.log(entry.id, entry.provider, entry.pricing.promptTokens);
}
```

```csharp
using System.Net.Http.Json;
using System.Text.Json;

using var http = new HttpClient();
var catalog = await http.GetFromJsonAsync<JsonElement>("https://api.momor.ai/models/chat");
foreach (var entry in catalog.GetProperty("data").EnumerateArray())
{
    Console.WriteLine($"{entry.GetProperty("id")} {entry.GetProperty("provider")}");
}
```

```json title="Response"
{
  "object": "list",
  "data": [
    {
      "id": "anthropic/claude-sonnet-5",
      "object": "model",
      "name": "Claude Sonnet 5",
      "description": "Agentic mid-tier model for multi-step coding, tool use and reasoning at lower cost than larger Claude models, with 1M-token context and adaptive thinking.",
      "ownedBy": "Anthropic",
      "provider": "anthropic",
      "resale": false,
      "type": "chat",
      "tier": "high",
      "contextLength": 1000000,
      "releasedAt": "2026-09-29",
      "capabilities": {
        "toolUse": true,
        "structuredOutput": "jsonSchema",
        "streaming": true,
        "caching": true,
        "contentTypes": ["text/*", "image/jpeg", "application/pdf"],
        "stop": true,
        "seed": false,
        "frequencyPenalty": false,
        "presencePenalty": false,
        "parallelToolCalls": true,
        "reasoning": true
      },
      "pricing": {
        "promptTokens": 3,
        "completionTokens": 15,
        "cacheReadMultiplier": 0.1,
        "cacheWriteMultiplier": 1.25,
        "thoughtTokens": 0
      }
    }
  ]
}
```