Tempr Gateway · Private beta

One endpoint. Your keys. Full observability.

An OpenAI-compatible API in front of the provider keys you already have. Point your existing SDK at one endpoint and get virtual keys, request logs, and analytics — no IDE license required.

Request beta access Read the docs

BYOKbring your own provider key(s)
OpenAI-compatibledrop-in /v1/chat/completions
3 plansFree, Pro & Scale

Drop-in for your existing SDK

Same request and response shape as OpenAI's API — swap the base URL and key, nothing else in your code changes. Python, Node, and every other OpenAI SDK work exactly the same way.

# Point any OpenAI SDK at Tempr Gateway
curl https://api.temprhq.io/v1/chat/completions \
  -H "Authorization: Bearer tvk_..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-4o",
    "messages": [{"role": "user", "content": "Say hi"}]
  }'

Full Python and Node examples in the Gateway quickstart.

Built for teams who already bring their own keys

Virtual keys, request logs, and analytics — BYOK all the way through, so Tempr never marks up or resells a token.

Bring your own keys

Connect your own OpenAI, Anthropic, Google, or aggregator keys. Tempr fronts none of its own — you pay your provider directly, and Tempr for the gateway itself.

Virtual keys

Issue scoped keys per app or environment with a model allowlist, a budget, and RPM/TPM limits — revoke instantly, no rotating your real provider key.

Request logs

Every call is searchable by key, model, provider, status, and latency, with a per-request detail view — metadata always included, prompt/response when you opt in.

Analytics

Requests, tokens, cost, latency (p50/p95), and error rate — broken down by key, model, and day.

Quotas, not surprises

Each plan includes a monthly request quota. Paid tiers keep serving past it on metered overage, capped at a limit you set — never a silent bill shock.

Fallback chains

Define an ordered list of provider/model candidates per key, so one provider's outage or rate limit doesn't take your app down with it.

Response caching

Opt in per request to exact-match caching for repeat prompts — cached hits are logged and billed as cached, not full price.

Content capture, your call

Request/response logging is on by default (7-day retention, 256 KB truncated) so you can debug real traffic — toggle it off, or switch to metadata-only, anytime.

OpenAI-compatible, end to end

POST /v1/chat/completions (streaming and non-streaming) and GET /v1/models, with tool and function calling passed straight through. Point any OpenAI client at Tempr and you're done.

Streaming, first-class

Server-sent events on /v1/chat/completions with the same chunk shape OpenAI streams — your existing streamed UI works unchanged.

Model routing

Provider-prefixed model ids like openai/gpt-4o pick the provider per request — and per-key allowlists pin exactly which models each key is allowed to serve.

Built for teams

Org-managed virtual keys pool provider keys centrally with per-member budget, rate, and model limits — one provider bill, hard caps per seat, SSO on the account.

How it works

1. Point your SDK at Tempr

Set the base URL to https://api.temprhq.io/v1 in any OpenAI client — Python, Node, curl, whatever you already use.

2. Connect your provider key(s)

Add your own OpenAI, Anthropic, Google, or aggregator keys in the Portal. Every request goes out on your key, at your provider's rates — Tempr never fronts tokens.

3. Issue virtual keys

Create a tvk_… key per app or environment with its own budget, rate limits, and model allowlist. Rotate or revoke instantly without touching the real provider key.

4. Ship with observability

From the first request you get logs, analytics by key and model, fallback chains, and caching — no SDK changes, no instrumentation code.

What teams use it for

The same gateway layer, whatever your reason for wanting keys, logs, and limits in front of your models.

Stop sharing raw provider keys

Teammates and services get scoped virtual keys with their own limits — nobody pastes the production OpenAI key into a Slack thread ever again.

Survive provider outages

Ordered fallback chains move traffic to the next candidate the moment a provider rate-limits or goes down — your app never knows.

Debug real production traffic

Logs searchable by key, model, status, and latency — with per-request detail and optional prompt/response capture when you need the full picture.

Never get a surprise bill

Every plan has a request quota; paid tiers serve past it on metered overage capped at a limit you set. A runaway script tops out quietly instead of billing endlessly.

Cut spend on repeat prompts

Opt in per request to exact-match response caching — cached hits are logged and billed as cached, not full price.

Change models without a deploy

The model is a string in the request, and allowlists keep production pinned — try a new model on a dev key, promote it by changing one line.

Bring a key from any of these

The same ~30-provider allowlist as Tempr Chat, enforced server-side — your key, routed straight to the provider. A few of the most popular:

OpenAIOpenAIFirst-party
AnthropicAnthropicFirst-party
Google GeminiGoogle GeminiFirst-party
DeepSeekDeepSeekFirst-party
xAIxAIFirst-party
MistralMistralFirst-party
Meta AIMeta AIFirst-party
CohereCohereFirst-party
OpenRouterOpenRouterAggregator
Together AITogether AIInference
Fireworks AIFireworks AIInference
Hugging FaceHugging FaceInference

View all providers & models →

What early users are saying

Illustrative quotes for preview purposes — replace with real customer feedback before launch.

"We swapped the base URL, kept our OpenAI client code exactly as-is, and suddenly had request logs we never had before. Took ten minutes."

— Platform engineer, devtools startup

"Fallback chains saved us during a provider outage — traffic just moved to the next candidate instead of paging anyone at 2am."

— Backend lead, e-commerce team

"No token markup, no shared pool — it's our own key with a much better dashboard in front of it. Exactly what we wanted from a gateway."

— Independent developer

Security & privacy

Bring-your-own-key all the way through — Tempr fronts no tokens and resells none.

Your keys, your account

Provider keys are stored encrypted at rest and never pooled or shared across customers. Every request goes out on a key you supplied.

Content capture, your call

Request/response logging is on by default (7-day retention, truncated at 256 KB) so you can debug real traffic — flip it to metadata-only or off entirely, per account.

Analytics without content

Even in metadata-only mode you keep the full dashboard — requests, tokens, cost, latency, and error rate by key, model, and day — with zero content stored.

Priced by request volume, not tokens

You pay your provider directly for tokens — this is what you pay Tempr for the gateway itself. Currently in private beta; beta access is by invite and no IDE license is required.

$0 / moFree — 10,000 req/mo
$49 / moPro — 250,000 req/mo
$249 / moScale — 2M req/mo

See full pricing

Gateway capabilities, plan by plan

Free, Pro, and Scale side by side — every plan is bring-your-own-key.

CapabilityFreeProScale
Requires your own provider API key(s)✔️✔️✔️
Requests included / month10,000250,0002,000,000
Rate limit10 req/min60 req/min240 req/min
Log retention7 days30 days90 days
OpenAI-compatible chat completions & models endpoints✔️✔️✔️
Tool / function calling passthrough✔️✔️✔️
Virtual keys (model allowlist, budget, RPM/TPM)✔️✔️✔️
Request logs & per-request detail✔️✔️✔️
Analytics (tokens, cost, latency, error rate)✔️✔️✔️
Fallback chains✔️✔️✔️
Response caching✔️✔️✔️
Content capture (per-account toggle)✔️✔️✔️
Streaming responses (SSE)✔️✔️✔️
Budget cap per virtual key✔️✔️✔️
Model allowlist per virtual key✔️✔️✔️
RPM / TPM limits per virtual key✔️✔️✔️
Metadata-only logging mode✔️✔️✔️
Overage beyond included requestsHard blockMetered, cappedMetered, capped
Overage rate$0.30 / 1,000 req$0.20 / 1,000 req

Gateway FAQ

The questions specific to the API. Account, BYOK, and billing questions live on the general FAQ page.

Yes — POST /v1/chat/completions (streaming and non-streaming) and GET /v1/models, with the same request and response shape the OpenAI SDKs already expect. Point the SDK's base URL at Tempr Gateway and use a virtual key in place of your OpenAI key.
The Free tier hard-blocks at 10,000 requests/month with an upgrade prompt. Pro and Scale keep serving past their allotment on metered overage, billed per 1,000 requests, until you hit your own configurable overage cap (default $50) — then it hard-blocks too, so a runaway script can't run up an open-ended bill.
Content capture is on by default (7-day retention on Free, longer on paid plans, truncated at 256 KB) so you have real request/response detail to debug against — but it's a per-account toggle, and metadata-only mode is always available if you'd rather nothing be stored.
Tempr Gateway never fronts provider keys or resells tokens — every request goes out on a key you supplied, at your provider's own rates. What you pay Tempr for is the gateway layer itself: virtual keys, logs, analytics, and quota management, priced by request volume.

Also on your account

Pair the Gateway with the same agent where you actually write code — one login covers everything.