scriptRun Beta

API Compatível com OpenAI: O Que É, Quem Suporta e Como Mudar com Segurança

AnnaAnna
17 novembro 2026
Negócios
Fluxos de Trabalho com IAAutomação
API Compatível com OpenAI: Como Funciona e O Que Se Quebra

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:

  1. URL base: o endpoint do provedor, como https://generativelanguage.googleapis.com/v1beta/openai/ para Gemini.

  2. Chave de API: a chave do provedor, não sua chave do OpenAI.

  3. 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.

ProvedorTipoURL base compatível com OpenAI
OpenAIAPI de referênciahttps://api.openai.com/v1
Anthropic (Claude)Provedor de modelohttps://api.anthropic.com/v1/
Google Gemini APIProvedor de modelohttps://generativelanguage.googleapis.com/v1beta/openai/
Mistral AIProvedor de modelohttps://api.mistral.ai/v1
DeepSeekProvedor de modelohttps://api.deepseek.com
xAI (Grok)Provedor de modelohttps://api.x.ai/v1
GroqProvedor de inferênciahttps://api.groq.com/openai/v1
Together AIProvedor de inferênciahttps://api.together.ai/v1
Fireworks AIProvedor de inferênciahttps://api.fireworks.ai/inference/v1
Azure OpenAI / Microsoft FoundryPlataforma de nuvemhttps://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/
Amazon BedrockPlataforma de nuvemhttps://bedrock-runtime.{region}.amazonaws.com/openai/v1
OpenRouterGatewayhttps://openrouter.ai/api/v1
OllamaServidor localhttp://localhost:11434/v1/
LM StudioServidor localhttp://localhost:1234/v1
vLLMServidor auto-hospedadohttp://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.

ÁreaO que geralmente funcionaO que frequentemente difere
Chat básicoMensagens entram, escolhas saemComo mensagens do sistema são tratadas
Parâmetrostemperature, max_tokens, stopCampos não suportados (seed, logprobs, penalties) são frequentemente silenciosamente ignorados, não rejeitados
Saída estruturadaSaída JSON básica em muitos modelosQuais tipos de response_format são aceitos e se esquemas "rigorosos" são aplicados
Chamadas de ferramentasDefinição de ferramentas e retorno de chamadaEsquemas de argumento rigorosos, chamadas paralelas, opções tool_choice
StreamingChunks token por tokenLimites de chunk, escolhas vazias, se o uso chega no final
EntradasTexto, frequentemente imagensÁudio, files e PDFs
Erros e limitesCódigos de status HTTPMensagens de erro e cabeçalhos de limite de taxa (consulte nosso guia para limites de taxa da API do OpenAI)
Outros endpointsLista de modelos, frequentemente embeddingsAPI 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 eleVocê está começando do zero com um provedor
Você quer comparar modelos ou mudar de provedores rapidamenteVocê 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ódigoVocê precisa de comportamento garantido que a camada compatível não promete
Você quer failover entre provedores sem novo código de integraçãoO 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 provedorUm gateway compatível com OpenAI
ConfiguraçãoUma conta, chave e cobrança por provedorUma conta, uma chave, uma conta
Mudança de modelosAlterar URL base, chave e modeloAlterar o nome do modelo
Interrupções e limites de taxaVocê constrói retries e failoverFrequentemente construído (verifique como)
LatênciaSem hop extraUm hop de rede extra
DependênciaCada provedorCada provedor mais o gateway
Caminho de dadosSeu aplicativo para o provedorSeu 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

  1. Liste o que você usa. Endpoints, parâmetros, ferramentas, esquemas JSON, streaming, imagens e arquivos.

  2. Verifique a página de compatibilidade do provedor para cada item, especialmente campos que são silenciosamente ignorados.

  3. Execute o teste de fumaça com seus prompts e modelos reais.

  4. 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.

  5. Compare saídas em uma amostra de pedidos reais: qualidade, latência e custo por 1.000 solicitações.

  6. Implante gradualmente. Comece com uma pequena parte do tráfego ou um recurso interno.

  7. 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.


Útil?
Compartilhe este artigo!

Crie workflows de IA em minutos

Crie automações, conecte APIs e acesse mais de 50 modelos de IA em uma única plataforma.

Construtor visual de workflows
API compatível com OpenAI
Marketplace de workflows e templates
Comece grátis, planos a partir de $5

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.

Leia mais do nosso blog

Publicações relacionadas

Fluxos de Trabalho com IAAutomação
API de LLM mais barata em 2026: preços verificados por 1 milhão de tokens
Negócios 20 novembro 2026

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.

1734
AnnaAnna
Mercado de IAFluxos de Trabalho com IAAutomação
Marketplace de Agentes de IA: as 10 Melhores Plataformas Comparadas (2026)
Negócios 19 novembro 2026

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.

1886
AnnaAnna
Fluxos de Trabalho com IAAutomação
API LLM Gratuita: 2026 Provedores, Limites e Pegadinhas Reais
Negócios 18 novembro 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.

1905
AnnaAnna
Fluxos de Trabalho com IAAutomação
Alternativas ao OpenRouter: 7 Gateways para Roteamento de LLM
Negócios 16 novembro 2026

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.

1560
AnnaAnna
© 2024-2026 PIXEL LORIS IT SERVICES L.L.C. All rights reserved.