---
title: "OpenRouter alternatives: self-hosted gateways and managed model APIs compared"
description: "OpenRouter alternatives compared: Bifrost, LiteLLM, Vercel, Cloudflare, Requesty, Eden AI, and Bedrock by provider keys, deployment, fees, and governance."
summary: "OpenRouter sells access to hundreds of models through one account and prepaid credits, a model that suits prototyping better than many production setups. This comparison covers nine alternatives across self-hosted gateways, managed gateways, and cloud platforms, plus OpenRouter vs LiteLLM."
type: "comparison"
canonical_url: "https://theaiengineering.com/articles/openrouter-alternatives"
markdown_url: "https://theaiengineering.com/articles/openrouter-alternatives.md"
topic: "AI gateways and LLM routing"
author: "The AI Engineering Editors"
publisher: "The AI Engineering"
published: "2026-11-19"
updated: "2026-11-19"
keywords: ["openrouter alternatives","openrouter vs litellm","litellm vs openrouter","openrouter alternative","open source openrouter alternative"]
citation: "The AI Engineering Editors. \"OpenRouter alternatives: self-hosted gateways and managed model APIs compared.\" The AI Engineering, updated Nov 19, 2026. https://theaiengineering.com/articles/openrouter-alternatives"
---

# OpenRouter alternatives: self-hosted gateways and managed model APIs compared

## TL;DR

- OpenRouter is a hosted model aggregator that offers 600+ models from 80+ providers through one OpenAI-compatible endpoint and one prepaid balance, with a 5.5% (Standard) or 8% (Business) fee on credit purchases as of November 16, 2026.
- Self-hosted gateways such as Bifrost, LiteLLM, and Agent Router call providers with your own keys from your own network and charge no per-token fee, but you operate them and need an account with each provider.
- Managed gateways differ mainly in fees: Vercel AI Gateway adds no markup, Cloudflare AI Gateway charges 5% only on Unified Billing credits, Requesty adds 5% to provider prices, and Eden AI charges 5.5% on credit purchases.
- Amazon Bedrock and Hugging Face Inference Providers serve many vendors' models under one bill, but they are not gateways, and their catalogs are limited to their own partners.
- OpenRouter and LiteLLM are often combined: a self-hosted gateway holds direct provider keys for primary traffic and calls OpenRouter as one upstream for models without a direct contract.

OpenRouter alternatives fall into three groups: self-hosted gateways that call model providers with your own keys, managed gateways that proxy requests from a vendor's network, and cloud platforms that sell many vendors' models through one account. This comparison covers why teams move off OpenRouter, the criteria that separate the options, nine alternatives checked against their own documentation on November 16, 2026, and OpenRouter vs LiteLLM in detail. It is part of our [AI gateways and LLM routing](https://theaiengineering.com/topics/ai-gateways) hub.

## What is OpenRouter?

OpenRouter is a hosted model aggregator that exposes hundreds of models from many providers through one [OpenAI-compatible API](https://theaiengineering.com/glossary/openai-compatible-api), one account, and one prepaid credit balance. Its pricing page listed more than 600 models from more than 80 providers on November 16, 2026.

Applications send requests to `https://openrouter.ai/api/v1` with an OpenRouter key. For each model, OpenRouter's [routing](https://theaiengineering.com/glossary/llm-routing) chooses among the providers that serve it by price, throughput, latency, and reliability, unless a `provider` object in the request overrides it with an `order`, an `only` allowlist, `data_collection: "deny"`, or `zdr: true`. A `models` array lists fallback models in priority order.

OpenRouter says it bills inference at each provider's list price and charges its fee when you buy credits, never per request. On November 16, 2026, its [pricing page](https://openrouter.ai/pricing) listed four plans:

| Plan | Platform fee on credit purchases | Notable inclusions |
|---|---|---|
| Free | Not applicable | 25+ free models, 50 requests per day |
| Standard (pay-as-you-go) | 5.5% | 600+ models, budgets and spend controls, data policy-based routing, 5 workspaces |
| Business (pay-as-you-go) | 8% | EU and US in-region routing, 1,000 workspaces, signed DPA on request |
| Enterprise | Fee discounts through sales | SSO with SAML, SCIM, private endpoints, contractual SLAs, invoicing |

OpenRouter's [FAQ](https://openrouter.ai/docs/faq) adds a $0.80 minimum fee per credit purchase and a 5% fee on crypto payments. [Bring your own key](https://openrouter.ai/docs/guides/overview/auth/byok) (BYOK) usage is free up to $25,000 of list-price inference per month on Standard and Business, then costs 5% of what the same request would cost on OpenRouter, deducted from your credits.

## Why teams look for OpenRouter alternatives

Teams look for OpenRouter alternatives when the aggregator model conflicts with how they buy and govern AI. The common reasons are existing provider contracts and keys, data residency and retention rules, a requirement to self-host, governance tied to their identity provider, a percentage fee that grows with spend, and the latency of an extra network hop.

### Provider keys and contracts

Many companies already hold committed-spend agreements, negotiated discounts, or raised rate limits directly with OpenAI, Anthropic, AWS, Google Cloud, or Azure. Credits bought on OpenRouter do not draw down those commitments. BYOK lets OpenRouter call providers with your keys, but BYOK traffic above the $25,000 monthly allowance carries the 5% fee. By default, when all your keys fail or hit rate limits, OpenRouter falls back to its own shared endpoints and bills your credits; a per-key "shared capacity fallback" setting can block that for specific models or a whole provider.

### Data residency and retention

OpenRouter's FAQ says it logs request metadata but not prompts or completions unless you opt in, and [Zero Data Retention](https://openrouter.ai/docs/guides/features/zdr) can be enforced per account, model group, or request. EU and US in-region routing is listed on Business and Enterprise only, and account and billing data may be processed in the US. A policy that prompts never leave the company network rules out every hosted service.

### Self-hosting

OpenRouter does not offer a self-hosted version. Air-gapped environments, on-premises clusters, and regulated workloads that require the proxy to run inside a VPC need gateway software they can deploy themselves.

### Per-team governance

OpenRouter's Standard plan includes budgets, spend controls, and five workspaces; Business raises the limit to 1,000 workspaces; and SSO with SAML and SCIM are Enterprise features. Platform teams that issue one key per team, service, or customer, attach budgets and [rate limits](https://theaiengineering.com/glossary/rate-limiting) to each, and map access to groups in their identity provider often want that control in a gateway they run.

### Fee structure

A percentage fee scales with spend. At 5.5%, $100,000 of inference bought through credits in a month carries $5,500 in fees; at the Business plan's 8%, it carries $8,000. Self-hosted gateways charge nothing per token, and some managed gateways, such as Vercel AI Gateway, add no markup or platform fee.

### Latency of an extra hop

Every aggregator or managed gateway adds a network hop between your application and the provider. OpenRouter's [latency documentation](https://openrouter.ai/docs/guides/best-practices/latency-and-performance) says it runs on Cloudflare Workers at the edge to add as little latency as possible, but publishes no fixed overhead figure. It notes higher latency while edge caches warm up in a new region and when credit balances run low. A gateway in the same region and network as your services keeps the hop short and measurable.

## How to choose an OpenRouter alternative

Choose an OpenRouter alternative by deciding first who should hold the provider relationship, then where the proxy is allowed to run. Those two answers eliminate most options. Catalog breadth, billing model, governance depth, data handling, and API compatibility then separate the rest. Every entry below is described against these seven criteria:

1. **Provider relationship and keys:** whether requests run on your provider accounts, with your contracts, discounts, and rate limits, or on the vendor's.
2. **Deployment:** self-hosted in your VPC or cluster, managed in a vendor's cloud, or tied to one cloud provider.
3. **Model catalog breadth:** how many providers and models are reachable, and whether each new provider needs its own account.
4. **Billing model:** prepaid credits with a percentage fee, pass-through pricing, a cloud bill, or no per-token charge.
5. **Governance:** [virtual keys](https://theaiengineering.com/glossary/virtual-key), per-team budgets, rate limits, SSO, role-based access, and audit logs.
6. **Data handling:** logging defaults, zero data retention options, regional endpoints, and whether a third party sees prompts at all.
7. **API compatibility:** OpenAI Chat Completions and Responses, Anthropic Messages, and how much client code changes during migration.

## Three architectures: aggregator, managed gateway, and self-hosted gateway

Every OpenRouter alternative uses one of three architectures. An aggregator resells model access from its own provider accounts. A managed gateway proxies requests from a vendor's network, often with provider keys you store there. A self-hosted gateway runs in your infrastructure and calls providers with keys you hold, so no third party sits on the data path.

**Figure 1: The three architectures differ in who runs the proxy and whose provider accounts serve and bill each request.**

Three side-by-side architectures: an aggregator calling providers on its own accounts, a managed gateway calling providers with stored customer keys, and a self-hosted gateway inside the customer's network.

Components:

- **Your app**: aggregator API key
- **Aggregator**: vendor-hosted proxy prepaid credits
- **Providers**: vendor's provider accounts
- **Your app**: gateway API key
- **Managed gateway**: vendor-hosted proxy your keys stored with vendor
- **Providers**: your provider accounts
- **Your app**: virtual key
- **Self-hosted gateway**: runs in your VPC keys stay with you
- **Providers**: your provider accounts

Groups:

- Aggregator: Your app, Aggregator, Providers
- Managed gateway with BYOK: Your app, Managed gateway, Providers
- Self-hosted gateway: Your app, Self-hosted gateway, Providers

Connections:

- Your app → Aggregator: internet
- Aggregator → Providers
- Your app → Managed gateway: internet
- Managed gateway → Providers: BYOK
- Your app → Self-hosted gateway: private network
- Self-hosted gateway → Providers: direct

The line between the first two is often a setting rather than a product category. OpenRouter, Vercel AI Gateway, Cloudflare AI Gateway, Requesty, Eden AI, and Hugging Face all sell model access through their own billing and also accept your provider keys. The third architecture differs in kind. An [AI gateway](https://theaiengineering.com/glossary/ai-gateway) you run yourself keeps prompts, keys, and logs inside your network. Our explainer on [what an AI gateway is](https://theaiengineering.com/articles/what-is-an-ai-gateway) walks through the request pipeline step by step.

## Self-hosted gateways

Self-hosted gateways are open-source proxies you deploy in your own VPC or cluster. You hold every provider key, providers bill you directly, and the gateway adds no per-token fee. In exchange, you operate a service every model call depends on, and you need an account with each provider you use, unless you add an aggregator as one upstream.

### Bifrost

**What it is:** Bifrost is an open-source AI gateway from Maxim AI, written in Go and licensed Apache 2.0, that puts many providers behind one OpenAI-compatible API. Its [supported providers page](https://docs.getbifrost.ai/providers/supported-providers/overview) listed 35 providers on November 16, 2026, including OpenAI, Anthropic, Bedrock, Vertex AI, Azure, Gemini, Groq, Mistral, Cohere, and xAI, plus self-hosted vLLM, SGLang, and Ollama.

**Deployment and billing:** Bifrost runs from `npx -y @maximhq/bifrost`, a Docker image (`docker run -p 8080:8080 maximhq/bifrost`), Kubernetes, or the Go SDK, inside your own network. You configure your own provider keys, providers bill you directly, and the open-source core is free to self-host. An enterprise edition adds clustering, adaptive routing, role-based access control, SSO, signed audit logs, secret manager integrations, and in-VPC deployment support.

**Strengths:**

- [Virtual keys](https://docs.getbifrost.ai/features/governance/virtual-keys) give each team, application, or customer its own credential with budgets, token-based and request-based rate limits, and deny-by-default provider and model access, all in the open-source edition.
- [Weighted load balancing](https://docs.getbifrost.ai/features/keys-management) spreads traffic across provider keys and moves to an untried key when one hits a rate limit, a rejected credential, or an exhausted quota.
- [Retries and fallbacks](https://docs.getbifrost.ai/features/retries-and-fallbacks) combine exponential backoff with jitter and a `fallbacks` list of `provider/model` entries, each with its own retry budget, across providers.
- Drop-in adapters for the OpenAI, Anthropic, Bedrock, Google GenAI, LangChain, and LiteLLM SDKs, a [migration path from a LiteLLM proxy](https://docs.getbifrost.ai/migration-guides/litellm), and an [MCP gateway](https://theaiengineering.com/glossary/mcp-gateway) that exposes connected tool servers at one `/mcp` endpoint.
- OpenRouter is itself a supported provider, so it can stay as one upstream for models without a direct contract.

Maxim AI reports about 11 µs of added overhead at 5,000 requests per second on a single t3.xlarge instance in its own published benchmark; measure overhead on your own traffic before relying on that figure.

**Trade-offs:** You run the gateway, its replicas, and its configuration store. SSO, role-based access, and audit logs require the enterprise edition. Every provider still needs its own account and key.

**Best for:** Platform teams that want to keep provider contracts and keys, enforce per-team budgets, and keep model traffic inside their own network.

### LiteLLM

**What it is:** LiteLLM, from BerriAI, is an open-source Python SDK and proxy server that calls more than 100 providers in the OpenAI format. The repository is MIT-licensed except for its enterprise directory, which has a separate license.

**Deployment and billing:** You run the proxy from its Docker image or Python package on your own infrastructure; it listens on port 4000 by default, and virtual keys require a PostgreSQL database and a master key. Providers bill you directly. LiteLLM's [enterprise page](https://docs.litellm.ai/docs/enterprise) states that SSO is free for up to five users; beyond that, SSO needs a license key, which also adds audit logs, role-based access control, secret managers, per-team logging and guardrails, and tag-based budgets. The page describes self-hosting only and lists no managed offering.

**Strengths:**

- More than 100 providers through one SDK and one proxy.
- Virtual keys, budgets, rate limits, and spend tracking per key, team, and user, plus load balancing, fallbacks, an admin UI, and an MCP gateway in the open-source edition.
- The Python SDK runs in-process for teams that want routing and fallbacks without deploying a proxy.

**Trade-offs:** You operate a Python service and a PostgreSQL database. Several governance features need the enterprise license. Each provider still needs its own account.

**Best for:** Python-centric teams that want an SDK and a proxy from one project.

### Agent Router

**What it is:** Agent Router, formerly Envoy AI Gateway, is an Apache 2.0 project of the Agentic AI Foundation built on Envoy. Its [project site](https://theagentrouter.ai) describes one OpenAI-compatible API for 22 built-in providers, including Anthropic, AWS Bedrock, Azure OpenAI, Google Gemini, Mistral, and self-hosted vLLM, with provider fallback, token limits per team, app, or model, and an MCP router that merges tool catalogs from many servers.

**Deployment and billing:** Agent Router runs on Kubernetes alongside Envoy, or locally with `aigw run`, which starts the router on port 1975. You hold the provider keys and pay providers directly.

**Strengths:** Envoy's data plane, Kubernetes-native deployment, routing to self-hosted model replicas through Kubernetes InferencePool resources, and one router for model and MCP traffic.

**Trade-offs:** The project assumes Kubernetes and Envoy; teams that run neither take on both to adopt it.

**Best for:** Kubernetes platform teams already standardized on Envoy.

## Managed gateways

Managed gateways are hosted proxies that a vendor operates. They remove the operations work, and most can either resell model access through credits or call providers with keys you store with them. The trade-off is a third party on the data path, so data processing terms, regional endpoints, and retention settings matter as much as routing features.

### Vercel AI Gateway

**What it is:** Vercel AI Gateway is a hosted gateway at `https://ai-gateway.vercel.sh` that accepts OpenAI Chat Completions, OpenAI Responses, and Anthropic Messages requests, as well as calls from Vercel's AI SDK. According to its [documentation](https://vercel.com/docs/ai-gateway), applications do not need to run on Vercel; a Vercel account is needed only for keys and billing.

**Deployment and billing:** Vercel hosts the gateway. On November 16, 2026, Vercel's [pricing documentation](https://vercel.com/docs/ai-gateway/pricing) stated no markup and no platform fee on tokens, including with BYOK. You buy AI Gateway Credits and pay any payment processing fees, and BYOK requires the paid tier. Optional add-ons cost extra: team-wide zero data retention and a team-wide provider allowlist cost $0.10 per 1,000 requests each, and regional endpoints in the EU or US, in beta, add 5% of inference cost on Pro and Enterprise plans.

**Strengths:** Budgets per team, project, API key, or team member; request logs that record every routing attempt; provider and model fallbacks; prompt caching across providers with `caching: 'auto'`; and text, image, video, speech, and embedding models behind one API.

**Trade-offs:** Budgets do not count BYOK spend. A failed BYOK request can retry on Vercel's provider keys and bill your credits. Team-wide data controls are paid add-ons.

**Best for:** TypeScript teams using the AI SDK, and any team that wants a managed endpoint without a percentage fee on tokens.

### Cloudflare AI Gateway

**What it is:** Cloudflare AI Gateway is a managed gateway on Cloudflare's network that proxies requests to providers including Workers AI, OpenAI, Anthropic, Google, and Replicate, and adds analytics, logging, caching, rate limiting, retries, model fallback, and dynamic routing.

**Deployment and billing:** Cloudflare hosts the gateway on its network. Cloudflare's [pricing page](https://developers.cloudflare.com/ai-gateway/reference/pricing/) lists analytics, caching, and rate limiting as free on all plans. Unified Billing lets you pay providers through Cloudflare, with no markup on provider pricing and a 5% fee on credits purchased. With [BYOK](https://developers.cloudflare.com/ai-gateway/configuration/bring-your-own-keys/), provider keys live in Cloudflare Secrets Store and clients send only a gateway token.

**Strengths:** Free core features, data loss prevention scanning on all plans, an OpenAI-compatible endpoint that takes `{provider}/{model}` names, and close integration with Workers and Workers AI.

**Trade-offs:** Legacy log storage is capped at 100,000 logs across all gateways on Workers Free and 10 million per gateway on Workers Paid; accounts whose first gateway was created on or after September 24, 2026 use Workers Logs instead. Cloudflare marks the gateway's `/compat` chat completions endpoint as deprecated for new single-model integrations and points them to its REST API. Rate limits and budget limits are set on gateways and dynamic routes.

**Best for:** Teams already building on Cloudflare Workers.

### Requesty

**What it is:** Requesty is a managed AI gateway and LLM router whose [documentation](https://docs.requesty.ai) lists 600+ models from 30+ providers behind an OpenAI-compatible base URL, `https://router.requesty.ai/v1`, plus an Anthropic Messages endpoint.

**Deployment and billing:** Requesty hosts the service. Its [pricing page](https://www.requesty.ai/pricing) listed provider prices plus 5% on November 16, 2026, a free tier limited to free models at 200 requests per day, and BYOK on its pay-as-you-go and enterprise plans.

**Strengths:** An EU endpoint, `https://router.eu.requesty.ai/v1`, that processes and stores traffic in Frankfurt; fallback policies, load balancing, and latency-based routing; budgets per team, user, and API key; and, on enterprise plans, SSO through Okta, Azure AD, Google Workspace, or OIDC, role-based access, audit logs, and PII [guardrails](https://theaiengineering.com/glossary/guardrails).

**Trade-offs:** The 5% fee has the same shape as OpenRouter's, and a vendor sits on the data path.

**Best for:** Teams that want OpenRouter-style one-account access with processing in the EU.

### Eden AI

**What it is:** Eden AI is an AI gateway from a French company based in Lyon and founded in 2021. Its homepage lists around 1,000 models from 80+ providers, including non-LLM models for tasks such as OCR, translation, and speech. LLM calls use an OpenAI-compatible `/v3/chat/completions` endpoint, and other AI tasks use `/v3/universal-ai`.

**Deployment and billing:** Eden AI hosts the service. Its [pricing page](https://www.edenai.co/pricing) listed provider prices with no markup and a 5.5% platform fee on credit purchases on November 16, 2026. [BYOK works per provider](https://www.edenai.co/docs/v3/general/byok.md), so one organization can mix its own keys for some providers with Eden AI billing for others.

**Strengths:** An EU endpoint, `https://api.eu.edenai.run/v3`, that refuses models not cleared for European processing with HTTP 451 before contacting any provider; per-key budgets that reset daily, weekly, or monthly; model allow-lists and roles; and a cost field in every response.

**Trade-offs:** The platform fee matches OpenRouter's Standard plan. SSO, SCIM, and audit logs require the Advanced plan.

**Best for:** European teams, and applications that combine LLM calls with OCR, translation, or speech APIs.

## Single-account multi-model platforms

Some platforms replace OpenRouter's one-account convenience without a separate gateway vendor: a cloud provider or model hub serves many vendors' models under one bill. They fit teams that already buy from that platform. They are not gateways, so per-team virtual keys, fallbacks to other clouds, and models outside their catalogs still need another layer.

### Amazon Bedrock

**What it is:** Amazon Bedrock is AWS's managed service for foundation models. Its [model catalog](https://docs.aws.amazon.com/bedrock/latest/userguide/model-cards.html) listed models from AI21 Labs, Amazon, Anthropic, Cohere, DeepSeek, Google (Gemma), Luma AI, Meta, MiniMax, Mistral AI, Moonshot AI, NVIDIA, OpenAI, Qwen, Stability AI, TwelveLabs, Writer, xAI, and Z.AI on November 16, 2026.

**Deployment and billing:** AWS runs Bedrock in its own Regions and bills on-demand usage per token on your AWS bill, with batch, flex, priority, and provisioned throughput options. Besides its own Converse API, Bedrock serves [OpenAI-compatible APIs](https://docs.aws.amazon.com/bedrock/latest/userguide/bedrock-mantle.html) at `https://bedrock-runtime.{region}.amazonaws.com/openai/v1`, authenticated with a Bedrock API key or AWS credentials.

**Strengths:** IAM permissions, CloudTrail audit logs, private connectivity through AWS PrivateLink, Bedrock Guardrails, and geographic inference profiles for data residency. AWS states that model providers have no access to Bedrock logs or to customer prompts and completions, because models run in deployment accounts that the Bedrock team operates.

**Trade-offs:** The catalog is AWS's, not every vendor's: the Google entries are Gemma open models, not Gemini. Which OpenAI-compatible APIs work varies by model and endpoint. Access control runs through IAM policies rather than gateway-style virtual keys with budgets.

**Best for:** AWS-committed organizations that want many vendors' models under one contract and AWS's security controls.

Microsoft Foundry and Google Cloud's Gemini Enterprise Agent Platform offer comparable multi-vendor catalogs on their own clouds; both are listed in our [inference providers directory](https://theaiengineering.com/platforms/inference-providers), and the labs behind the models are in the [model providers directory](https://theaiengineering.com/platforms/model-providers).

### Hugging Face Inference Providers

**What it is:** Hugging Face Inference Providers routes requests for Hub models to partner providers, including Cerebras, Cohere, DeepInfra, Fireworks, Groq, Novita, Scaleway, Together, and others, through one Hugging Face token. Its OpenAI-compatible endpoint, `https://router.huggingface.co/v1`, picks the fastest provider for a model by default; appending `:cheapest`, `:preferred`, or a provider name to the model ID changes the choice.

**Deployment and billing:** Hugging Face hosts the router. Its [pricing page](https://huggingface.co/docs/inference-providers/pricing) states that Hugging Face passes provider rates through with no markup. PRO accounts receive $2.00 of monthly credits, and Team and Enterprise organizations $2.00 per seat. With a custom provider key, the provider bills you and Hugging Face does not charge for the call.

**Strengths:** Provider choice per model, automatic failover when a provider is flagged unavailable, organization billing through an `X-HF-Bill-To` header, and admin settings to cap spending and disable providers.

**Trade-offs:** The OpenAI-compatible endpoint covers chat completions only. The catalog centers on open-weight models hosted on the Hub. Governance stops at organization spending limits and provider toggles.

**Best for:** Teams that standardize on open-weight models and want to switch hosts per model.

Single-host platforms such as Together AI, Fireworks AI, and DeepInfra also run many open-weight models under one account, without routing across hosts.

## OpenRouter alternatives compared

The table summarizes each option on the five questions that usually decide a migration: who holds the provider keys, where the service runs, how you pay, what governance it includes, and whether it accepts OpenAI-format requests. Pricing and plan details are as each vendor's own pages listed them on November 16, 2026; OpenRouter is included for reference.

| Option | Who holds provider keys | Deployment | Billing | Governance | OpenAI-compatible |
|---|---|---|---|---|---|
| Bifrost | You | Self-hosted (npx, Docker, Kubernetes, Go SDK) | Providers bill you; open-source core free | Virtual keys with budgets and rate limits; RBAC, SSO, audit logs in enterprise | Yes, plus Anthropic, Bedrock, and GenAI formats |
| LiteLLM | You | Self-hosted (Docker, Python package) | Providers bill you; enterprise license for some features | Virtual keys, budgets, rate limits; SSO free to 5 users | Yes |
| Agent Router | You | Self-hosted (Kubernetes or `aigw`) | Providers bill you | Token limits per team, app, or model | Yes |
| Vercel AI Gateway | Vercel, or you with BYOK | Managed | Credits at provider list price, no markup; paid add-ons | Budgets per team, project, key, or member | Yes, plus Anthropic Messages |
| Cloudflare AI Gateway | You with stored keys, or Cloudflare with Unified Billing | Managed | Core features free; 5% fee on Unified Billing credits | Rate limits and budgets on gateways and routes | Yes |
| Requesty | Requesty, or you with BYOK | Managed | Provider price plus 5% | Budgets per team, user, key; SSO on enterprise | Yes, plus Anthropic Messages |
| Eden AI | Eden AI, or you per provider | Managed | 5.5% fee on credit purchases | Per-key budgets, model allow-lists; SSO on Advanced | Yes |
| Amazon Bedrock | AWS | Managed in AWS Regions | Per-token on your AWS bill | IAM policies, CloudTrail | Yes, varies by model |
| Hugging Face Inference Providers | Hugging Face, or you with a custom key | Managed | Provider rates, no markup | Organization spending limits, provider toggles | Chat completions only |
| OpenRouter (reference) | OpenRouter, or you with BYOK | Managed | 5.5% or 8% fee on credit purchases; BYOK free to $25,000 a month, then 5% | Workspaces and budgets; SSO and SCIM on Enterprise | Yes |

## OpenRouter vs LiteLLM

OpenRouter is a hosted service that sells access to hundreds of models through one account and prepaid credits. LiteLLM is open-source software you run yourself, with your own provider keys, to put many providers behind one OpenAI-compatible endpoint. The choice is between buying model access and operating your own gateway, and many teams use both.

| | OpenRouter | LiteLLM |
|---|---|---|
| What it is | Hosted model aggregator | Open-source Python SDK and self-hosted proxy |
| Who operates it | OpenRouter | You |
| Provider accounts | Not needed; BYOK optional | One per provider you use |
| Catalog | 600+ models from 80+ providers through one account | 100+ providers, each reached with your key |
| Billing | Credits at list price; 5.5% (Standard) or 8% (Business) fee on purchases | No fee; providers bill you; you pay for infrastructure and any enterprise license |
| Governance | Workspaces, budgets, spend controls; SSO and SCIM on Enterprise | Virtual keys, budgets, rate limits per key, team, and user; SSO free to five users |
| Data path | Every request passes through OpenRouter | Requests stay in your network until they reach a provider |
| Data residency | Zero data retention routing on all plans; EU and US in-region routing on Business and Enterprise | Wherever you deploy the proxy and whichever provider regions you choose |
| Operations | None | The proxy, a PostgreSQL database for keys and spend, upgrades, and scaling |

### When OpenRouter fits better

OpenRouter fits when you want to try many models without opening provider accounts, when a small team has no provider contracts to protect, when an application needs open-weight models from hosts you would not contract with directly, and when one prepaid balance is simpler than a dozen provider invoices. Its provider fallback works without configuration.

### When LiteLLM fits better

LiteLLM fits when you already pay providers directly and want those contracts and rate limits to apply, when the proxy must run inside your network, when each team or customer needs its own key with a budget, and when a percentage fee on spend is hard to justify. In exchange, you run a Python service and a database and apply LiteLLM's upgrades yourself.

### Using OpenRouter and LiteLLM together

LiteLLM [lists OpenRouter as a provider](https://docs.litellm.ai/docs/providers/openrouter): set `OPENROUTER_API_KEY` and prefix model names with `openrouter/`. The gateway then routes primary traffic to providers on your own keys and keeps OpenRouter as a fallback, or as the only path to models you have no direct contract for, while virtual keys and budgets apply to both.

**Figure 2: A self-hosted gateway can keep direct provider keys for primary traffic and reach OpenRouter as one more upstream.**

Applications call one self-hosted gateway, which sends primary traffic to two providers on the team's own keys and uses OpenRouter as a fallback upstream.

Components:

- **Applications**: one virtual key per team
- **Self-hosted gateway**: budgets, rate limits, logs fallbacks across upstreams
- **Provider A**: your key and contract
- **Provider B**: your key and contract
- **OpenRouter**: models without a contract

Connections:

- Applications → Self-hosted gateway
- Self-hosted gateway → Provider A: primary
- Self-hosted gateway → Provider B
- Self-hosted gateway → OpenRouter: fallback

In LiteLLM's [proxy configuration](https://docs.litellm.ai/docs/proxy/configs), the pattern is two model entries and a fallback rule. Replace the placeholders with real model IDs:

```yaml
model_list:
  - model_name: chat-default
    litellm_params:
      model: anthropic/<claude-model-id>
      api_key: "os.environ/ANTHROPIC_API_KEY"
  - model_name: chat-backup
    litellm_params:
      model: openrouter/<vendor>/<model-id>
      api_key: "os.environ/OPENROUTER_API_KEY"

litellm_settings:
  fallbacks: [{"chat-default": ["chat-backup"]}]
```

Start the proxy with `litellm --config config.yaml`, and clients call `chat-default` at `http://localhost:4000` with a LiteLLM virtual key. Bifrost supports the same arrangement, since OpenRouter is one of its listed providers and fallbacks are a `provider/model` list.

## How to migrate off OpenRouter

Migrating off OpenRouter is mostly a base URL and model-name change, because every alternative here accepts OpenAI-format requests. The real work sits in OpenRouter-specific request fields, model identifiers, and fallback behavior, which no other service interprets the same way. Inventory those first, then run old and new paths side by side before cutting over.

- **Model IDs:** OpenRouter uses `vendor/model` slugs. Map each one to the target's naming, such as `provider/model` in Bifrost, `{provider}/{model}` on Cloudflare, or a `model_name` alias in LiteLLM.
- **OpenRouter-only fields:** the `provider` object (`order`, `only`, `ignore`, `data_collection`, `zdr`, `sort`, `max_price`) and the `models` fallback array mean nothing to other services. Move that intent into gateway configuration.
- **Fallbacks:** OpenRouter falls back across hosts of the same model automatically. On a self-hosted gateway, define [fallback chains](https://theaiengineering.com/glossary/model-failover) and [load balancing](https://theaiengineering.com/glossary/llm-load-balancing) explicitly; our guide to [LLM routing](https://theaiengineering.com/articles/llm-routing) covers retry and fallback design.
- **Served-model reporting:** OpenRouter's response `model` field shows which model answered after a fallback. Confirm the new service reports the same fact; Bifrost, for example, returns the serving provider and model in [response headers](https://docs.getbifrost.ai/providers/response-headers).
- **Usage and cost:** compare token counts and cost on a sample of real requests before cutting over.
- **Data settings:** re-create zero data retention and regional requirements as provider-level or gateway-level settings, since they do not carry over.

Where to go next: our [AI gateways directory](https://theaiengineering.com/platforms/ai-gateways) lists more self-hosted and managed options by deployment model, the [LLM routing guide](https://theaiengineering.com/articles/llm-routing) covers fallback and load-balancing strategy, and the [LLM observability guide](https://theaiengineering.com/articles/llm-observability) covers the tracing that complements gateway logs.

## Frequently asked questions

### Is there an open-source alternative to OpenRouter?

Yes. Bifrost (Apache 2.0, written in Go), LiteLLM (MIT outside its enterprise directory, written in Python), and Agent Router (Apache 2.0, built on Envoy) are open-source gateways that expose many providers through one OpenAI-compatible API. Unlike OpenRouter, they run in your own infrastructure and call providers with your own API keys, so you need an account with each provider whose models you use.

### Does OpenRouter charge a markup on model prices?

OpenRouter states that it bills inference at each provider's list price with no markup. Its fee applies when you buy credits: on November 16, 2026, its pricing page listed 5.5% on the Standard plan and 8% on the Business plan, and its FAQ listed a $0.80 minimum per purchase and a 5% fee on crypto payments. Enterprise plans offer fee discounts through sales.

### Can I use my own API keys with OpenRouter?

Yes. OpenRouter's bring-your-own-key feature stores your provider keys encrypted in your workspace and uses them for requests to that provider. On November 16, 2026, BYOK usage was free up to $25,000 of list-price inference per month on Standard and Business plans, then cost 5% of the equivalent OpenRouter price. By default, OpenRouter falls back to its shared endpoints, billed to your credits, when your keys fail.

### Does OpenRouter store prompts and completions?

OpenRouter's FAQ says it does not log prompts and completions by default, only metadata such as timestamps, the model used, and token counts, unless you opt in. Upstream providers have their own retention policies, so OpenRouter offers Zero Data Retention routing for an account or a single request, and a data_collection setting of deny that skips providers that retain user data.

### Can you use OpenRouter with LiteLLM?

Yes. LiteLLM lists OpenRouter as a provider: set the OPENROUTER_API_KEY environment variable and prefix model names with openrouter/. A common pattern sends primary traffic to providers on your own keys and keeps OpenRouter as a fallback, or as the source for models you have no direct contract for, while LiteLLM's virtual keys and budgets govern all of it. Bifrost supports the same pattern.

### What is the difference between an AI gateway and a model aggregator?

A model aggregator such as OpenRouter resells model access: requests run on the aggregator's provider accounts, and you pay it through credits. An AI gateway is a proxy that applies routing, keys, budgets, and logging to requests that run on your own provider accounts. The categories overlap, because most managed gateways also resell access and most aggregators accept your own keys.

## Terms in this guide

- [AI gateway](https://theaiengineering.com/glossary/ai-gateway): An AI gateway is a proxy layer between applications and model providers that exposes one API for many models and centralizes routing, failover, access control, cost tracking, caching, and logging.
- [OpenAI-compatible API](https://theaiengineering.com/glossary/openai-compatible-api): An OpenAI-compatible API is an HTTP API that accepts OpenAI's request and response formats, so code written for OpenAI's SDKs can call another server by changing the base URL, API key, and model name.
- [LLM routing](https://theaiengineering.com/glossary/llm-routing): LLM routing is the practice of directing each request to one of several language models or providers, based on rules or a learned classifier, to balance cost, quality, latency, and availability.
- [Rate limiting](https://theaiengineering.com/glossary/rate-limiting): Rate limiting is the enforcement of a maximum number of requests or tokens a client may send to an API within a time window, with excess requests rejected, usually with HTTP 429.
- [Virtual key](https://theaiengineering.com/glossary/virtual-key): A virtual key is an API key issued by an AI gateway that maps a caller to its allowed models, budget, and rate limits, while the gateway keeps the real provider credentials.
- [MCP gateway](https://theaiengineering.com/glossary/mcp-gateway): An MCP gateway is a proxy that sits between MCP hosts and many MCP servers, exposing them through one endpoint and centralizing authentication, tool access policy, and audit logging.
- [Guardrails](https://theaiengineering.com/glossary/guardrails): Guardrails are programmatic checks placed around a large language model that validate, filter, or block inputs, outputs, and tool calls so an AI application stays within its safety, security, and policy limits.
- [Model failover](https://theaiengineering.com/glossary/model-failover): Model failover is the automatic rerouting of an LLM request to a backup model, deployment, or provider when the primary target returns an error, times out, or hits a rate limit.
- [LLM load balancing](https://theaiengineering.com/glossary/llm-load-balancing): LLM load balancing is the distribution of requests for one model across several interchangeable deployments, such as API keys, regions, providers, or replicas, by weight, latency, load, or remaining quota.

## Related guides

- [What is an AI gateway? How it works and when you need one](https://theaiengineering.com/articles/what-is-an-ai-gateway): An AI gateway is a proxy between your apps and model providers. Learn how it works, its core features, AI gateway vs API gateway, and open source options.
- [LLM routing: strategies, fallbacks, and learned routers](https://theaiengineering.com/articles/llm-routing): LLM routing guide: rule-based and cost-aware strategies, fallbacks, load balancing, semantic and learned routers like RouteLLM, router evals, and pitfalls.
- [LLM observability: what to capture, which metrics, and tools](https://theaiengineering.com/articles/llm-observability): LLM observability guide: what to capture in traces and spans, metrics to track, OpenTelemetry GenAI conventions, tool categories, and keeping prompts private.
- [AI guardrails: types, where they run, and how to test them](https://theaiengineering.com/articles/ai-guardrails): AI guardrails are checks that block, redact, or flag LLM inputs, outputs, and tool calls. Learn the types, where they run, trade-offs, and how to test them.

Part of the [AI gateways and LLM routing](https://theaiengineering.com/topics/ai-gateways) topic hub.

## Cite this guide

The AI Engineering Editors. "OpenRouter alternatives: self-hosted gateways and managed model APIs compared." The AI Engineering, updated Nov 19, 2026. https://theaiengineering.com/articles/openrouter-alternatives

- Title: OpenRouter alternatives: self-hosted gateways and managed model APIs compared
- Author: The AI Engineering Editors
- Publisher: The AI Engineering
- Published: 2026-11-19
- Updated: 2026-11-19
- URL: https://theaiengineering.com/articles/openrouter-alternatives
- Markdown: https://theaiengineering.com/articles/openrouter-alternatives.md

To cite one section, link to its anchor:

- [What is OpenRouter?](https://theaiengineering.com/articles/openrouter-alternatives#what-is-openrouter)
- [Why teams look for OpenRouter alternatives](https://theaiengineering.com/articles/openrouter-alternatives#why-teams-look-for-openrouter-alternatives)
- [How to choose an OpenRouter alternative](https://theaiengineering.com/articles/openrouter-alternatives#how-to-choose-an-openrouter-alternative)
- [Three architectures: aggregator, managed gateway, and self-hosted gateway](https://theaiengineering.com/articles/openrouter-alternatives#three-architectures-aggregator-managed-gateway-and-self-hosted-gateway)
- [Self-hosted gateways](https://theaiengineering.com/articles/openrouter-alternatives#self-hosted-gateways)
- [Managed gateways](https://theaiengineering.com/articles/openrouter-alternatives#managed-gateways)
- [Single-account multi-model platforms](https://theaiengineering.com/articles/openrouter-alternatives#single-account-multi-model-platforms)
- [OpenRouter alternatives compared](https://theaiengineering.com/articles/openrouter-alternatives#openrouter-alternatives-compared)
- [OpenRouter vs LiteLLM](https://theaiengineering.com/articles/openrouter-alternatives#openrouter-vs-litellm)
- [How to migrate off OpenRouter](https://theaiengineering.com/articles/openrouter-alternatives#how-to-migrate-off-openrouter)
- [Frequently asked questions](https://theaiengineering.com/articles/openrouter-alternatives#faq)
