live at auric-iai4.onrender.com

Multi-provider inference gateway

One key.
Every model.
Nothing overspent.

Auric puts OpenAI, Anthropic, Gemini, Groq, Together, DeepInfra, and Mistral behind one OpenAI-compatible endpoint. Cheapest-first routing, instant failover, and a billing ledger that holds funds atomically so concurrent requests can't overdraw an account.

Get your API key

providers, one endpoint

overdraw under concurrency, proven by test

prompts retained, by default

Routing simulation. Illustrative, not a live feed

→ anthropic · claude-sonnet-5 $0.0031 settled

Before Auric

Seven providers. Seven ways to get rate-limited, billed, or paged at 3 a.m.

Every provider has its own SDK, its own tool-calling shape, its own outage schedule. Without a shared layer, a 429 from one vendor is your incident, and nobody has a single number for what the team is spending.

Without Auric

# a client per provider, a key per client,
# a rate limit per key, no shared spend view
openai_client = OpenAI(api_key=OPENAI_KEY)
anthropic_client = Anthropic(api_key=ANTHROPIC_KEY)
gemini_client = genai.Client(api_key=GEMINI_KEY)
# ...and your own retry/failover glue

With Auric

curl https://auric-iai4.onrender.com/v1/chat/completions \
  -H "Authorization: Bearer sk-auric-..." \
  -d '{"model": "llama-3.3-70b", "stream": true,
       "messages": [{"role": "user", "content": "hi"}]}'

How it works

Three steps from zero to metered, multi-provider inference.

Create an account

Self-serve at the dashboard, or from the CLI: auric keys new-account you@company.com 25 mints a prepaid account and an admin key.

Point your SDK at Auric

Swap one line: base_url = "https://auric-iai4.onrender.com/v1". Same OpenAI client you already use, or the Anthropic Messages format. Both work.

Call any model

Auric translates the request, tries the cheapest configured provider first, fails over on error, and settles the metered cost against your balance.

What's inside the gateway

Built for the parts that break in production, not the demo.

Translation

One shape, every provider

OpenAI-format requests translate to Anthropic and Gemini's native shapes and back, including streaming tool/function calls, so agent clients like Claude Code work against any model.

Routing

Cheapest-first, instant failover

Candidates for a model are tried cheapest first. A transport error retries once against the same provider before failing over; a 429 or 5xx fails over to the next candidate immediately, and a provider that keeps failing gets circuit-broken with backoff.

Billing

Atomic hold, then settle

Every request escrows its worst-case cost before routing and settles the metered actual after streaming, proven by a concurrency test to never collectively overdraw a balance. Send an Idempotency-Key header on billed endpoints to make a retried request safe to resend without double-billing.

Privacy

Zero-retention by default

Prompt and completion content is never persisted unless you explicitly turn on debug logging with AURIC_ZERO_RETENTION=0.

Teams

Roles, budgets, and model allowlists

Each key carries a role, admin or member, an optional monthly spend cap enforced at the same atomic gate that protects the account balance, and an optional allowlist scoping it to specific models. Crossing 80% or 95% of the spend cap fires an outbound webhook, so budget overruns are caught before the invoice.

Observability

See it, don't guess it

GET /metrics exposes Prometheus counters for requests, latency, tokens, and cost. GET /readyz returns 503 when the database is unreachable, for load-balancer health checks. Every settled request writes a structured log line.

Billing, made legible

A ledger you can read, not a black box you have to trust.

Every call resolves to one settled line: which provider served it, how many tokens moved, and what it cost. GET /v1/usage returns the same ledger your account is billed from.

Worked example. Hand-computed from the published per-model rates below, not a real account /v1/usage

Model	Provider	In / out tokens	Rate ($/1M in–out)	Cost
claude-sonnet-5	anthropic	1,200 / 640	3.00–15.00	$0.0132
gpt-4.1-mini	openai	2,400 / 700	0.40–1.60	$0.0021
llama-3.3-70b	deepinfra	800 / 300	0.23–0.40	$0.0003
gemini-2.0-flash	google	1,600 / 500	0.10–0.40	$0.0004

rates and cheapest-provider pick from the built-in catalog, at the default margin (1.0×, no markup unless AURIC_MARGIN is set) $25.00 starting balance → $24.9841 after these four calls

→

Hold before you route. The worst-case cost is escrowed against your spendable balance (balance minus everything already held) before the request leaves Auric.

→

Settle what actually happened. The hold is released and the metered actual is deducted once the provider's usage is known, falling back to a tokenizer-based floor if none is reported.

→

Set your own margin. AURIC_MARGIN applies a multiplier to both the estimate and the settled charge, reflected live in /v1/models pricing.

→

Scale past one node. Point AURIC_DATABASE_URL at Postgres and every replica shares one ledger with an atomic conditional debit, so no replica can overdraw on its own.

An empty balance returns 402. It doesn't return a surprise invoice.

→

Provable, not promised

100 concurrent $0.10 holds against a $1.00 balance grant exactly 10, never more, enforced by a concurrency test on both single-node and shared Postgres.

→

One bad response can't take the gateway down

Provider stream goroutines recover from panics independently, so a malformed upstream response drops that one request, not every tenant's.

→

No silent stranded escrow

A failed settle retries twice, then pages an operator instead of just logging. A crash between a hold and a settle is still cleared automatically at the next restart.

→

Self-serve payments

Stripe Checkout top-ups with an idempotent webhook credit, so balances move without an operator running a CLI command.

Also in the box

A self-hosted agent, same binary.

Alongside the gateway, auric serve runs a personal, autonomous agent with a web chat UI, and auric chat gives the same agent as a terminal REPL. Sandboxed code execution with no inherited host environment, an SSRF-guarded fetch tool that blocks loopback and private-network targets, a policy engine that checks every tool call before it runs, and a hash-chained audit log you can independently verify.

run_code sandbox, no host env SSRF-guarded fetch policy-gated tools hash-chained audit log per-session budget

Terminal

$ export ANTHROPIC_API_KEY=sk-ant-...
$ go run ./cmd/auric serve
auric listening on http://localhost:7000  (model=claude-sonnet-5, policy: all tools; 4 denied patterns; max 16 iterations; cap $5.00/session)

$ auric verify
audit chain intact: 214 records verified

Get started

Point your existing code
at one URL.