API

Models

List the models your key can call, with the price you are billed, context windows and input types, and the catalogue query behind the pricing page.

List models

GEThttps://backend.alfnrl.io/v1/models

The models your key can call, in the OpenAI list format, so models.list() in the OpenAI SDKs, and tools that call it on start-up, work against the AlphaNeural base URL. Each entry also carries the price you are billed and what the model can take, in the shape OpenRouter-style clients already read.

curl https://backend.alfnrl.io/v1/models \
  -H "Authorization: Bearer $ALPHANEURAL_API_KEY"

import os
from openai import OpenAI
 
client = OpenAI(
    base_url="https://backend.alfnrl.io/v1",
    api_key=os.environ["ALPHANEURAL_API_KEY"],
)
 
for model in client.models.list():
    print(model.id, model.model_extra.get("context_length"))

import OpenAI from "openai";
 
const client = new OpenAI({
  baseURL: "https://backend.alfnrl.io/v1",
  apiKey: process.env.ALPHANEURAL_API_KEY,
});
 
for await (const model of client.models.list()) {
  // The extras are not in the OpenAI types; the SDK keeps them on the object.
  const { context_length } = model as typeof model & { context_length?: number };
  console.log(model.id, context_length);
}

{
  "object": "list",
  "data": [
    {
      "id": "openrouter/anthropic/claude-haiku-4.5",
      "object": "model",
      "created": 0,
      "owned_by": "anthropic",
      "description": "Claude Haiku 4.5 ...",
      "context_length": 200000,
      "pricing": {"prompt": "0.0000011", "completion": "0.0000055"},
      "architecture": {
        "modality": "text+image->text",
        "input_modalities": ["text", "image"],
        "output_modalities": ["text"],
        "tokenizer": "Claude"
      },
      "top_provider": {"context_length": 200000, "max_completion_tokens": 64000},
      "supported_parameters": ["max_tokens", "temperature", "tools", "response_format"]
    },
    {"id": "openrouter/openai/gpt-4o-mini", "object": "model", "created": 0, "owned_by": "openai", "context_length": 128000, "pricing": {"prompt": "0.000000165", "completion": "0.00000066"}}
  ]
}

Entries are sorted by id. Each entry's id is exactly what you send as model.

Field
`id`, `object`	The model id, and always `model`.
`created`	Always `0`: the gateway records no registration date.
`owned_by`	The publisher, parsed from the id (`anthropic`, `openai`, ...). `alphaneural` when the id carries none, such as one of your own deployments.
`description`	The catalogue description, when there is one.
`context_length`	The input window in tokens.
`pricing.prompt`, `pricing.completion`	US dollars per token, as decimal strings, margin included: the price you are billed, the same figure Pricing quotes per million.
`architecture`	`input_modalities` and `output_modalities` (`text`, `image`, ...), `modality` as `text+image->text`, and the `tokenizer` family.
`top_provider`	`context_length` again, and `max_completion_tokens`, the reply limit, when known.
`supported_parameters`	The OpenAI request parameters this model accepts, when known. The gateway drops any parameter a model does not support rather than refusing the request.

Every field after owned_by is left out, not sent as null, when it is not known. pricing is left out for a model with no registry price; that is not a free model, and it will be billed from the provider's reported cost.

Only chat models are listed, because this base URL serves chat completions only. Embedding, image and audio models your key can reach are listed by the raw gateway at https://proxy.alfnrl.io/v1/models, which lists every model the key can reach, with ids only. The two lists are therefore not identical.

The list is what your key may call, not the whole catalogue: a Private or Standalone key sees its own deployments and nothing else. When the gateway refuses the key, its status is passed through: 401 for a key it does not know, 400 for one it cannot use, 429 when it is rate limited. See Errors.

The catalogue over GraphQL

The same prices and capabilities, for every model in the public catalogue rather than the ones your key can call, are available from the catalogue query. No authentication is needed:

curl https://backend.alfnrl.io/query \
  -H "Content-Type: application/json" \
  -d '{"query": "{ litellmModels { name vendor displayInputCostPerToken displayOutputCostPerToken maxInputTokens maxOutputTokens inputModalities outputModalities } }"}'

{
  "data": {
    "litellmModels": [
      {
        "name": "openrouter/openai/gpt-4o-mini",
        "vendor": "openai",
        "displayInputCostPerToken": 1.65e-7,
        "displayOutputCostPerToken": 6.6e-7,
        "maxInputTokens": 128000,
        "maxOutputTokens": null,
        "inputModalities": null,
        "outputModalities": null
      }
    ]
  }
}

Field
`name`	The model id to send as `model`.
`vendor`	The publisher, parsed from the name. `null` when the name carries none.
`displayInputCostPerToken`, `displayOutputCostPerToken`	The price per token in US dollars, margin included: the prices on Pricing, which quotes them per million. `null` means free or unpriced; the catalogue cannot tell the two apart, so never read `null` as a price of zero.
`maxInputTokens`, `maxOutputTokens`	Context window and reply limit. `null` where not recorded, which for `maxOutputTokens` is most models.
`inputModalities`, `outputModalities`	What the model accepts and produces, such as `["text", "image"]`. Few models have these recorded yet, so expect `null`.

This is the same catalogue /models and Pricing are built from, and it lists alphaneural/auto first, with alphaneural as its vendor and every price null.

Model ids

Catalogue models are named openrouter/<vendor>/<model>, for example openrouter/anthropic/claude-haiku-4.5. Copy ids from /models, Pricing or the list above.
alphaneural/auto is not a model but a router: the server picks a ladder of catalogue models for each request and you pay for the one that answered. See Routing.
Your own deployments are called by their deployment name, once the deployment has completed on a template that serves through the gateway (the vLLM and API templates). Until you publish a deployment to the catalogue, only a Private or Standalone key reaches it (see Authentication).
An id nobody serves is still forwarded, and the gateway's error for it is returned unchanged.

API