Blank white background with no objects or features visible.

Olá, EMEA! A TrueFoundry está expandindo sua presença pela Europa, Oriente Médio e África. Leia mais. →

O que é uma API compatível com OpenAI? A interface que unifica provedores de LLM

Published: novembro 20, 2026

Resumo
  • "Compatível com OpenAI" significa que um provedor expõe o esquema Chat Completions, o endpoint POST /v1/chat/completions, o formato de requisição messages, o formato de resposta choices/usage e streaming SSE, para que o código existente com SDKs da OpenAI funcione alterando apenas a URL base e o nome do modelo.
  • Tornou-se o padrão de fato por um acaso de timing. A OpenAI lançou primeiro, os SDKs foram adotados em todos os lugares e todos os provedores subsequentes acharam mais barato imitar o esquema do que ensinar um novo ao ecossistema.
  • Compatível não é idêntico. Dialetos de chamada de ferramentas (tool-calling) diferem, a contagem de tokens do usage varia e parâmetros como seed, logit_bias e penalidades frequentemente não têm efeito silenciosamente (no-op) em backends que não são da OpenAI. Código que presume comportamento idêntico quebra de formas sutis.
  • Um gateway expõe um único endpoint compatível com OpenAI para todos os provedores. Você envia o mesmo corpo de requisição e altera apenas o valor de model; o gateway traduz para a API real de cada backend e normaliza a resposta.
  • O retorno é operacional, não cosmético: um único ponto de integração oferece failover, caching, atribuição de custos e observabilidade gratuitamente, algo que nenhuma integração direta por provedor oferece.

Escolha quase qualquer produto de LLM lançado nos últimos três anos e inspecione sua API. A probabilidade é alta de que ele aceite uma requisição com um campo model, um array messages de objetos {role, content} e temperature, e retorne um array choices com um bloco usage contando tokens. Esse formato não veio de um órgão de padronização. Veio da API Chat Completions da OpenAI — e venceu.

Para uma equipe de plataforma, "compatível com OpenAI" é uma expressão estrutural. É a razão pela qual você pode avaliar um novo modelo de código aberto (open-weight) na sexta-feira e tê-lo servindo tráfego na segunda-feira sem reescrever sua aplicação. É também uma expressão que promete mais do que cumpre silenciosamente: dois endpoints podem ser ambos "compatíveis com OpenAI" e ainda assim divergir sobre como as chamadas de ferramentas são retornadas, como os tokens são contados e se o parâmetro que você definiu realmente faz alguma coisa.

Este post explica o que o padrão realmente é, o que a "compatibilidade" garante e o que não garante, e como um gateway transforma muitos provedores parcialmente compatíveis em um único endpoint no qual você pode construir com confiança.

Quer um único endpoint compatível com OpenAI em todos os provedores, com failover e rastreamento de custos? Agende uma demonstração.

Como o esquema Chat Completions se tornou o padrão

Os padrões geralmente vencem por uma de duas razões: ou são impostos, ou chegam primeiro e são adotados antes que alguém projete uma alternativa. O esquema Chat Completions pertence firmemente ao segundo caso.

A OpenAI publicou o endpoint /v1/chat/completions e, fundamentalmente, lançou SDKs oficiais em Python e JavaScript que o encapsulavam. Esses SDKs foram incorporados em tutoriais, modelos iniciais, integrações de frameworks e bases de código de produção em toda a indústria. Quando os provedores concorrentes tiveram modelos que valiam a pena servir, a superfície de integração já estava padronizada na prática: milhões de linhas de código já sabiam como chamar client.chat.completions.create(...).

Um novo provedor enfrentava então uma escolha: definir sua própria API elegante e pedir a todo o ecossistema que a aprendesse, ou implementar o esquema da OpenAI e herdar todos os SDKs, frameworks e ferramentas gratuitamente. Quase todos escolheram o segundo caminho. As pilhas de servimento open-weight o adotaram para que qualquer coisa executada neles ficasse instantaneamente acessível a partir do código existente. O resultado é um padrão de fato sem um documento formais de padrões: o esquema é "qualquer coisa que o SDK da OpenAI envia e espera de volta".

É por isso que a expressão é mais importante do que parece. A compatibilidade não é um recurso que um fornecedor adiciona por capricho. É o bilhete de entrada para um ecossistema e molda como você pode arquitetar sua escolha de modelos.

O que "compatível com OpenAI" realmente significa

Simplificando, a compatibilidade é um contrato sobre quatro coisas: o endpoint, o formato da requisição, o formato da resposta e o streaming.

O endpoint. Um serviço compatível aceita POST /v1/chat/completions com um cabeçalho Authorization: Bearer <key>. Muitos também implementam /v1/models, /v1/embeddings e /v1/completions. A URL base muda por provedor; o caminho não.

O formato da requisição. No mínimo: uma string model e um array messages de objetos com um role (system, user, assistant, tool) e content. Parâmetros opcionais que o cliente pode enviar incluem temperature, top_p, max_tokens (modelos mais novos da OpenAI usam max_completion_tokens), stream, stop, tools, tool_choice e response_format.

O formato da resposta. Um objeto JSON com um array choices; cada escolha possui um index, uma message com role e content (e tool_calls quando o modelo chama uma função) e um finish_reason (stop, length, tool_calls, content_filter). Um objeto usage informa prompt_tokens, completion_tokens e total_tokens.

Streaming. Com stream: true, a resposta é um text/event-stream de eventos enviados pelo servidor (server-sent events). Cada linha data: carrega um trecho cujo choices[].delta contém o(s) token(s) incremental(is). A transmissão termina com um data: [DONE] literal.

Anatomy of an OpenAI-compatible exchange: the request carries model, messages, tools, and stream; the response carries choices (with message and finish_reason) and a usage token count.
Anatomia de uma troca compatível com OpenAI: a requisição carregamodel,messages,toolsestream; a resposta carregachoices(commessageefinish_reason) e uma contagem de tokensusage.

Um exemplo prático: mesmo corpo, modelo diferente

Aqui está o retorno concreto. Este corpo de requisição tem como alvo a OpenAI:

POST https://api.openai.com/v1/chat/completions
Authorization: Bearer sk-...

{
"model": "gpt-4.1",
"messages": [
{"role": "system", "content": "You are a terse assistant."},
{"role": "user", "content": "Summarize MCP in one sentence."}
],
"temperature": 0.2,
"stream": false
}

Para executar o mesmo prompt em um provedor diferente por meio de um endpoint compatível, você altera duas coisas: a URL base e o valor de model. Os campos messages, temperature e stream permanecem intocados. Seu código de parsing, que lê choices[0].message.content e usage.total_tokens, não muda absolutamente nada. Essa é toda a proposta de valor em uma única diferença: a escolha do modelo se torna uma string, não uma reescrita de código.

A resposta, independentemente do backend que a serviu, retorna como:

{
"id": "chatcmpl-...",
"choices": [
{"index": 0,
"message": {"role": "assistant", "content": "MCP is an open protocol..."},
"finish_reason": "stop"}
],
"usage": {"prompt_tokens": 24, "completion_tokens": 18, "total_tokens": 42}
}

A lacuna entre "compatível" e "idêntico"

Aqui é onde as equipes se prejudicam. "Compatível com OpenAI" é uma alegação sobre o esquema, não uma garantia de comportamento idêntico. O envelope é igual; o conteúdo pode diferir de maneiras que só surgem sob carga ou em casos de borda.

Dialetos de chamada de ferramentas (tool-calling). A maior divergência. A OpenAI retorna chamadas de função em message.tool_calls, cada uma com um id, um type e um objeto function cujo arguments é um blob JSON convertido em string que você deve analisar. Alguns backends compatíveis retornam argumentos como um objeto já analisado, emitem o campo único function_call mais antigo, transmitem deltas de chamada de ferramenta de forma diferente ou lidam com chamadas de ferramentas paralelas de forma inconsistente. Código que faz JSON.parse nos argumentos de forma cega lançará um erro em um backend que já os analisou.

Contagem de tokens. As contagens de usage são calculadas pelo próprio tokenizador de cada provedor. O mesmo prompt enviado a dois modelos gera prompt_tokens diferentes porque os tokenizadores diferem. Pior, alguns backends omitem usage completamente em respostas de streaming, a menos que você defina uma flag, fazendo com que o rastreamento de custos que depende disso leia zero silenciosamente.

Parâmetros no-op silenciosos. Você pode enviar seed, logit_bias, frequency_penalty, presence_penalty ou response_format: {type: "json_schema"} para um endpoint compatível e receber um 200 OK de volta, com o parâmetro completamente ignorado. O endpoint aceitou o campo porque o esquema permite; o backend simplesmente não o implementa. Esta é a classe mais nociva de bug porque nada gera erro. Seu pipeline "determinístico" que depende de seed é silenciosamente não determinístico.

Manipulação de prompt do sistema e de papéis. Alguns backends incorporam a mensagem system no primeiro turno do usuário, ou suportam apenas uma mensagem do sistema, ou tratam um content vazio de forma diferente. O comportamento em conversas de vários turnos pode desviar.

Semântica de finish-reason. Quando um modelo para porque deseja chamar uma ferramenta, a OpenAI informa finish_reason: "tool_calls". Nem todo backend usa a mesma string, o que quebra loops de agentes que fazem desvios com base nisso.

A tabela abaixo separa o que o padrão oferece de forma confiável do que você deve verificar por provedor.

O que "compatível com OpenAI" garanteO que ainda difere por provedor
Endpoint e caminho POST /v1/chat/completionsURL base e particularidades de autenticação
Array messages com role/contentComo mensagens de system são tratadas ou mescladas
choices[].message.content na respostaFormato da chamada de ferramenta (stringificado vs arguments analisado)
Streaming SSE com trechos delta, sentinela [DONE]Se usage é informado em respostas transmitidas
Um objeto de contagem de tokens usage (geralmente)Tokenizador, portanto a contagem de tokens difere para o mesmo texto
A requisição aceita parâmetros padrão sem erroSe seed, logit_bias, penalidades realmente se aplicam
Campo finish_reason presenteStrings exatas de finish_reason, especialmente para chamadas de ferramentas

A lição não é "a compatibilidade é falsa". É "a compatibilidade lhe dá 90% de graça e você deve testar os últimos 10% por provedor". Esses últimos 10% são precisamente o trabalho que um gateway pode absorver para que sua aplicação nunca precise lidar com isso.

Veja como a TrueFoundry permite trocar modelos pelo nome sem tocar no código da aplicação. Agende uma demonstração.

Um único endpoint para todos os provedores: o padrão gateway

Se cada provedor é quase compatível, mas sutilmente diferente, a arquitetura limpa é parar de fazer sua aplicação falar com cada provedor diretamente. Coloque um endpoint compatível com OpenAI na frente de todos eles e deixe essa camada cuidar da tradução e da normalização.

One OpenAI-compatible endpoint fans out to many backends, OpenAI, Anthropic, Google, and open-weight models, behind a single interface.
Um endpoint compatível com OpenAI se distribui para vários backends — OpenAI, Anthropic, Google e modelos open-weight — por trás de uma única interface.

É isso que um AI gateway faz, e é estruturalmente a mesma ideia de um proxy LLM: uma única porta de entrada lógica, muitos backends atrás dela. A TrueFoundry expõe uma API unificada compatível com OpenAI na frente de cada provedor. Sua aplicação continua enviando o formato Chat Completions que já conhece. Para alternar modelos, você altera o valor de model para um nome lógico que o gateway resolve; todo o resto — corpo da requisição, SDK, parsing — permanece constante.

Como o gateway normaliza as diferenças descritas acima, seu código deixa de se importar se um determinado backend converte argumentos de chamada de ferramenta em string ou informa usage em transmissões. O gateway apresenta um dialeto consistente. Bibliotecas de código aberto como o LiteLLM popularizaram essa camada de tradução em código; nosso texto explicativo sobre o que é o LiteLLM cobre essa abordagem e onde um gateway gerenciado vai além.

Mas o motivo para adotar o padrão não é apenas uma interface organizada. Uma vez que cada requisição flui por um endpoint, você desbloqueia recursos que são impossíveis de adicionar a integrações dispersas por provedor:

Roteamento. Um nome lógico de modelo pode ser respaldado por vários destinos reais, e o gateway escolhe entre eles por latência, peso ou prioridade. Veja o que é um roteador LLM para seleção de modelos consciente de custo e qualidade.

Fallback. Se um provedor retornar um erro 500 ou expirar o tempo limite, o gateway tenta novamente na mesma requisição contra um destino de fallback, de modo que uma falha em um único provedor não surja como um erro para o usuário. Esse é o tema do fallback de LLM.

Caching. Caching exato e semântico no gateway reduzem a latência e os gastos para prompts repetidos ou quase duplicados, de forma transparente, atrás do mesmo endpoint.

Observabilidade e atribuição de custos. Como toda requisição passa por um só lugar, você obtém métricas de custo, token e latência por requisição, etiquetadas por usuário, equipe e modelo, alimentando a observabilidade de LLM e a atribuição de custos para orçamentos de equipe. Uma integração direta por provedor não oferece nada disso sem instrumentação personalizada em cada um.

Nenhum desses recursos exigiu que você adotasse uma nova API. Eles vieram da padronização na interface que você já usa. Se você está avaliando opções, o guia como escolher um AI gateway apresenta os critérios.

Integração direta com o provedor versus um gateway compatível

A decisão não é dogmática; é sobre com quantos provedores você lida e o quanto se importa com resiliência e visibilidade de custos.

DimensãoDireto para cada provedorGateway compatível com OpenAI
Mudanças no cliente para trocar modelosReescrever conforme o SDK/particularidades do provedorAlterar apenas a string model
Tratamento de diferenças de chamada de ferramentas / usageSeu código, por provedorNormalizado uma vez no gateway
Failover em quedas do provedorConstruir e manter por conta própriaFallback integrado com tentativas na mesma requisição
CachingConstruir por conta própria, por provedorCaching exato + semântico no gateway
Atribuição de custos por equipe/usuárioReunir faturamentos de cada provedorPor requisição, etiquetado, em um só lugar
Limites de taxa / orçamentosPor provedor, não coordenadoOrçamentos e limites centrais, 429 em caso de violação
Adicionar um novo provedorNovo projeto de integraçãoAdicionar um destino a um modelo lógico

A integração direta é defensável quando você chama exatamente um provedor e nunca chamará outro. No momento em que deseja um segundo modelo, resiliência contra uma queda ou uma única fonte da verdade para os custos, o gateway se paga.

Onde as equipes erram

Assumir que compatível significa idêntico. O esquema é igual; o comportamento nem sempre. As equipes portam um prompt para um backend mais barato, veem que "funciona" e lançam em produção, apenas para descobrir semanas depois que seed foi ignorado e as saídas nunca foram reprodutíveis. Teste os parâmetros dos quais você realmente depende em cada backend.

Confiar nousagepara custos sem verificar o streaming. Vários backends omitem o bloco usage em respostas transmitidas a menos que explicitamente solicitado. Painéis de custo baseados nele marcam zero e parecem ótimos até que a fatura real chegue. Verifique se o uso está presente no estilo exato de requisição que você executa em produção.

Definir a URL base e o SDK de forma rígida (hardcoded) por provedor. Isso recria a dispersão que o padrão deveria eliminar. Cada novo modelo se torna um projeto de integração e cada queda de provedor se torna a sua queda. Padronize em um único endpoint e faça da escolha do modelo uma configuração, não código.

Analisar argumentos de chamada de ferramenta sem proteger o formato. Alguns backends retornam arguments como uma string, outros como um objeto. Um JSON.parse cego gera erro no segundo caso. Normalize o formato antes de analisar, ou deixe que um gateway o normalize para você.

Tratar o gateway como mero encanamento de TI. O endpoint é a parte fácil. O valor está no que um único ponto de controle permite: roteamento, fallback, caching, orçamentos e atribuição de custos, que você não consegue adaptar de forma barata em N integrações diretas.

Conclusão

O esquema Chat Completions da OpenAI tornou-se o padrão não por decreto, mas por chegar primeiro e ser adotado em todos os lugares. "Compatível com OpenAI" é o ingresso para esse ecossistema: envie o formato de requisição familiar, analise a resposta familiar. Isso lhe dá uma enorme vantagem — a escolha do modelo como uma string de configuração —, desde que você respeite que compatível não é idêntico e teste os comportamentos dos quais realmente depende.

A maneira mais limpa de obter essa vantagem sem os pontos críticos é padronizar em um único endpoint compatível com OpenAI na frente de cada provedor. Sua aplicação mantém a interface que já conhece e o gateway absorve as particularidades de cada provedor, adicionando roteamento, fallback, caching, orçamentos e atribuição de custos que você nunca conseguiria acoplar em integrações dispersas. Uma interface na entrada; todos os modelos atrás dela.

Unifique todos os provedores de LLM atrás de uma API compatível com OpenAI. Agende uma demonstração.

Try now.

One gateway for all your models, MCP servers, and agents. No credit card needed.

Start free
Table of Contents

One Gateway for Every LLM, Agent and MCP Server

Book a 30-min with our AI expert

Book a Demo

The fastest way to build, govern and scale your AI

Book Demo
Summarize with
ChatGPT logo by OpenAI
Perplexity AI logo
Blurry red snowflake on white background, symmetrical frosty design with soft edges and abstract shape.

Discover More

No items found.
novembro 20, 2026
|
5 min read

Grok 4.3 no Amazon Bedrock: Roteamos Quatro Modelos de Fronteira por um Único Gateway e Medimos o Custo

Ferramentas de LLM
comparação
novembro 20, 2026
|
5 min read

GPT-6.1 Terra: API, Benchmarks, Preço & Como Usar

No items found.
TrueFoundry AI gateway is an enterprise alternative to Bifrost and Portkey
novembro 20, 2026
|
5 min read

Bifrost vs Portkey: Precificação, Recursos de Gateway e Adequação Enterprise Comparados

No items found.
novembro 20, 2026
|
5 min read

Evolução do Machine Learning: Um Mergulho Profundo na Jornada de Savin

True ML Talks
No items found.
Take a quick product tour
Start Product Tour
Product Tour