Skip to main content
GoModel routes OpenAI-compatible requests to many AI providers through one gateway. For most providers, setting the API key is the whole setup. The pages in this section exist for the ones whose setup is not purely “set an API key” — auth flows from cloud credentials, deployment-based URLs, region or project requirements, dual native + OpenAI-compatible API surfaces, or other quirks.

​
Configuring providers without env vars

Every credential below (OPENAI_API_KEY, ANTHROPIC_API_KEY, …) can instead be set from the Providers page in the admin dashboard (/admin/dashboard) — no restart required. This is the easiest way to run GoModel with zero provider env vars: start the gateway with none configured (the catalog starts empty; the gateway still boots and serves the dashboard), then add providers from the UI. A provider added this way registers into the running gateway immediately. Providers declared via env vars or config.yaml always take precedence: a name configured either way is read-only in the dashboard (shown with a “Config” badge), the same rule GoModel already applies to MCP servers, virtual models, and rate limits. API keys and service-account secrets are masked (***) once saved — editing a provider re-sends *** for anything you didn’t change, and the gateway keeps the stored value. Disabling a provider (rather than deleting it) unregisters it from routing but keeps its configuration on file. The same multi-key rotation env vars support (api_keys, an ordered list) is available from the dashboard form.

​
Supported providers

Example model identifiers are illustrative and subject to change; consult provider catalogs for current models. Feature columns reflect gateway API support, not every individual model capability exposed by an upstream provider. ✅ Supported ❌ Unsupported

​
Provider notes

  • llm-d — point LLMD_BASE_URL at the Router/EPP service and declare LLMD_MODELS when the route does not serve /v1/models. The dedicated provider injects trusted inference-objective and user-path fairness headers.
  • Z.ai GLM Coding Plan — set ZAI_BASE_URL=https://api.z.ai/api/coding/paas/v4.
  • MiniMax regions and current text models — the default global endpoint is https://api.minimax.io/v1; accounts on the China platform should set MINIMAX_BASE_URL=https://api.minimaxi.com/v1. The current text model IDs are MiniMax-M3 (1,000,000-token context; text, image, and video input) and MiniMax-M2.7 (204,800-token context; text input). Per-million-token USD pricing is 0.60input,0.60 input, 2.40 output, and 0.12cachedinputforM3,and0.12 cached input for M3, and 0.30 input, 1.20output,1.20 output, 0.06 cached input, and $0.375 cache writes for M2.7. M3 supports adaptive or disabled thinking; M2.7 always thinks.
  • Amazon Bedrock Mantle — GPT-5.6 Sol, Terra, and Luna accept only the Responses API on Mantle. GoModel sends /v1/responses requests directly to AWS and selects the required /openai/v1/responses upstream path.
  • Fireworks AI — model IDs are account-scoped paths such as accounts/fireworks/models/gpt-oss-120b; use them verbatim in requests and in FIREWORKS_MODELS.
  • ElevenLabs — a voice-only provider: /v1/audio/speech (text-to-speech) and /v1/audio/transcriptions (speech-to-text) are supported, but chat, /v1/responses, and embeddings are not (the ❌s above reflect that, not a gateway limitation). The OpenAI voice field must be an ElevenLabs voice_id. See the ElevenLabs guide for supported audio formats and speech-to-text models.
  • Chutes AI — defaults to https://llm.chutes.ai/v1 and discovers its current model IDs, context limits, capabilities, and pricing from the live catalog. GoModel translates /v1/responses requests to chat completions; Chutes’ shared LLM endpoint does not expose embeddings. Passthrough support requires explicit operator opt-in by adding chutes to ENABLED_PASSTHROUGH_PROVIDERS.
  • Meta (Muse Spark) — the Meta Model API is OpenAI-compatible; set META_API_KEY and route to muse-spark-1.1. Muse Spark models are not in the upstream model catalog yet, so declare context_window and pricing under providers.meta.models metadata in config.yaml if you want cost tracking and context-window reporting.
  • Kilo AI — model IDs use provider/model (for example, anthropic/claude-sonnet-4.5) and are forwarded unchanged. GoModel serves /v1/responses by translating it to Kilo’s chat-completions endpoint. If another configured provider exposes the same raw model ID, select Kilo explicitly with kilo/anthropic/claude-sonnet-4.5; GoModel removes only the outer kilo/ routing qualifier before forwarding.
  • Xiaomi MiMo — TTS (mimo-v2.5-tts*) and ASR (mimo-v2.5-asr) are served through /v1/audio/speech and /v1/audio/transcriptions (translated to MiMo’s chat-completions audio dialect) as well as directly via chat completions; for 1M context append [1m] to the model ID and list it in XIAOMI_MODELS.
  • OpenCode Go (OpenCode Zen) — routes per model: most models use OpenAI-style /chat/completions, while /messages-only models (default qwen3.7-max, override with OPENCODE_GO_MESSAGES_MODELS) are sent to the Anthropic-native endpoint. Set OPENCODE_GO_API_KEY; the base URL defaults to https://opencode.ai/zen/go/v1.
  • ChatGPT subscription — serves /v1/responses only, billed against the ChatGPT plan’s quota rather than API credit. The upstream accepts a strict parameter allowlist and streams only; GoModel adapts requests and collapses the stream for non-streaming callers. Set CHATGPT_API_KEY to the access token from codex login. Reported cost is not real spend: these model IDs also exist on the OpenAI Platform, so the registry attaches their per-token prices to flat-rate subscription traffic — keep budgets and cost load balancing off it.
  • Kimi Code — no per-token pricing; quota refreshes weekly and is also constrained by a rolling 5-hour window. Usage-cost tracking reports zero for Kimi Code, so cost load-balancing cannot price it; prefer conservative retry strategies.
  • Hetzner (experimental) — Hetzner declares the inference API experimental: expect breaking changes and no SLA. The model catalogue and rate-limit windows change while the experiment runs; query the live /v1/models endpoint and the official docs instead of relying on snapshots. The example model ID in the table above (Qwen/Qwen3.6-35B-A3B-FP8) is the entry from the official Hetzner docs as of 2026-08-17 and may differ at read time. Free while experimental, so usage-cost tracking reports zero and cost load-balancing cannot price it. No embeddings endpoint; chat, /v1/responses (via chat), model listing, and passthrough only. Passthrough is a generic forwarder — the ✅ marks adapter capability; Hetzner’s tolerance for arbitrary upstream paths is unverified while the API is experimental. hetzner is included in the default ENABLED_PASSTHROUGH_PROVIDERS allowlist so /p/hetzner/... routes work without operator opt-in; remove it from the list to gate them.
  • Configured model lists — available for every provider with <PROVIDER>_MODELS, for example OPENROUTER_MODELS=openai/gpt-oss-120b,anthropic/claude-sonnet-4 or ORACLE_MODELS=openai.gpt-oss-120b,xai.grok-3. DeepSeek defaults to https://api.deepseek.com; set DEEPSEEK_BASE_URL only when using a compatible proxy or alternate DeepSeek endpoint. By default, CONFIGURED_PROVIDER_MODELS_MODE=fallback uses those lists only when upstream /models is unavailable or empty. Set CONFIGURED_PROVIDER_MODELS_MODE=allowlist to expose only configured models for providers that define a list, skipping their upstream /models calls.
  • Model categories (chat vs embeddings vs audio) — a model’s category comes from its modes, resolved from four sources in precedence order: the remote model registry, operator metadata declared under providers.<name>.models in config.yaml (e.g. modes: [embedding]), capability signals in the provider’s own model listing (Gemini supportedGenerationMethods, Cohere endpoints, OpenRouter architecture modalities, Ollama /api/show capabilities), and finally a conservative name check for models still unclassified: IDs containing embed or matching well-known embedding families (bge, e5, gte, minilm) are categorized as embedding models, and IDs containing rerank as reranking models — namespaced IDs like org/model are checked by their final path segment. Declare operator metadata only when a model stays unclassified after all of this. Categories affect dashboard grouping and failover suggestions only; /v1/embeddings routes to any model the provider serves regardless of category.
  • vLLM — set VLLM_API_KEY only if the upstream server was started with --api-key.
  • llama.cpp / LM Studio — LLAMACPP_BASE_URL is required (llama-server’s default port collides with GoModel’s own 8080, so there is no default); LLAMACPP_API_KEY is optional. Do not register these servers as ollama, which speaks Ollama’s native API. See llama.cpp.
  • llm-d — LLMD_BASE_URL is required. LLMD_API_KEY is optional and is sent only when the Gateway in front of the Router requires bearer auth.
  • SGLang — set SGLANG_API_KEY only if the upstream server was started with --api-key; otherwise SGLANG_BASE_URL is enough.
  • Multiple API keys for one provider — set OPENAI_API_KEY_2, OPENAI_API_KEY_3, and so on to spread sessions across keys while keeping each conversation on one key for prompt-cache affinity. See API key rotation.
  • Multiple instances of one provider type — without config.yaml, use suffixed env vars such as OPENAI_EAST_API_KEY and OPENAI_EAST_BASE_URL; add OPENAI_EAST_MODELS to configure that instance’s model list. This registers provider openai-east with type openai. Vertex AI follows the same suffix pattern — VERTEX_US_PROJECT registers provider vertex-us. Vertex project and location env vars must match the instance prefix: for a suffixed instance such as VERTEX_US_PROJECT, also set VERTEX_US_LOCATION and any other suffixed settings for that instance, rather than the generic VERTEX_PROJECT / VERTEX_LOCATION. VERTEX_AUTH_TYPE defaults to Application Default Credentials (gcp_adc).

​
Why some providers have dedicated pages

These are the providers most users hit friction on:
  • Google Vertex AI — needs a GCP project, region, and either Application Default Credentials or a service-account JSON key.
  • Amazon Bedrock — no API key of its own; uses the AWS credential chain and requires explicit model access in the Bedrock console.
  • Azure OpenAI — deployment-scoped base URLs, the api-version query parameter, and the api-key header instead of Authorization: Bearer.
  • Oracle GenAI — requires an OCI IAM policy for generativeaiapikey and a region-specific OpenAI-compatible endpoint URL.
  • Google Gemini (AI Studio) — two routing modes (native generateContent vs OpenAI-compatible) with different image-input behavior.
  • Anthropic — reasoning effort maps to Claude’s adaptive thinking and effort control, which differ across model generations.
  • DeepSeek — reasoning effort mapping quirks for DeepSeek V4.
  • Ollama / SGLang / vLLM — local-model hosting with optional multi-instance setup through suffixed env vars and provider-qualified model IDs.
  • Xiaomi MiMo — thinking mode on by default, a [1m] context suffix, and TTS/ASR that run through chat completions rather than native audio endpoints.
  • OpenCode Go — OpenCode Zen splits models across OpenAI-style /chat/completions and Anthropic-native /messages; GoModel routes per model (the /messages-only set is maintained manually, default qwen3.7-max).
  • ChatGPT subscription — a Responses-only upstream with a strict parameter allowlist, used to put GoModel between Codex and a ChatGPT plan.
Every provider page shows three launch forms in one CodeGroup: Docker with --env-file .env (recommended), Docker with inline -e flags, and a prebuilt binary from make build. Once you have more than a couple of variables, copy .env.template, fill in the values you need, and reuse the same file for both Docker and the native binary.
Providers without a dedicated page (OpenAI, Groq, Fireworks AI, Meta, OpenRouter, Kilo AI, Z.ai, xAI, MiniMax) follow the same pattern: set the API key (and optional base URL where supported), start GoModel, route by model ID. The full env-var reference lives in Configuration.

​
Provider status

The admin dashboard (/admin/dashboard) shows live status for every configured provider in the Providers Overview section of the Overview page. GoModel dashboard Providers Overview with a Degraded openai card showing a failing model and a Healthy vllm card Each card’s status pill combines two signals — model discovery (can the provider’s model inventory be fetched?) and request health (are real requests through the gateway succeeding?). Real-traffic signals only ever worsen a status, never mask a discovery failure. Hover over the pill for the classification reason and the most recent error. Expand a card (the arrow strip at the bottom, or the section-wide Show Details switch) to see request health details:
  • Recent Requests — requests and errors through the gateway in the last 10 minutes.
  • Breaker State — the provider’s live circuit-breaker state (see Resilience).
  • Models (Recent Traffic) — per-model request/error counts. A model with at least 3 errors making up half or more of its windowed requests is flagged in red — this catches a single broken model on an otherwise healthy provider, which model discovery alone cannot see. Hover a row for the model’s latest error message.
Request-health tracking is passive: it observes traffic your clients already send (the gateway’s own background probes — model discovery and availability checks — are excluded), so an idle provider simply shows no recent requests. Counters are in-memory per gateway instance and reset on restart. The same data is available as JSON from GET /admin/providers/status for scripting and external monitoring.
Last modified on August 22, 2026