Provider guide

xAI Grok through one OpenAI-compatible gateway

Call xAI’s Grok models with your OpenAI SDK through Routeplane — with fallback, in-data-plane guardrails, residency routing, and cost attribution.

xAI serves Grok over an OpenAI-compatible API. Routeplane’s adapter is a faithful passthrough, tolerating Grok’s reasoning_content on responses, with the gateway’s fallback and governance wrapped around it.

Drop Grok into a fallback chain to add it to your rotation without changing client code.

Drop in your OpenAI client

Point your existing OpenAI SDK at the gateway and add two headers — your virtual key and the provider. Nothing else about your code changes.

bashcurl
curl https://api.routeplane.ai/v1/chat/completions \
  -H "content-type: application/json" \
  -H "x-routeplane-api-key: rp_your_gateway_key" \
  -H "x-routeplane-provider: xai" \
  -d '{"model":"grok-3","messages":[{"role":"user","content":"Hello!"}]}'
pythonopenai SDK
import openai

client = openai.OpenAI(
    api_key="rp_your_gateway_key",
    base_url="https://api.routeplane.ai/v1",
    default_headers={
        "x-routeplane-api-key": "rp_your_gateway_key",
        "x-routeplane-provider": "xai",   # route to xAI Grok
    },
)

resp = client.chat.completions.create(
    model="grok-3",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(resp.choices[0].message.content)
typescriptopenai SDK
import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: 'rp_your_gateway_key',
  baseURL: 'https://api.routeplane.ai/v1',
  defaultHeaders: {
    'x-routeplane-api-key': 'rp_your_gateway_key',
    'x-routeplane-provider': 'xai', // route to xAI Grok
  },
});

const completion = await client.chat.completions.create({
  model: 'grok-3',
  messages: [{ role: 'user', content: 'Hello!' }],
});
console.log(completion.choices[0]?.message.content);

Or use the Routeplane SDK

The Routeplane SDKs subclass the official OpenAI clients, wire up the x-routeplane-* headers for you, and add typed access to routing metadata and the non-OpenAI surfaces.

bashinstall
pip install routeplane
pythonrouteplane SDK
from routeplane import Routeplane

client = Routeplane(
    api_key="rp_your_gateway_key",
    provider="xai",   # route to xAI Grok
)

resp = client.chat.completions.create(
    model="grok-3",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(resp.choices[0].message.content)
bashinstall
npm i @routeplane/sdk
typescript@routeplane/sdk
import { Routeplane } from '@routeplane/sdk';

const client = new Routeplane({
  apiKey: process.env.ROUTEPLANE_API_KEY!, // rp_...
  provider: 'xai',                 // route to xAI Grok
});

const completion = await client.chat.completions.create({
  model: 'grok-3',
  messages: [{ role: 'user', content: 'Hello!' }],
});
console.log(completion.choices[0]?.message.content);

Add a fallback chain

Try xAI first; fall back to OpenAI. Make the provider header a comma-separated list and the gateway walks it in order, skipping any provider whose circuit is open.

bashcurl
curl https://api.routeplane.ai/v1/chat/completions \
  -H "content-type: application/json" \
  -H "x-routeplane-api-key: rp_your_gateway_key" \
  -H "x-routeplane-provider: xai,openai" \
  -d '{"model":"grok-3","messages":[{"role":"user","content":"Hello!"}]}'

xAI Grok on the gateway

The adapter supports chat completions and native streaming. Embeddings requests return a clean 422 — route them to a provider that offers them.

Reasoning content tolerated

Grok can return a reasoning_content field; the adapter tolerates it on responses so it flows through without breaking the OpenAI shape.

xAI Grok model pricing

List prices for the xAI Grok models you can call through the gateway — click any model for its per-token cost page.

grok-3 grok-3-mini

Sovereign routing

Sovereign routing works with xAI Grok the same way it works everywhere: add x-routeplane-residency to a request, and when the gateway classifies regulated personal data in it, only providers resident in the requested region stay eligible — a hard constraint that overrides the provider header. Declare where xAI Grok runs by setting XAI_REGION.

Keep reading

Frequently asked questions

Is Routeplane a drop-in replacement for calling xAI Grok directly?

Yes. The gateway is OpenAI-compatible, so switching is a base-URL change — point your existing OpenAI SDK at https://api.routeplane.ai/v1 and set the x-routeplane-provider header to xai. You keep your code and gain automatic fallback, in-data-plane PII guardrails, sovereign routing, and per-team cost attribution.

Which xAI Grok models can I use through Routeplane?

Any xAI Grok model the provider serves. See the list prices linked above for the ones we publish.

Can I enforce data residency on xAI Grok requests?

Yes. Add the x-routeplane-residency header (for example IN) and, when a request carries regulated personal data, the gateway restricts routing to providers eligible in that region — overriding the provider header if it has to. The xAI Grok adapter reads XAI_REGION to declare where it is resident.

Route your first request this week.

Point your existing OpenAI-compatible client at Routeplane, set one header, and get fallback, guardrails, and sovereign routing across every provider.

Request access → Read the quickstart