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

# Model capabilities

> Discover supported operations, parameters, modalities, billing modes, and provider endpoints at runtime.

Capabilities can differ between provider endpoints for the same model. Query `GET /v1/models` with your Planck API key to see the models and routes currently available to your organization.

<Warning>
  Do not hard-code a provider-wide capability list. Availability can depend on
  the exact model version, endpoint, credentials, organization policy, and
  PTB/BYOK mode.
</Warning>

## Gateway operations

| Capability          | Route                           | Registry operation     |
| ------------------- | ------------------------------- | ---------------------- |
| Chat Completions    | `POST /v1/chat/completions`     | `chat_completions`     |
| Responses           | `POST /v1/responses`            | `responses`            |
| Embeddings          | `POST /v1/embeddings`           | `embeddings`           |
| Images              | `POST /v1/images/generations`   | `image_generations`    |
| Reranking           | `POST /v1/rerank`               | `rerank`               |
| Video               | `POST /v1/videos`               | `video_generations`    |
| Audio transcription | `POST /v1/audio/transcriptions` | `audio_transcriptions` |
| Audio translation   | `POST /v1/audio/translations`   | `audio_translations`   |
| Text to speech      | `POST /v1/audio/speech`         | `audio_speech`         |
| Files               | `/v1/files*`                    | `files`                |

## Inspect one model

```bash cURL theme={null}
curl -s https://api.inquantum.ai/v1/models/gpt-4o \
  -H "Authorization: Bearer $PLANCK_API_KEY" | jq '{
    id,
    operations,
    inputModalities,
    outputModalities,
    supportsTools,
    supportsToolChoice,
    supportsWebSearch,
    supportsImageInput,
    hasByok,
    hasPtb,
    endpoints
  }'
```

```typescript TypeScript theme={null}
const response = await fetch("https://api.inquantum.ai/v1/models/gpt-4o", {
  headers: { Authorization: `Bearer ${process.env.PLANCK_API_KEY}` },
});

if (!response.ok) throw new Error(await response.text());

const model = await response.json();
console.log(model.operations);
console.log(model.endpoints.map((endpoint: any) => ({
  provider: endpoint.provider,
  parameters: endpoint.supportedParameters,
  operations: endpoint.supportedOperations,
  hasByok: endpoint.hasByok,
  hasPtb: endpoint.hasPtb,
})));
```

## Read the response

| Field                     | Meaning                                                                   |
| ------------------------- | ------------------------------------------------------------------------- |
| `operations`              | Union of operations supported by at least one accessible endpoint.        |
| `supportedParameters`     | Union of request parameters supported by accessible endpoints.            |
| `inputModalities`         | Model inputs such as `text`, `image`, or `audio`.                         |
| `outputModalities`        | Model outputs such as `text`, `image`, or `audio`.                        |
| `supportsTools`           | At least one accessible endpoint accepts `tools`.                         |
| `supportsToolChoice`      | At least one accessible endpoint accepts `tool_choice`.                   |
| `supportsReasoningEffort` | At least one endpoint accepts a reasoning control.                        |
| `supportsWebSearch`       | At least one endpoint exposes the hosted `web` plugin.                    |
| `supportsImageInput`      | The model metadata includes image input.                                  |
| `hasByok`                 | At least one endpoint is available with your configured provider keys.    |
| `hasPtb`                  | At least one endpoint is available with Planck credits for this request.  |
| `endpoints`               | Provider-specific capabilities, pricing, limits, and compliance metadata. |

<Info>
  Model-level booleans and arrays are unions. If your request needs several
  features together—for example streaming plus tools—verify that one endpoint
  contains every required parameter and operation.
</Info>

## Match a complete requirement

This example finds endpoints that support Chat Completions, streaming, tools, and tool selection together.

```typescript TypeScript theme={null}
const requiredParameters = ["stream", "tools", "tool_choice"];

const compatible = model.endpoints.filter((endpoint: any) =>
  endpoint.supportedOperations.includes("chat_completions") &&
  requiredParameters.every((parameter) =>
    endpoint.supportedParameters.includes(parameter),
  ) &&
  (endpoint.hasByok || endpoint.hasPtb),
);

if (compatible.length === 0) {
  throw new Error("No accessible endpoint satisfies every requirement");
}

console.table(compatible.map((endpoint: any) => ({
  provider: endpoint.provider,
  context: endpoint.contextLength,
  maxOutput: endpoint.maxCompletionTokens,
  byok: endpoint.hasByok,
  ptb: endpoint.hasPtb,
})));
```

To lock routing to a compatible provider, use the provider-qualified model syntax described in [Provider routing](/gateway/provider-routing#lock-to-specific-provider).

## Common checks

| You want to…            | Check                                                         |
| ----------------------- | ------------------------------------------------------------- |
| Stream chat             | endpoint has `chat_completions` and parameter `stream`        |
| Call tools              | endpoint has parameters `tools` and, if needed, `tool_choice` |
| Request structured JSON | endpoint has `response_format` or `structured_outputs`        |
| Send an image           | `supportsImageInput` and `inputModalities` includes `image`   |
| Use hosted web search   | `supportsWebSearch` or `supportedPlugins` includes `web`      |
| Set reasoning effort    | `supportsReasoningEffort` and endpoint reasoning parameter    |
| Pay with credits        | endpoint `hasPtb` is `true`                                   |
| Use your provider key   | endpoint `hasByok` is `true`                                  |

## List and filter models

```bash Models with tools and streaming theme={null}
curl -s https://api.inquantum.ai/v1/models \
  -H "Authorization: Bearer $PLANCK_API_KEY" | \
  jq -r '.data[]
    | select(any(.endpoints[];
        (.supportedOperations | index("chat_completions")) and
        (.supportedParameters | index("tools")) and
        (.supportedParameters | index("stream"))))
    | .id'
```

```bash Models with image input theme={null}
curl -s https://api.inquantum.ai/v1/models \
  -H "Authorization: Bearer $PLANCK_API_KEY" | \
  jq -r '.data[] | select(.supportsImageInput) | .id'
```

The response is already filtered by accessible credentials, PTB availability, and your organization's model policy. A model can disappear or change availability when those inputs change, so refresh this data rather than treating it as a permanent build-time list.

<CardGroup cols={2}>
  <Card title="Provider routing" icon="route" href="/gateway/provider-routing">
    Select or exclude providers after checking endpoint capabilities.
  </Card>

  <Card title="Models API" icon="brackets-curly" href="/rest/ai-gateway/get-v1models">
    See the model discovery endpoint reference.
  </Card>
</CardGroup>