# OpenRouter models (group op)

> Original: https://api.6io.io/en/docs/openrouter/ (HTML). All pages: https://api.6io.io/llms.txt

The `op` group gives access to the chat models in the [OpenRouter](https://openrouter.ai/models) 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](https://api.6io.io/md/en/chat.md)).

The request body is passed to OpenRouter as it is, so the parameters of a model are described in the OpenRouter documentation: [Parameters](https://openrouter.ai/docs/api-reference/parameters) and [Provider routing](https://openrouter.ai/docs/guides/routing/provider-selection). 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](https://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](https://api.6io.io/md/en/chat.md).
- 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:

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

Response (shortened):

```json
{
  "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:

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

| `provider` field | What it does |
| --- | --- |
| `order` | which providers to try, and in what order |
| `only` | only these providers |
| `ignore` | every provider except these |
| `allow_fallbacks` | `false`: do not move on to other providers when the chosen ones are unavailable |
| `quantizations` | allowed precision: `int4`, `int8`, `fp4`, `fp6`, `fp8`, `fp16`, `bf16`, `fp32`, `unknown` and the others in the OpenRouter docs |
| `sort` | how to rank providers: `price`, `throughput` or `latency` (more below) |
| `require_parameters` | `true`: only providers that support every parameter of the request |
| `data_collection` | `deny`: only providers that do not store your data |
| `zdr` | `true`: only providers with zero data retention |
| `max_price` | price ceiling (`prompt`, `completion`, `request`, `image`); **in OpenRouter's units and dollars, not in credits**, see their documentation |
| `preferred_min_throughput`, `preferred_max_latency` | preferred speed and latency (a soft condition) |

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:

```json
{"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](https://api.6io.io/md/en/billing.md). Free models and provider errors are covered in [Chat](https://api.6io.io/md/en/chat.md) and [Retries and failures](https://api.6io.io/md/en/retries.md).