AnuraGate Documentation

AnuraGate is a unified AI gateway that sits between your app and every AI provider. Use a single base URL and virtual key to access OpenAI, Anthropic, Google, and more — while AnuraGate automatically enforces security, controls costs, and logs everything.

AI agents can leak PII, run up bills, get stuck in loops, or produce harmful outputs. AnuraGate gives you PII redaction, spend caps, circuit breakers, policy firewalls, and AI-powered audits — all without changing your code. Just swap the base URL.

# Replace your base URL — one key, any model
BASE_URL=https://anuragate.com/v1

# OpenAI
curl $BASE_URL/chat/completions \
  -H "Authorization: Bearer gk_your_virtual_key" \
  -H "Content-Type: application/json" \
  -d '{"model":"gpt-4o","messages":[{"role":"user","content":"Hello"}]}'

# Anthropic
curl $BASE_URL/chat/completions \
  -H "Authorization: Bearer gk_your_virtual_key" \
  -H "Content-Type: application/json" \
  -d '{"model":"claude-sonnet-4-20250514","messages":[{"role":"user","content":"Hello"}]}'

# Google
curl $BASE_URL/chat/completions \
  -H "Authorization: Bearer gk_your_virtual_key" \
  -H "Content-Type: application/json" \
  -d '{"model":"gemini-2.5-pro","messages":[{"role":"user","content":"Hello"}]}'

Examples

Ready-to-run example apps covering Watcher integrations, security features, and the Financial Gateway. Each example is a self-contained Node.js script with a .env.example and step-by-step README — clone, fill in your keys, and run.

Request Headers

Headers you can send with your proxy requests to control AnuraGate behavior.

Response Headers

Headers AnuraGate adds to every proxy response.

Error Codes

AnuraGate returns standard HTTP status codes with structured error bodies.

{
  "error": {
    "message": "Daily spend limit exceeded for this key",
    "type": "gate_error",
    "code": "budget_exceeded"
  }
}

Webhook Events

Configure a webhook URL in your dashboard to receive real-time notifications. Pro and Enterprise plans only.

POST https://your-webhook.example.com/gate
Content-Type: application/json

{
  "event": "budget.alert",
  "teamId": "org_abc123",
  "keyName": "my-key",
  "data": {
    "currentSpend": 4.12,
    "dailyLimit": 5.00,
    "percentUsed": 82.4
  },
  "timestamp": "2026-02-18T10:30:00.000Z"
}

Financial Gateway events (finance.*) are documented in the Financial Gateway section below.

Snapshot Protocol

Git snapshots capture your codebase state at the moment of each AI request. Configure a snapshot endpoint URL in your virtual key settings.

Request (from AnuraGate to your endpoint)

POST https://your-snapshot-endpoint.example.com/snapshot
Content-Type: application/json

{
  "action": "snapshot",
  "virtualKey": "my-key",
  "sessionId": "sess_abc123",
  "model": "gpt-4o",
  "timestamp": "2026-02-18T10:30:00.000Z"
}

Expected Response

{
  "snapshotId": "snap_abc123",
  "commitHash": "a1b2c3d4",
  "branch": "main",
  "diffSummary": "+42 -15 across 3 files"
}

Your endpoint should create a git stash or commit, then return the snapshot metadata. AnuraGate will store the snapshot ID in the request log and include it in the x-gate-snapshot-id response header.

Audit Headers

When double-check AI runs, these headers are added to the response.

Blocking vs. Async Mode

In async mode, the audit runs in the background after the response is sent. The audit headers will still be present but the response is never blocked. In blocking mode, AnuraGate waits for the audit to complete before returning the response. If the audit fails (risk = high or critical), the response is replaced with an HTTP 451 error.

Performance

AnuraGate includes latency headers, connection reuse, session-based key pinning, and provider-level prompt caching to minimize overhead for latency-sensitive workloads like real-time chat agents.

Gate Metadata

Every response includes a gate object with performance metrics, cost, and cache statistics.

Non-streaming responses

The gate object is added to the JSON response body alongside the standard OpenAI fields:

{
  "id": "chatcmpl-...",
  "choices": [...],
  "usage": {
    "prompt_tokens": 120,
    "completion_tokens": 35,
    "total_tokens": 155
  },
  "gate": {
    "provider": "openai",
    "upstream_ms": 432,
    "overhead_ms": 18,
    "cost": 0.0023,
    "cached_tokens": 80,
    "cache_creation_tokens": 0,
    "session_id": "agent-session-42",
    "session_cost": 0.0150,
    "session_requests": 5
  }
}

Streaming responses

A custom event: gate SSE event is emitted after data: [DONE] with the same fields. First-token timing is also sent as an SSE comment before the first content chunk. Standard SSE parsers ignore comments, so this is fully backwards-compatible.

: x-gate-first-token-ms=523

data: {"id":"chatcmpl-...","choices":[{"delta":{"content":"Hello"}}]}

data: [DONE]

event: gate
data: {"provider":"openai","upstream_ms":432,"overhead_ms":18,"first_token_ms":523,"cost":0.0023,"usage":{"prompt_tokens":120,"completion_tokens":35,"total_tokens":155,"cached_tokens":80,"cache_creation_tokens":0}}

Parsing the gate event (JavaScript)

const source = new EventSource(url);

// Normal chunks arrive as "message" events
source.onmessage = (e) => { /* handle content chunks */ };

// Gate metadata arrives as a custom "gate" event
source.addEventListener("gate", (e) => {
  const gate = JSON.parse(e.data);
  console.log(gate.upstream_ms);    // 432
  console.log(gate.cost);           // 0.0023
  console.log(gate.usage);          // { prompt_tokens, cached_tokens, ... }
});

Latency Headers

The same timing values are also available as response headers for simpler integrations:

Session Key Pinning

When you send an x-gate-session header, AnuraGate pins subsequent requests in that session to the same upstream API key. This maximizes provider-side prompt cache hits (e.g. OpenAI's automatic caching) when you make multiple sequential calls with the same prompt prefix.

# All requests in the same session use the same upstream key
curl $BASE_URL/chat/completions \
  -H "Authorization: Bearer gk_your_key" \
  -H "x-gate-session: agent-session-42" \
  -d '{"model":"gpt-4o","messages":[...]}'

Prompt Caching

Prompt caching is opt-in. Enable it on your virtual key via the dashboard (Key Settings → Prompt Caching toggle). Once enabled, AnuraGate automatically leverages each provider's native caching mechanism to reduce latency and cost when your agent sends the same system prompt or conversation prefix repeatedly. No code changes are required — just flip the toggle.

Connection Reuse

AnuraGate maintains persistent HTTP connections to upstream providers, eliminating TLS handshake overhead (~100-200ms) on sequential requests. This is especially impactful for agent workflows that make 3+ calls per user message. Connection pooling is automatic and requires no configuration.

Presets API

Apply one-click security presets to configure all your keys at once.

Apply a Preset

POST /api/dashboard/security/presets
Content-Type: application/json
Cookie: (Clerk session)

{
  "presetId": "standard",
  "keys": ["my-key-1", "my-key-2"]  // optional — omit for all keys
}

// Response
{
  "success": true,
  "presetId": "standard",
  "applied": 5,
  "skipped": 0,
  "errors": []
}

Watcher SDK

The AnuraGate Watcher SDK (@gate/watcher) is a self-hosted package that connects third-party services (WhatsApp Web, Telegram, etc.) to AnuraGate. Session tokens stay on your machine — AnuraGate never stores credentials. You can use it as a CLI tool or embed it directly into your Node.js application with a plug-and-play UI widget.

1. Create an Integration

Go to the AnuraGate Dashboard → Integrations and create a new integration. Select your tool (e.g. WhatsApp Web, Telegram, or Jira) and Watcher as the mode. You will receive an integrationId and your existing virtual key (gk-…) is used to authenticate.

2. Install the SDK

npm install @gate/watcher

3. Backend Setup (Node.js)

Add the watcher to your existing Express / HTTP server. This is all the server-side code you need — five lines:

const express = require("express");
const { GateWatcher, widgetMiddleware } = require("@gate/watcher");

const app = express();

// Serve the widget JS from the SDK
app.use(widgetMiddleware());

// Create the watcher
const watcher = new GateWatcher({
  gateKey:        "gk-your-virtual-key",
  integrationId:  "ti_your-integration-id",
});

// Start the server, then attach the watcher
const server = app.listen(3000);
watcher.attach(server);

// Events (optional)
watcher.on("qr",    () => console.log("QR ready"));
watcher.on("ready", () => console.log("WhatsApp connected"));
watcher.on("message", (msg) => console.log("Message from", msg.from));

watcher.start();

4. Frontend Setup (Any Page)

Drop the widget into any page served by your Express app. No framework required — the SDK provides all styles and logic:

<div id="whatsapp"></div>
<script src="/gate-watcher/widget.js"></script>
<script>GateWatcher.mount('#whatsapp')</script>

This renders a card with a "Connect WhatsApp" button. Clicking it opens a modal with a QR code. Once scanned, the card updates to show the connected status.

5. Widget Options

GateWatcher.mount('#whatsapp', {
  wsPath: '/ws/whatsapp',   // WebSocket path (default)
  theme:  'light',          // 'light' or 'dark'
})

6. React Components

For React apps, import the customer-facing QR component or the full admin panel:

import { GateWatcherQR } from "@gate/watcher/react";

// Clean QR-only flow for end users
<GateWatcherQR
  wsUrl="ws://localhost:3000/ws/whatsapp"
  onReady={() => console.log("Connected!")}
/>

// Or the full admin panel with event feed
import { GateWatcherPanel } from "@gate/watcher/react";
<GateWatcherPanel wsUrl="ws://localhost:3000/ws/whatsapp" />

7. CLI Mode

For quick testing or headless environments, run the watcher from the command line. Create a .env file and run:

# .env
GATE_KEY=gk-your-virtual-key
GATE_INTEGRATION_ID=ti_your-integration-id

# Run
npx @gate/watcher

The QR code will be displayed in the terminal. Set WEB_PORT=3001 in your .env to also launch a local web panel for scanning.

How It Works