Provider Support
Every provider type, the gateway endpoints it serves, and the credentials it needs. Provider support is the same in the V1 and V2 consoles.
You add a provider to an app in Create App or in the app's LLM Providers section. In the V2 console you can also add it once in Settings > AI Gateway > Models and link it to many apps (see Providers and Models). Your code always authenticates with a Quilr key; provider credentials never leave the gateway.
Capability matrix
One row per provider type. The type is what you select in the console and what you pass as X-Provider-Name.
✓ means the provider serves that API natively. ↻ means the gateway reaches it from that API by any-to-any formats: an endpoint switch on the same credential, a built-in adapter, or two-way translation. Soon means coming soon.
- Gemini generateContent and Bedrock Converse / InvokeModel clients reach the same conversational providers. The format explorer shows how each client format reaches each provider, model by model.
- Chat on
vertex_aiand theanthropic_messages*types uses the built-in adapters described in Chat Completions adapters. - Speech on
mistralis transcription only. xAI and Mistral also serve the extra APIs in xAI and Mistral. Cerebras is described in Cerebras, Groq in Groq, Perplexity in Perplexity, Cohere in Cohere, and ElevenLabs in ElevenLabs. Speech oncohereis transcription only. bedrockalso serves native Bedrock Runtime calls from boto3.vertex_aialso serves the native Vertex AI routes.- Speech is text-to-speech and speech-to-text. Sarvam also serves translation, transliteration and language detection.
- Manual: enter Oracle model IDs yourself.
- Endpoint families: moderations, images, completions (FIM), files, batches and videos are served for several of these types. See Endpoint families. Mistral, xAI and Cohere also have vendor routes (Mistral and xAI, Cohere).
azureopenaialso serves Microsoft-Decision-1 deployments on the decision routes,perplexityserves itspplx-decidermodels there, andtypesafeserves only those routes. See Decision models.azureopenaialso serves Mistral Document AI deployments on Azure AI Foundry for document OCR, and Claude deployments there useanthropic_messages_azure. See Azure AI Foundry models.- QuilrAI-provided models back an app through a
generalprovider with base URLhttps://models.quilrai.dev/v1. Direct integration is coming soon. See QuilrAI-Provided Models.
Endpoints
Combine a regional base URL with a path below.
Credentials by provider
Every provider also has a Provider label and a Models list. Field names in code font are the API names used by the Management APIs. The auth option value goes in auth_type (Vertex AI, Oracle) or aws_auth_mode (AWS).
Rules that apply to every app:
- Every Oracle provider also needs the OCI region (
oci_region) and Generative AI project OCID (oci_project_id).oraclealso needs the compartment OCID (oci_compartment_id); it is optional fororacle_responses. Oracle does not acceptbase_url; the endpoint comes from the region. - Fields from a different auth option are rejected (for example, AWS access keys with
assume_role). Switching the auth option removes the old option's credentials. - The Base URL and Azure API version overrides on Responses, Assistants, Realtime and rerank types are in the V1 console form. In the V2 console, set them through the Management APIs.
- Every model-serving provider needs at least one model. For Azure, the model ID is the deployment name.
- Labels may use letters, numbers, spaces,
_,.and-, and must be unique within the app.primaryis reserved. - The consoles accept each provider type once per app. The API accepts several providers of the same type under different labels; select one with
provider_label, sinceprovideralone is then ambiguous. quilr_sdkandcopilot_studioapps cannot add other providers.- For a Bedrock IAM role, see AWS Bedrock - Assume Role Setup.
- Credentials not listed here (Azure Entra ID or managed identity, AWS default chain or web identity, OpenAI organization or project headers, custom upstream headers) are not supported.
What the forms look like
Chat Completions
/openai_compatible/v1/chat/completions works with OpenAI SDKs and OpenAI-compatible wrappers. Providers that already speak the OpenAI format (OpenAI, Azure OpenAI, Anthropic OpenAI-compatible, DeepSeek, Gemini, xAI, Mistral, Cerebras, Groq, Oracle, Sarvam, custom endpoints) get the request natively. bedrock (native Bedrock chat or Converse), vertex_ai (Gemini generateContent) and the anthropic_messages* types use the built-in Chat Completions adapters; every other provider is reached through any-to-any formats.
Sarvam serves only its chat models here. Its speech and text models use the Sarvam routes.
Anthropic Messages
/anthropic_messages/v1/messages takes the native Anthropic request shape. Use it with the Anthropic SDKs and Claude Code. Served natively by anthropic_messages, anthropic_messages_bedrock, anthropic_messages_azure, anthropic and Claude models on bedrock; DeepSeek through its Anthropic-compatible endpoint. Every other conversational provider (for example GPT on Azure OpenAI) is reached through any-to-any formats.
AWS Bedrock Runtime (boto3)
Point a boto3 bedrock-runtime client at https://guardrails-usa-2.quilr.ai/bedrock-runtime (or your region) and sign with the Quilr key as both access key ID and secret. Paths: /model/{model_id}/converse, /converse-stream and /invoke (also under /bedrock-runtime/).
Converse and Claude-body InvokeModel requests can also reach providers that are not on Bedrock (for example a Mistral or OpenAI model on the same app); see any-to-any formats. Only Bedrock Runtime is proxied, not the Bedrock control plane or Agent Runtime. See AWS Bedrock - boto3 Runtime.
Vertex AI
/vertex_ai/ accepts generateContent requests for Gemini models on the app, including multimodal and image-output models. Guardrails scan request text. When attachment scanning is enabled, supported inline images and documents can also be inspected using OCR, document text extraction and the enabled Image Risks. Remote file references are not downloaded for scanning. Audio, video and non-text model outputs are not content-scanned by this feature.
Embeddings
/openai_compatible/v1/embeddings takes the OpenAI embeddings shape for openai, azureopenai, mistral (for example mistral-embed), perplexity (pplx-embed-v1-0.6b, pplx-embed-v1-4b; see Perplexity embeddings), cohere (embed-v4.0, embed-v5.0-pro, the v3 models; see Cohere), general and bedrock_embeddings (Titan and Cohere Embed on Bedrock).
Rerank
All three rerank paths take a Cohere-compatible body (model, query, documents, optional top_n, return_documents) and return a response in Cohere format. Guardrails scan query and documents. Responses are scores and indices, so they are not scanned. bedrock_rerank serves Cohere Rerank 3.5 and Amazon Rerank and uses the bedrock:InvokeModel permission. cohere and cohere_rerank are billed from Cohere's billed units: search units for Rerank 3 and 4, input tokens for Rerank 5.
TTS & STT
/openai_compatible/v1/audio/speech, /audio/transcriptions and /audio/translations work with openai, azureopenai, sarvam and groq (Whisper and Orpheus models; see Groq). elevenlabs serves /audio/speech and /audio/transcriptions (see ElevenLabs). mistral serves /audio/transcriptions only (Voxtral models, for example voxtral-mini-latest), and so does cohere (cohere-transcribe-03-2026; language is required). Azure deployments use the /openai/deployments/{deployment}/ prefix.
On a Sarvam provider these routes adapt to Sarvam's APIs:
Transcriptions accept response_format of json, verbose_json or text, and timestamp_granularities[]=segment. model is required.
These rules apply to every speech provider:
Sarvam Speech and Text
Native routes accept and return Sarvam's own formats. Auth: Authorization: Bearer, api-key or api-subscription-key, each with the Quilr key.
Chat models (sarvam-105b, sarvam-105b-conversations, and the beta glm5.2, gemma4, deepseekv4-flash) use the standard Chat Completions endpoint.
Responses API
/openai_responses/v1/responses is a native passthrough for openai, openai_responses, azureopenai, openai_responses_azure, xai_responses, oracle_responses, bedrock, groq, perplexity (its Agent API) and general endpoints that serve /responses; xai switches to xAI's Responses endpoint with the same key. Create, retrieve, cancel, delete and list input items are supported; Groq's Responses API is stateless and Perplexity's Agent API serves no stored-response routes, so groq and perplexity serve create only. Azure-style paths work too: /openai_responses/openai/deployments/{deployment}/responses. The deployment goes in body.model.
Guardrails scan input_text parts and instructions on the request, and output_text on non-streaming responses. On native providers, previous_response_id and built-in tools pass through.
Other providers (Claude on Anthropic, Bedrock or Azure AI Foundry, Gemini, Mistral, Cerebras, DeepSeek and more) are reached by translation. Stored state such as previous_response_id does not carry over, and hosted tools are dropped so the model answers without them; see Limits.
Azure AI Foundry models
An Azure AI Foundry resource can hold Azure OpenAI deployments and Foundry Models deployments from other vendors. They are served by two provider types:
Other Foundry Models deployments, such as Mistral chat models, are not listed or supported yet.
Add the provider
- In Azure AI Foundry, open the resource's deployment details page and copy the resource endpoint and key.
- For Azure OpenAI, Mistral Document AI and Microsoft-Decision-1 deployments, add an Azure › OpenAI chat provider (
azureopenai) with the endpoint and key. Click Check key and list models: the list includes the resource's deployments by deployment name, with their type. - For Claude, add an Azure › Anthropic messages provider (
anthropic_messages_azure) with the key and the Base URLhttps://<resource>.services.ai.azure.com, then enter each deployment name (for exampleclaude-opus-4-5). Azure does not list Claude deployments.
The deployment list is read on a best-effort basis. If a resource does not return it, the models from Azure OpenAI's catalog are still listed, and you can add other deployment names yourself.
Azure document OCR example
curl https://guardrails-usa-2.quilr.ai/openai_compatible/v1/ocr \
-H "Authorization: Bearer <Quilr key>" -H "Content-Type: application/json" \
-d '{"model": "mistral-document-ai-2512", "document": {"type": "document_url", "document_url": "data:application/pdf;base64,<base64 PDF>"}}'
model is the deployment name. The request and response are Mistral's OCR format.
Azure Foundry behavior
xAI and Mistral
xai and xai_responses call https://api.x.ai/v1; mistral calls https://api.mistral.ai/v1. Each takes one API key; the base URL is fixed by QuilrAI, and any base_url sent through the Management API is ignored.
Add the provider
- Open Settings > Models > Models and click Add your own models (the same picker appears when you create or edit an app).
- Search for
mistral,grokorxaiand select the Mistral AI or xAI tile. For xAI, choose Chat completions or Responses under Which API does the gateway talk to?. - Keep or edit the Provider label, paste the API key, click Check key and list models, then select the models and save. See Providers and Models.
Mistral lists models from /v1/models and sorts each into chat, embedding, moderation, OCR, transcription or FIM from its capability flags. xAI lists language models, plus image and video models your key can reach; xai_responses lists language models only. Enable every model you call, on every API.
Vendor routes
Each vendor's own APIs have their own route under /mistral/ or /xai/. These take and return the vendor's own request format, unchanged, and serve only that vendor's connections:
The shared endpoints serve them too:
Chat requests with PDF or file parts on an xai key go to xAI Responses, which reads them; Mistral receives them as document URLs. Files, batches and videos are off by default; see Endpoint Families.
xAI and Mistral examples
# xAI Responses with xAI's own web search tool
curl https://guardrails-usa-2.quilr.ai/xai/v1/responses \
-H "Authorization: Bearer <Quilr key>" -H "Content-Type: application/json" \
-d '{"model": "grok-4.20-0309-non-reasoning", "input": "What is new at xAI?", "tools": [{"type": "web_search"}]}'
# xAI image generation with xAI's own fields
curl https://guardrails-usa-2.quilr.ai/xai/v1/images/generations \
-H "Authorization: Bearer <Quilr key>" -H "Content-Type: application/json" \
-d '{"model": "grok-imagine-image", "prompt": "A plain white square.", "aspect_ratio": "16:9"}'
# Codestral fill-in-the-middle (Mistral's own request and response; streaming works too)
curl https://guardrails-usa-2.quilr.ai/mistral/v1/fim/completions \
-H "Authorization: Bearer <Quilr key>" -H "Content-Type: application/json" \
-d '{"model": "codestral-latest", "prompt": "def add(a, b):\n return", "suffix": "\n\nprint(add(1, 2))", "max_tokens": 32}'
# Mistral document OCR
curl https://guardrails-usa-2.quilr.ai/mistral/v1/ocr \
-H "Authorization: Bearer <Quilr key>" -H "Content-Type: application/json" \
-d '{"model": "mistral-ocr-latest", "document": {"type": "document_url", "document_url": "https://example.com/invoice.pdf"}}'
The OpenAI SDK works against the xAI route: set base_url to https://guardrails-usa-2.quilr.ai/xai/v1 and call client.responses.create(...) with your Quilr key.
Provider behavior
When a converted request reaches xAI or Mistral, the gateway adapts parameters the provider does not accept (for example, Mistral's random_seed for seed; unsupported penalties and logit_bias are dropped for xAI).
Guardrails, routing and limits
- Chat, Responses (including
/xai/v1/responses), embeddings and transcription get the same guardrails as any other provider. - OCR, FIM, images, moderation, files, batches and videos are not scanned by DLP, on the vendor routes as on the shared ones. Access controls, model allow-lists, rate and token limits and quotas apply. See Endpoint Families.
- A vendor route serves only its vendor's connections. On an app with several providers it picks the vendor's connection for the model; another provider is refused with
400(unsupported_provider_for_<family>, orprovider_not_supported_on_routeon/xai/v1/responses). - Routing groups:
mistralandxaiare own-family members of Chat Completions groups;xai_responsesof OpenAI Responses groups. On/xai/v1/responses, group members of other provider types are skipped. See Routing and Fallbacks.
Cerebras
cerebras calls https://api.cerebras.ai/v1. It takes one API key; the base URL is fixed by QuilrAI, and any base_url sent through the Management API is ignored.
Add the provider
- Open Settings > Models > Models and click Add your own models (the same picker appears when you create or edit an app).
- Search for
cerebrasand select the Cerebras tile. - Keep or edit the Provider label, paste the API key, click Check key and list models, then select the models and save. See Providers and Models.
Cerebras lists models from /v1/models; every model is a chat model. Enable every model you call.
Cerebras examples
# Chat Completions (streaming and tool calls work too)
curl https://guardrails-usa-2.quilr.ai/openai_compatible/v1/chat/completions \
-H "Authorization: Bearer <Quilr key>" -H "Content-Type: application/json" \
-d '{"model": "gpt-oss-120b", "messages": [{"role": "user", "content": "Say hello."}], "max_completion_tokens": 256}'
# Legacy text completions
curl https://guardrails-usa-2.quilr.ai/openai_compatible/v1/completions \
-H "Authorization: Bearer <Quilr key>" -H "Content-Type: application/json" \
-d '{"model": "gpt-oss-120b", "prompt": "The capital of France is", "max_tokens": 16}'
# Anthropic Messages client, translated to Cerebras Chat Completions
curl https://guardrails-usa-2.quilr.ai/anthropic_messages/v1/messages \
-H "x-api-key: <Quilr key>" -H "Content-Type: application/json" \
-d '{"model": "gpt-oss-120b", "max_tokens": 256, "messages": [{"role": "user", "content": "Say hello."}]}'
Cerebras behavior
Groq
groq calls https://api.groq.com/openai/v1. It takes one API key; the base URL is fixed by QuilrAI, and any base_url sent through the Management API is ignored.
Add the provider
- Open Settings > Models > Models and click Add your own models (the same picker appears when you create or edit an app).
- Search for
groqand select the Groq tile. - Keep or edit the Provider label, paste the API key, click Check key and list models, then select the models and save. See Providers and Models.
Groq lists models from /models. Whisper models are listed as speech to text, Orpheus models as text to speech, and every other model as chat; inactive models are left out. Enable every model you call.
Groq examples
# Chat Completions (streaming and tool calls work too)
curl https://guardrails-usa-2.quilr.ai/openai_compatible/v1/chat/completions \
-H "Authorization: Bearer <Quilr key>" -H "Content-Type: application/json" \
-d '{"model": "openai/gpt-oss-20b", "messages": [{"role": "user", "content": "Say hello."}], "max_completion_tokens": 256}'
# Responses (Groq stores nothing: leave store unset or false)
curl https://guardrails-usa-2.quilr.ai/openai_responses/v1/responses \
-H "Authorization: Bearer <Quilr key>" -H "Content-Type: application/json" \
-d '{"model": "openai/gpt-oss-20b", "input": "Say hello."}'
# Speech to text
curl https://guardrails-usa-2.quilr.ai/openai_compatible/v1/audio/transcriptions \
-H "Authorization: Bearer <Quilr key>" \
-F model=whisper-large-v3-turbo -F file=@meeting.wav
# Text to speech (WAV)
curl https://guardrails-usa-2.quilr.ai/openai_compatible/v1/audio/speech \
-H "Authorization: Bearer <Quilr key>" -H "Content-Type: application/json" \
-d '{"model": "canopylabs/orpheus-v1-english", "voice": "autumn", "input": "Hello from Groq."}' \
--output hello.wav
Groq behavior
Perplexity
perplexity calls https://api.perplexity.ai. It takes one API key; the base URL is fixed by QuilrAI, and any base_url sent through the Management API is ignored. Perplexity's Agent API needs paid API credits on the Perplexity account (without them it answers 403 restricted_api_key).
Perplexity's older Sonar chat completions (/chat/completions with sonar, sonar-pro, sonar-reasoning-pro, sonar-deep-research) are closed to new Perplexity accounts ("Sonar is now the Agent API"), so the gateway serves every Perplexity model on the Agent API. Perplexity recommends perplexity/sonar or another Agent API model in their place.
Add the provider
- Open Settings > Models > Models and click Add your own models (the same picker appears when you create or edit an app).
- Search for
perplexityand select the Perplexity tile ("Web-grounded answers · Direct API"). - Keep or edit the Provider label, paste the API key, click Check key and list models, then select the models and save. See Providers and Models.
Perplexity lists its Agent API models from /v1/models (for example openai/gpt-6-luna, anthropic/claude-sonnet-5-5, perplexity/sonar); the gateway adds the decision models pplx-decider-latest, pplx-decider-flash-latest, pplx-decider-v1.2 and pplx-decider-flash-v1.2 and the embedding models pplx-embed-v1-0.6b and pplx-embed-v1-4b. Model validation sends one small request per model: a Responses call with no tools, a one-question decision request, or a one-word embedding. Enable every model you call.
Perplexity examples
# Responses on the Agent API, with Perplexity's web search tool
curl https://guardrails-usa-2.quilr.ai/openai_responses/v1/responses \
-H "Authorization: Bearer <Quilr key>" -H "Content-Type: application/json" \
-d '{"model": "openai/gpt-6-luna", "input": "What changed in the EU AI Act this month?",
"tools": [{"type": "web_search"}], "max_output_tokens": 800}'
# Chat Completions (translated to the Agent API; streaming and tool calls work too)
curl https://guardrails-usa-2.quilr.ai/openai_compatible/v1/chat/completions \
-H "Authorization: Bearer <Quilr key>" -H "Content-Type: application/json" \
-d '{"model": "perplexity/sonar", "messages": [{"role": "user", "content": "Say hello."}], "max_tokens": 256}'
Perplexity behavior
Perplexity embeddings
Perplexity's embedding models return quantized vectors only (base64_int8 or base64_binary), and they are not normalized; Perplexity recommends cosine similarity. The gateway serves them two ways:
dimensions is passed to Perplexity (128 up to the model's size: 1024 for pplx-embed-v1-0.6b, 2560 for pplx-embed-v1-4b). A request takes up to 512 non-empty texts. Int8 vectors are quantized, so floats decoded from them are close to, not identical with, full-precision embeddings. Input tokens are billed at $0.004 (0.6b) or $0.03 (4b) per 1M.
curl https://guardrails-usa-2.quilr.ai/openai_compatible/v1/embeddings \
-H "Authorization: Bearer <Quilr key>" -H "Content-Type: application/json" \
-d '{"model": "pplx-embed-v1-0.6b", "input": ["What is retrieval-augmented generation?"]}'
Cohere
cohere calls https://api.cohere.com. It takes one API key; the endpoint is fixed by QuilrAI, and any base_url sent through the Management API is ignored. Chat, OpenAI-shaped embeddings and transcription use Cohere's OpenAI-compatible API (https://api.cohere.com/compatibility/v1); rerank, Cohere-shaped embeddings and the Cohere routes use Cohere's own API.
Add the provider
- Open Settings > Models > Models and click Add your own models (the same picker appears when you create or edit an app).
- Select the Cohere tile ("Chat, embeddings & rerank · Direct API"), then Chat, embeddings & rerank.
- Keep or edit the Provider label, paste the API key, click Check key and list models, then select the models and save. See Providers and Models.
The gateway lists Cohere's models from its /v1/models, typed by what each model serves: chat, embedding, rerank, speech to text or parse. Validation sends a 3-token chat request for chat models and reads the model's own entry for the others. Cohere trial keys are rate limited and not licensed for production use.
Cohere examples
# Chat Completions (streaming and tool calls work too)
curl https://guardrails-usa-2.quilr.ai/openai_compatible/v1/chat/completions \
-H "Authorization: Bearer <Quilr key>" -H "Content-Type: application/json" \
-d '{"model": "command-a-03-2025", "messages": [{"role": "user", "content": "Say hello."}], "max_tokens": 256}'
# Cohere's own embed request, with int8 vectors
curl https://guardrails-usa-2.quilr.ai/cohere/v2/embed \
-H "Authorization: Bearer <Quilr key>" -H "Content-Type: application/json" \
-d '{"model": "embed-v4.0", "texts": ["What is retrieval-augmented generation?"],
"input_type": "search_document", "embedding_types": ["float", "int8"]}'
With the Cohere SDK, set the base URL to https://guardrails-usa-2.quilr.ai/cohere and the API key to your Quilr key.
Cohere behavior
Cohere routes
Cohere's own APIs, in Cohere's request and response format, for Cohere providers only. Point the Cohere SDK at https://guardrails-usa-2.quilr.ai/cohere.
Batch, embed-job and dataset ids belong to the Cohere account that created them, so later calls must use the same app. Cohere's raw model list and API key check are not exposed; the gateway's model list applies the app's model visibility.
ElevenLabs
elevenlabs calls https://api.elevenlabs.io for text to speech, speech to text and ElevenLabs' other generation APIs (see ElevenLabs routes). It takes one API key; the console always uses that endpoint. Through the Management API you can instead set base_url to one of ElevenLabs' own hosts (https://api.us.elevenlabs.io or the data-residency hosts https://api.eu.residency.elevenlabs.io, https://api.in.residency.elevenlabs.io, https://api.sg.residency.elevenlabs.io); any other value is refused. ElevenLabs serves speech only, so it has no chat or embeddings.
Add the provider
- Open Settings > Models > Models and click Add your own models (the same picker appears when you create or edit an app).
- Select the ElevenLabs tile ("Text to speech & speech to text"), then Speech.
- Keep or edit the Provider label, paste the API key, click Check key and list models, then select the models and save. See Providers and Models.
The gateway lists the text-to-speech models your key can use from ElevenLabs' /v1/models, plus the models ElevenLabs does not list there: the Scribe models (scribe_v3, scribe_v2, scribe_v2_medical, scribe_v1), eleven_text_to_sound_v2 (sound effects), music_v1 (music), eleven_multilingual_sts_v2 and eleven_english_sts_v2 (voice changer) eleven_multilingual_ttv_v2 (voice design) and elevenlabs-dubbing (dubbing). Select the ones the app may use. Validation reads that list, so checking a key generates no audio and costs nothing.
Every /elevenlabs/ route goes to the app's ElevenLabs provider; a model_id must be one of the app's models (otherwise 403 model_access_denied). When a request leaves model_id out, the model ElevenLabs uses by default is the one checked and sent: eleven_multilingual_v2 for speech, eleven_v3 for dialogue, eleven_text_to_sound_v2 for sound effects, music_v1 for music and eleven_english_sts_v2 for the voice changer. Voice design, previews, remix and saving a designed voice need eleven_multilingual_ttv_v2 among the app's models. Dubbing takes no model, so every dubbing route (create, list, get, delete, audio, transcript) needs elevenlabs-dubbing among the app's models: dubbing projects belong to the ElevenLabs account, so only apps you enable can create, read or delete them. Reading or deleting a stored transcript likewise needs one of the Scribe models among the app's models. Content-based policy rules see the text each route sends (the same fields guardrails scan), never a messages or input field the client adds. A form that sends model_id twice, or a part without a plain name="...", is refused with 400.
Text that leaves the gateway is scanned by guardrails in full: the text to speak and its previous_text / next_text, every dialogue line, sound and music prompts, music styles and lyrics (music_v1 sections and music_v2 chunks, including a plan's source plan), voice descriptions, alignment text and dubbing names. A blocked request answers 400; redacted text is what ElevenLabs receives. Stored transcripts (every channel and any transcript edit) and dubbing transcripts (JSON, SRT and WebVTT) are scanned before they are returned. Uploaded audio and video are forwarded unchanged and are not scanned. ElevenLabs refusals keep ElevenLabs' status and code, marked X-Quilr-Error-Source: upstream.
ElevenLabs examples
# Text to speech with the OpenAI SDK shape (voice is an ElevenLabs voice id)
curl https://guardrails-usa-2.quilr.ai/openai_compatible/v1/audio/speech \
-H "Authorization: Bearer <Quilr key>" -H "Content-Type: application/json" \
-d '{"model": "eleven_flash_v2_5", "input": "Hello from the gateway.", "voice": "JBFqnCBsd6RMkjVDRZzb", "response_format": "mp3"}' \
--output hello.mp3
# ElevenLabs' own streaming route: audio arrives as ElevenLabs produces it
curl "https://guardrails-usa-2.quilr.ai/elevenlabs/v1/text-to-speech/JBFqnCBsd6RMkjVDRZzb/stream?output_format=mp3_44100_128" \
-H "xi-api-key: <Quilr key>" -H "Content-Type: application/json" \
-d '{"text": "Hello from the gateway.", "model_id": "eleven_v3"}' --output hello.mp3
# Speech to text with word timings
curl https://guardrails-usa-2.quilr.ai/elevenlabs/v1/speech-to-text \
-H "xi-api-key: <Quilr key>" -F model_id=scribe_v2 -F file=@meeting.mp3
# Two-voice dialogue
curl https://guardrails-usa-2.quilr.ai/elevenlabs/v1/text-to-dialogue \
-H "xi-api-key: <Quilr key>" -H "Content-Type: application/json" \
-d '{"model_id": "eleven_v3", "inputs": [{"text": "Hi there.", "voice_id": "JBFqnCBsd6RMkjVDRZzb"}, {"text": "Hello!", "voice_id": "EXAVITQu4vr4xnSDxMaL"}]}' \
--output dialogue.mp3
# Sound effect from a prompt
curl https://guardrails-usa-2.quilr.ai/elevenlabs/v1/sound-generation \
-H "xi-api-key: <Quilr key>" -H "Content-Type: application/json" \
-d '{"text": "a short door knock", "duration_seconds": 1}' --output knock.mp3
With the ElevenLabs SDK, set the base URL to https://guardrails-usa-2.quilr.ai/elevenlabs and the API key to your Quilr key; the SDK's xi-api-key header carries it. xi-api-key is accepted on the /elevenlabs/ routes only; the OpenAI-shaped routes take Authorization: Bearer, api-key or x-api-key.
ElevenLabs behavior
ElevenLabs routes
ElevenLabs' own APIs, in ElevenLabs' request and response format, for ElevenLabs providers only. Point the ElevenLabs SDK at https://guardrails-usa-2.quilr.ai/elevenlabs. Every route below is on by default.
Stored transcripts, dubbings and designed voices belong to the ElevenLabs account that created them, so later calls must use the same app.
Endpoint families
Moderations, images, completions (including DeepSeek fill-in-the-middle), files, batches and videos are served under /openai_compatible/v1/ in the OpenAI shape for the providers that support them:
Mistral OCR and FIM, and xAI images, videos and batches, have their own vendor routes under /mistral/ and /xai/. These routes enforce access, model allow-lists and limits but are not scanned by guardrails. See Endpoint Families.
Decision models
Decision models answer typed questions about text or JSON with probabilities instead of generated text. Use them for classification, routing, ranking and yes/no gates. Three providers serve them:
Call any of them in either format:
The three question types:
Microsoft-Decision-1 on Azure
- In Azure AI Foundry, deploy Microsoft-Decision-1 under a name of your choice (Azure does not allow the name
Microsoft-Decision-1itself), for exampledecision-1. - Add an Azure provider (
azureopenai) with the resource endpoint and key from the deployment details page. Check key and list models lists the deployment as a decision model, or add its name yourself. Model validation checks it on the decision route, since the model has no chat route. - Send the deployment name as
model.
TypeSafe
typesafe calls https://api.typesafe.ai/v1. It takes one API key; the base URL is fixed by QuilrAI, and any base_url sent through the Management API is ignored. TypeSafe serves only decision models, so the provider is available on the decision routes and nowhere else.
- Open Settings > Models > Models and click Add your own models (the same picker appears when you create or edit an app).
- Search for
typesafeand select the TypeSafe tile ("Decision models · Direct API"). It has one API, System One. - Keep or edit the Provider label, paste the API key, click Check key and list models, then select the models and save. See Providers and Models.
TypeSafe lists the aliases jev-latest and jev-preview; the gateway also lists the versioned jev-1.14.0 and jev-1.13.0 so an app can pin a version. All four are decision models. Model validation sends a one-question System One request for each, which costs a few input tokens. Answers name the version that answered, for example jev-1.14.0 for jev-latest.
TypeSafe SDK: point the SDK at the gateway and use your Quilr key. Pass compression=False: the SDK compresses request bodies of 1 KB or more with zstd on Python 3.14 and later or with the typesafe-sdk[zstd] extra, and the gateway refuses zstd bodies with 415.
from typesafe_sdk import TypeSafeClient, Noul, Choice
client = TypeSafeClient(
api_key="<Quilr key>",
base_url="https://guardrails-usa-2.quilr.ai/typesafe",
model="jev-latest",
compression=False,
)
response = client.system_one(
state="I was charged twice for my plan. Please refund the duplicate charge.",
questions={
"refund": Noul(instructions="Is the customer asking for a refund?"),
"team": Choice(instructions="Which team should handle this ticket?",
criteria={"billing": "Charges and refunds", "engineering": "Bugs and outages"}),
},
)
print(response.answers["refund"].noul, response.answers["team"].choice)
print([model.name for model in client.models.list().models])
client.models.list() calls GET /typesafe/v1/models, which returns the decision models the app may use in TypeSafe's format. It is answered from the app's configuration, so release_date is empty.
Perplexity decisions
A Perplexity provider also serves Perplexity's decision models (its Decisions API, https://api.perplexity.ai/v1/decisions, which takes the System One format). Select the pplx-decider models with your other Perplexity models. pplx-decider-latest selects pplx-decider-v1.2 and pplx-decider-flash-latest selects pplx-decider-flash-v1.2.
Perplexity SDK: point the SDK at https://guardrails-usa-2.quilr.ai/perplexity and use your Quilr key; client.decisions.create(...) calls POST /perplexity/v1/decisions.
from perplexity import Perplexity
client = Perplexity(api_key="<Quilr key>", base_url="https://guardrails-usa-2.quilr.ai/perplexity")
response = client.decisions.create(
model="pplx-decider-latest",
state={"review": "The headphones sound great, but the battery stopped charging after two weeks."},
questions={"defect": {"type": "noul", "instructions": "Does the review report a product defect?"}},
)
print(response.answers["defect"].noul)
Decision model examples
curl https://guardrails-usa-2.quilr.ai/openai_compatible/v1/decisions \
-H "Authorization: Bearer <Quilr key>" \
-H "Content-Type: application/json" \
-d '{
"model": "decision-1",
"input": "The API returns 500 on every call.",
"questions": [
{"type": "choice", "name": "team", "instructions": "Which team should handle this ticket?",
"choices": [{"value": "billing", "description": "Charges and refunds"},
{"value": "engineering", "description": "Bugs and outages"}]}
]
}'
The same question in System One format, on TypeSafe:
curl https://guardrails-usa-2.quilr.ai/typesafe/v1/systemone \
-H "Authorization: Bearer <Quilr key>" \
-H "Content-Type: application/json" \
-d '{
"model": "jev-latest",
"state": "The API returns 500 on every call.",
"questions": {
"team": {"type": "choice", "instructions": "Which team should handle this ticket?",
"criteria": {"billing": "Charges and refunds", "engineering": "Bugs and outages"}}
}
}'
{
"model": "jev-1.14.0",
"answers": {
"team": {"type": "choice", "choice": "engineering", "confidence": 0.9,
"probabilities": {"billing": 0.05, "engineering": 0.95}}
},
"usage": {"input_tokens": 120, "output_tokens": 3}
}
Use your Azure deployment name, a Jev model or a pplx-decider model as model in either format.
Decision model behavior
Assistants API
/openai_assistants/ serves the OpenAI Assistants API (threads, runs, file search) through openai_assistants and openai_assistants_azure. Use it only for apps already built on Assistants.
Realtime API
wss://<base>/openai_realtime/v1/realtime is a websocket passthrough for OpenAI Realtime voice and text, served by openai_realtime and openai_realtime_azure. Aliases: /openai/v1/realtime, /openai/realtime, /openai_realtime/openai/v1/realtime, /openai_realtime/openai/realtime.
The Quilr key is accepted, in priority order, as an Authorization: Bearer header, an api-key header, an api-key or api_key query parameter, an authorization query parameter, or the openai-insecure-api-key.<key> subprotocol (stripped before forwarding).
Guardrails are not yet applied to live Realtime events. Session logging (handshake status, byte counts, usage) still runs.
Selecting a Provider on Multi-Provider Apps
When an app has several providers that can serve a request, choose one by provider type or label. Without a selector, the gateway uses the one enabled provider that has the requested model; if several have it, one is selected at random.
For apps linked to platform providers, the label is the platform provider's label.
SDK
/sdk/v1/check scans text, messages or JSON for guardrail findings without calling any LLM. On gateway deployments with SDK attachment support, request checks also inspect inline images, documents and data URLs embedded in text using the app's attachment protections. Create an app with the quilr_sdk provider. Install with pip install quilrai or npm install quilrai. See SDK Mode, or try it in the LLM Gateway Playground.
Microsoft Copilot Studio
Create an app with the copilot_studio provider and register https://guardrails-usa-2.quilr.ai/copilot_studio/<Quilr key> (or your region) in Power Platform. Copilot Studio calls /validate and /analyze-tool-execution before tool execution. Block, redact and partial-redact outcomes return blockAction: true; scanning errors fail open. See Copilot Studio.