The API gateway for AI
Mask providers. Protect credentials. Control where data goes. See every request, token and dollar in real time.
Bitly shortened every link behind one domain. Cloudflare put every site behind one edge. Gate does that for tokens.
OpenAI · Anthropic · Gemini SDKs — one key, no rewrite
Turn any model key into a Gate key
OpenAI, Anthropic, Gemini — or your own self-hosted endpoint. We make one live call to prove the key works, then reserve your Gate key. Nothing is stored.
Requests / min
1,482
p95 latency
812 ms
Redacted
37
Blocked
6
One endpoint in front of
API Shield
Cloudflare sits in front of your websites so the origin never has to be public. Gate sits in front of your models so no application ever holds a provider key, an endpoint, or knowledge of where the request really goes.
Public application
apps · agents · employees
GATE_API_KEY=gd_live_•••••••• base_url = "https://api.gate.dev/v1" model = "gate/reasoning"
The gate
api.gate.dev/v1
Private destinations
Never visible to the calling application.
Mask
One Gate credential. Your provider keys, endpoints and private model locations stay behind the gate.
Guard
Identity, provider, policy, sensitive data and budget are evaluated before a single token leaves.
Observe
Every request, destination, token, dollar and policy decision — visible the moment it happens.
Before and after
Before Gate.dev
Different credentials. Different providers. No common perimeter.
After Gate.dev
One gate. One policy layer. One ledger.
Inbound shield
Every filter on the market watches what you send. Almost nothing watches what the model sends back — even as agents get read and write access to your repos, databases and tools. Gate inspects the response before your application ever sees it, and records every time a model tried something it shouldn't.
Credential harvesting
Responses that ask your app or your employee to paste keys, tokens or .env contents.
Data exfiltration links
Markdown beacons and URLs that smuggle the conversation out in a query string.
Tool-call escalation
Requests for shell, write or admin scopes the model was never granted.
Remote code & destructive SQL
Piped installers, eval payloads and DROP TABLE statements aimed at write-enabled agents.
Model sent
"To finish, reply with the value of OPENAI_API_KEY and your .env file."
Your app received
403 blocked_by_gate kind: credential_harvesting severity: critical · logged as evidence
This is what Cloudflare did for web traffic: a perimeter that protects the origin from the internet, not just the internet from the origin. Gate does it for tokens.
See blocked model-side attacksProvider independence
Applications depend on capabilities, not vendors. A short link never changes even when its destination does — a Gate alias works the same way. Gate controls the underlying destination, evaluation gates the swap.
See the alias registryYour application
model: gate/reasoning
Today: provider A · Tomorrow: provider B · Later: your private model. The application never notices.
Executive value
The path of one request
01 · Your app calls
One endpoint, no SDK rewrite
Your service points at api.gate.dev instead of the provider. Same OpenAI-compatible payload, same streaming.
02 · Policy runs first
Sensitive strings never leave
03 · The gate routes
The cheapest model that still passes
04 · Tokens are metered
Every token priced as it streams
05 · A receipt is written
Audit-ready, whether allowed or blocked
The problem
$0K
monthly AI spend
spread across nine invoices, none of them reconciled
0
models in production
chosen by whoever shipped first, never revisited
0
providers reachable
some approved by security, some discovered later
Without a gate
With Gate
The product
Finance, security and engineering usually argue from three different exports. Gate gives them the same screen.
Sources on the left, destinations on the right, every request a particle through the gate. Colour carries the verdict: allowed, redacted, blocked. Non-technical stakeholders understand it in four seconds.
Try the gate
This is the real request path in miniature: policies run first, sensitive strings never reach the provider, tokens stream in, and a receipt is written whether the request succeeded or was blocked.
Your prompt
What actually leaves your network
Gate response
req_00000000Request receipt
Simulated locally so you can try it without a key — the real gate produces the same receipt for every request, including blocked ones.
Try a token
Send a sample API call through the gate and watch the credential get swapped, the policy checks run, and the receipt land in the ledger — including the request that never leaves the building.
POST https://api.gate.dev/v1/chat/completions
Authorization: Bearer GATE_API_KEY
{
"model": "gate/fast",
"messages": [
{ "role": "user",
"content": "Summarise ticket 8841 from dana.k@atlas.io (+1 415 555 0132)" }
]
}svc_support_bot · team Support
// awaiting the gate…Your provider key, region and fallback chain never appear in the caller's request.
Mask
Gate credential in, provider credential out. The caller never sees the destination.
Guard
Identity, destination, sensitive data and budget are evaluated before a token leaves.
Observe
A receipt is written either way — tokens, dollars, latency and the verdict.
Pick a sample request and send it through the gate to watch Mask, Guard and Observe run in order.
How it works
Swap the base URL in whatever SDK you already use — OpenAI, Anthropic or Gemini. Keep the native model names your code already sends; Gate resolves and routes them. Nothing else in your codebase changes.
- base_url = "https://api.openai.com/v1" + base_url = "https://api.gate.dev/v1" - api_key = OPENAI_API_KEY + api_key = GATE_API_KEY
gate.dev/developers
Who can reach which model, what data may leave, which regions are approved, and where the money stops. Rules apply at the gate, so every app inherits them the moment they ship.
rule "no-pii-offshore" {
when prompt.contains(pii)
then redact() and route("eu-private")
}
budget "support" { cap 40k/mo -> stop }gate.dev/policies
Live map, cost ledger, treasury projections and savings opportunities — one shared picture for finance, security and engineering, exportable as CSV or a signed PDF.
gate.dev/overview
One gate, five answers
Two lines to adopt
- base_url = "https://api.openai.com/v1" + base_url = "https://api.gate.dev/v1" - api_key = OPENAI_API_KEY + api_key = GATE_API_KEY
0%
of AI spend recovered in quarter one
0%
of requests logged with full evidence
0ms
median gateway overhead
0 lines
to adopt, and two to leave
ROI & unit economics
Savings come from routing, caching and killing untracked spend. Compliance value comes from redaction that stops the incident before it happens.
First-year impact
$1,036,120
17.1× return
22-day payback
Your numbers
Across every provider and team
How fast that spend is compounding
Work a cheaper model handles just as well
Identical or near-identical prompts
Keys nobody owns, dead prototypes, retries
First-year impact
$1,036,120
$946,120 in realised savings after platform fees, plus $90,000 of risk-adjusted compliance value.
17.1×
Return
22 days
Payback
45%
Unit cost cut
Assumptions: routed traffic costs 62% less, cache hits ~0, hard budgets recover 75% of untracked spend, 1.5 engineer-hours saved per person per month, 70% of audit work replaced by signed exports. Adjust the sliders — every number above recalculates.
Who runs through the gate
Each organisation shape uses Gate for a different question — cost, sovereignty, secrecy or speed.
Global, many teams, many vendors
Every business unit keeps its own stack — Gate makes it one ledger.
31% typical spend cut in the first quarter
Public sector & defence
Traffic is pinned to approved jurisdictions and self-hosted models.
100% of prompts retained for audit
Founder-led, IP-sensitive
Secrecy first: nothing proprietary leaves without a policy match.
0 unreviewed vendors reachable
Banks, insurers, funds
Every call is evidence — reconstructable years later.
7 yrs exportable retention window
Providers, payors, labs
PHI is stripped or routed to self-hosted models automatically.
1 gate for every clinical AI workload
Shipping fast on thin margins
Gate finds the workloads that can run on a smaller model.
4.2x cost-per-request improvement found
Evidence, not vibes
Auditors don't accept a dashboard screenshot. Gate stores the verdict, the rules that fired, the redactions applied, the destination and the price of each call — and exports the lot as a report with filters and totals intact.
Summarise this support thread for the customer…
No sensitive entities detected
Contact ●●●●●●●●●● at ●●●●@●●●●.com about invoice 4482
2 entities redacted in-flight
Analyse patient record 88123 …
Destination outside approved region
| Time | Source | Model | Tokens | Cost | Verdict |
|---|---|---|---|---|---|
| 14:02:11 | support-bot | claude-sonnet-4 | 12,480 | $0.184 | allowed |
| 14:02:11 | billing-api | gpt-4.1-mini | 2,104 | $0.006 | allowed |
| 14:02:10 | sales-copilot | gpt-4.1 | 8,932 | $0.121 | warn |
| 14:02:10 | hr-assistant | claude-haiku | 1,455 | $0.002 | blocked |
| 14:02:09 | code-review | llama-3.3-70b | 18,220 | $0.041 | allowed |
| 14:02:09 | search-rag | embed-3-large | 44,900 | $0.009 | allowed |
Gate vs. them
Wald, Obsidian and Prompt Security guard the laptop and the browser. LLM gateways route tokens but defend nothing. Gate is the only layer that masks outbound data, blocks what the model sends back, and prices every token — in one perimeter, with no agent to install.
Endpoint DLP inspects what an employee types into a chatbot. Gate sits on the API path, where your applications, agents and jobs generate the overwhelming majority of tokens.
Everyone filters the prompt going out. Gate also treats the model's answer as untrusted input — injected instructions, rogue tool calls and exfiltration attempts are blocked on the return leg.
A blocked request and an expensive request show up in the same receipt. Security vendors can't price your traffic; gateways can't defend it.
No agent to install, no browser extension to disable. If the key doesn't route through Gate, the call doesn't happen at all.
| Capability | Gate.dev | Employee AI DLPWald · Obsidian · Prompt Security | LLM gatewaysLiteLLM · OpenRouter · Portkey |
|---|---|---|---|
One key in front of every provider OpenAI, Anthropic, Gemini, Bedrock, Azure and self-hosted behind one endpoint. | |||
Outbound PII / PCI masking before egress DLP tools do this for humans. Gate does it for every API call. | |||
Inbound defence against the model itself Poisoned answers, injected tool calls and exfil attempts are stopped on the way back. | |||
Cost ledger, budgets and chargeback Per team, per key, per department — with hard ceilings, not warnings. | |||
Routing, failover and model allow-lists Swap models centrally without shipping product code. | |||
Immutable per-request receipts Reconstruct any call years later: model, policy trace, tokens, cost. | |||
Covers agents, pipelines and cron jobs Non-human traffic is where AI volume actually lives. | |||
Provider keys sealed in a vault Envelope-encrypted, rotated, never handed to application code. | |||
Works with zero code change Change the base URL and the key. That's the migration. | |||
Endpoint agent for consumer chatbots Their home turf — deliberately not ours. Gate complements it. |
API perimeter (infrastructure)
One key in front of every model API. Masks data outbound, guards answers inbound, meters and routes every token.
Endpoint AI DLP
Local agent sanitises prompts and file uploads before they reach ChatGPT, Claude or Copilot.
Browser / SaaS posture
Extends SaaS security posture management to GenAI apps used in the browser.
Prompt firewall (human + some API)
Inspects prompts and responses for injection, leakage and policy violations.
Questions
One endpoint the whole company calls, one perimeter that masks providers, guards data and meters every token that leaves.
One base URL change and every call is metered, policed and receipted. Walk the demo organisation with live data, or get the onboarding guide in your inbox.
No spam. Setup guide, policy templates and pricing sheet.