List models

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

This is how an application discovers, at boot, which model ids its key can call and what binds them. Never hard-code a list you guessed.

Request

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.runinfra.ai/v1",
    api_key=os.environ["RUNINFRA_GATEWAY_KEY"],
)
for model in client.models.list().data:
    print(model.id)

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.runinfra.ai/v1",
  apiKey: process.env.RUNINFRA_GATEWAY_KEY,
});
const models = await client.models.list();
console.log(models.data.map((model) => model.id));

curl https://api.runinfra.ai/v1/models \
  -H "Authorization: Bearer $RUNINFRA_GATEWAY_KEY"

Response

{
  "object": "list",
  "data": [
    {
      "id": "deepseek-v4-flash",
      "object": "model",
      "owned_by": "runinfra",
      "created": 1785679270,
      "availability": "available",
      "max_request_bytes": 3670016,
      "context_window": 1048576,
      "context_length": 1048576,
      "max_output_tokens": 1048576,
      "response_time_ceiling_seconds": 240,
      "session_affinity_idle_ttl_seconds": 900,
      "pricing": { "input": 0.13, "output": 0.27 },
      "cached_input_price_usd_per_mtok": 0.01,
      "cached_input_price": 0.01,
      "cache_isolation": "isolated",
      "cache_tiers": ["gpu"],
      "cache_retention": "best_effort",
      "max_concurrent_requests_per_api_key": 16,
      "max_tokens_per_minute_per_workspace": 4000000
    },
    {
      "id": "nemotron-3-5-lightning-30b",
      "object": "model",
      "owned_by": "runinfra",
      "created": 1786619239,
      "availability": "paused",
      "max_request_bytes": 3670016,
      "context_window": 262144,
      "max_output_tokens": 1048576,
      "max_concurrent_requests_per_api_key": 16,
      "max_tokens_per_minute_per_workspace": 4000000,
      "paused_until": "2026-09-12T11:07:19.211Z"
    }
  ]
}

The numeric values above are an example. Read them from your own response, because they move with capacity.

Field	Type	Value
`object`	string	`list` at the top level, `model` for each item.
`data[].id`	string	The id to send in the `model` field of an inference request.
`data[].owned_by`	string	`runinfra`.
`data[].created`	integer	Unix seconds, the creation time of the underlying record.
`data[].availability`	string	`available` or `paused`.
`data[].max_request_bytes`	integer	Largest request body the gateway accepts. Enforced at the gateway, so it is the same for every model.
`data[].context_window`	integer	Tokens the model can hold in one request. Present only where a served window has been reported.
`data[].context_length`	integer	The same served window under the name OpenAI-compatible catalog readers commonly use.
`data[].max_output_tokens`	integer	Generated tokens allowed in one request. Rejected above, never clamped.
`data[].pricing`	object	Hosted input and output prices in USD per one million tokens. Workspace deployments omit it.
`data[].cached_input_price_usd_per_mtok`	number	Hosted cached-input price in USD per one million tokens, when the effective cached tier is active.
`data[].cached_input_price`	number	The same cached-input price in USD per one million tokens under the short discovery key.
`data[].cache_isolation`	string	`isolated` when the active request path separates cache entries by tenant, otherwise `shared`.
`data[].cache_tiers`	string[]	Proven storage tiers, such as `gpu` or `host_ram`.
`data[].cache_retention`	string	`best_effort` for GPU capacity-pressure retention, or the model’s proven retention statement. No TTL is implied.
`data[].max_concurrent_requests_per_api_key`	integer	Requests one key may have in flight against this model. A workspace resolves to the same number.
`data[].max_tokens_per_minute_per_workspace`	integer	Tokens per minute one workspace may spend on this model, over a rolling 60 second window.
`data[].paused_until`	string	ISO 8601 scheduled return. Present only when `availability` is `paused`.

The fields are additive. A workspace deployment omits hosted pricing and cache facts rather than inheriting them from a model with the same id.

The four limit fields exist so you never learn a limit from a 429

They are read from the code that enforces them, so a published limit and an applied limit cannot drift apart. All four are additive to and disjoint from the fields the OpenAI Model object declares, so a client typed against the OpenAI SDK keeps parsing this response and ignores what it does not recognize.

Absent means undeclared, never zero and never unlimited

A field appears only where the limit it names is actually enforced for that model. A model that has not reported a served window carries no context_window rather than borrowing another model’s number.

Bytes can bind before tokens

max_request_bytes is a byte ceiling, not a token ceiling, and the two bind independently. For a very long prompt the byte ceiling is often the one that binds first, whatever the context window says.

Prices and cache behavior

Hosted model prices are returned here for discovery and repeated on each model’s page in the Model Library. The page also carries the human-readable cache eviction and retention statement, served precision when verified, capabilities, and the recommended output budget.

Available and paused

A paused model keeps its place in the list. It is a real configured model that is temporarily not serving, so poll this endpoint or retry the call itself to detect it coming back. The id does not change across a pause.

Retrieve one model

curl https://api.runinfra.ai/v1/models/deepseek-v4-flash \
  -H "Authorization: Bearer $RUNINFRA_GATEWAY_KEY"

Returns a single object with the same fields and no list wrapper. An id your key cannot reach returns 404 model_not_found. URL-encode any id containing a slash.

Which models appear

For a normal workspace key the list combines the public hosted models with the verified workspace deployments that key can reach. Models with the same identity are de-duplicated. A key pinned to one deployment sees only what that scope reaches and does not receive the general hosted list.

Authentication and rate limits

The endpoint needs a workspace API key, uses that key’s requests-per-minute limit, and returns X-RateLimit-Limit, X-RateLimit-Remaining, X-RateLimit-Reset and X-RateLimit-Tier. Listing models reserves no inference credit, but it is still an authenticated request against your per-minute budget, so do not call it in a hot loop.

Use the returned id exactly. Do not substitute a model’s internal served-model identifier.

Chat completions

Send one of these ids as the model field.

Authentication

The key that decides which ids you see.

Rate limits

The three layers that can refuse you.

Start here

Guides

API reference

Request

Response

The four limit fields exist so you never learn a limit from a 429

Absent means undeclared, never zero and never unlimited

Bytes can bind before tokens

Prices and cache behavior

Available and paused

Retrieve one model

Which models appear

Authentication and rate limits

Chat completions

Authentication

Rate limits

​Request

​Response

​The four limit fields exist so you never learn a limit from a 429

​Absent means undeclared, never zero and never unlimited

​Bytes can bind before tokens

​Prices and cache behavior

​Available and paused

​Retrieve one model

​Which models appear

​Authentication and rate limits

​Related

Chat completions

Authentication

Rate limits

Request

Response

The four limit fields exist so you never learn a limit from a 429

Absent means undeclared, never zero and never unlimited

Bytes can bind before tokens

Prices and cache behavior

Available and paused

Retrieve one model

Which models appear

Authentication and rate limits

Related