Busbar sits between your application and every provider it calls. Point any SDK at one URL — it routes to the backends you choose, translates across six wire protocols without dropping a feature, and keeps serving through provider failures before your user sees a byte.
# Already speak OpenAI? Just swap the base URL.
- client = OpenAI(api_key=OPENAI_KEY)
+ client = OpenAI(
+ api_key=BUSBAR_TOKEN,
+ base_url="http://busbar:8080",
+ )
# "fast" = a pool you define in config:
# 80% Claude / 20% GPT-4o, Gemini on failover.
client.chat.completions.create(
model="fast",
messages=[{"role": "user", "content": "Hi!"}],
)Left as OpenAI, may have been served by Anthropic, came back as OpenAI — translated both ways. If a lane returned 429 mid-flight, Busbar rerouted before your client saw a byte. The model name is a config value, not a code dependency.
You define a model name and the backends behind it. Busbar accepts any input protocol — OpenAI, Anthropic, Gemini, Bedrock, Cohere, Responses — and routes and translates accordingly. One model name, reachable by every client; you choose what runs behind it. It’s a different class of tool than a proxy with a long model list.
BusbarSix wire protocols, native on both sides, bridged through one internal format rich enough to hold every protocol’s features. Anthropic thinking blocks, Gemini safety settings, and Bedrock tool use survive the hop — nothing is flattened to OpenAI shape.
Enables Point whatever SDK your code already speaks at one URL, and reach every model through it.
A circuit breaker on every provider lane classifies each error — provider outage, your bad request, context overflow, hard auth failure — and treats each differently instead of retrying into a wall. A failed lane reroutes mid-flight, before your client sees a single byte.
Enables A flaky provider is pulled and probed back gently; a rate-limit storm on one lane never starves the healthy ones.
Routing is the first hook: a policy — built-in (weighted, cheapest, fastest, least-busy, usage), a webhook in any language, or a sandboxed Rhai script — inspects each request and decides who serves it, from per-member cost, latency, live concurrency, budget, and rate headroom. A slow or broken hook falls back, never blocks a request.
Enables The same fail-safe machinery is built to carry PII-steering, audit, caching, and guardrails — your own logic on the request path, in any language.
Issue virtual keys with daily, monthly, or all-time spend caps and per-key RPM/TPM limits. Restrict a key to specific model pools, cap staging independently of production, and revoke instantly. Usage is tracked per key and queryable via the admin API.
Enables Cost control enforced at the gateway, not self-policed by callers.
Busbar terminates TLS itself — cert and key in config, no reverse proxy required. Turn on mTLS and a client must present a certificate signed by your CA; anyone without one is rejected at the handshake, before any bearer-token check is reached.
Enables Zero-trust ingress without standing up a service mesh.
One static binary — no runtime, no sidecar, no interpreter in the request path — ships for Linux, macOS, and Windows (Intel and ARM). Provider keys live in one place; your app carries only a scoped token. Prometheus /metrics and OTLP traces built in.
Enables Your infrastructure, your keys, your data path — rotating an upstream key is one restart, not a deploy sweep.
One command pulls the binary and the provider catalog. Write a minimal config, point an SDK at it, and you’re serving. No sudo, no runtime, no virtualenv.
Full walkthrough →curl -fsSL https://getbusbar.com/install.sh | shproviders:
anthropic:
api_key_env: ANTHROPIC_KEY
models:
claude-sonnet:
provider: anthropic
max_concurrent: 10export ANTHROPIC_KEY=sk-ant-...
BUSBAR_CONFIG=./config.yaml busbar # serving on :8080curl localhost:8080/v1/chat/completions \
-d '{"model":"claude-sonnet",
"messages":[{"role":"user","content":"hi"}]}'