Skip to main content

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.

Provider typeProviderChatMessagesResponsesAssistantsRealtimeEmbeddingsRerankSpeechList models
openaiOpenAI✓↻✓--✓-✓✓
openai_responsesOpenAI✓↻✓-----✓
openai_assistantsOpenAI---✓----✓
openai_realtimeOpenAI----✓---✓
azureopenaiAzure OpenAI✓↻✓--✓-✓✓
openai_responses_azureAzure OpenAI✓↻✓-----✓
openai_assistants_azureAzure OpenAI---✓----✓
openai_realtime_azureAzure OpenAI----✓---✓
anthropicAnthropic (OpenAI-compatible)✓✓↻-----✓
anthropic_messagesAnthropic↻✓↻-----✓
anthropic_messages_bedrockAnthropic on AWS Bedrock↻✓↻-----✓
anthropic_messages_azureAnthropic on Azure AI Foundry↻✓↻-----✓
bedrockAWS Bedrock (Converse, boto3 runtime)✓✓✓-----✓
bedrock_embeddingsAWS Bedrock-----✓--✓
bedrock_rerankAWS Bedrock------✓-✓
vertex_aiGoogle Vertex AI↻↻↻-----✓
gemini_chatcompletionsGoogle Gemini API (OpenAI-compatible)✓↻↻-----✓
deepseekDeepSeek✓↻↻-----✓
xaixAI✓↻↻-----✓
xai_responsesxAI↻↻✓-----✓
mistralMistral✓↻↻--✓-✓✓
cerebrasCerebras✓↻↻-----✓
groqGroq✓↻✓----✓✓
perplexityPerplexity (Agent API)↻↻✓--✓--✓
cohereCohere✓↻↻--✓✓✓✓
typesafeTypeSafe (decision models only)--------✓
oracleOracle OCI Generative AI✓SoonSoon-----Manual
oracle_responsesOracle OCI Generative AISoonSoon✓-----Manual
sarvamSarvam✓SoonSoon----✓✓
elevenlabsElevenLabs (speech only)-------✓✓
cohere_rerankCohere------✓-✓
jina_rerankJina------✓-✓
voyage_rerankVoyage------✓-✓
generalCustom endpoint (vLLM, Ollama, LiteLLM, any OpenAI-compatible URL)✓↻✓--✓--✓
general_rerankCustom endpoint with a Cohere-shaped /rerank------✓-✓
quilr_sdkQuilrAI SDK (guardrails only, no upstream)---------
copilot_studioMicrosoft Copilot Studio (guardrails only)---------
  • 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_ai and the anthropic_messages* types uses the built-in adapters described in Chat Completions adapters.
  • Speech on mistral is 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 on cohere is transcription only.
  • bedrock also serves native Bedrock Runtime calls from boto3. vertex_ai also 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).
  • azureopenai also serves Microsoft-Decision-1 deployments on the decision routes, perplexity serves its pplx-decider models there, and typesafe serves only those routes. See Decision models.
  • azureopenai also serves Mistral Document AI deployments on Azure AI Foundry for document OCR, and Claude deployments there use anthropic_messages_azure. See Azure AI Foundry models.
  • QuilrAI-provided models back an app through a general provider with base URL https://models.quilrai.dev/v1. Direct integration is coming soon. See QuilrAI-Provided Models.

Endpoints​

Combine a regional base URL with a path below.

SurfacePathAuth
Chat Completions/openai_compatible/v1/chat/completionsAuthorization: Bearer <Quilr key>
Embeddings/openai_compatible/v1/embeddingsAuthorization: Bearer <Quilr key>
Speech/openai_compatible/v1/audio/speech, /audio/transcriptions, /audio/translationsAuthorization: Bearer <Quilr key>
Endpoint families/openai_compatible/v1/moderations, /images/*, /completions, /files, /batches, /videosAuthorization: Bearer <Quilr key>
Mistral vendor routes/mistral/v1/ocr, /mistral/v1/fim/completionsAuthorization: Bearer <Quilr key>
xAI vendor routes/xai/v1/responses, /xai/v1/images/*, /xai/v1/videos/*, /xai/v1/batches/*Authorization: Bearer <Quilr key>
Cohere vendor routes/cohere/v2/embed, /cohere/v2/rerank, /cohere/v2/parse, /cohere/v1/tokenize, /cohere/v1/detokenize, /cohere/v2/batches/*, /cohere/v1/embed-jobs/*, /cohere/v1/datasets/*Authorization: Bearer <Quilr key>
Anthropic Messages/anthropic_messages/v1/messagesx-api-key: <Quilr key>
Responses/openai_responses/v1/responsesAuthorization: Bearer <Quilr key>
Assistants/openai_assistants/Authorization: Bearer <Quilr key>
Realtimewss://<base>/openai_realtime/v1/realtimeAuthorization: Bearer <Quilr key>
Bedrock Runtime (boto3)/bedrock-runtime/model/{model_id}/converse and related operationsAWS SigV4 with the Quilr key
Vertex AI/vertex_ai/Authorization: Bearer <Quilr key>
Rerank/rerank/v2/rerank, /rerank/v1/rerank, /rerank/rerankAuthorization: Bearer <Quilr key>
Sarvam native/sarvam/...Authorization: Bearer <Quilr key>
Decision models/openai_compatible/v1/decisions, /typesafe/v1/systemoneAuthorization: Bearer <Quilr key>
QuilrAI SDK/sdk/v1/checkAuthorization: Bearer <Quilr key>
Copilot Studio/copilot_studio/{Quilr key}Quilr key in the path

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).

Provider typeAuth optionRequiredOptionalWhere to set
openai, anthropic_messages, sarvamAPI keyAPI key (api_key)-Console, API
openai_responses, openai_assistants, openai_realtimeAPI keyAPI keyBase URL (base_url, default OpenAI)Console, API
anthropic, gemini_chatcompletions, deepseekAPI keyAPI key-Console, API
xai, xai_responses, mistralAPI keyAPI key- (the endpoint is fixed: https://api.x.ai/v1 or https://api.mistral.ai/v1)Console, API
cerebrasAPI keyAPI key- (the endpoint is fixed: https://api.cerebras.ai/v1)Console, API
groqAPI keyAPI key- (the endpoint is fixed: https://api.groq.com/openai/v1)Console, API
perplexityAPI keyAPI key- (the endpoint is fixed: https://api.perplexity.ai)Console, API
cohereAPI keyAPI key- (the endpoint is fixed: https://api.cohere.com)Console, API
elevenlabsAPI keyAPI keyBase URL (base_url): an ElevenLabs regional or data-residency host only (default https://api.elevenlabs.io)Console (API key), API
typesafeAPI keyAPI key- (the endpoint is fixed: https://api.typesafe.ai/v1)Console, API
cohere_rerank, jina_rerank, voyage_rerankAPI keyAPI keyBase URL (default: the vendor's API)Console, API
azureopenaiAPI keyAPI key, Azure endpoint (azure_endpoint)Azure API version (azure_api_version, default 2024-10-21; the consoles require it)Console, API
openai_responses_azure, openai_assistants_azure, openai_realtime_azureAPI keyAPI key, Azure endpointAzure API version (defaults 2025-03-01-preview, 2024-05-01-preview, 2025-04-01-preview)Console, API
anthropic_messages_azureAPI keyAPI key, Base URL (the Azure AI Foundry base URL)Anthropic version (anthropic_version, default 2023-06-01)Console, API
general, general_rerankAPI keyAPI key, Base URL-Console, API
bedrock, anthropic_messages_bedrock, bedrock_embeddings, bedrock_rerankStatic credentials (static, default)AWS access key (aws_access_key), AWS secret key (aws_secret_key)AWS region (aws_region, default us-east-1), AWS session token (aws_session_token)Console, API
sameAssume role (assume_role)Role ARN (aws_role_arn), External ID (aws_external_id)AWS region, Role session name (aws_role_session_name), Session duration (aws_session_duration_seconds, 900 to 43200, default 3600)Console, API
vertex_aiAPI key (api_key, default)API key, GCP project ID (gcp_project_id)GCP region (gcp_region, default us-central1)Console, API
sameService account (service_account)Service account JSON (service_account_json)GCP project ID (the consoles require it; the API falls back to the JSON's project_id), GCP regionConsole, API
sameExpress (express)API key (Gemini API key; calls generativelanguage.googleapis.com, no project or region)-Management API only
sameApplication Default Credentials (adc)GCP project ID. Uses the gateway's own Google identity.GCP regionManagement API only
oracle, oracle_responsesAPI key (api_key, default)API key-Console, API
sameGateway user principal (gateway_user_principal)No secret. See Oracle OCI - Gateway Sign-In Setup.-Console, API
sameUser principal (user_principal)Tenancy OCID (oci_tenancy_id), User OCID (oci_user_id), Key fingerprint (oci_fingerprint), Private key (oci_private_key)Private key passphrase (oci_private_key_passphrase)Console, API
sameSession principal (session_principal)Session token (oci_session_token), Private keyPrivate key passphraseConsole, API
sameInstance principal (instance_principal), Resource principal (resource_principal)No secret-Console, API
quilr_sdk, copilot_studioNoneLabel only-Console, API

Rules that apply to every app:

  • Every Oracle provider also needs the OCI region (oci_region) and Generative AI project OCID (oci_project_id). oracle also needs the compartment OCID (oci_compartment_id); it is optional for oracle_responses. Oracle does not accept base_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. primary is 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, since provider alone is then ambiguous.
  • quilr_sdk and copilot_studio apps 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/).

OperationCoverage
converseAny selected model that supports Converse. Request and response guardrails.
converse_streamRequest guardrails; the event stream passes through unchanged.
invoke_modelAmazon Nova, Anthropic and OpenAI-style Bedrock models. Request and response guardrails.
invoke_model_with_response_streamReturns ValidationException.

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:

OpenAI fieldSarvam field
inputtext
voicespeaker
speedpace
response_formatoutput_audio_codec (default MP3; pcm is raw linear16)

Transcriptions accept response_format of json, verbose_json or text, and timestamp_granularities[]=segment. model is required.

These rules apply to every speech provider:

TopicBehavior
BillingText to speech is billed per character sent for character-priced models (tts-1, tts-1-hd, Orpheus, ElevenLabs, Bulbul). gpt-4o-mini-tts is billed from OpenAI's token usage when you request stream_format: "sse"; for binary audio OpenAI reports no usage, so the gateway estimates the tokens from the text and the audio's length and marks them estimated. Transcription is billed per second of audio: the duration the provider reports, or the uploaded file's measured length when it reports none (Groq, Sarvam, translations). gpt-4o-*-transcribe models are billed from their token usage; with response_format text, srt or vtt OpenAI returns no usage, so the gateway estimates the audio input tokens from the audio's length (10 per second) and marks them estimated. ElevenLabs reports what it billed on every call (credits, and on transcription the exact USD charge on your plan); the log keeps it, and when ElevenLabs reports the USD charge it is the request's cost (marked provider_reported_cost) unless you set your own model costs on the provider.
BudgetsSpeech requests count toward request limits. Token and spend budgets do not charge them.
Request idEvery speech response carries x-quilr-request-id, the id of its request log entry.
Upload sizeAudio uploads above 200 MB are refused with 413 and attachment_too_large before reaching the provider. Providers apply their own lower limits (25 MB for OpenAI-style APIs).
ErrorsA provider failure carries X-Quilr-Error-Source: upstream, like every other route. On the ElevenLabs and Sarvam routes it also carries X-Quilr-Error-Code and "source": "upstream" in the error body, and the provider's own message is never echoed. A refusal by the gateway itself (for example webhook=true under guardrails) carries no upstream marker.
GuardrailsThe text to speak and the returned transcript are scanned, and so is every text hint sent with the audio: a transcription prompt for every provider, and ElevenLabs previous_text, next_text, keyterms and transcript_edit. Each field is scanned in full and can block the request or be redacted before it is sent. When response guardrails apply, stream=true transcription is returned after the scan as one transcript.text.delta and the final transcript.text.done event. A redacted verbose_json transcript is returned without word timings, which would repeat the original text.

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.

EndpointPurposeModels
/sarvam/text-to-speechSpeech synthesisbulbul:v3 (default), bulbul:v2
/sarvam/speech-to-textTranscription (multipart/form-data, one file)saaras:v3 (default), saaras:v4
/sarvam/speech-to-text-translateSpeech translationsaaras:v3, saaras:v4 (both need mode=translate), saaras:v2.5
/sarvam/translateText translationmayura:v1 (default), sarvam-translate:v1
/sarvam/transliterateTransliterationsarvam-transliterate
/sarvam/text-lidLanguage detectionsarvam-text-lid

Chat models (sarvam-105b, sarvam-105b-conversations, and the beta glm5.2, gemma4, deepseekv4-flash) use the standard Chat Completions endpoint.

TopicLimit or behavior
ModelsEnable every model and alias you call, including sarvam-transliterate and sarvam-text-lid.
Synthesislanguage_code is required. bulbul:v3: 2500 characters, speaker shubh, 24000 Hz. bulbul:v2: 1500 characters, speaker anushka, 22050 Hz.
RecognitionModes transcribe, translate, verbatim, translit, codemix. Segment timestamps only. Keep recordings under 30 seconds; bodies are capped at 25 MB.
Translationmayura:v1: 11 languages, auto source, 1000 characters. sarvam-translate:v1: 23 languages, explicit source, 2000 characters.
GuardrailsScan synthesized text, transcripts, text hints and translated output. Uploaded audio is forwarded unchanged and never logged.
Not coveredEmbeddings, rerank, Responses, Realtime, batch and streaming speech.

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:

DeploymentProvider typeAPIListed by Check key and list models
Azure OpenAI models (for example gpt-5.4-mini)azureopenaiChat, Responses, embeddings, speech and moreYes
Mistral Document AI (mistral-document-ai-2512, mistral-ocr-*)azureopenaiDocument OCR at /openai_compatible/v1/ocrYes, as an OCR model
Microsoft-Decision-1azureopenaiDecision modelsYes, as a decision model
Claude (for example claude-opus-4-5)anthropic_messages_azureAnthropic MessagesNo: enter the deployment name

Other Foundry Models deployments, such as Mistral chat models, are not listed or supported yet.

Add the provider​

  1. In Azure AI Foundry, open the resource's deployment details page and copy the resource endpoint and key.
  2. 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.
  3. For Claude, add an Azure › Anthropic messages provider (anthropic_messages_azure) with the key and the Base URL https://<resource>.services.ai.azure.com, then enter each deployment name (for example claude-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​

TopicBehavior
DocumentsAzure cannot fetch URLs. Send document_url or image_url as a base64 data: URI. Any other URL returns 400 ocr_document_url_unsupported before the request is counted or sent. Azure's own size and page limits apply.
Model checkModel validation confirms that an OCR deployment exists on the OCR route without running OCR, under any deployment name: the gateway asks the resource which model the deployment runs. Unknown deployments return Azure's 404 DeploymentNotFound.
Usage accountingOCR counts requests, like the other endpoint families, and is billed per processed page (usage_info.pages_processed): $3 per 1,000 pages for mistral-document-ai-2512. Annotation pages are not billed.
GuardrailsOCR runs no guardrails and no failover, like the other endpoint families.

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.

Provider typeConsole tile and APIWhat one key serves
mistralMistral AI › Chat completionsChat, embeddings, transcription, moderation, document OCR, Codestral fill-in-the-middle (FIM). Files and batch jobs when enabled.
xaixAI › Chat completionsChat, Grok Imagine image generation and edits. Video generation and batches when enabled.
xai_responsesxAI › ResponsesxAI's Responses API, which xAI recommends for new integrations.

Add the provider​

  1. Open Settings > Models > Models and click Add your own models (the same picker appears when you create or edit an app).
  2. Search for mistral, grok or xai and select the Mistral AI or xAI tile. For xAI, choose Chat completions or Responses under Which API does the gateway talk to?.
  3. 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:

APIPathProvider types
Mistral document OCR/mistral/v1/ocrmistral
Mistral fill-in-the-middle/mistral/v1/fim/completionsmistral
xAI Responses, with xAI's server-side tools (web search, X search)/xai/v1/responses; GET, DELETE /xai/v1/responses/{response_id}xai_responses, xai
xAI image generation and edits/xai/v1/images/generations, /xai/v1/images/edits (JSON body)xai
xAI video generation (off by default)/xai/v1/videos/generations, /edits, /extensions; GET /xai/v1/videos/{request_id}xai
xAI batches (off by default)/xai/v1/batches (create, list); /xai/v1/batches/{batch_id} (get); /xai/v1/batches/{batch_id}/requests (add, list); /xai/v1/batches/{batch_id}/results; /xai/v1/batches/{batch_id}:cancelxai

The shared endpoints serve them too:

APIPathxAIMistral
Chat Completions/openai_compatible/v1/chat/completions✓ (xai; switch on xai_responses)✓
Responses/openai_responses/v1/responses✓ (xai_responses; switch on xai). The multi-agent model is Responses only.Translated to Chat
Anthropic Messages, Gemini, Bedrock ConverseTheir native pathsTranslatedTranslated
Embeddings/openai_compatible/v1/embeddings-✓
Transcription/openai_compatible/v1/audio/transcriptions-✓
Moderations/openai_compatible/v1/moderations-✓
Files, batches (off by default)/openai_compatible/v1/files, /batchesFiles✓

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​

TopicMistral AIxAI
Vendor routesRequest and response are Mistral's own (FIM random_seed, chat-shaped FIM choices).Request and response are xAI's own (aspect_ratio, resolution, duration, xAI video and batch objects).
Output limit on chatSend max_tokens. Mistral has no max_completion_tokens and no stream_options.max_completion_tokens is accepted. The gateway requests streaming usage for you.
Rejected fieldsUnsupported fields come back as Mistral's own HTTP 422.Reasoning models reject presence_penalty, frequency_penalty and stop; the error is passed through.
StreamingChat and FIM.Chat and Responses.
ModerationThe response gets OpenAI's per-result flagged field.-
Responses-Create, retrieve and delete. cancel and input_items return 400 operation_not_supported.
Not availableAudio translations.Legacy completions: xAI rejects /v1/completions for every current model.

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>, or provider_not_supported_on_route on /xai/v1/responses).
  • Routing groups: mistral and xai are own-family members of Chat Completions groups; xai_responses of 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.

Provider typeConsole tile and APIWhat one key serves
cerebrasCerebras › Chat completionsChat and legacy text completions on open-weight models such as gpt-oss and Qwen.

Add the provider​

  1. Open Settings > Models > Models and click Add your own models (the same picker appears when you create or edit an app).
  2. Search for cerebras and select the Cerebras tile.
  3. 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.

APIPathCerebrasExample model
Chat Completions/openai_compatible/v1/chat/completions✓gpt-oss-120b
Legacy completions/openai_compatible/v1/completions✓gpt-oss-120b
Responses/openai_responses/v1/responsesTranslated to Chatgpt-oss-120b
Anthropic Messages, Gemini, Bedrock ConverseTheir native pathsTranslated to Chat-
Embeddings, images, speech, moderations-- (Cerebras does not serve them)-
Files, batches-- (Cerebras Batch is a private preview)-

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​

TopicCerebras
ReasoningReasoning models such as gpt-oss-120b return their reasoning to every client format: thinking blocks for Anthropic Messages, reasoning items for Responses. Reasoning effort is fitted to low, medium or high.
Tool loopsMulti-turn tool calls work from every client format; earlier reasoning is sent back in Cerebras' reasoning field.
Rejected fieldsCerebras rejects unknown fields; the error comes back as Cerebras' own HTTP 400 (wrong_api_format).
StreamingChat and legacy completions.
Context windowAn over-long request is classified as a context-length error, so routing failover can move it to a model with a larger window.

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.

Provider typeConsole tile and APIWhat one key serves
groqGroq › Chat completions and ResponsesChat, Responses, speech to text and text to speech on open-weight models such as gpt-oss, Qwen, Whisper and Orpheus.

Add the provider​

  1. Open Settings > Models > Models and click Add your own models (the same picker appears when you create or edit an app).
  2. Search for groq and select the Groq tile.
  3. 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.

APIPathGroqExample model
Chat Completions/openai_compatible/v1/chat/completions✓openai/gpt-oss-20b
Responses (create only)/openai_responses/v1/responses✓openai/gpt-oss-20b
Speech to text/openai_compatible/v1/audio/transcriptions✓whisper-large-v3-turbo
Speech translation to English/openai_compatible/v1/audio/translations✓whisper-large-v3
Text to speech/openai_compatible/v1/audio/speech✓ (WAV)canopylabs/orpheus-v1-english
Anthropic Messages, Gemini, Bedrock ConverseTheir native pathsTranslated to Chat-
Legacy completions, embeddings, images, moderations, files, batches-- (not routed to Groq)-

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​

TopicGroq
ResponsesGroq's Responses API is a stateless beta. store must be unset or false and previous_response_id is not supported; Groq's own HTTP 400 comes back. Retrieve, cancel, delete and list input items return 400 (operation_not_supported).
ReasoningReasoning models such as openai/gpt-oss-20b return their reasoning to every client format: thinking blocks for Anthropic Messages, reasoning items for Responses. Translated requests fit reasoning effort to low, medium or high.
Tool loopsMulti-turn tool calls work from every client format; earlier reasoning is sent back in Groq's reasoning field. Give reasoning models enough output tokens (for example 1024), or the tool call can fail with Groq's tool_use_failed.
History from other providersGroq rejects some fields other providers return, so Chat history is fitted before it is sent: OpenAI's refusal, annotations and audio and any field set to null are removed, and reasoning_content is sent as reasoning. A conversation can move to Groq from OpenAI or DeepSeek, for example by failover.
SpeechOrpheus returns WAV only; the gateway asks for WAV when you send no response_format. Each Orpheus model's terms must be accepted once in the Groq console for the key's organization, or Groq answers model_terms_required (also shown by Check key and list models). /audio/translations works on whisper-large-v3 only.
StreamingChat and Responses. Streams always carry usage, so billing has it.
CapacityGroq's 498 capacity_exceeded (flex tier full) is treated as a rate limit, so routing failover can retry or move the request.
BillingChat by tokens, Whisper by audio seconds, Orpheus by characters. Groq bills a transcription shorter than 10 seconds as 10 seconds; the gateway records the actual length, so very short clips are logged slightly below Groq's invoice. Groq's browser search tool ({"type": "browser_search"} on gpt-oss models) adds $5 per 1,000 searches and $1 per 1,000 page visits, on Chat and Responses.

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).

Provider typeConsole tile and APIWhat one key serves
perplexityPerplexity › Agent API, Decisions and EmbeddingsPerplexity's Agent API, which runs OpenAI, Anthropic, Google, xAI and Perplexity models (including perplexity/sonar) with built-in web search, its pplx-decider decision models and its pplx-embed embedding models.

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​

  1. Open Settings > Models > Models and click Add your own models (the same picker appears when you create or edit an app).
  2. Search for perplexity and select the Perplexity tile ("Web-grounded answers · Direct API").
  3. 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.

APIPathPerplexityExample model
Responses (create only)/openai_responses/v1/responses✓ (Agent API)openai/gpt-6-luna
Chat Completions/openai_compatible/v1/chat/completionsTranslated to Responsesperplexity/sonar
Anthropic Messages, Gemini, Bedrock ConverseTheir native pathsTranslated to Responses-
Decisions/openai_compatible/v1/decisions, /typesafe/v1/systemone, /perplexity/v1/decisions✓pplx-decider-latest
Embeddings (OpenAI-style unit floats)/openai_compatible/v1/embeddings✓pplx-embed-v1-0.6b
Embeddings (Perplexity's int8 or binary)/perplexity/v1/embeddings✓pplx-embed-v1-4b
Contextualized embeddings, Search API, Orchestrator API, images, files, batches-- (not routed to Perplexity)-

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​

TopicPerplexity
ResponsesThe Agent API continues a conversation by previous_response_id, but serves no stored-response routes: retrieve, cancel, delete and list input items return 400 (operation_not_supported) instead of Perplexity's 404. max_output_tokens is required for anthropic/* models.
Agent optionspreset, effort, max_steps and models pass through unchanged on Responses requests. Send model with them: the gateway routes by model, and Perplexity runs model when both it and preset are set. Billing uses the model Perplexity reports serving, so a models fallback is priced as the model that answered. Model access rules check model; models named only in models are not checked.
Web search and toolsPerplexity's own tools (web_search, fetch_url, finance_search, ...) pass through on Responses requests. Responses can carry a search_results output item beside the answer; clients of other formats receive the answer text.
Other formatsChat Completions, Anthropic Messages, Gemini and Bedrock clients are translated to the Agent API, including streaming and multi-turn tool calls.
BillingTokens at each model's rate (Perplexity passes other vendors' models through at their list price; the catalog prices Perplexity's own ids). Cache writes the Agent API reports are billed at the model's cache-write rate. Web search and URL fetch calls are counted from Perplexity's tool_calls_details: Perplexity's own model ids are priced at $2.50 and $0.50 per 1,000 calls; other vendors' ids (openai/..., anthropic/...) use that vendor's catalog rate, which you can override per provider with your own model costs.
Not coveredPerplexity's Sonar chat completions (closed to new accounts), contextualized embeddings, Search API and Orchestrator API (limited preview).

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:

RouteWhat you sendWhat you get
/openai_compatible/v1/embeddingsThe OpenAI shape. encoding_format float (default) or base64 (the OpenAI Python SDK's default)Unit-length vectors: the int8 vector divided by its length, so cosine similarity is unchanged and a dot product equals it, as vector stores built for OpenAI embeddings expect. base64 returns little-endian float32, as from OpenAI.
/openai_compatible/v1/embeddings with encoding_format base64_int8 or base64_binaryPerplexity's own encodingsPerplexity's vectors exactly as it sent them
/perplexity/v1/embeddingsPerplexity's request (the Perplexity SDK with base_url=https://guardrails-usa-2.quilr.ai/perplexity)Perplexity's answer unchanged; this route serves Perplexity providers only (400 provider_not_supported_on_route otherwise)

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.

Provider typeConsole tile and APIWhat one key serves
cohereCohere › Chat, embeddings & rerankCommand and Aya chat models, Embed, Rerank, Transcribe and Parse models, and Cohere's tokenize, batch, embed-job and dataset APIs.
cohere_rerankCohere › Rerank onlyRerank only, with an optional base URL. Unchanged.

Add the provider​

  1. Open Settings > Models > Models and click Add your own models (the same picker appears when you create or edit an app).
  2. Select the Cohere tile ("Chat, embeddings & rerank · Direct API"), then Chat, embeddings & rerank.
  3. 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.

APIPathCohereExample model
Chat Completions/openai_compatible/v1/chat/completions✓command-a-03-2025
Anthropic Messages, Responses, Gemini, Bedrock ConverseTheir native pathsTranslated to Chatcommand-r7b-12-2024
Embeddings (OpenAI shape)/openai_compatible/v1/embeddings✓embed-v4.0
Embeddings (Cohere shape)/cohere/v2/embed✓embed-v4.0
Rerank/rerank/v1/rerank, /cohere/v2/rerank✓rerank-v3.5, rerank-v5.0-pro
Speech to text/openai_compatible/v1/audio/transcriptions✓cohere-transcribe-03-2026
Parse, tokenize, batches, embed jobs, datasetsCohere routes✓parse-v5.0
Cohere's native /v2/chat (documents, citations), text to speech-- (not routed)-

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​

TopicCohere
ReasoningCohere's reasoning is on or off: reasoning_effort other than none is sent as high, which is the only other value Cohere accepts.
Unsupported parametersCohere refuses n above 1 and some OpenAI-only fields with its own 422 error, which the gateway returns as sent.
EmbeddingsEvery Embed model works on the OpenAI route; Cohere supplies input_type there. On /cohere/v2/embed, v3 models need input_type. The texts are scanned by the app's request guardrails; image inputs (images, inputs) are refused with 400 invalid_cohere_embed_input because they cannot be scanned on this route.
RerankBilled from Cohere's billed units: $2.00 per 1,000 searches for Rerank 3, 3.5 and 4 Fast, $2.50 for Rerank 4 Pro, and input tokens for Rerank 5. Existing cohere_rerank providers are billed the same way.
Speech to textTranscriptions only; language is required.
BillingTokens at Cohere's catalog rates. Parse is billed per page from Cohere's billed units ($1.50 per 1,000 pages for parse-v5.0). Command A Plus, Aya Vision, Tiny Aya, North and Transcribe have no published price yet and show as unpriced; add your own model costs to price them.

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.

RouteWhat it doesGuardrailsEnabled
POST /cohere/v2/embedEmbeddings in Cohere's shape (float, int8, uint8, binary, ubinary)RequestAlways
POST /cohere/v2/rerankRerank (cohere and cohere_rerank providers)RequestAlways
POST /cohere/v2/parseParse an image document with parse-v5.0-Always
POST /cohere/v1/tokenize, /cohere/v1/detokenizeTokenize text or turn tokens back into text (no model call)-Always
/cohere/v2/batches, /cohere/v2/batches/{id}, :cancelCreate, list, get and cancel batches-When the deployment enables batches
/cohere/v1/embed-jobs, /{id}, /{id}/cancelCreate, list, get and cancel embed jobs-When the deployment enables batches
/cohere/v1/datasets, /usage, /{id}Upload (multipart), list, get, delete datasets and read usage-When the deployment enables files

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.

Provider typeConsole tile and APIWhat one key serves
elevenlabsElevenLabs › SpeechText to speech with the Eleven v4, v3, Multilingual and Flash models, speech to text with the Scribe models, and ElevenLabs' other generation APIs (dialogue, sound effects, music, voice changer, voice design, dubbing).

Add the provider​

  1. Open Settings > Models > Models and click Add your own models (the same picker appears when you create or edit an app).
  2. Select the ElevenLabs tile ("Text to speech & speech to text"), then Speech.
  3. 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.

APIPathElevenLabsExample model
Text to speech (OpenAI shape)/openai_compatible/v1/audio/speech✓eleven_flash_v2_5
Speech to text (OpenAI shape)/openai_compatible/v1/audio/transcriptions✓scribe_v2
Text to speech (ElevenLabs shape)/elevenlabs/v1/text-to-speech/{voice_id}, .../stream✓eleven_v3
Speech to text (ElevenLabs shape)/elevenlabs/v1/speech-to-text✓scribe_v2
Speech with character timing/elevenlabs/v1/text-to-speech/{voice_id}/with-timestamps, .../stream/with-timestamps✓eleven_v3
Text to dialogue (several voices)/elevenlabs/v1/text-to-dialogue, /stream, /with-timestamps, /stream/with-timestamps✓eleven_v3
Stored transcriptsGET/DELETE /elevenlabs/v1/speech-to-text/transcripts/{transcription_id}✓-
Sound effects/elevenlabs/v1/sound-generation✓eleven_text_to_sound_v2
Music/elevenlabs/v1/music, /stream, /detailed, /detailed/stream, /plan, /stem-separation, /video-to-music✓ (paid ElevenLabs plan)music_v1
Voice changer/elevenlabs/v1/voice-changer/{voice_id}, /stream✓eleven_multilingual_sts_v2
Audio isolation/elevenlabs/v1/audio-isolation, /stream✓-
Voice design/elevenlabs/v1/text-to-voice/design, /create-previews, /{voice_id}/remix, /elevenlabs/v1/text-to-voice✓ (paid ElevenLabs plan)eleven_multilingual_ttv_v2
Forced alignment/elevenlabs/v1/forced-alignment✓-
Dubbing/elevenlabs/v1/dubbing (create, list), /{dubbing_id} (get, delete), /{dubbing_id}/audio/{language}, /{dubbing_id}/transcript/{language}✓elevenlabs-dubbing
Models and voicesGET /elevenlabs/v1/models, /v1/voices, /v2/voices, /v1/voices/{voice_id}, /v1/shared-voices✓-
Speech translation, chat, embeddings-- (ElevenLabs has none)-
Realtime WebSocket speech, voice agents (Agents platform), voice cloning, Studio, account and workspace APIs-- (not routed)-

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​

TopicElevenLabs
Voicesvoice (OpenAI shape) or the path's voice_id must be an ElevenLabs voice id from your ElevenLabs account. OpenAI voice names such as alloy are not mapped.
Audio formatsresponse_format mp3 (default), opus, pcm (24 kHz) and wav (24 kHz) map to ElevenLabs formats; you can also pass an ElevenLabs output_format value such as mp3_44100_192. aac and flac are refused with 400. Some formats need a higher ElevenLabs plan.
Unsupported OpenAI optionsinstructions, stream_format: "sse" on speech, and prompt, stream=true, srt and vtt on transcription are refused with 400 rather than ignored. webhook and use_multi_channel work on /elevenlabs/v1/speech-to-text only.
StreamingThe /stream routes (speech, dialogue, music, voice changer, audio isolation) relay audio as it arrives. If ElevenLabs fails partway, the transfer ends with an error rather than as a complete file. The OpenAI-shaped speech route returns the whole file.
Transcriptsverbose_json returns the text, language, duration and word timings.
GuardrailsEvery text ElevenLabs receives is scanned: the text to speak with previous_text and next_text, and transcription keyterms and transcript_edit. The returned transcript is scanned too; a redacted transcript is returned without word timings, entities or extra export formats, since those repeat the text. webhook=true and transcript_edit are refused with 400 on /elevenlabs/v1/speech-to-text while the app's guardrails or a QuilrQL policy apply: ElevenLabs would deliver a webhook transcript without the gateway seeing it, and transcript_edit returns a second, edited transcript that is not scanned. Query parameters such as enable_logging=false (zero retention) are passed to ElevenLabs unchanged. Uploaded audio is forwarded unchanged and never logged.
BillingText to speech per character sent ($0.08 per 1,000 for v4, v3 and Multilingual v2; $0.04 for v4 Turbo, v3 Conversational, Flash and Turbo); speech to text per second of audio from ElevenLabs' reported duration ($0.20 per hour, scribe_v2_medical included). Options ElevenLabs charges extra for are billed too: keyterms (+$0.05 per hour, and at least 20 seconds with more than 100 keyterms), transcript_edit (+$0.07 per hour, at least 10 seconds), detect_speaker_roles (+10%), and use_multi_channel (every channel at the full duration). The request log shows how the billed audio was reached. The other APIs are billed at ElevenLabs' list prices: sound effects $0.12 and music $0.15 per minute of generated audio; voice changer and audio isolation $0.12 per minute of audio sent; dubbing $0.50 per minute of the uploaded media ($0.33 with watermark=true). Voice design, forced alignment, stem separation and music plans have no published price and are logged as unpriced. Every call also logs the credits ElevenLabs reports, and when ElevenLabs reports the exact charge in US dollars (transcription), that charge is the logged cost. Speech requests count toward request limits; token and spend budgets do not charge them.
ErrorsElevenLabs' status code is kept and its error status (for example invalid_api_key) becomes error.code; ElevenLabs' message is not passed through because it can quote your text.

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.

RouteWhat it doesGuardrailsModel checked
POST /elevenlabs/v1/text-to-speech/{voice_id}, /stream, /with-timestamps, /stream/with-timestampsSpeech, whole file or streamed, optionally with character timingRequest (text, previous_text, next_text)model_id, default eleven_multilingual_v2
POST /elevenlabs/v1/text-to-dialogue, /stream, /with-timestamps, /stream/with-timestampsSeveral voices in one clipRequest (every line)model_id, default eleven_v3
POST /elevenlabs/v1/speech-to-textTranscribe uploaded audio or videoRequest (keyterms, transcript_edit) and responsemodel_id (required)
GET, DELETE /elevenlabs/v1/speech-to-text/transcripts/{transcription_id}Read or delete a stored transcriptResponse (every channel and edit)Any scribe_* model
POST /elevenlabs/v1/sound-generationSound effect from a promptRequest (text)model_id, default eleven_text_to_sound_v2
POST /elevenlabs/v1/music, /stream, /detailed, /detailed/streamCompose musicRequest (prompt, styles, lyrics)model_id, default music_v1
POST /elevenlabs/v1/music/planBuild a composition planRequest (prompt and source plan)model_id, default music_v1
POST /elevenlabs/v1/music/video-to-musicMusic for an uploaded videoRequest (description, tags)model_id, default music_v1
POST /elevenlabs/v1/music/stem-separationSplit uploaded audio into stems- (audio only)-
POST /elevenlabs/v1/voice-changer/{voice_id}, /streamRe-voice uploaded speech- (audio only)model_id, default eleven_english_sts_v2
POST /elevenlabs/v1/audio-isolation, /streamRemove background noise- (audio only)-
POST /elevenlabs/v1/text-to-voice/design, /create-previews, /{voice_id}/remix, POST /elevenlabs/v1/text-to-voiceDesign, preview, remix and save a voiceRequest (voice description, preview text, voice name)eleven_multilingual_ttv_v2
POST /elevenlabs/v1/forced-alignmentAlign text to uploaded audioRequest (text)-
/elevenlabs/v1/dubbing (create, list), /{dubbing_id} (get, delete), /{dubbing_id}/audio/{language_code}Dub uploaded media and fetch the resultRequest (name)elevenlabs-dubbing
GET /elevenlabs/v1/dubbing/{dubbing_id}/transcript/{language_code}Dubbing transcript (JSON, SRT or WebVTT)Responseelevenlabs-dubbing
GET /elevenlabs/v1/modelsList models, filtered to the app's models and its policy--
GET /elevenlabs/v1/voices, /v2/voices, /v1/voices/{voice_id}, /v1/shared-voicesList voices--

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:

FamilyProviders
Moderationsopenai, mistral, general
Imagesopenai, azureopenai, gemini_chatcompletions, general
Completionsopenai, azureopenai, deepseek, cerebras, general
Files (off by default)openai, azureopenai, mistral, xai
Batches (off by default)openai, azureopenai, mistral
Videos (off by default)openai

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:

ProviderProvider typeModelsmodel value
Microsoft-Decision-1 on Azure AI FoundryazureopenaiYour Microsoft-Decision-1 deploymentThe deployment name
TypeSafetypesafeJev: jev-latest, jev-preview, jev-1.14.0, jev-1.13.0A Jev model id or alias
Perplexityperplexitypplx-decider-latest, pplx-decider-flash-latest, pplx-decider-v1.2, pplx-decider-flash-v1.2A decider id or alias (the perplexity/ prefix also works)

Call any of them in either format:

FormatPathQuestionsAnswers
OpenAI Decisions/openai_compatible/v1/decisionsinput and a questions array of predicate, choice and scoreAn answers array in question order
System One/typesafe/v1/systemone, or /perplexity/v1/decisions (Perplexity's own path, for the Perplexity SDK)state and a questions map of noul, choice and scoreAn answers map keyed by question name

The three question types:

OpenAI DecisionsSystem OneAnswer
predicatenoulA probability from 0 to 1 that the statement is true
choice with choiceschoice with a criteria mapThe chosen option, a probability per option and a confidence
score with levelsscore with a criteria listA score on the levels, a probability per level and a confidence

Microsoft-Decision-1 on Azure​

  1. In Azure AI Foundry, deploy Microsoft-Decision-1 under a name of your choice (Azure does not allow the name Microsoft-Decision-1 itself), for example decision-1.
  2. 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.
  3. 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.

  1. Open Settings > Models > Models and click Add your own models (the same picker appears when you create or edit an app).
  2. Search for typesafe and select the TypeSafe tile ("Decision models · Direct API"). It has one API, System One.
  3. 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​

TopicBehavior
UpstreamAzure: <resource>/providers/microsoft/v1/systemone. Any endpoint copied from the portal works (/openai/v1, /models and project URLs are trimmed to the resource). TypeSafe: https://api.typesafe.ai/v1/systemone with the stored key as a bearer token. Perplexity: https://api.perplexity.ai/v1/decisions with the stored key as a bearer token.
Format conversionOpenAI Decisions requests are converted to System One and the answers converted back. Text parts of input join into the state; safety_identifier is dropped. System One requests are forwarded as sent.
GuardrailsScan the input or state and every question field before conversion, including object keys. Answers are probabilities and your own labels, so they are not scanned.
Not coveredImages, Box questions, audio and video, refused with 400 decision_media_not_supported (Microsoft-Decision-1 reads text and JSON only; TypeSafe's image support is a preview; image content could not be scanned). No streaming.
CompressionRequest bodies may be gzip or deflate encoded. zstd is refused with 415 invalid_content_encoding.
RoutingDecision routes serve only Azure, TypeSafe and Perplexity providers. They never join a routing group or route. Chat Completions refuses TypeSafe models.
Model accessA request reaches only models listed in the serving provider's models; any other model is refused with 403 model_access_denied. An Azure provider with no models listed serves every deployment.
BillingInput tokens are charged ($0.042 per 1M on Azure and TypeSafe; $0.02 for pplx-decider and $0.01 for pplx-decider-flash on Perplexity); output tokens are free. Token, quota and budget limits apply as on other routes.
ErrorsGateway errors use the OpenAI {"error": {...}} shape. TypeSafe's and Perplexity's own errors are returned as they sent them.

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 coverage

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.

EndpointBody fieldHeaderQuery parameter
Chat Completions, Anthropic Messages, Vertex AI, Embeddings, Rerank, Responses, Decision modelsprovider or provider_labelX-Provider-Name / X-Provider-Label-
Sarvam native (multipart routes: as a form field)provider or provider_labelX-Provider-Name / X-Provider-Label-
Realtime-X-Provider-Name / X-Provider-Labelprovider or provider_label

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.