API Compatível com OpenAI: O Que É, Quem Suporta e Como Mudar com Segurança
Índice:
Resposta rápida: Uma API compatível com OpenAI aceita os mesmos pedidos e retorna as mesmas respostas que a API do OpenAI.
Assim, o SDK oficial do OpenAI e as ferramentas construídas sobre ele podem chamar outros modelos alterando três valores: a URL base, a chave de API e o nome do modelo. Anthropic, Google Gemini, Mistral, Groq, DeepSeek, OpenRouter, Ollama, vLLM e muitos outros oferecem uma.
-
O que permanece igual: a forma do pedido, o SDK, a maior parte do seu código.
-
O que pode quebrar: esquemas JSON rigorosos, chamadas de ferramentas, detalhes de streaming, parâmetros ignorados, mensagens de erro e cabeçalhos de limite de taxa.
-
SDK nativo ou API compatível? Use a API compatível para mudar e comparar rapidamente. Use o SDK nativo quando precisar de recursos exclusivos do provedor.
-
Antes de mudar: execute um breve teste de fumaça e mantenha um rollback de uma linha.
A maioria dos aplicativos de IA começam na API do OpenAI, portanto a maior parte do código é escrita para o SDK do OpenAI.
Uma API compatível com OpenAI permite manter esse código e enviar os mesmos pedidos para Claude, Gemini, modelos de código aberto ou seu próprio servidor.
É a razão pela qual mudar de modelo pode levar minutos em vez de uma reescrita.
"Compatível" não significa "idêntico", porém, e as diferenças aparecem em produção.
Este guia explica como as APIs compatíveis com OpenAI funcionam, quais provedores oferecem uma, o que quebra quando você muda e como testar um provedor antes de confiar nele.
Se preferir alcançar vários provedores através de uma chave e uma conta, a API compatível com OpenAI do ScriptRun funciona com o SDK do OpenAI que você já usa.
O que é uma API compatível com OpenAI
Uma API compatível com OpenAI é qualquer API que copia a interface da API do OpenAI: os mesmos endpoints, o mesmo formato de solicitação e resposta JSON e a mesma autenticação de token Bearer.
Como a forma corresponde, qualquer cliente construído para OpenAI pode se comunicar com ela.
De todos os endpoints da API compatível com OpenAI, aquele que quase todos os provedores copiam é Chat Completions, /v1/chat/completions, porque é o que a maioria dos SDKs e frameworks chama.
Muitos também copiam /v1/models e /v1/embeddings. O suporte para endpoints mais novos, como Responses, files, batches ou audio, varia muito mais.
O formato do OpenAI se tornou o padrão comum porque chegou primeiro e quase todo framework o adotou: LangChain, LlamaIndex, o Vercel AI SDK, n8n e muitos outros.
Provedores de modelos o copiaram para que os desenvolvedores pudessem testar seus modelos sem aprender um novo SDK.
Servidores auto-hospedados como vLLM, Hugging Face Text Generation Inference (TGI), Ollama e LM Studio o copiaram para que modelos locais pudessem se conectar às mesmas ferramentas.
Como uma API compatível com OpenAI funciona
Você aponta o SDK do OpenAI para um servidor diferente alterando três valores:
-
URL base: o endpoint do provedor, como https://generativelanguage.googleapis.com/v1beta/openai/ para Gemini.
-
Chave de API: a chave do provedor, não sua chave do OpenAI.
-
Nome do modelo: um ID de modelo desse provedor, como gemini-3.8-flash.
Tudo o mais, incluindo suas mensagens, parâmetros e tratamento de resposta, permanece igual. Aqui está a mesma solicitação em três linguagens, usando o endpoint documentado do Gemini do Google.
Python
from openai import OpenAI
client = OpenAI(
api_key="GEMINI_API_KEY",
base_url="https://generativelanguage.googleapis.com/v1beta/openai/",
)
response = client.chat.completions.create(
model="gemini-3.8-flash",
messages=[
{
"role": "user",
"content": "Explain an OpenAI compatible API in one sentence."
}
],
)
print(response.choices[0].message.content)
Node.js
import OpenAI from "openai";
const client = new OpenAI({
apiKey: process.env.GEMINI_API_KEY,
baseURL: "https://generativelanguage.googleapis.com/v1beta/openai/",
});
const response = await client.chat.completions.create({
model: "gemini-3.8-flash",
messages: [
{
role: "user",
content: "Explain an OpenAI compatible API in one sentence."
}
],
});
console.log(response.choices[0].message.content);
curl
curl "https://generativelanguage.googleapis.com/v1beta/openai/chat/completions" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $GEMINI_API_KEY" \
-d '{
"model": "gemini-3.8-flash",
"messages": [
{
"role": "user",
"content": "Hello"
}
]
}'
📌 DICA: copie cada URL base exatamente como o provedor a documenta.
O SDK do OpenAI adiciona caminhos como /chat/completions ao que você fornece, portanto, um /v1 faltante ou extra é o erro de configuração mais comum.
Quais provedores oferecem uma API compatível com OpenAI
Quase todo grande provedor de modelos, plataforma de nuvem, gateway e servidor de inferência auto-hospedado agora oferece uma.
A API compatível com OpenAI do Groq, a API compatível com OpenAI do DeepSeek e o endpoint compatível com OpenAI do Together AI aceitam as mesmas solicitações; apenas a URL base, chave e modelo mudam.
Estas são as URLs base documentadas.
| Provedor | Tipo | URL base compatível com OpenAI |
|---|---|---|
| OpenAI | API de referência | https://api.openai.com/v1 |
| Anthropic (Claude) | Provedor de modelo | https://api.anthropic.com/v1/ |
| Google Gemini API | Provedor de modelo | https://generativelanguage.googleapis.com/v1beta/openai/ |
| Mistral AI | Provedor de modelo | https://api.mistral.ai/v1 |
| DeepSeek | Provedor de modelo | https://api.deepseek.com |
| xAI (Grok) | Provedor de modelo | https://api.x.ai/v1 |
| Groq | Provedor de inferência | https://api.groq.com/openai/v1 |
| Together AI | Provedor de inferência | https://api.together.ai/v1 |
| Fireworks AI | Provedor de inferência | https://api.fireworks.ai/inference/v1 |
| Azure OpenAI / Microsoft Foundry | Plataforma de nuvem | https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/ |
| Amazon Bedrock | Plataforma de nuvem | https://bedrock-runtime.{region}.amazonaws.com/openai/v1 |
| OpenRouter | Gateway | https://openrouter.ai/api/v1 |
| Ollama | Servidor local | http://localhost:11434/v1/ |
| LM Studio | Servidor local | http://localhost:1234/v1 |
| vLLM | Servidor auto-hospedado | http://localhost:8000/v1 |
As URLs base para Anthropic e Gemini foram verificadas em relação à sua própria documentação em 13 de novembro de 2026.
As outras vêm da referência de compatibilidade do DevelopersDigest, que foi verificada em relação à documentação de cada provedor em 18 de outubro de 2026.
Os provedores mudam essas informações, portanto verifique a documentação antes de fazer deploy.
Compatível não é idêntico: o que quebra quando você muda
Compatibilidade com API do OpenAI significa que um provedor aceita o formato do OpenAI. Não promete o comportamento do OpenAI.
As chamadas simples funcionam quase em qualquer lugar; os problemas aparecem nos recursos nos quais os aplicativos de produção dependem.
| Área | O que geralmente funciona | O que frequentemente difere |
|---|---|---|
| Chat básico | Mensagens entram, escolhas saem | Como mensagens do sistema são tratadas |
| Parâmetros | temperature, max_tokens, stop | Campos não suportados (seed, logprobs, penalties) são frequentemente silenciosamente ignorados, não rejeitados |
| Saída estruturada | Saída JSON básica em muitos modelos | Quais tipos de response_format são aceitos e se esquemas "rigorosos" são aplicados |
| Chamadas de ferramentas | Definição de ferramentas e retorno de chamada | Esquemas de argumento rigorosos, chamadas paralelas, opções tool_choice |
| Streaming | Chunks token por token | Limites de chunk, escolhas vazias, se o uso chega no final |
| Entradas | Texto, frequentemente imagens | Áudio, files e PDFs |
| Erros e limites | Códigos de status HTTP | Mensagens de erro e cabeçalhos de limite de taxa (consulte nosso guia para limites de taxa da API do OpenAI) |
| Outros endpoints | Lista de modelos, frequentemente embeddings | API Responses, batches, files, audio |
API compatível com OpenAI do Anthropic: o que é diferente
O Anthropic é incomumente claro sobre sua camada. Sua documentação diz que a camada é "principalmente destinada a testar e comparar recursos de modelo, e não é considerada uma solução de longo prazo ou pronta para produção para a maioria dos casos de uso".
Eles também listam diferenças específicas:
-
O parâmetro strict para chamadas de função é ignorado, portanto argumentos de ferramentas não têm garantia de corresponder ao seu esquema.
-
response_format aceita apenas json_schema com strict: true; json_object ou text retorna um erro 400.
-
Entradas de áudio e arquivo retornam um erro 400, e o cache de prompt não é suportado através dessa camada.
-
Campos como logprobs, seed, presence_penalty e frequency_penalty são silenciosamente ignorados.
-
Os formatos de erro correspondem ao do OpenAI, mas as mensagens de erro detalhadas não, e alguns cabeçalhos de limite de taxa têm nomes diferentes.
Fonte: Anthropic, compatibilidade do SDK OpenAI.
API compatível com OpenAI do Gemini: o que é diferente
A camada do Google cobre mais terreno: chat, streaming, chamada de função, compreensão de imagem e áudio, saída estruturada, embeddings e partes da API Batch.
Opções específicas do Gemini, como configurações de pensamento e conteúdo em cache, entram em extra_body. O Google ainda rotula o suporte da biblioteca OpenAI como beta e diz: "Se você ainda não está usando as bibliotecas OpenAI, recomendamos que você chame a API Gemini diretamente."
Fonte: Google, compatibilidade OpenAI da API Gemini.
API compatível com OpenAI ou SDK nativo do provedor
Nenhum é sempre correto. Escolha pelo que você precisa.
| Escolha uma API compatível com OpenAI quando… | Escolha o SDK nativo quando… |
|---|---|
| Seu aplicativo já usa o SDK do OpenAI ou um framework construído sobre ele | Você está começando do zero com um provedor |
| Você quer comparar modelos ou mudar de provedores rapidamente | Você precisa de recursos específicos do provedor, como cache de prompt e suporte a PDF do Anthropic, ou opções de grounding e cache do Gemini |
| Você usa vários provedores e quer um caminho de código | Você precisa de comportamento garantido que a camada compatível não promete |
| Você quer failover entre provedores sem novo código de integração | O provedor diz que sua camada não é destinada à produção, como faz o Anthropic |
Muitas equipes fazem ambos.
Eles usam uma API compatível com OpenAI para a maioria do tráfego e um SDK nativo para um ou dois recursos que precisam dela.
Direto para cada provedor ou através de um gateway
Você pode apontar seu aplicativo para o endpoint compatível de cada provedor diretamente ou para um gateway que oferece um endpoint compatível com OpenAI para muitos provedores.
| Direto para cada provedor | Um gateway compatível com OpenAI | |
|---|---|---|
| Configuração | Uma conta, chave e cobrança por provedor | Uma conta, uma chave, uma conta |
| Mudança de modelos | Alterar URL base, chave e modelo | Alterar o nome do modelo |
| Interrupções e limites de taxa | Você constrói retries e failover | Frequentemente construído (verifique como) |
| Latência | Sem hop extra | Um hop de rede extra |
| Dependência | Cada provedor | Cada provedor mais o gateway |
| Caminho de dados | Seu aplicativo para o provedor | Seu aplicativo para o gateway para o provedor |
Um gateway compensa quando você usa mais de um provedor, precisa de failover ou quer gastos e limites em um único lugar.
Pergunte a qualquer gateway, incluindo o ScriptRun, quanto de latência adiciona, qual é seu registro de uptime e como ele lida com seus dados.
Para saber como os pedidos são roteados entre modelos, consulte nosso guia para roteadores de LLM.
Teste qualquer API compatível com OpenAI em cinco minutos
Não confie em um rótulo "compatível" até testar os recursos que seu aplicativo usa.
Este script verifica cinco coisas em relação a qualquer provedor: chat básico com dados de uso, streaming, chamada de ferramenta, esquema JSON rigoroso e tratamento de erro.
Defina três variáveis de ambiente - LLM_BASE_URL, LLM_API_KEY e LLM_MODEL; execute o script e leia as linhas PASS e FAIL.
Python
import json
import os
from openai import OpenAI
client = OpenAI(
base_url=os.environ["LLM_BASE_URL"],
api_key=os.environ["LLM_API_KEY"]
)
MODEL = os.environ["LLM_MODEL"]
def basic_chat():
r = client.chat.completions.create(
model=MODEL,
messages=[{"role": "user", "content": "Reply with the word OK."}],
max_tokens=10
)
assert r.choices[0].message.content, "empty reply"
assert r.usage and r.usage.total_tokens > 0, "no usage data"
def streaming():
stream = client.chat.completions.create(
model=MODEL,
messages=[{"role": "user", "content": "Count to 3."}],
stream=True
)
text = "".join(
c.choices[0].delta.content or ""
for c in stream if c.choices
)
assert text, "empty stream"
def tool_calling():
tool = {
"type": "function",
"function": {
"name": "get_weather",
"description": "Get the weather for a city",
"parameters": {
"type": "object",
"properties": {
"city": {"type": "string"}
},
"required": ["city"]
}
}
}
r = client.chat.completions.create(
model=MODEL,
messages=[
{"role": "user", "content": "What's the weather in Paris?"}
],
tools=[tool]
)
call = r.choices[0].message.tool_calls[0]
assert json.loads(call.function.arguments)["city"], "no city argument"
def json_schema():
schema = {
"type": "object",
"properties": {
"answer": {"type": "string"}
},
"required": ["answer"],
"additionalProperties": False
}
r = client.chat.completions.create(
model=MODEL,
messages=[{"role": "user", "content": "Say hello."}],
response_format={
"type": "json_schema",
"json_schema": {
"name": "reply",
"schema": schema,
"strict": True
}
}
)
assert "answer" in json.loads(r.choices[0].message.content)
def error_handling():
try:
client.chat.completions.create(
model="model-that-does-not-exist",
messages=[{"role": "user", "content": "hi"}]
)
except Exception as err:
status = getattr(err, "status_code", None)
assert status and 400 <= status < 500, f"unexpected error: {err!r}"
return
raise AssertionError("no error for an unknown model")
for name, test in [
("basic chat + usage", basic_chat),
("streaming", streaming),
("tool calling", tool_calling),
("strict JSON schema", json_schema),
("error handling", error_handling)
]:
try:
test()
print(f"PASS {name}")
except Exception as err:
print(f"FAIL {name}: {err}")
Um FAIL nem sempre descarta um provedor. Ele informa qual parte do seu código precisa de uma solução alternativa ou quais solicitações devem permanecer em outro modelo.
Lista de verificação de migração: mudança sem quebrar a produção
-
Liste o que você usa. Endpoints, parâmetros, ferramentas, esquemas JSON, streaming, imagens e arquivos.
-
Verifique a página de compatibilidade do provedor para cada item, especialmente campos que são silenciosamente ignorados.
-
Execute o teste de fumaça com seus prompts e modelos reais.
-
Mova a configuração para variáveis de ambiente: URL base, chave e modelo. Voltar é então uma alteração de configuração, não um deploy.
-
Compare saídas em uma amostra de pedidos reais: qualidade, latência e custo por 1.000 solicitações.
-
Implante gradualmente. Comece com uma pequena parte do tráfego ou um recurso interno.
-
Monitore erros e limites de taxa e mantenha o provedor antigo pronto como fallback para as primeiras semanas.
Usando a API compatível com OpenAI do ScriptRun
A Open API do ScriptRun oferece um endpoint compatível com OpenAI e uma chave de API para modelos do OpenAI, Anthropic (Claude) e Google (Gemini).
Você mantém o SDK do OpenAI e altera duas linhas:
from openai import OpenAI
client = OpenAI(
base_url="SCRIPTRUN_BASE_URL", # from your ScriptRun dashboard
api_key="YOUR_SCRIPTRUN_KEY",
)
response = client.chat.completions.create(
model="MODEL_ID", # any model available in ScriptRun
messages=[{"role": "user", "content": "Hello"}],
)
print(response.choices[0].message.content)
O que você obtém além do formato compatível:
-
Uma conta em vez de muitas: sem inscrições separadas ou verificações KYC com cada provedor e uma única conta.
-
Roteamento inteligente e failover: escolha modelos por qualidade, custo e tamanho de contexto, com alternância automática entre provedores durante interrupções.
-
Confiabilidade integrada: tentativas com backoff e idempotência em nível de solicitação, para que uma chamada repetida não seja processada duas vezes.
-
Controle: chaves por projeto, limites e quotas.
-
Acesso e cobrança para equipes globais: acesso sem VPN, cartões, criptografia e SWIFT, além de contratos e notas fiscais para empresas.
-
Fluxos de trabalho quando você precisar: a API Workflow adiciona ramificação, webhooks, timeouts e retries para tarefas de IA em várias etapas.
A mesma ressalva se aplica como para qualquer gateway: execute o teste de fumaça acima em relação ao ScriptRun com seus próprios prompts antes de mover o tráfego de produção.
Obtenha uma chave de API do ScriptRun e experimente com o código que você já tem.
Perguntas Frequentes sobre a API Compatível com OpenAI
A API Claude é compatível com OpenAI?
Sim. A Anthropic oferece uma camada de compatibilidade com o SDK do OpenAI em https://api.anthropic.com/v1/. A Anthropic diz que é principalmente para testes e comparação de modelos, não para uso em produção a longo prazo, e alguns recursos se comportam de forma diferente. Para todos os recursos do Claude, use a API nativa ou um gateway que suporte Claude.
A API Gemini é compatível com OpenAI?
Sim. Defina a URL base para https://generativelanguage.googleapis.com/v1beta/openai/, use uma chave de API Gemini e um nome de modelo Gemini. O Google rotula esse suporte como beta.
A API do Ollama é compatível com OpenAI?
Sim. A API compatível com OpenAI do Ollama é executada no seu servidor local em http://localhost:11434/v1/. O SDK do OpenAI precisa de um valor de chave de API, mas o Ollama local a ignora.
O OpenRouter é compatível com o OpenAI?
Sim. A URL base compatível com OpenAI do OpenRouter é https://openrouter.ai/api/v1.
Existe uma API compatível com OpenAI gratuita?
Servidores locais como Ollama, LM Studio e vLLM são gratuitos para executar no seu próprio hardware. Vários provedores hospedados também têm camadas gratuitas com limites.
A API Groq é compatível com OpenAI?
Sim. A URL base compatível com OpenAI do Groq é https://api.groq.com/openai/v1. Observe o /openai adicional no caminho: usar uma URL /v1 simples é um erro de configuração comum. Você altera a URL base, a chave de API e o nome do modelo, e seu código permanece o mesmo, a menos que você dependa de recursos que o Groq trata de forma diferente.
Publicações relacionadas
API de LLM mais barata em 2026: preços verificados por 1 milhão de tokens
Qual é a API de LLM mais barata? Preços verificados da OpenAI, Claude, Gemini, DeepSeek, Qwen, Mistral e Groq, além de custos reais de carga de trabalho e taxas ocultas.
Marketplace de Agentes de IA: os 10 melhores lugares para encontrar, executar e vender agentes de IA em 2026
O que é um marketplace de agentes de IA, 10 principais plataformas comparadas por custo para testar e quem pode vender, uma lista de verificação de segurança e como listar o seu próprio agente em 2026.
API LLM Gratuita: Quais Provedores Ainda São Gratuitos em 2026 (Limites, Chaves e Pegadinhas)
Cada API LLM gratuita que vale a pena usar em 2026, verificada contra documentação oficial: camadas gratuitas versus créditos, limites, termos de dados, como obter uma chave e código de fallback.
Alternativas OpenRouter: 7 Gateways de LLM Comparados em Roteamento, Preços e Aprisionamento
Alternativas do OpenRouter comparadas: taxas, roteamento, BYOK e auto-hospedagem em 7 gateways de LLM, com lista de verificação de migração e preços verificados de 2026.








