api-reference

OmniRoute LLM Providers: Complete Guide to Supported AI Models and APIs

August 25, 2026 diegosouzapw/OmniRoute ↗

OmniRoute supports 300+ LLM providers spanning OpenAI-compatible APIs, Anthropic Claude, Google Gemini, local Ollama models, and custom HTTP endpoints. The canonical provider registry is defined in [src/shared/constants/providers.ts](https://github.com/diegosouzapw/OmniRoute/blob/release/v3.8.51/src/shared/constants/providers.ts) and consumed by the routing, executor, and translator layers.

OmniRoute is an open-source LLM routing gateway designed to unify access to diverse model providers through a single OpenAI-compatible API. Whether you need commercial APIs, self-hosted models, or hybrid deployments, OmniRoute maps incoming requests to the appropriate executor based on its extensible provider system. This guide covers every provider category, implementation details, and practical code examples.

Major LLM Provider Categories

OmniRoute organizes providers into logical groups based on API compatibility and hosting model. The following categories reflect the entries in [providers.ts](https://github.com/diegosouzapw/OmniRoute/blob/release/v3.8.51/src/shared/constants/providers.ts).

OpenAI-Compatible Providers

These providers implement the OpenAI /v1/chat/completions schema, enabling seamless integration:

  • openai — Official OpenAI API (GPT-4, GPT-3.5-turbo, embeddings)
  • azure-openai — Microsoft Azure OpenAI Service with enterprise features
  • openrouter — Aggregator providing unified access to multiple models
  • together — TogetherAI inference platform
  • fireworks — Fireworks AI serverless inference
  • deepseek — DeepSeek AI models
  • groq — Groq LPUs for ultra-low latency inference
  • perplexity — Perplexity Labs API

Anthropic and Claude Ecosystem

  • anthropic — Direct Anthropic API access
  • claude — Dedicated Claude model executor with extended context handling

Google AI Platforms

  • gemini — Google Gemini API (formerly Bard/PaLM)
  • vertex — Google Cloud Vertex AI with enterprise IAM integration

Cohere and Specialized APIs

  • cohere — Cohere Generate and Embed endpoints
  • mistral — Mistral AI's La Plateforme API

Local and Self-Hosted Models

OmniRoute supports on-premise deployment through these executors:

  • ollama — Local Ollama instance management
  • llama-cpp — Direct llama.cpp bindings
  • lmstudio — LM Studio local server
  • vllm — vLLM high-throughput serving
  • generic-rest — Arbitrary HTTP endpoint for custom implementations

Community and Cloud Providers

Additional providers include huggingface, replicate, xai, and others registered dynamically via the provider registry.

How Providers Are Registered and Executed

The provider system follows a three-stage pipeline: definition → registration → execution.

Provider Definition in Source Code

Each provider entry in [src/shared/constants/providers.ts](https://github.com/diegosouzapw/OmniRoute/blob/release/v3.8.51/src/shared/constants/providers.ts) contains a Zod-validated schema specifying:

  • Provider ID and display name
  • Default base URL and endpoint paths
  • Authentication method (API key, OAuth, or none)
  • Supported model families and capability flags
  • Feature support (streaming, function calling, vision, etc.)

Runtime Registration

The [open-sse/config/providerRegistry.ts](https://github.com/diegosouzapw/OmniRoute/blob/release/v3.8.51/open-sse/config/providerRegistry.ts) module loads provider definitions and binds:

  • Executor — Provider-specific request handling (e.g., OpenAIExecutor, AnthropicExecutor)
  • Translator — Schema conversion between OmniRoute's unified format and provider-native formats (see open-sse/translator/)
  • Feature flags — Capability negotiation for model selection

OAuth and Credential Handling

For providers requiring OAuth flows, credentials are resolved via [src/lib/oauth/providers.ts](https://github.com/diegosouzapw/OmniRoute/blob/release/v3.8.51/src/lib/oauth/providers.ts) and injected securely without exposing tokens in logs or error messages.

Listing and Querying Providers: Code Examples

CLI: List All Registered Providers

omniroute providers list

This command reads [providers.ts](https://github.com/diegosouzapw/OmniRoute/blob/release/v3.8.51/src/shared/constants/providers.ts) and outputs provider IDs, authentication requirements, and default endpoints.

Programmatic: Query Provider Models

import { getProviderRegistry } from '@omniroute/open-sse/config/providerRegistry';

async function listProviderModels(providerId: string) {
  const registry = await getProviderRegistry();
  const provider = registry.get(providerId);
  
  if (!provider) {
    throw new Error(`Unknown provider: ${providerId}`);
  }

  const models = await provider.executor.listModels();
  
  return {
    provider: providerId,
    models: models.map(m => ({
      id: m.id,
      capabilities: m.capabilities,
    })),
  };
}

// Usage
const openaiModels = await listProviderModels('openai');
console.log(openaiModels);

The executor abstraction ensures identical code works across all 300+ providers regardless of their native API differences.

API Endpoint: Discover Available Models

curl -X GET http://localhost:3000/v1/models \
  -H "Authorization: Bearer $OMNIROUTE_API_KEY"

Returns a unified listing of models across all configured providers, matching OpenAI's /v1/models response format.

Multi-Provider Routing with Combos

OmniRoute's combo system enables intelligent failover and load distribution across multiple LLM providers as implemented in [open-sse/services/combo.ts](https://github.com/diegosouzapw/OmniRoute/blob/release/v3.8.51/open-sse/services/combo.ts).

Fill-First Strategy Example

import { handleChatCore } from 'open-sse/handlers/chatCore';

const response = await handleChatCore({
  combo: {
    strategy: 'fill-first',
    targets: ['openai', 'anthropic', 'gemini'],
  },
  body: {
    model: 'gpt-4o',
    messages: [
      { role: 'user', content: 'Explain quantum computing in 3 sentences' }
    ],
    stream: false,
  },
});

console.log(response.choices[0].message.content);

Execution flow:

  1. OmniRoute attempts the request against openai
  2. If OpenAI returns an error or timeout, it immediately tries anthropic
  3. If Anthropic fails, it falls through to gemini
  4. First successful response is returned to the client

Round-Robin Strategy

const comboSpec = {
  strategy: 'round-robin',
  targets: ['groq', 'fireworks', 'together'],
};

Distributes requests evenly across providers for cost optimization and rate limit management.

Complete Provider Reference Documentation

The auto-generated [docs/reference/PROVIDER_REFERENCE.md](https://github.com/diegosouzapw/OmniRoute/blob/release/v3.8.51/docs/reference/PROVIDER_REFERENCE.md) contains:

  • Alphabetical listing of all 300+ provider IDs
  • Version-specific model availability
  • Authentication requirements per provider
  • Capability matrices (streaming, tools, JSON mode, vision)
  • Rate limit and context window specifications

This document is regenerated from [providers.ts](https://github.com/diegosouzapw/OmniRoute/blob/release/v3.8.51/src/shared/constants/providers.ts) on each release and serve as the single source of truth for provider support.

Provider Configuration Example

// omniroute.config.ts
export default {
  providers: {
    openai: {
      apiKey: process.env.OPENAI_API_KEY,
      baseUrl: 'https://api.openai.com/v1',
      defaultModel: 'gpt-4o',
    },
    anthropic: {
      apiKey: process.env.ANTHROPIC_API_KEY,
      baseUrl: 'https://api.anthropic.com/v1',
    },
    ollama: {
      baseUrl: 'http://localhost:11434',
      // No API key required for local Ollama
    },
    'generic-rest': {
      baseUrl: 'https://internal-llm.company.com/api',
      headers: {
        'X-Custom-Auth': process.env.INTERNAL_API_KEY,
      },
    },
  },
  
  // Default combo for unqualified requests
  defaultCombo: {
    strategy: 'fill-first',
    targets: ['openai', 'anthropic'],
  },
};

Summary

Frequently Asked Questions

How do I add a custom LLM provider to OmniRoute?

Use the generic-rest provider type in [providers.ts](https://github.com/diegosouzapw/OmniRoute/blob/release/v3.8.51/src/shared/constants/providers.ts) or create a custom executor extending the base executor class. The generic-rest provider accepts arbitrary base URLs, custom headers, and request/response transformation functions without modifying core OmniRoute code. For full custom providers, implement the ProviderExecutor interface and register via [providerRegistry.ts](https://github.com/diegosouzapw/OmniRoute/blob/release/v3.8.51/open-sse/config/providerRegistry.ts).

Does OmniRoute support OAuth-based providers like Google Vertex AI?

Yes. OAuth flows are handled in [src/lib/oauth/providers.ts](https://github.com/diegosouzapw/OmniRoute/blob/release/v3.8.51/src/lib/oauth/providers.ts), which manages token refresh and secure credential injection. Configure the vertex provider with a service account key file path or workload identity, and OmniRoute automatically exchanges tokens without exposing credentials in request logs.

Can I run OmniRoute with only local models and no external APIs?

Absolutely. Configure only local providers like ollama, llama-cpp, lmstudio, or vllm in your OmniRoute configuration. Remove or omit commercial provider entries, and all requests will route to your self-hosted infrastructure. The unified API remains identical, enabling seamless development-to-production workflows.

Have a question about this repo?

These articles cover the highlights, but your codebase questions are specific. Give your agent direct access to the source. Share this with your agent to get started:

Share the following with your agent to get started:
curl -s "https://instagit.com/install.md"
Works with
Claude Codex Cursor VS Code OpenClaw Any MCP Client

Maintain an open-source project? Get it listed too →