Your control plane
for AI traffic
Route, observe, and govern AI requests across providers from one proxy. Complete visibility without rebuilding your stack.
Overview
Control Surface
Operational Metrics
Last 24h ▾12.4
1,789 total
0.8%
14 failures
1.24s
Within target
$0.004
$0.10 total
Provider Execution
| Provider | Requests | Avg Latency | Success | Status |
|---|---|---|---|---|
| OpenAI | 1,234 | 890ms | 99.2% | Healthy |
| Anthropic | 412 | 1.1s | 98.8% | Healthy |
| Groq | 143 | 234ms | 100% | Healthy |
The problem
AI traffic is invisible by default
Most teams ship AI features and then lose sight of them. Costs accumulate, failures hide, and routing is hard-coded. There is no control plane.
Costs that appear without warning
AI costs compound across models and features with no central view. By the time you notice a spike, it has already happened.
Traffic you cannot see or control
Which feature is sending the most tokens? Which model is failing silently? Without observability, these questions go unanswered.
Providers with no fallback path
A provider outage or latency spike becomes a feature outage. Teams patch it manually, every time.
Routing decisions buried in application code
Every model swap or feature-level override is a code change and a deployment. There is no runtime control.
Capabilities
One proxy. Complete control.
Lectr sits in front of your AI providers and gives you routing, visibility, cost management, and policy enforcement — without changing how your application works.
Route traffic by feature, task, and provider
Define routing rules in the dashboard. Send cost-sensitive features to smaller models, route latency-critical paths to faster providers, and set priorities — all without touching application code.
Conditions: feature tag · task type · provider · model · priority ordering
See every request, model, and provider in real time
Full request log with model, latency, token usage, cost estimate, and status — with streaming support. Drill into any request. Understand traffic distribution across providers and features instantly.
Metrics: req/min · P95 latency · error rate · cost/hr · token usage
Track and control spending per feature and model
Cost is broken down by feature tag, model, and provider. Set soft and hard budget caps. When a threshold is hit, Lectr can automatically fall back to a cheaper model instead of cutting traffic.
Budget policies · spend alerts · model-level breakdown · CSV export
Surface unusual behavior before it becomes an incident
Lectr automatically detects anomalies in request volume, error rates, latency, and cost patterns. Review, dismiss, or investigate — with a full feed of what changed and when.
Automated detection · dismiss workflow · baseline learning
Set limits that protect against runaway spend
Define per-org and per-feature budget policies with soft and hard caps. Set P95 latency targets per org. Rate limits are enforced via Redis, shared across all proxy instances.
Hard caps · soft caps · latency targets · rate limiting · per-org enforcement
How it works
Ship in minutes. Not months.
Lectr is designed for teams that move fast. Getting started is a one-line change. Everything else builds from there.
Point your app at Lectr
Change one line in your OpenAI client config. Set the base URL to your Lectr proxy endpoint and add your org key header. No SDK changes, no rewrites.
Tag requests by feature
Add an optional X-Lectr-Feature header to group requests. Traffic from your chat feature, summarization pipeline, and embeddings are tracked and billed separately from day one.
See everything. Control everything.
Open the dashboard. Every request is logged. Provider health is live. Costs are broken down by feature and model. Set routing rules, budget limits, and fallback strategies without redeploying.
Integration
One line to get started
Change the base URL. Add your org key. That is the entire integration. Your existing code keeps working exactly as before.
from openai import OpenAI
client = OpenAI(
api_key="sk-your-key",
)
resp = client.chat.completions.create(
model="gpt-4o-mini",
messages=[...],
)from openai import OpenAI
client = OpenAI(
base_url="https://proxy.lectr.ai/v1",
api_key="sk-your-key",
default_headers={
"X-Lectr-Key": "lc_your-org-key",
"X-Lectr-Feature": "chat" # optional
}
)Why Lectr
Built for serious teams
Lectr is designed to be infrastructure you depend on, not a dashboard you check occasionally. It is positioned to grow with your system as your AI usage matures.
Not just a logger
Most AI observability tools are passive. They record what happened. Lectr gives you routing rules, budget policies, and fallback strategies you can change at runtime — without a redeployment.
Works across providers
OpenAI, Anthropic, Groq, Gemini, Azure — Lectr routes across them all through a single OpenAI-compatible endpoint. Swap providers or distribute load without changing application code.
Control without rebuilding
Lectr is a transparent proxy. It sits between your application and your providers. Your existing code stays exactly as it is. You gain observability and control without an architectural rewrite.
Privacy by design
Lectr captures metadata only — model, latency, token counts, cost estimates, and error codes. No prompts, no responses, no raw request bodies are ever stored. Your data stays yours.
Lectr is built on a clear progression: visibility gives you data, understanding tells you what it means, and control lets you act on it. Each layer earns the right to the next.
Start controlling your AI traffic
Get full visibility over every request, provider, and cost. Set routing rules and budget limits from the dashboard — no redeploy required.