API Documentation

AnuraGate is an OpenAI-compatible proxy. Point your existing SDK at AnuraGate and all requests are routed, secured, and tracked automatically.

# Replace your base URL — that's it
OPENAI_BASE_URL=https://your-gate-instance.vercel.app/v1

# Or use curl directly
curl https://your-gate-instance.vercel.app/v1/chat/completions \
  -H "Authorization: Bearer gk_your_virtual_key" \
  -H "Content-Type: application/json" \
  -d '{"model":"gpt-4o","messages":[{"role":"user","content":"Hello"}]}'

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"
}

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.

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 (like WhatsApp Web) 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 WhatsApp Web as the tool 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