---
title: "Live vs on-request vs research models: read a catalogue"
description: "How to tell which catalogue models you can call today, which need an enquiry and which were only tested, using BroadNet's catalogue and /v1/models as the example."
url: https://broadrouter.com/blog/understand-model-status/
lang: en
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

# Live, on request, research: read a model catalogue clearly

By the BroadNet Inference team · 7 min read · Published 2026-11-15 · Updated 2026-11-16

A model you can call has an exact API ID, a published price and a live status on the provider's rate card or price feed. On-request models need an enquiry and usually a private model ID. Research entries record what the provider tested and are not callable. Read the feed and API reference, then confirm with one request.

## Key takeaways

-   Three different lists: the rate card (callable now), on-request (ask first) and research (tested, not offered). Only the first takes a self-serve key.
-   BroadNet's pricing.json gives each model a status of live or on\_request, and paid\_only for models that need a top-up. On 15 November 2026 it listed six live models.
-   BroadNet's catalogue also lists about 270 models run in its lab, plus about 90 remote models it says it never ran on its own hardware. Neither list is an offer.
-   On 15 November 2026, BroadNet's /v1/models returned only the two transcription models. Its docs say to use the model IDs in the API reference for requests.
-   When a provider's pages disagree, trust the feed and the API reference for what to send, test with one request, and ask the provider.

**On this page**

1.  What are the three kinds of catalogue entry?
2.  How does BroadNet’s catalogue show it?
3.  Which source is the rate card?
4.  Can you trust GET /v1/models?
5.  How do you check status in code?
6.  What does “on request” look like in practice?
7.  A five-step check before you build on a model
8.  What should you never infer from a catalogue?
9.  Where BroadNet Inference fits

Provider catalogues mix three kinds of entry on one page: models you can call now, models you can ask for, and models the provider only tested. They look alike in a table. They are very different when you write code against them. This post shows how to tell them apart, using BroadNet’s catalogue as the worked example. BroadRouter is BroadNet’s own site, so we checked every BroadNet page cited here on 15 November 2026 and quote it rather than paraphrase where it matters.

## What are the three kinds of catalogue entry?

| Status | What it means | What you need | How you call it |
| --- | --- | --- | --- |
| **Live** | On the public rate card with a published price | An account and an eligible key | The public model ID on the public base URL |
| **On request** | The provider can deploy it, but not self-serve | An enquiry and an agreement | Usually a private model ID or endpoint |
| **Research** | Tested, benchmarked, quantised or ruled out | Nothing; it is not for sale | You can’t |

The trap is the third row. A provider that publishes its research honestly will list far more models than it sells. That is useful information about how it chooses models. It is not an availability claim.

## How does BroadNet’s catalogue show it?

BroadNet’s [model catalogue](https://www.broadnet.ai/inference/models) has all three on one page, in this order:

1.  **“Live on the Inference API”.** The box says: “These models are on the rate card today.”
2.  **“Available on request”.** Three entries: a BroadNet fine-tune of Cohere Transcribe Arabic, Qwen3-VL 30B-A3B Instruct and Qwen3-VL 8B Instruct. Their model pages say “private id issued per customer”.
3.  **“The catalogue”.** Every model BroadNet says it has run in its lab (about 270, measured in September 2026), tagged PROD (carried live traffic), SERVED, BENCH, QUANT, FT or RULED OUT. It is grouped into language models, speech to text, text to speech, OCR, embeddings, image and video generation, and more.
4.  **“Remote and API models benchmarked”.** In BroadNet’s words: “About 90 models we never ran on our hardware but pushed through our safety, routing and Arabic harnesses.” It names models from Anthropic, OpenAI, Google, Meta and others.

Only the first group is callable with a self-serve key. The third and fourth groups include text-to-speech, image-generation and embedding models, none of which BroadNet’s public API offers. Seeing FLUX or a Claude model in the table tells you BroadNet measured it, not that you can send it a request. The reasons BroadNet gives for the rejected ones are summarised in [models BroadNet ruled out](https://broadrouter.com/blog/models-broadnet-ruled-out/), and the hardware side in [BroadNet’s GPU hardware and serving](https://broadrouter.com/blog/broadnet-gpu-fleet-and-serving/).

## Which source is the rate card?

The machine-readable one. BroadNet publishes [pricing.json](https://inference.broadnet.ai/pricing.json?utm_source=broadrouter&utm_medium=referral&utm_campaign=blog-understand-model-status&utm_content=body), which its API reference describes as “the same file our pricing and plans pages are built from”. For each model it gives:

-   `id`: the exact string to send as `model`;
-   `status`: `live` or `on_request`;
-   `paid_only`: true when the model opens only after a qualifying top-up;
-   prices, `context_length`, `modalities` for chat models, and `languages` for transcription.

On 15 November 2026 the feed listed six live models: DeepSeek V4.1 Flash, GLM 5.3, Qwen3.8 27B, Gemma 4 VL 26B, BroadNet Transcribe Arabic and BroadNet Transcribe. The API reference’s model table listed the same six IDs.

The catalogue page’s “Live on the Inference API” box, on the same day, showed four of them: it left out GLM 5.3 and Qwen3.8 27B, and still did when we rechecked on 16 November 2026. (Qwen3.8 27B appeared lower down as SERVED in the lab table.) We don’t know which page is behind, and we could not confirm with a paid request. This is normal on any provider’s site, and it is why you should read the feed and the API reference for what to send, then test.

## Can you trust GET /v1/models?

Check what it means for each provider. The OpenAI Python SDK documents `models.list()` as listing “the currently available models”, and many tools call it to fill a model picker. Other OpenAI-compatible APIs implement it differently.

BroadNet’s API reference says: “Use the model IDs in this reference for direct API requests. GET /v1/models supplies public catalogue metadata for external monitors.” When we called it on 15 November 2026, without a key, it returned only `broadnet/cohere-transcribe-arabic` and `broadnet/cohere-transcribe`, each with fields such as `input_modalities`, `capacity` and an `is_ready` flag set to false. None of the four live chat models was listed. So a tool that builds its model list only from `/v1/models` would show no chat models for BroadNet; type the model ID in by hand, as the [OpenAI-compatible base URLs](https://broadrouter.com/blog/openai-compatible-api-base-urls/) post describes for other clients.

## How do you check status in code?

This script reads BroadNet’s public feed and `/v1/models`, both without a key, and prints each model’s status and access. It is safe to run in CI to catch a model being added, moved to on-request or retired.

```python
import json, urllib.request

FEED = "https://inference.broadnet.ai/pricing.json"
MODELS = "https://inference.broadnet.ai/v1/models"

def get(url):
    req = urllib.request.Request(url, headers={"User-Agent": "catalogue-check/1.0"})
    with urllib.request.urlopen(req, timeout=30) as r:
        return json.load(r)

feed = get(FEED)
assert feed["schema_version"] == 1, "unknown feed schema: re-read the docs before trusting it"
print(f"prices updated {feed['updated']}")
for m in feed["models"]:
    status = m.get("status", "live")                       # docs: live or on_request
    access = "top-up required" if m.get("paid_only") else "open from sign-up"
    inputs = ", ".join(m.get("modalities", [])) or f"audio, {m.get('language_count', len(m.get('languages', [])))} language(s)"
    print(f"{status:10} {m['id']:36} {m['kind']:5} {inputs:22} {access}")

listed = {m["id"] for m in get(MODELS)["data"]}
callable_ = {m["id"] for m in feed["models"] if m.get("status", "live") == "live"}
print("live in the feed but not in /v1/models:", sorted(callable_ - listed))
print("in /v1/models but not live in the feed:", sorted(listed - callable_))
```

Run live on 15 November 2026, it printed:

```text
prices updated 2026-11-14
live       broadnet/deepseek-v4.1-flash         chat  text, image            top-up required
live       broadnet/glm-5.3                     chat  text                   top-up required
live       broadnet/qwen3.8-27b                 chat  text, image            top-up required
live       broadnet/gemma-4-26b-a4b             chat  text, image            open from sign-up
live       broadnet/cohere-transcribe-arabic    stt   audio, 1 language(s)   open from sign-up
live       broadnet/cohere-transcribe           stt   audio, 14 language(s)  open from sign-up
live in the feed but not in /v1/models: ['broadnet/deepseek-v4.1-flash', 'broadnet/gemma-4-26b-a4b', 'broadnet/glm-5.3', 'broadnet/qwen3.8-27b']
in /v1/models but not live in the feed: []
```

“Open from sign-up” is our script’s label for a row without `paid_only`, not a field in the feed; on BroadNet that means the $5 starting credit reaches it. The `schema_version` check follows the docs, which say the version changes only when an existing field changes meaning, and that new fields can appear at any time.

The final check is a request. A [cURL quickstart](https://broadrouter.com/guides/curl-quickstart/) call with the model ID and a short prompt returns 200 if the model is live for your key, and an error with a machine-readable code if not.

## What does “on request” look like in practice?

BroadNet’s on-request model pages show what changes. The [Qwen3-VL 30B-A3B page](https://www.broadnet.ai/inference/models/qwen3-vl-30b-a3b), for example, has an “Ask for access” button instead of a price, lists the model ID as “private id issued per customer”, and gives a 16K-token context. The BroadNet fine-tune of Cohere Transcribe Arabic works the same way. BroadNet’s API reference explains the mechanism: private endpoints, its Arabic fine-tunes and other models on request “are reached with a private ID issued with the endpoint.”

Three consequences for your code and your plans:

-   **No public ID to hard-code.** You can’t write the request until the provider issues the ID, so keep the model ID in configuration, not in code.
-   **Different limits.** An on-request deployment can have a different context window, rate limit and region from anything on the public rate card. Ask for them in writing.
-   **Different terms.** BroadNet’s Terms say private endpoints and reserved capacity follow a separate written agreement. Prices, availability and processing location come from that agreement, not from the public pages.

## A five-step check before you build on a model

Run this for every model you plan to depend on, at any provider:

1.  **Find it on the rate card or feed**, not only in a blog post, a model page or a benchmark table.
2.  **Copy the exact ID** from the API reference. Names drift: version suffixes, “Flash” and “Pro” variants, and provider prefixes like `broadnet/` all matter.
3.  **Check access.** Does your key or plan cover it? On BroadNet, `paid_only` models need a top-up, and the DeepSeek session plans cover DeepSeek V4.1 Flash only.
4.  **Check the capability you need on that model**, such as images, tools or structured output, in the docs. A capability on one model says nothing about the next.
5.  **Send one request** with a realistic prompt, and keep the response’s request ID. Repeat in CI if the model is critical.

## What should you never infer from a catalogue?

-   **That a benchmarked model is for sale.** A row in a research table is a measurement.
-   **That on request means soon.** It means a conversation. BroadNet presents on-request models, private endpoints and regional processing as enquiries through its contact page; see [planning a private endpoint](https://broadrouter.com/blog/private-endpoint-planning/).
-   **That a capability applies to every model.** BroadNet’s docs say vision is “offered only where the model row explicitly says images or vision”, and document tool calling for GLM 5.3 and Qwen3.8 27B only. [Text, speech or vision](https://broadrouter.com/blog/text-speech-vision/) maps tasks to the models that take each input.
-   **That today’s list is permanent.** BroadNet’s Terms (§7.4) say it may change, suspend or retire a model or feature and, where it can, give reasonable notice on the catalogue page. Self-serve has no availability commitment; service levels exist only in a separate written agreement.
-   **That a model name means the same model everywhere.** BroadNet’s remote list includes “GLM 5.3 Flash”, which is not the `broadnet/glm-5.3` on its rate card. Always copy the exact ID.

The same checks apply to any provider. Our [provider checklist](https://broadrouter.com/blog/choose-llm-api-provider-checklist/) has the rest of the questions to ask.

## Where BroadNet Inference fits

BroadNet Inference’s live models and prices are on our [models](https://broadrouter.com/models/) and [pricing](https://broadrouter.com/pricing/) pages, built from the same pricing.json. Models BroadNet offers on request are listed separately under [on request](https://broadrouter.com/models/#on-request). The research catalogue on broadnet.ai is worth reading for how BroadNet chooses models, and for its published reasons for rejecting some, but treat every row in it as evidence, not as an offer.

Free tools for this

-   [LLM API cost calculator](https://broadrouter.com/tools/llm-api-cost-calculator/) Price a workload on every model at once, with cache hits, reasoning and a flat-plan check.
-   [LLM token counter](https://broadrouter.com/tools/token-counter/) Exact token counts with each model's real tokenizer, with a token view and cost.
-   [Context window calculator](https://broadrouter.com/tools/context-window-calculator/) Will it fit? Window used per model, room left for output, cost to send.

[All free tools](https://broadrouter.com/tools/)

## Terms in this article

[Tool calling](https://broadrouter.com/glossary/tool-calling/)

Tool calling, also called function calling, is an LLM API feature in which the model returns a structured request to run a function the developer has defined, with JSON arguments. The application runs the function and sends the result back; the model never runs code itself.

[Base URL](https://broadrouter.com/glossary/base-url/)

A base URL is the fixed root address of an API, such as https://api.example.com/v1, that a client puts in front of every endpoint path, such as /chat/completions. In OpenAI-compatible SDKs, changing the base URL, together with the API key and model ID, points the same code at a different provider.

[Embeddings](https://broadrouter.com/glossary/embeddings/)

Embeddings are lists of floating-point numbers (vectors) that a model produces to represent a piece of text, an image or other input. Inputs with similar meaning get vectors that are close together, so distance between vectors can rank search results, cluster documents or find related items.

[Prepaid credit](https://broadrouter.com/glossary/prepaid-credit/)

Prepaid credit is money added to an API account before use. Each request deducts its cost from the balance, and when the balance runs out, metered requests stop until you top up. It caps spend at what you have paid in.

[Context window](https://broadrouter.com/glossary/context-window/)

A context window is the maximum number of tokens a language model can work with in a single request. It covers the prompt, conversation history, tool definitions, images and the generated output, including any reasoning tokens. Anything that does not fit must be cut, summarised or split across several requests.

[OpenAI-compatible API](https://broadrouter.com/glossary/openai-compatible-api/)

An OpenAI-compatible API is an HTTP API that accepts the same request and response formats as the OpenAI API, such as POST /v1/chat/completions, so OpenAI SDKs and tools can use it by changing only the base URL, the API key and the model name.

[Rate limit](https://broadrouter.com/glossary/rate-limit/)

A rate limit is a cap an API places on how much a client can use it in a time window, such as requests per minute or tokens per minute. Requests over the limit are refused, usually with HTTP 429 Too Many Requests, until usage falls back under it.

[Structured output](https://broadrouter.com/glossary/structured-output/)

Structured output is an LLM API feature that constrains a model's reply to a format the developer specifies, usually a JSON Schema, so code can parse it reliably. It is stricter than JSON mode, which guarantees valid JSON but not a particular shape.

## Questions

### How do I know if I can call a model on an API?

It must have an exact API ID, a published price and a live status on the provider's rate card or machine-readable price feed, and your key must be eligible for it. Then send one small request. A 200 response with that model ID is the proof.

### What does "available on request" mean?

The provider can deploy the model for you, but not through a self-serve key. You make an enquiry, agree terms and usually receive a private model ID or endpoint. At BroadNet, on-request models are reached with a private ID issued with the endpoint.

### Why can't I call a model listed in a research or benchmark table?

Because the table records what the provider tested, not what it sells. BroadNet's catalogue lists text-to-speech, image generation and embedding models it benchmarked, and about 90 remote models it says it never ran on its own hardware. None has a public API ID or price.

### Does GET /v1/models list every model I can use?

Not always. In the OpenAI API it lists currently available models, but other providers implement it differently. On 15 November 2026, BroadNet's returned only its two transcription models, and its docs say the endpoint supplies catalogue metadata for monitors; use the IDs in the API reference.

### Which BroadNet models need a top-up?

In pricing.json on 15 November 2026, DeepSeek V4.1 Flash, GLM 5.3 and Qwen3.8 27B had paid\_only set, so they open after a qualifying top-up. Gemma 4 VL 26B and both transcription models were open from sign-up, on the starting credit.

## Keep reading

-   [Models BroadNet evaluated and ruled out, and why](https://broadrouter.com/blog/models-broadnet-ruled-out/)
-   [BroadNet's GPU hardware and serving approach, as BroadNet describes it](https://broadrouter.com/blog/broadnet-gpu-fleet-and-serving/)
-   [How to choose an LLM API provider: a 20-point checklist](https://broadrouter.com/blog/choose-llm-api-provider-checklist/)
-   [The Safety Map: how 39 LLMs handle sensitive data](https://broadrouter.com/blog/llm-safety-map-39-models/)
-   [OpenAI-compatible API base URLs: 14 providers, checked](https://broadrouter.com/blog/openai-compatible-api-base-urls/)
-   [A private endpoint starts with a clear workload](https://broadrouter.com/blog/private-endpoint-planning/)
-   [Text, speech or vision? Start with the task](https://broadrouter.com/blog/text-speech-vision/)
-   [Artificial Analysis alternatives: where to compare LLMs in 2026](https://broadrouter.com/blog/artificial-analysis-alternatives/)
-   [LLM API SLAs compared: what Azure, Bedrock, Google and OpenAI promise](https://broadrouter.com/blog/llm-api-sla-uptime-compared/)
-   [Guide: First request to BroadNet Inference with curl](https://broadrouter.com/guides/curl-quickstart/)
-   [Guide: Use the OpenAI Python SDK with BroadNet Inference](https://broadrouter.com/guides/openai-python-sdk/)

Try it on your real workload. New accounts start with $5 of credit for Gemma and transcription. DeepSeek, GLM and Qwen3.8 need a top-up.

[Get started](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=blog-understand-model-status&utm_content=page-cta) ·

**Sources**

-   [BroadNet Inference model catalogue: live, available on request, lab catalogue and remote models benchmarked (checked 2026-11-15)](https://www.broadnet.ai/inference/models)
-   [BroadNet Inference pricing.json: status, paid\_only and model IDs (checked 2026-11-15)](https://inference.broadnet.ai/pricing.json?utm_source=broadrouter&utm_medium=referral&utm_campaign=blog-understand-model-status&utm_content=sources)
-   [BroadNet Inference API reference: model IDs, private IDs, GET /v1/models, pricing.json fields (checked 2026-11-15)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=blog-understand-model-status&utm_content=sources)
-   [BroadNet Inference GET /v1/models response (checked 2026-11-15)](https://inference.broadnet.ai/v1/models?utm_source=broadrouter&utm_medium=referral&utm_campaign=blog-understand-model-status&utm_content=sources)
-   [BroadNet model page, Qwen3-VL 30B-A3B Instruct: on request, private ID issued per customer (checked 2026-11-15)](https://www.broadnet.ai/inference/models/qwen3-vl-30b-a3b)
-   [BroadNet Terms of Service, §7.4 availability, last updated 23 September 2026 (checked 2026-11-15)](https://www.broadnet.ai/terms)
-   [OpenAI Python SDK, models.list(): "Lists the currently available models" (checked 2026-11-15)](https://github.com/openai/openai-python/blob/main/src/openai/resources/models.py)
