Plugin Store
Everything you can plug into Busbar.
Busbar ships small and complete — a memory store and token auth in the box. Everything heavier is a plugin you add without recompiling the core: where state lives (stores), how requests are trusted (auth), and your own code on the request path (hooks). Browse them all below — and vote for what you want built next.
Memory
RAM store — zero setup, ephemeral.
The default. Virtual keys, budgets, rate limits, and usage all live in memory — nothing to install, nothing to provision. Ideal for a single node, a dev box, or a stateless tier where durability lives elsewhere. A restart clears it; that’s the trade for zero moving parts.
Built into the core — the default when no store is configured.
SQLite
Durable local persistence, one file.
Keys, budgets, and usage survive restarts in a single SQLite file — no external service to run. Write-behind by design: enforcement stays in memory on the hot path, and SQLite is the durable mirror flushed behind it. The single-node durability answer.
Ships in the binary today; moving to a drop-in store plugin as the plugin system lands.
Postgres
Shared, durable, multi-node.
One Postgres behind a cluster of Busbar nodes — shared virtual keys, budgets, and usage across the fleet. The foundation for horizontal scale: every node enforces from memory and reconciles against a single source of truth. Designed; landing as a downloadable store plugin.
Redis
Fast shared state, TTL-native.
An idea, not a product yet: a shared store backed by Redis, using its native TTLs for rate-limit windows and its speed for cross-node counters. Tell us if this is the one you’d reach for.
Your store
Have a backend Busbar should speak?
The store is a small, sync contract — keys, budgets, usage, metering. If you want Busbar’s state in DynamoDB, Mongo, MySQL, or your own service, the contract is the whole job. Tell us what you need and we’ll help you build it.
Email us, or open a PR against the repo.
Tokens
Static bearer tokens, constant-time.
The default client auth: a constant-time allowlist of bearer tokens, checked on every request across both header and bearer carriers. Zero dependencies, in the core. Pair it with the admin token that guards the management API.
Built into the core — the default request auth.
OIDC
Log in with your IdP.
Validate incoming requests against an OIDC provider — Okta, Auth0, Entra ID, Google — so gateway access follows your existing identity instead of a static token list. Designed; landing as an auth plugin.
AD / LDAP
Directory groups decide access.
An idea: authenticate against Active Directory or LDAP and let group membership map to virtual keys and budgets — the model enterprises already run on. Upvote if this is your world.
mTLS
Client certificates, CA-pinned.
An idea: trust requests by client certificate, pinned to a CA you control — strong service-to-service auth with no shared secrets in configs or env vars. Tell us if certs are how you’d rather authenticate.
Your auth
Trust requests your own way?
HMAC-signed requests, a bespoke token service, a SASO scheme of your own — the auth contract is small and stackable. Tell us how you need requests trusted and we’ll help you wire it in.
Email us, or open a PR against the repo.
Headroom
Context compression, on the path.
A rewrite gate that trims and compacts a request’s context before it ships, so a long conversation stays under the window without your app rebuilding the prompt. Written once, it works against every protocol and provider Busbar speaks. Measured: about 50% fewer input tokens on noisy histories for sub-millisecond overhead; short chats pass through untouched.
Powered by the open-source Headroom project.
Smart Router
Route by cost, latency, and live load.
A worked example, not a finished product: a routing gate that picks the backend per request from real signals — each member’s cost, latency, live concurrency, and rate headroom. It’s a template to read, fork, and shape into the router you actually want.
Read the write-up: the smart router you want is a hook.
PII Guard
Redact sensitive data before it leaves.
A gate that inspects and rewrites the request body, stripping or masking sensitive data — credit-card numbers, SSNs and other socials, patient records — before it reaches any provider. One guard covers every model behind Busbar, so the redaction rule lives in one place, not in every app.
Secret Shield
Keep your .env out of the prompt.
AI coding agents load your .env into memory and can slip those secrets into a prompt — where they get logged, committed, or exfiltrated. A gate that scrubs the outbound body against your registered secrets catches them before the request ever leaves, for every provider at once.
SIEM Audit
Every call, in your security stack.
A fire-and-forget tap that streams the full request and response to your SIEM or compliance archive without touching the hop. A complete, provider-agnostic audit trail for every AI call your org makes.
Semantic Cache
Skip the call when you already know the answer.
A gate that recognises a request it has answered before and short-circuits it — returning the cached response instead of paying for the round-trip. Provider-agnostic, so the cache spans every model behind Busbar.
Your hook
Built something worth sharing?
A guardrail, a router, a cost meter, an audit sink — anything that runs on the path. Tell us what it does and where it lives, and we’ll list it here and link straight to your repo.
Email us, or open a PR against the repo.
New to the request path? Start with the hooks docs for the config shape, the tap/gate lifecycle, and how a hook falls back safely without ever blocking a request. Stores and auth are set in configuration.