AI API Compatibility Tester: Translate OpenAI Requests to Anthropic, Gemini, Mistral, Groq, Ollama (2026)

Why an OpenAI-format request is a useful pivot

Somewhere around 2024 the OpenAI Chat Completions schema quietly became the shape everyone copied (messages with system, user, assistant roles, tools, temperature, max_tokens, stream, and optionally response_format). Anthropic, Mistral, Groq, Together, Fireworks, every local server I’ve touched (Ollama, LM Studio, llama.cpp’s server). They all expose some flavor of an OpenAI-compatible endpoint at /v1/chat/completions. Gemini and Cohere kept their own native schemas. Even they ship an OpenAI adapter, though. So here’s my rule of thumb. Write to the OpenAI shape, translate outward, and you’ve handed yourself the least painful exit the day you want to leave.

Here’s the part nobody warns you about, though. “OpenAI-compatible” is a spectrum, not a checkbox. Plain chat (messages in, completion out) ports cleanly and you’ll barely notice. Tools mostly work. It’s how arguments get parsed and how parallel calls come back that varies just enough to bite you. Vision exists on OpenAI, Anthropic, Gemini, except each one wants the image wrapped its own special way. JSON mode? A mess across the board, honestly. Streaming runs everywhere, then the chunk format drifts at the edges and your parser chokes. This tool lays every feature against every provider so you can price the move before you commit.

What the feature matrix covers in 2026

I picked the ten features that actually decide whether a port is an afternoon or a week. Basic chat messages. System message as a real field, versus something you cram into the first user turn. Temperature and max_tokens behaving the same way by default. Tools / function calling, single and parallel. Vision inputs (image_url and base64). JSON mode / structured outputs with schema enforcement. Streaming over Server-Sent Events. response_format with an explicit schema. seed for reproducible sampling. And logprobs, when you want token-level confidence. Every cell is a green check, a red cross, or a partial flag carrying a one-line “yeah, but” caveat.

Whenever a provider drops a new flagship, I refresh the matrix. The 2026 baseline I’m testing against: GPT-5 turbo and GPT-5 mini on OpenAI, Claude Opus 4.7 and Sonnet 4.6 on Anthropic, Gemini 3.0 Pro on Google, Mistral Large 3 and Codestral 2 on Mistral, Command R+ 2026 on Cohere, Llama 4 405B and Mixtral 8x22B served through Groq, and whatever GGUF you feel like running through Ollama or llama.cpp.

How the request translation works

For each provider you get a snippet you can actually run, written in that provider’s own SDK. Under the hood it’s doing five boring conversions, the kind that are easy to botch. Role normalisation (Anthropic pulls system into its own field, Gemini folds it into the first user turn). Tool schema mapping (OpenAI wraps things in type: function with a nested function object, Anthropic wants a flat tools array, Gemini wants function_declarations). Vision reshaping (OpenAI takes a content array with image_url, Anthropic uses type: image with source, Gemini wants inline data plus a mime type). Parameter renaming, where Mistral keeps max_tokens but Gemini insists on maxOutputTokens. Then lining up the response envelope, because every provider wraps the model output a little differently.

Copy it as a starting point, not a finished thing. The naive translation nails maybe 80 percent of cases, in my experience. That last 20 percent? It needs provider-specific tuning. Which is exactly what the warnings under each snippet are for (“Anthropic prefers prompt caching on the first 1024 tokens, consider adding cache_control”), so you know which follow-ups earn your time and which you can ignore.

Common provider gotchas the tool calls out

• Anthropic system message: it’s a top-level system string, not a message with role system. Your messages array has to start with user. Skip that and you’ll get a 400.
• Gemini message format: the roles are user and model, not assistant. Trips up everyone the first time. Content lives inside a parts array, too.
• Mistral tool calls: parallel tool calling only works on Large 3, last I checked. The smaller models hand tools back one at a time.
• Cohere “preamble” vs “system”: Cohere calls it preamble, not system, on the v2/chat endpoint. The newer messages-style v2 takes both. Old v1 doesn’t, so check which one you’re on.
• Groq streaming: to save bytes, SSE chunks drop delta.role after the first one. Assume it’s on every chunk and your client breaks. Ask me how I know.
• Ollama JSON mode: it’s format: json at the top level of the request, not response_format the way OpenAI does it.
• Vision base64 size limits: OpenAI takes up to 20 MB per image, Gemini 20 MB. Anthropic caps at 5 MB, though, and that’s the one that’ll surprise you. The tool flags any embedded image too big for where it’s headed.

When to keep the OpenAI client versus when to switch SDKs

Honestly? The compatibility layer is good enough that most teams just keep the official openai Node or Python client and re-point it at a new base URL and key. That alone covers OpenAI, Groq, Together, Fireworks, Ollama. Mistral too, once you override a couple of headers. Anthropic and Gemini are where I’d actually swap to the native SDK. They expose prompt caching, server-side tool use, grounded responses the OpenAI client just can’t reach. So my rule. Switch SDKs only when the feature you want is provider-native (Anthropic’s caching, Gemini grounding with search). Otherwise stay put. The diff isn’t worth it, I think, unless you’re chasing one of those.

Frequently asked questions

Sources & further reading

• OpenAI, API reference
• Anthropic, API documentation

Related tools and resources