Models

The live catalog of models. Always dynamic — we don't keep a static list in these docs because it drifts the moment we add a model.

Auth: Bearer token or x-api-key. Requires scope inference.models. Responses are cached for 5 minutes — safe to poll.

List models

GET /v1/models

Returns the models available to your key. Add ?include_meta=true for Melious-specific capability metadata. owned_by is the model's brand (the organization that published the weights), not "melious".

curl https://api.melious.ai/v1/models \
  -H "Authorization: Bearer sk-mel-<YOUR_API_KEY>"

{
  "object": "list",
  "data": [
    { "id": "<MODEL_ID>", "object": "model", "created": 1699999999, "owned_by": "<BRAND>" },
    { "id": "<ANOTHER_MODEL_ID>", "object": "model", "created": 1699999999, "owned_by": "<BRAND>" }
  ]
}

curl "https://api.melious.ai/v1/models?include_meta=true" \
  -H "Authorization: Bearer sk-mel-<YOUR_API_KEY>"

{
  "object": "list",
  "data": [
    {
      "id": "<MODEL_ID>",
      "object": "model",
      "created": 1699999999,
      "owned_by": "Qwen",
      "_meta": {
        "type": "chat",
        "input_modalities": ["text"],
        "output_modalities": ["text"],
        "capabilities": {
          "streaming": true,
          "function_calling": true,
          "vision": false,
          "structured_output": true,
          "json_schema": true,
          "reasoning": false
        },
        "context_length": 131072,
        "max_output_tokens": 16384,
        "reasoning_type": "non_reasoning",
        "reasoning_effort": null,
        "knowledge_cutoff": "2024-10",
        "release_date": "2025-03-01",
        "huggingface_url": "https://huggingface.co/Qwen/Qwen3-235B-A22B",
        "pricing": {
          "input_cost_per_million_eur": 0.50,
          "output_cost_per_million_eur": 1.50,
          "cache_read_cost_per_million_eur": 0.13,
          "currency": "EUR"
        }
      }
    }
  ]
}

`_meta.type`

One of chat, embeddings, audio, image, reranker, guardrail, decision. Tells you which endpoint to hit — decision models answer through System One.

`_meta.capabilities`

Boolean flags you can branch on when picking a model programmatically. Common keys: streaming, function_calling, vision, structured_output, json_schema, reasoning. Absence of a key means "not applicable" for that model type (e.g. embedding models don't have vision). For input types (image, audio) read _meta.input_modalities — that is what the request path checks.

Decision models carry one object instead of a flag: capabilities.decision = {"max_request_bytes", "max_questions", "max_choice_options", "max_score_levels", "images"} — images is a boolean and is false today. See System One.

`_meta.context_length`

Max context tokens for chat, embedding, and decision models (the largest window across active providers). null for image, audio, reranker, and guardrail models, and for a model with no active provider. Use a model with a larger context window if your request exceeds this limit.

`_meta.max_output_tokens`

The model's default maximum output tokens, from its parameter configuration. null when the model doesn't specify one.

`_meta.reasoning_type`

One of reasoning, non_reasoning, hybrid. Hybrid models can toggle reasoning on or off per request using reasoning_effort.

`_meta.reasoning_effort`

The effort we apply when your request doesn't set reasoning_effort: low, medium, or high. null when the model has no effort control (sending a value then changes nothing).

`_meta.knowledge_cutoff`

The model's training data cutoff date (e.g. 2024-10). null when not available.

`_meta.release_date`

When the model was released (ISO date string, e.g. 2025-03-01). null when not available.

`_meta.huggingface_url`

Link to the model's HuggingFace page, when the model has one. null for closed or proprietary models.

`_meta.pricing`

User-facing pricing for the model: the lowest input rate and the lowest output rate across the active providers, each taken separately, so the pair may come from two providers. Present only when at least one active provider has pricing for the model type. All amounts are in EUR.

The fields vary by model type:

Model type	Pricing fields
`chat`	`input_cost_per_million_eur`, `output_cost_per_million_eur`, `cache_read_cost_per_million_eur` (optional), `currency`
`embeddings`, `reranker`	`input_cost_per_million_eur`, `currency`
`image`	`image_cost_per_image_eur`, `currency`
`audio`	`audio_cost_per_minute_eur`, `currency`
`guardrail`	`input_cost_per_million_eur`, `output_cost_per_million_eur`, `currency`
`decision`	`input_cost_per_million_eur`, `currency`

cache_read_cost_per_million_eur is only present when at least one provider supports prompt caching for that model. Token costs are per 1 million tokens. These are the lowest available rates for the model, in EUR, at the same cleaned prices we bill. The rate you pay on a given request is the serving provider's — balanced routing weighs price against speed and grid, so it isn't always the lowest; :price gets you closest. The exact charge is billing_cost on the response.

Retrieve one model

GET /v1/models/{id}

Returns a single model object in the same shape. include_meta=true works here too. An alias resolves to its canonical model.

curl "https://api.melious.ai/v1/models/<MODEL_ID>?include_meta=true" \
  -H "Authorization: Bearer sk-mel-<YOUR_API_KEY>"

Finding models programmatically

A common pattern: filter on capabilities before picking.

from openai import OpenAI

client = OpenAI(api_key="sk-mel-<YOUR_API_KEY>", base_url="https://api.melious.ai/v1")

# OpenAI SDK doesn't expose ?include_meta, so hit the raw endpoint
import httpx
models = httpx.get(
    "https://api.melious.ai/v1/models",
    params={"include_meta": "true"},
    headers={"Authorization": "Bearer sk-mel-<YOUR_API_KEY>"},
).json()

# Pick the largest-context chat model that supports tools
candidates = [
    m for m in models["data"]
    if m["_meta"]["type"] == "chat"
    and m["_meta"]["capabilities"].get("function_calling")
]
best = max(candidates, key=lambda m: m["_meta"]["context_length"] or 0)
print(best["id"], best["_meta"]["context_length"])

What's not here

The model list endpoint doesn't return provider-level details (which providers serve a model, their health status, or raw provider costs). _meta.pricing is the lowest available rate across providers, not a quote for your request. For the authoritative per-request cost, read billing_cost on each inference response.

Errors

Unknown model — unknown model ID on the single-retrieve endpoint.
Permission error — missing inference.models scope.
model_not_allowed — 403: the key can't use this model.

Human-readable catalog: melious.ai/hub • Model stance and families: Models concept • Routing by capability: Routing.

On this page