The open-source AI gateway you run yourself

One OpenAI-, Anthropic-, Gemini- and ElevenLabs-compatible API in front of every provider, for chat, embeddings, images, video, speech, transcription and music, with single sign-on, roles, budgets, alias routes, request logs, a playground and an MCP portal, in one Rust process.

Website · Documentation · Live demo · Discussions · Changelog

The Kaeso console: connecting an Anthropic provider key, sending an OpenAI-format request to claude-haiku-5-5 from a terminal, and the request arriving at the top of the request logs

Install

On a server or your computer with Docker and Compose 2.24 or newer:

curl -fsSL https://kaeso.app/install.sh | sh

It installs Kaeso with PostgreSQL, ClickHouse and Valkey into ./kaeso, starts it at https://localhost and prints the link that creates the first user. Add -s -- --domain kaeso.example.com to serve your own domain. The quick start continues from there, and install by hand shows each step.

On a cloud or a hosting platform, the platform templates run the same release:

Render · Railway · DigitalOcean · Fly.io · AWS · Azure · Google Cloud · Coolify · Dokploy · CapRover

Send your first request

Point the OpenAI SDK at Kaeso and call any model in your project, Claude included:

from openai import OpenAI
client = OpenAI(base_url="https://kaeso.example.com/v1", api_key="sk-kso-…")
print(client.responses.create(model="claude-haiku-5-5", input="Hello").output_text)

The Anthropic SDK works the same way with base_url="https://kaeso.example.com". Kaeso translates the request and the reply between the formats (calling models).

Built in are Anthropic, Baseten, Cerebras, Cohere, DeepSeek, ElevenLabs, Fireworks AI, Gemini Enterprise Agent Platform, Google AI Studio, Groq, Hugging Face, MiniMax, Mistral, Moonshot, Nebius Token Factory, NVIDIA, Ollama Cloud, OpenAI, OpenRouter, QwenCloud, SambaNova, Scaleway, SiliconFlow, SpaceX (xAI), Together AI, Vercel and Z.ai (supported providers). A server of your own, such as vLLM, Ollama, LM Studio or llama.cpp, joins as a custom provider.

The console

The pages below show the console with sample data. The live demo is a read-only install to try it yourself.

Analytics Requests, tokens, cost and errors per organization, project, model and member, against the period before.	Playground Try any model in the project, up to four side by side, for text, images, speech, music, transcription and video.
Request logs Every request with its model, status, tokens, cost, timing and caller, and its content and media if you keep them.	Models A catalogue per project with the prices and capabilities of every model from KPMR, the Kaeso Provider & Model Registry.
Alias routes Name the models behind an alias, with fallbacks, conditions on headers and tokens, and weighted splits.	Limits and budgets Hard or soft spend, token and rate limits per project, member, service account or key, checked before the provider is called.

How it works

flowchart LR
  accTitle: How Kaeso sits between apps and providers
  accDescr: Apps, SDKs and coding tools call the gateway in the OpenAI, Anthropic, Gemini or ElevenLabs format, and MCP clients call its MCP portal. The gateway resolves the model, checks rights and limits, calls the provider in its own format, and writes usage and logs to PostgreSQL, ClickHouse and Valkey, which the console reads.
  apps[Apps, SDKs and coding tools]:::outside
  mcp[MCP clients]:::outside
  subgraph install [Your Kaeso install]
    direction LR
    gateway[Gateway]:::accent
    console[Console]
    data[(PostgreSQL, ClickHouse, Valkey)]
    gateway --- data
    console --- gateway
  end
  providers[Model providers]:::outside
  servers[Your MCP servers]:::outside
  apps -- OpenAI, Anthropic, Gemini or ElevenLabs format --> gateway
  mcp -- MCP --> gateway
  gateway -- the provider's format --> providers
  gateway -- MCP --> servers

Single sign-on and roles Each organization signs in through its own OpenID Connect provider, for any number of people at no cost, with organization and project roles and single rights on top (members and roles).	One format in, any provider out Apps speak the OpenAI, Anthropic, Gemini or ElevenLabs API, for chat, images, audio and video; Kaeso decodes every request, encodes it for the provider and translates the reply and the stream back (format translation).	Media through the same gateway Images, video, speech, transcription, sound effects and music go through the same keys, limits, request logs and costs as chat, on every provider that makes them (images, audio, videos).
An MCP portal per project Connect your own MCP servers once, review their tools, and let claude.ai, ChatGPT, Cursor or any MCP client call them through one signed-in portal (MCP portal).	Verifiable releases Every image and release file carries signed build provenance; `gh attestation verify` checks it, and the updater installs nothing whose signatures don't match (upgrades).	Rust, and more gateways when you need them One process with no garbage collector between your app and the provider; run several behind Caddy or a load balancer and they share everything a request depends on (multiple gateways).

How it compares

Checked on 6 November 2026 against each project's repository and documentation. Open an issue when a row is out of date.

	Kaeso	LiteLLM	Bifrost	Portkey Gateway
Gateway written in	Rust	Python	Go	TypeScript
License	MIT	MIT, except `enterprise/`	Apache 2.0	MIT
Single sign-on when self-hosted for free	Yes, OpenID Connect	Up to 5 users (docs)	Enterprise (pricing)	Enterprise (docs)
Budgets when self-hosted for free	Yes	Yes (docs)	Yes (pricing)	Enterprise and some Pro plans (docs)
Web console when self-hosted	Yes	Yes	Yes	Request logs only (README)
MCP portal for your own MCP servers	Yes, per project	Yes (docs)	Yes (docs)	Yes (docs)

Works with

Tool	How
Claude Code and Codex	Kaeso is their model provider, so every session is logged and budgeted
The Kaeso plugins for Claude Code and Cursor	Manage Kaeso through its MCP server, from keys to limits; the Claude Code plugin's skill connects the server for you
claude.ai, ChatGPT and any MCP client	Call your MCP servers' tools through a project's MCP portal
The OpenAI, Anthropic, Google Gen AI and ElevenLabs SDKs, in any language, and anything with a base URL setting	Point the base URL at Kaeso; supported providers lists what each provider can do through each API

In this repository

Part	What it is
`crates/`	The gateway, the updater and KPP, the protocol every request is decoded to; `kaeso-kpp` and `kaeso-codecs` are on crates.io
`apps/console`	The web console
`packages/ui` and `packages/tokens`	The UI library and design tokens behind it, on npm, with a showcase
`apps/docs`	The documentation at docs.kaeso.app, in English, German and Chinese
`deploy/`, `render.yaml`, `.railway/` and `.do/`	The Compose package, the container images and the templates for Render, Railway, DigitalOcean, Fly.io, AWS, Azure, Google Cloud, Coolify, Dokploy and CapRover
`plugins/`	The Claude Code and Cursor plugins for Kaeso's MCP server

Architecture explains how the parts fit, and contributing how to work in them.

Community

Discussions for questions, ideas and what you built.
@kaesoapp on X for releases.
Good first issues to start contributing, with the contributing guide.

License

MIT. The Kaeso name and logo are not covered by the license. All trademarks belong to their owners; Kaeso is not affiliated with any provider or client it names. Third-party notices, trademarks included, are in NOTICE.md.