BYTETOOLS

OpenRouter Models API

Free LLM catalogue API with no key: every model OpenRouter routes to, with per-token pricing, context length, modalities and supported parameters. Tested example included.

No API key requiredCORS enabledHTTPSFree tier

Endpoint tested and returned HTTP 200 on 2026-08-21

What is the OpenRouter Models API?

OpenRouter's models endpoint is readable without an API key and lists every language model it routes to. Each entry gives per-token prompt and completion pricing, context length, input and output modalities, tokenizer and the request parameters that model supports.

OpenRouter aggregates models from dozens of providers behind one API, and the catalogue endpoint is the part you can read without any credentials at all. Because it is a routing layer, the pricing it publishes is what you would actually pay through OpenRouter rather than a list price scraped from a marketing page — and it updates as providers change their rates.

Two structures repay attention. `architecture.input_modalities` and `output_modalities` are arrays, so a model accepting text, image and video is described precisely rather than being flattened into a single "multimodal" label. And `supported_parameters` tells you which request options a model actually honours — whether it accepts tool calls, structured outputs or a reasoning effort setting — which is the difference between a request that works and one that silently ignores half of what you sent. Prices are strings in USD per token, so a value like `0.000003` needs multiplying by a million to get the familiar per-million-token figure.

Quick facts

Base URL
https://openrouter.ai/api/v1
Authentication
No API key to list models. Actually calling a model for inference requires an API key and credit.
Rate limit
No published limit on the catalogue endpoint. It changes a few times a day at most.
Pricing
Free to read. Inference through OpenRouter is paid per token.
CORS
Enabled — callable directly from browser JavaScript
Official docs
Read the docs

How to use the OpenRouter Models API

Every request below was executed against the live API on 2026-08-21, and the response shown is the real body it returned — not an illustration.

1. List every available language model

GET https://openrouter.ai/api/v1/models

curl
curl 'https://openrouter.ai/api/v1/models'
JavaScript (fetch)
const res = await fetch("https://openrouter.ai/api/v1/models");
if (!res.ok) throw new Error(`Request failed: ${res.status}`);
const data = await res.json();
console.log(data);
Python (requests)
import requests

res = requests.get("https://openrouter.ai/api/v1/models", timeout=20)
res.raise_for_status()
print(res.json())
Response — HTTP 200 (truncated)
{
  "data": [
    {
      "id": "stealth/ox-alpha",
      "canonical_slug": "stealth/ox-alpha",
      "hugging_face_id": null,
      "name": "Ox Alpha",
      "created": 1787256295,
      "description": "Ox Alpha is a reasoning model designed for coding, sustained agentic work, and production workloads. It is suited for long-horizon software engineering, complex reasoning, and workflows that combine text with...",
      "context_length": 1048576,
      "architecture": {
        "modality": "text+image+video->text",
        "input_modalities": [
          "text",
          "image",
          "video"
        ],
        "output_modalities": [
          "text"
        ],
        "tokenizer": "Other",
        "instruct_type": null
      },
      "pricing": {
        "prompt": "0",
        "completion": "0"
      },
      "top_provider": {
        "context_length": 1048576,
        "max_completion_tokens": 131072,
        "is_moderated": false
      },
      "per_request_limits": null,
      "supported_parameters": [
        "include_reasoning",
        "max_tokens",
        "reasoning",
        "reasoning_effort",
        "response_format",
        "temperature",
        "tool_choice",
        "tools",
        "top_k",
        "top_p"
      ],
      "default_parameters": {
        "temperature": 1,
        "top_p": 0.95
      },
      "supported_voices": null,
      "knowledge_cutoff": null,
      "expiration_date": "2098-12-31",
      "links": {
        "details": "/api/v1/models/stealth/ox-alpha/endpoints"
      },
      "reasoning": {
        "mandatory": true,
        "defau

Parameters

ParameterTypeRequiredDescription
(none)n/aOptionalThe models endpoint takes no required parameters and returns the whole catalogue.
categoryqueryOptionalFilter to a category of models, where OpenRouter has classified them. programming
/models/{author}/{slug}/endpointspathOptionalPer-provider endpoints for one model, showing which upstream providers serve it and at what price.

Response fields

dataarray
Every model in the catalogue.
data[].id / canonical_slugstring
Model identifier in `author/model` form — this is what you pass when making an inference request.
data[].namestring
Human-readable display name.
data[].descriptionstring
Provider-supplied summary of what the model is for.
data[].context_lengthinteger
Maximum context window in tokens.
data[].pricingobject
USD per token as strings, with `prompt` and `completion` at minimum and often image, request and reasoning rates too. Multiply by a million for the usual per-MTok figure.
data[].architecture.modalitystring
Compact summary such as `text+image+video->text`.
data[].architecture.input_modalities / output_modalitiesarray
Precise lists of what the model accepts and produces.
data[].architecture.tokenizerstring
Tokenizer family, which matters if you are counting tokens yourself.
data[].top_providerobject
The default upstream provider's context limit and whether it moderates requests.
data[].supported_parametersarray
Request options this model honours — tool calling, structured outputs, reasoning effort and so on.
data[].hugging_face_idstring
Corresponding Hugging Face repository for open-weight models; null for proprietary ones.
data[].createdinteger
Unix timestamp of when the model was added to the catalogue.

What you can build with the OpenRouter Models API

  • Build a model picker showing live pricing and context limits
  • Compare per-token costs across providers before choosing a model
  • Check whether a model supports tool calling before wiring it up
  • Track when new models appear in the catalogue

Common errors and how to fix them

Prices look implausibly small

Pricing is USD per single token, as a string.

Fix: Multiply by 1,000,000 for the per-million-token figure everyone quotes, and parse the string first.

Free model still charged

A zero prompt and completion price does not always mean zero cost.

Fix: Check every key in the `pricing` object — request, image and reasoning charges can be non-zero.

Parameter silently ignored

Not every model honours every request option.

Fix: Read `supported_parameters` before sending tool definitions or a reasoning setting.

Large response

The catalogue covers hundreds of models.

Fix: Cache it. It changes a few times a day, so per-request fetching is wasteful.

OpenRouter Models API — frequently asked questions

Can I list OpenRouter models without an API key?

Yes. The models endpoint is fully public. A key and credit are only needed to actually run inference.

How do I read the pricing figures?

They are USD per single token, serialised as strings. Multiply by a million to get the per-million-token price that providers usually advertise.

What is supported_parameters for?

It lists which request options a given model actually honours — tool calling, structured outputs, reasoning effort. Sending an unsupported option is silently ignored rather than rejected, so checking first saves confusing debugging.

Is the pricing the same as the provider's own?

It is what you pay through OpenRouter, which is the useful number if you route through them. A provider's direct list price can differ.

Tools that pair with this API

OpenRouter Models is an independent third-party service and is not affiliated with ByteTools or ByteVancer. Details on this page were verified on 2026-08-21; always check the official documentation before relying on this API in production, as terms and limits can change.