Free tool · no sign-up

OpenAI compatibility matrix: 25 providers across 18 features

Which OpenAI API features survive a base-URL change? This matrix records what each provider documents on its OpenAI-compatible surface — not what its native API can do.

Test an endpoint

Showing 25 of 25 providers.

Documentation status on the OpenAI-compatible surface, checked 20 November 2026. ✓ documented · ◐ partial or model-dependent · — not documented · ? unverified. “Docs” opens the provider's reference.
ProviderChat completionsStreamingTool callingParallel toolsJSON modeJSON SchemaVision inputAudio inputImage generationEmbeddingsBatch APIResponses APIPrompt cachingLogprobsSeedFiles APIFine-tuningRerankDocumentedSource
OpenAI
Native
✓✓✓✓✓✓✓◐✓✓✓✓✓✓✓✓✓—16.5 / 18Docs
Azure OpenAI
Yes
✓✓✓✓✓✓✓◐✓✓✓◐✓✓✓✓✓—16 / 18Docs
Anthropic
Partial (SDK shim)
✓✓✓◐◐◐✓◐——✓—✓◐—◐◐—9.5 / 18Docs
Google Gemini
Yes
✓✓✓◐◐✓✓✓✓✓✓—✓✓◐✓✓—14.5 / 18Docs
Mistral AI
Yes
✓✓✓◐✓✓✓◐—✓✓—◐✓✓✓✓—13.5 / 18Docs
Cohere
Partial
✓✓✓◐✓◐◐——✓✓——◐———✓9 / 18Docs
Groq
Yes
✓✓✓✓✓✓✓◐——◐——✓✓———10 / 18Docs
Together AI
Yes
✓✓✓✓✓✓✓◐✓✓✓—◐✓✓✓✓✓16 / 18Docs
Fireworks AI
Yes
✓✓✓✓✓✓✓◐✓✓✓—◐✓✓✓✓✓16 / 18Docs
DeepInfra
Yes
✓✓✓◐✓◐✓◐✓✓◐—◐✓✓—✓✓13.5 / 18Docs
OpenRouter
Yes
✓✓✓◐✓◐✓◐✓◐——◐✓✓———10.5 / 18Docs
Perplexity
Yes
✓✓◐—◐—————————————3 / 18Docs
xAI
Yes
✓✓✓✓✓✓✓◐✓◐◐—✓✓✓✓——13.5 / 18Docs
DeepSeek
Yes
✓✓✓◐✓✓————◐—✓✓✓———9 / 18Docs
Moonshot AI
Yes
✓✓✓◐✓✓✓◐—✓◐—◐✓✓—✓—12 / 18Docs
Alibaba DashScope
Yes
✓✓✓◐✓✓✓◐✓✓✓—◐✓✓✓✓✓15.5 / 18Docs
Zhipu AI
Yes
✓✓✓◐✓✓✓◐✓✓◐—◐✓✓—✓✓14 / 18Docs
MiniMax
Yes
✓✓✓◐✓◐✓◐—✓◐—◐✓——✓—10.5 / 18Docs
Cerebras
Yes
✓✓✓◐✓✓———————✓————6.5 / 18Docs
SambaNova
Yes
✓✓✓◐✓◐✓◐—✓◐—◐✓——✓—10.5 / 18Docs
Replicate
Partial
◐◐◐———◐◐✓◐✓———————5 / 18Docs
Hugging Face Inference Providers
Yes
✓✓✓◐✓◐✓◐✓✓◐—◐✓✓—✓—12.5 / 18Docs
Ollama
Yes
✓✓✓◐✓✓✓◐—✓——◐✓✓——◐11 / 18Docs
vLLM
Yes
✓✓✓✓✓✓✓◐✓✓✓—✓✓✓✓—✓15.5 / 18Docs
LM Studio
Yes
✓✓✓◐✓✓✓◐—✓—◐✓✓✓——◐12 / 18Docs

The “Documented” count adds 1 for ✓ and 0.5 for ◐. It is a documentation-completeness count, not a quality, speed or price ranking. A provider with fewer checks can be the better choice for your workload.

How to read the matrix

The columns describe the OpenAI-compatible API surface, not the provider's native API. Anthropic's native Messages API has features that its OpenAI SDK shim does not expose; Gemini's native API differs from its OpenAI compatibility layer; Cohere's rerank endpoint is native. A “—” means the feature is not documented on the compatibility surface, not that the provider cannot do it at all.

The matrix is a shortlist tool. It answers “can I keep my OpenAI client code?” at the level of endpoints and parameters. It does not answer “will my tool schema behave the same way?”, “does streaming include usage?”, “are parallel tool calls actually parallel?”, or “does JSON Schema reject additional properties?”. Those require a test against your payloads.

The features that break a migration

Six compatibility traps that a chat-completions smoke test will miss.
FeatureWhy it breaksWhat to test
Tool callingSchema dialect, required fields, parallel calls and the shape of tool_calls vary.Send a schema with nested objects, an enum and a required field. Assert the arguments parse.
JSON SchemaSome providers support only json_object, not a full schema. Others accept a schema but do not enforce it.Send a schema with additionalProperties: false and a required array. Check for extra keys.
StreamingUsage chunks, finish reasons and keep-alives differ. Some omit usage unless asked.Stream 100 tokens. Assert the final chunk, usage fields and reconnect behaviour.
VisionImage URL vs base64, supported MIME types, resolution limits and token accounting differ.Send one URL and one base64 image. Compare the extracted text and the token count.
EmbeddingsDimensions, normalization, input limits and batch size differ. A different model means a different vector space.Embed the same 20 documents. Check dimensions and cosine similarity ordering.
BatchFile format, completion window, partial failure semantics and pricing differ.Submit a 3-request batch with one invalid line. Check the error file and the billing.

Drop-in is a spectrum

There are four levels of compatibility, and the matrix collapses them into one table. The first is native: OpenAI itself. The second is a compatible endpoint: the provider implements the same routes and request shapes, often with a subset of parameters. The third is a shim: an adapter translates OpenAI requests into a different native API, which is what Anthropic's OpenAI SDK compatibility does. The fourth is local serving: vLLM, Ollama, LM Studio and llama.cpp implement an OpenAI-shaped server in front of local weights.

The level matters more than the checkmarks. A native-compatible endpoint with a missing feature fails loudly; a shim can fail quietly by ignoring an unsupported parameter. If a provider ignores response_format instead of rejecting it, your JSON parser fails downstream, not at the API boundary. Test the response, not the status code.

A 30-minute compatibility test

Use the OpenAI SDK with a different base_url and run five checks: streaming, tool calling, JSON Schema, vision and embeddings. The snippet below is a starting point; replace the model IDs with ones the provider actually serves.

import json
from openai import OpenAI

client = OpenAI(base_url="https://api.plugsky.com/v1", api_key="YOUR_KEY")

# 1. Streaming and final chunk
stream = client.chat.completions.create(
    model="plugsky-plus",
    messages=[{"role": "user", "content": "Count to five."}],
    stream=True,
)
chunks = list(stream)
assert chunks, "no chunks"
print("stream chunks:", len(chunks), "finish:", chunks[-1].choices[0].finish_reason)

# 2. Tool calling
tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "parameters": {
            "type": "object",
            "properties": {"city": {"type": "string"}},
            "required": ["city"],
            "additionalProperties": False,
        },
    },
}]
r = client.chat.completions.create(
    model="plugsky-plus",
    messages=[{"role": "user", "content": "Weather in Paris?"}],
    tools=tools,
)
print("tool calls:", r.choices[0].message.tool_calls)

# 3. JSON Schema
r = client.chat.completions.create(
    model="plugsky-plus",
    messages=[{"role": "user", "content": "Return a color and a hex code."}],
    response_format={"type": "json_schema", "json_schema": {
        "name": "color", "strict": True,
        "schema": {"type": "object",
                   "properties": {"name": {"type": "string"}, "hex": {"type": "string"}},
                   "required": ["name", "hex"], "additionalProperties": False},
    }},
)
print(json.loads(r.choices[0].message.content))

# 4. Embeddings
e = client.embeddings.create(model="plugsky-embed", input=["alpha", "beta"])
print("dimensions:", len(e.data[0].embedding))

Add a vision check if the provider claims image input, and a batch check if the workload is deferrable. Record the model ID, date and result in your migration ticket. A compatibility matrix is a hypothesis; this script is the experiment.

What the matrix does not tell you

Methodology

The matrix was compiled from public documentation on 20 November 2026. Each provider's docs link is in the row. A feature is marked ✓ only when the documentation describes it on the OpenAI-compatible surface; ◐ when it is limited to some models, requires a flag, or is described as partially compatible; — when it is not documented there; and ? when the documentation was ambiguous. No cell is based on a private conversation, a sales deck or an unverified blog post.

The matrix is not a benchmark and does not test runtime behaviour. It is a documentation map. For runtime evidence, use the compatibility checker and the compatibility report. For the endpoint shape Plugsky implements, see the API reference and the model catalogue.

FAQ

What does “documented” mean in the matrix?

It means the provider's public documentation describes the feature on its OpenAI-compatible surface as of 20 November 2026. It does not mean the feature works identically, supports the same parameters, or is available on every model. A green check is a reason to test, not a guarantee.

Which providers are true drop-in replacements?

Very few. OpenAI itself is the reference. Azure OpenAI is close but versioned and deployment-based. Gemini, Mistral, Groq, Together, Fireworks, DeepInfra, OpenRouter, xAI, DeepSeek, Moonshot, DashScope, Zhipu, MiniMax, Cerebras, SambaNova, Hugging Face, Ollama, vLLM and LM Studio expose an OpenAI-shaped endpoint, but each differs on tools, JSON Schema, batch, files and Responses. Anthropic and Cohere offer partial compatibility or a shim.

Why is the Responses API mostly absent?

The Responses API is OpenAI's newer stateful interface, and most providers implemented the older Chat Completions shape first. A provider can support Chat Completions well and have no Responses endpoint. If your application depends on Responses objects, server-side conversation state or built-in tools, test that endpoint specifically rather than assuming chat compatibility carries over.

Does a checkmark mean the model is good?

No. The matrix measures interface features, not quality, latency, price, rate limits, data residency or safety. A provider can support every column and still be wrong for your workload. Use the matrix to shortlist, then run your own evaluation on the tasks you care about.

How was the matrix compiled?

From each provider's public API documentation, OpenAI compatibility guide and reference pages, checked on 20 November 2026. Where the documentation was ambiguous or described a native-only feature, the cell is partial or not documented rather than a guess. The docs link on each row is the source to re-check.

Sources and verification

Primary sources were opened and checked on 20 November 2026. Product terms and datasets change; the linked source is authoritative.

One endpoint, 39 hosted models

Plugsky implements the OpenAI chat-completions surface at https://api.plugsky.com/v1. Keep the SDK, change the base URL, and check the model catalogue for context and modality.

Read the API reference → Browse models