AI Gateway

One API, one key, every model.

Airelay speaks the OpenAI API, so any OpenAI-compatible SDK works unchanged. Behind it: 45 providers, 2,376 models, routing that survives outages, and a stack of AI plugins you switch on from the dashboard.

Get started free Quickstart

Bring your own keys — your provider bills you

Connect your own provider accounts. Each provider charges you directly at its own price; Airelay meters each request and adds a flat 4% on that cost. No wallet to top up, no resold tokens.

Encrypted, or in your own Vault

Keys are encrypted at rest in Airelay, or kept in your organisation's own Noviqent Vault space and resolved only when a request needs them.

Never stored in the gateway engine

For most providers the credential is injected per request rather than written into the routing engine's configuration. How keys are handled →

Gateway keys for your apps

Your apps authenticate with Airelay gateway keys you issue and revoke from the dashboard — your provider keys never ship inside an app.

Routing policies

Create a policy from the dashboard and call it like a model. 7 strategies, mix any providers you've connected:

request.json

{
  "model": "policy/primary-with-backup",
  "messages": [{ "role": "user", "content": "Summarise this contract" }]
}

# policy/primary-with-backup  (type: fallback)
#   1. anthropic/claude-3-5-sonnet   retries: 1
#   2. openai/gpt-4o                 retries: 1
#   3. groq/llama-3.3-70b-versatile  retries: 0

Fallback chain
An ordered list of models — if one is rate-limited, erroring, timing out or returns nothing usable, the next one takes the request.
Weighted load balancing
Split traffic across models or accounts by weight — most to a cheaper model, a slice to a stronger one.
Lowest latency
Send each request to whichever entry has been answering fastest recently.
Lowest cost
Pick the cheapest entry for the request, using per-model token prices from the catalog.
Lowest usage
Spread load to whichever entry has handled the least traffic, to stay under per-key rate limits.
Priority tiers
Prefer a top tier and only drop to the next tier when every entry above it is unavailable.
Semantic routing
Describe what each entry is good at; each prompt is routed to the entry whose description best matches its meaning.

Detecting “unavailable”

A rate limit or a 500 is easy to catch. A provider that returns 200 with nothing useful isn't — here's what Airelay does about each.

Per-key circuit breaker

After a few consecutive failures a provider key is skipped for a cooldown that backs off the longer failures continue — instead of every request rediscovering the outage.

Structural failure detection

A response with no completion choices at all counts as a failure and triggers fallback — deliberately narrow, so a short or tool-call-only answer is never mistaken for a broken one.

Response feedback API

Every response carries an X-Airelay-Request-Id. If your app decides an answer was unhelpful, POST /v1/feedback with it — the same circuit breaker treats a provider that keeps producing bad answers like one that's down.

AI Guardrails & Plugins

Policy you switch on, not code you write

14 AI plugins you enable for your whole organisation, or attach to specific routes. They run inside the gateway on every matching request — your application code doesn't change.

PII redaction — with UK identifiers

Detect and replace personal data before a prompt leaves your organisation: names, emails, card numbers and more, plus UK-specific identifiers — National Insurance number, UK postcode, Bank sort code, NHS number, UK phone number. Choose placeholder, redact or mask, and optionally restore the original values in the response (restore mappings expire after 1 hour).

Semantic cache

Answer repeat and near-duplicate prompts from cache by meaning, not exact text — set the similarity threshold and TTL, see hit rates, and clear the cache from the dashboard.

Semantic prompt guard

Describe the topics you allow and the ones you don't. Prompts are compared by meaning, so a rephrased jailbreak or an off-topic request is caught without a brittle keyword list.

Semantic response guard

The same meaning-based allow/deny check applied to what the model says back — stop a response that drifts into a topic you've ruled out before it reaches your user.

Third-party guardrails

Call the content-safety service you already trust on input, output or both — AWS Bedrock Guardrails, Azure AI Content Safety, Google Model Armor, Lakera Guard, or your own guardrail endpoint.

RAG injection

Upload documents to a collection and relevant passages are retrieved and added to the prompt automatically — grounding answers in your own content without building a retrieval pipeline.

Prompt compression

Trim long conversation histories towards a target ratio while keeping the most recent turns intact — fewer input tokens on long-running chats.

Token & cost budgets

Rate-limit by requests, tokens or cost per time window — per consumer, route or model — so one runaway script can't burn through a month's budget in an afternoon.

LLM-as-judge quality scoring

Sample responses and have a judge model score them, so you can track answer quality over time alongside latency and cost.

Prompt templates & decorators

Keep system prompts and reusable templates in the gateway, and prepend or append instructions to every request — change them centrally without redeploying your apps.

Request & response transformation

Reshape AI requests and responses in flight — add fields, rewrite content, or normalise output for downstream systems.

Keyword prompt guard

For the simple cases: allow or deny prompts matching patterns you define, evaluated before anything is sent to a provider.

Designed to fail safe for your users

Guards and helpers fail open on a timeout by default, so a slow check never takes your app down — switch any guard to fail closed when blocking matters more than availability.
Blocked or rate-limited requests are clearly marked in the response headers and in your request log, so you can see which plugin stopped them.
Semantic cache hits are flagged per response, and hit rate is tracked in analytics.

Try it without a key

A curated set of models with a genuine no-cost provider tier works the moment you sign up — no provider key, no card — up to 20 requests per organisation per day.

google/gemini-2.0-flash
google/gemini-1.5-flash
groq/llama-3.1-8b-instant
groq/llama-3.3-70b-versatile
mistral/mistral-small-latest

Connect your own key any time for full model access and your provider's own limits.

45 providers, 2,376 models

Search the model catalog by provider, price, context window and data residency from the dashboard. Providers include:

OpenAI
Anthropic
Google Gemini
Google Vertex AI
Azure OpenAI
AWS Bedrock
Mistral
Cohere
Groq
Together AI
DeepSeek
xAI
Perplexity
Hugging Face
IBM watsonx
Cerebras
SambaNova
Fireworks AI
DeepInfra
AI21
Nvidia NIM
Databricks
Cloudflare Workers AI
Replicate

Swap one base URL. Keep answering.

Free to sign up, no card needed to try the free models. Connect your own provider keys whenever you're ready.

Get started free Read the quickstart