Provider guide

Mistral through one OpenAI-compatible gateway

Call Mistral models with your OpenAI SDK through Routeplane — with fallback, in-data-plane guardrails, and residency routing that fits Mistral’s EU footprint.

Mistral already speaks the OpenAI wire dialect, so Routeplane’s adapter is a faithful passthrough with the gateway’s value added around it: fallback, guardrails, sovereign routing, and cost attribution. Both chat completions and embeddings are supported.

Mistral’s EU hosting makes it a good anchor for GDPR-style residency — declare an EU region and let the gateway hard-lock regulated requests to it.

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: mistral" \
  -d '{"model":"mistral-large","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": "mistral",   # route to Mistral
    },
)

resp = client.chat.completions.create(
    model="mistral-large",
    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': 'mistral', // route to Mistral
  },
});

const completion = await client.chat.completions.create({
  model: 'mistral-large',
  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="mistral",   # route to Mistral
)

resp = client.chat.completions.create(
    model="mistral-large",
    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: 'mistral',                 // route to Mistral
});

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

Add a fallback chain

Try Mistral 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: mistral,openai" \
  -d '{"model":"mistral-large","messages":[{"role":"user","content":"Hello!"}]}'

Mistral on the gateway

The adapter supports chat completions, native streaming, and embeddings.

EU residency

Set MISTRAL_REGION (e.g. EU) to make Mistral eligible for residency-locked routing. When a request carries regulated data and asks for that region, the gateway routes only to providers resident there.

Mistral model pricing

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

mistral-large mistral-small codestral

Sovereign routing

Sovereign routing works with Mistral 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 Mistral runs by setting MISTRAL_REGION.

Keep reading

Quickstart — send your first request in a few minutes.
Providers & routing strategy — how eligibility, fallback, and strategies work.
Python SDK and TypeScript SDK — the full typed clients.
All providers — every model provider behind the gateway.

Frequently asked questions

Is Routeplane a drop-in replacement for calling Mistral 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 mistral. You keep your code and gain automatic fallback, in-data-plane PII guardrails, sovereign routing, and per-team cost attribution.

Which Mistral models can I use through Routeplane?

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

Can I enforce data residency on Mistral 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 Mistral adapter reads MISTRAL_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