#OpenRouter models (group op)

The op group gives access to the chat models in the OpenRouter catalog. A model name is op/<author>/<model>, for example op/openai/gpt-4o-mini. Requests and responses are OpenAI-compatible: POST /v1/chat/completions (see Chat).

The request body is passed to OpenRouter as it is, so the parameters of a model are described in the OpenRouter documentation: Parameters and Provider routing. This page covers only what is different here: how to find a model and its providers, what is supported and what is not.

#Finding a model

• GET /v1/models returns every model on sale with prices in credits. OpenRouter models start with op/.
• Names are the same as on openrouter.ai/models; only the op/ prefix is added.
• Free variants (…:free) are on sale too, but only while the API balance is above zero: see Chat.
• A suffix works only where that variant is a separate entry of the catalog (as :free is). The OpenRouter shortcut suffixes :nitro, :floor and :online do not work: the answer is 404 model_not_found. Use provider.sort instead of :nitro and :floor (below).

#Providers of a model: list and prices

One model is usually run by several providers that differ in price, numeric precision and speed. The list with prices in credits:

curl https://api.6io.io/v1/models/op/meta-llama/llama-3.3-70b-instruct/providers \
  -H "Authorization: Bearer sixio_sk_..."

Response (shortened):

{
  "id": "op/meta-llama/llama-3.3-70b-instruct",
  "name": "Meta: Llama 3.3 70B Instruct",
  "context": 131072,
  "pricing": {"currency": "credits", "prompt_per_million": "9.480000000000", "completion_per_million": "30.810000000000", "request": "0.000000000000"},
  "providers": [
    {
      "name": "DeepInfra",
      "tag": "deepinfra/turbo",
      "quantization": "fp8",
      "context": 131072,
      "max_output": 16384,
      "uptime_30m": 99.8,
      "default": true,
      "pricing": {"currency": "credits", "prompt_per_million": "9.480000000000", "completion_per_million": "30.810000000000", "request": "0.000000000000"}
    }
  ]
}

• Providers are listed from the cheapest. default: true marks the one a request goes to first when you do not choose a provider.
• tag is what goes into provider.order, only and ignore. A short name (deepinfra) matches all variants of that provider (deepinfra/turbo).
• quantization is the numeric precision (fp8, fp16, bf16, int4…), uptime_30m is the availability over the last 30 minutes, in percent.
• This works for op/ models only. vn/ has no provider list: Venice runs its own models.

The same data is in the console: the Models tab, click a model.

#Choosing a provider

Without a choice, a request goes to the cheapest provider with precision fp8 or better (fp8, mxfp8, fp16, bf16, fp32), and to the next cheapest one if that fails. Closed models do not state a precision, so no precision filter is added for them.

Your own choice is the provider field of the request body, in the OpenRouter format:

{
  "model": "op/meta-llama/llama-3.3-70b-instruct",
  "messages": [{"role": "user", "content": "Hello"}],
  "provider": {"order": ["novita", "deepinfra"], "allow_fallbacks": false}
}

How provider is handled here:

• If you set neither sort nor order, we add sort: "price".
• If you set none of quantizations, only and order, we add a filter for precision fp8 or better (only when the model has such a provider).
• Everything else is passed on as it is.
• The reserve is calculated with the prices of the provider the request goes to first. When that is not known in advance (for example, order is set), the highest price among the suitable providers is used. The actual cost is always what is charged.

Examples:

{"provider": {"sort": "throughput"}}
{"provider": {"sort": "latency"}}
{"provider": {"only": ["deepinfra"], "allow_fallbacks": false}}
{"provider": {"quantizations": ["fp16", "bf16"]}}
{"provider": {"ignore": ["novita"]}}

#Sorting

• "sort": "price": the cheapest provider (already the default here). OpenRouter's :floor suffix does the same.
• "sort": "throughput": the fastest in tokens per second. OpenRouter's :nitro suffix does the same.
• "sort": "latency": the lowest time to the first token.
• The object form {"sort": {"by": "throughput", "partition": "none"}} is accepted too: partition says whether providers are ranked inside each model or all together. It matters only with several models, and the models field is not supported here, so a string is usually enough.

#Plugins and web search

Not supported yet. These requests are refused before any charge with 400 unsupported_parameter:

• the plugins field (web search {"id": "web"}, PDF parsing and the other OpenRouter plugins);
• the web_search_options field (the :online model suffix gives 404 model_not_found);
• OpenRouter server tools in tools: types openrouter:…;
• the models field (a list of fallback models) and preset.

The reason is money. Web search and plugins cost extra on top of the tokens (per OpenRouter's documentation, Exa search is currently $0.007 per request plus $0.001 for each result beyond ten), and that amount is not part of the reserve. Until it is, such requests cannot be accepted.

What you can do now:

• search the web yourself and put the text you found into messages;
• use plain function calling (tools of type function): it works as in OpenAI;
• instead of models, send the request with provider.order and allow_fallbacks, and retry with another model in your own code on failure.

#What works as in OpenRouter

All other request parameters are passed on as they are: temperature, top_p, max_tokens, stop, tools and tool_choice, response_format (structured output), reasoning and more. Which of them a given model and provider understand is shown by GET https://openrouter.ai/api/v1/models/<author>/<model>/endpoints (the supported_parameters field) or the model page on openrouter.ai.

#Money

The price in credits is calculated from the provider's cost (usage.cost in the response); see Balance and prices. Free models and provider errors are covered in Chat and Retries and failures.