Models

GET /models and GET /models/{id}: which models your key can call, their prices and limits, how ids match the catalog at safeguard.sh/models, and how a model becomes callable.

The inference API reads the same model catalog that safeguard.sh/models shows. A model in the catalog can be called through the API only after it passes Safeguard's launch checks, described below.

List the models you can call

GET /models lists the models your key can call right now.

curl https://api.safeguard.sh/gpt/v1/models \
  -H "Authorization: Bearer $SAFEGUARD_INFERENCE_KEY"

Add ?all=true to list every model published in the catalog, including the ones you cannot call yet, each with its status and the reason it cannot be called:

curl "https://api.safeguard.sh/gpt/v1/models?all=true" \
  -H "Authorization: Bearer $SAFEGUARD_INFERENCE_KEY"

The response

{
  "object": "list",
  "data": [
    {
      "id": "MODEL_ID",
      "object": "model",
      "created": 0,
      "owned_by": "openai",
      "name": "Example model",
      "context_length": 128000,
      "max_output_tokens": 16384,
      "pricing": {
        "input_per_mtok_usd": "1.0",
        "output_per_mtok_usd": "4.0",
        "markup_percent": 0
      },
      "status": "available",
      "runnable": true,
      "routable": true,
      "unavailable_reason": null,
      "zdr_available": true,
      "region": null
    }
  ]
}

The values above are illustrative.

Field	Meaning
`id`	The model id to pass as `model`.
`owned_by`	The model's provider family, such as `openai`, `anthropic`, `google` or `safeguard`.
`name`	The model's display name in the catalog.
`context_length`	The context window in tokens, when the catalog states one.
`max_output_tokens`	The most output tokens the model allows, when the catalog states one. Requests are capped at this.
`pricing.input_per_mtok_usd`, `pricing.output_per_mtok_usd`	Price per million input and output tokens in US dollars, as decimal strings. For third-party models this is the provider's list price.
`pricing.cached_input_per_mtok_usd`	Present only when the catalog has a separate price for cached input tokens.
`pricing.markup_percent`	Always `0`.
`status`	`available` only when you can call the model now: the catalog lists it as available and it passes the launch checks below. Otherwise `request_access` or `coming_soon`. A model the catalog lists as available that is still held by the launch checks shows `request_access`.
`runnable`	`true` when you can call the model now. The same rule decides what the gateway serves.
`routable`	The same as `runnable`, kept for older clients.
`unavailable_reason`	Why the model cannot be called, in a sentence, such as "Coming soon." or "Available on request. It is not sold through the API yet." `null` when it can be called.
`zdr_available`	`true` when the model can be used with zero data retention.
`region`	A short region code for the model's route when the catalog records one, otherwise `null`.
`created`	Always `0`.

Get one model

GET /models/{id} returns one published model as a single object in the same shape, whether or not you can call it yet. Model ids contain a /, and you send them as they are:

curl https://api.safeguard.sh/gpt/v1/models/openai/gpt-6-sol \
  -H "Authorization: Bearer $SAFEGUARD_INFERENCE_KEY"

An id that is not in the catalog, or not published in it, returns 404 with the code model_not_found.

A model id has the form provider/model, for example openai/gpt-6-sol or safeguard/griffin. It is the model id shown on the model's page at safeguard.sh/models, not the page's address: the page for openai/gpt-6-astra lives at /models/openai-gpt-6-astra, but the API takes openai/gpt-6-astra.

The catalog also lists models that the chat completions endpoint does not serve, such as embedding, image, rerank and transcription models. The API routes only models priced per million tokens, so a model shown as Price on request cannot be called through it.

Provider routes

Each response says which route served it, in the provider field. These are the routes the gateway has clients for:

`provider`	Provider
`openai`	OpenAI
`anthropic`	Anthropic
`google`	Google (Gemini API)
`mistral`	Mistral AI
`deepseek`	DeepSeek
`xai`	xAI
`cohere`	Cohere
`together`	Together AI (open-weight host)
`fireworks`	Fireworks AI (open-weight host)
`groq`	Groq (open-weight host)
`safeguard`	Safeguard's own inference

A route being listed here does not mean any of its models can be called today. That is decided model by model.

How a model becomes callable

The gateway checks these on every request. A model is callable only when all of them hold:

The catalog lists the model as available, with both an input and an output price.
Safeguard has an account with the model's provider configured for the API.
For every provider other than Safeguard itself, the provider's launch checklist is complete: its terms are confirmed to allow resale at list price, it is on the Trust Center subprocessor list, and Safeguard's data processing agreement, privacy notice and AI disclosure cover it.
A real end-to-end test call to that model, on that route, has succeeded.

DeepSeek prices its API by time of day, while the gateway bills one rate, so DeepSeek models stay unavailable through the API until that is resolved.

A request for a catalog model that fails any check is refused with 503 model_unavailable. GET /models?all=true shows such a model with runnable: false and its unavailable_reason. Models that are not published in the catalog are never listed or served.

Availability per workspace

The API Platform must be on for your workspace. Safeguard switches it on.
Where it is on, every workspace can call the same models, and so can every key in it.
If your workspace requires zero data retention, only models with zdr_available: true can be called; any other model is refused with 503 model_unavailable.

Safeguard's own models

The catalog lists Safeguard's three models (safeguard/griffin, safeguard/eagle and safeguard/lion) and safeguard/zero, which answers data questions with no model. Griffin, Eagle and Lion are one model each, with no size variants. Griffin is listed at $0.0001 per million input tokens and $0.0001 per million output tokens, Eagle at $0.00001 and $0.00001, and Lion at $0.000001 and $0.000001. Zero has no model weights, uses no model tokens and is priced at $0. None of them can be called through the API yet. See Safeguard models.

How fresh the list is

The gateway re-reads the catalog every 60 seconds. If the catalog cannot be read, it keeps using its last copy for up to 10 minutes; after that, requests are refused with 503 model_unavailable until the catalog is back. It never guesses a price.