LemonData logoLemonData

Configurações

Idioma
Blog

Migre da OpenAI para a LemonData em 5 minutos

L
LemonData
·26 de fevereiro de 2026·522 visualizações
Migre da OpenAI para a LemonData em 5 minutos

Mudar da API oficial da OpenAI para a LemonData leva apenas duas alterações de linha. Seu código existente, prompts e nomes de modelos funcionam como estão. Você também ganha acesso a mais de 300 modelos da OpenAI, Anthropic, Google, DeepSeek e outros, através da mesma API key.

Se você estiver comparando opções de gateway antes de migrar, leia a comparação de preços e a comparação OpenRouter vs LemonData. Se sua equipe precisar de um roteiro específico por região, o guia para desenvolvedores na China cobre a parte de pagamento e operacional.

A Versão Curta

  1. Cadastre-se em lemondata.cc e obtenha uma API key (você ganha $1 de crédito grátis)
  2. Substitua seu base_url e api_key
  3. Pronto. Todo o resto permanece igual.

Python (OpenAI SDK)

# Antes: OpenAI oficial
from openai import OpenAI
client = OpenAI(api_key="sk-openai-xxx")

# Depois: LemonData (altere 2 linhas)
from openai import OpenAI
client = OpenAI(
    api_key="sk-lemon-xxx",
    base_url="https://api.lemondata.cc/v1"
)

# Todo o resto permanece igual
response = client.chat.completions.create(
    model="gpt-4.1",
    messages=[{"role": "user", "content": "Hello!"}]
)
print(response.choices[0].message.content)

Streaming, function calling, vision: tudo funciona de forma idêntica. O OpenAI Python SDK envia requisições para qualquer base_url que você apontar.

Node.js (OpenAI SDK)

// Antes: OpenAI oficial
import OpenAI from 'openai';
const openai = new OpenAI({ apiKey: 'sk-openai-xxx' });

// Depois: LemonData (altere 2 linhas)
import OpenAI from 'openai';
const openai = new OpenAI({
  apiKey: 'sk-lemon-xxx',
  baseURL: 'https://api.lemondata.cc/v1',
});

// Todo o resto permanece igual
const completion = await openai.chat.completions.create({
  model: 'gpt-4.1',
  messages: [{ role: 'user', content: 'Hello!' }],
});
console.log(completion.choices[0].message.content);

Nota: é baseURL (camelCase) no SDK do Node.js, não base_url.

curl

# Antes: OpenAI oficial
curl https://api.openai.com/v1/chat/completions \
  -H "Authorization: Bearer sk-openai-xxx" \
  -H "Content-Type: application/json" \
  -d '{"model":"gpt-4.1","messages":[{"role":"user","content":"Hello"}]}'

# Depois: LemonData (altere a URL e a key)
curl https://api.lemondata.cc/v1/chat/completions \
  -H "Authorization: Bearer sk-lemon-xxx" \
  -H "Content-Type: application/json" \
  -d '{"model":"gpt-4.1","messages":[{"role":"user","content":"Hello"}]}'

Mesmo caminho de endpoint, mesmo corpo de requisição, mesmo formato de resposta.

Abordagem por Variáveis de Ambiente

Se o seu código lê de variáveis de ambiente (o que deveria fazer), você nem precisa tocar no código:

# Antes
export OPENAI_API_KEY="sk-openai-xxx"
export OPENAI_BASE_URL="https://api.openai.com/v1"

# Depois
export OPENAI_API_KEY="sk-lemon-xxx"
export OPENAI_BASE_URL="https://api.lemondata.cc/v1"

O OpenAI SDK lê automaticamente OPENAI_API_KEY e OPENAI_BASE_URL do ambiente. Zero alterações de código.

O Que Você Ganha Após a Migração

Uma vez na LemonData, você mantém total compatibilidade com a OpenAI e ganha acesso a recursos adicionais:

Mais de 300 Modelos, Uma Única API Key

Seu código OpenAI existente agora funciona com Claude, Gemini, DeepSeek, Mistral e centenas de outros. Em muitos casos, a única coisa que você precisa mudar é o parâmetro model:

# GPT-4.1 (OpenAI): $2.00/$8.00 por 1M tokens
response = client.chat.completions.create(model="gpt-4.1", messages=messages)

# Claude Sonnet 4.6 (Anthropic): $3.00/$15.00 por 1M tokens
response = client.chat.completions.create(model="claude-sonnet-4-6", messages=messages)

# Gemini 2.5 Pro (Google)
response = client.chat.completions.create(model="gemini-2.5-pro", messages=messages)

# DeepSeek V3: $0.28/$0.42 por 1M tokens (use "deepseek-chat" ou o alias "deepseek-v3")
response = client.chat.completions.create(model="deepseek-chat", messages=messages)

A redundância multicanal significa que, se um provedor upstream tiver problemas, o gateway roteia automaticamente para um canal alternativo. Nenhuma mudança de código é necessária.

Acesso a Protocolo Nativo (Opcional)

Se você quiser usar modelos da Anthropic ou Google com todas as suas capacidades nativas (extended thinking, prompt caching com cache_control, Google search grounding), a LemonData suporta seus protocolos nativos através da mesma base URL:

# Anthropic nativo: use o Anthropic SDK
# Extended thinking, cache_control, Citations funcionam todos nativamente
from anthropic import Anthropic
client = Anthropic(
    api_key="sk-lemon-xxx",
    base_url="https://api.lemondata.cc"  # Sem /v1. O Anthropic SDK adiciona /v1/messages sozinho.
)

# Google Gemini nativo: use o Google SDK
# Search grounding, grounding_metadata funcionam todos nativamente
from google import genai
client = genai.Client(
    api_key="sk-lemon-xxx",
    http_options={"base_url": "https://api.lemondata.cc"}  # Sem sufixo de caminho. O SDK adiciona /v1beta/models/... sozinho.
)

Isso é inteiramente opcional. O endpoint compatível com OpenAI funciona para todos os modelos. Mas se você precisar do extended thinking da Anthropic ou do grounding do Google, o acesso ao protocolo nativo oferece esses recursos sem qualquer perda de conversão de formato.

O Que Geralmente Muda Durante a Migração

A maioria das migrações é tecnicamente simples, mas operacionalmente descuidada. As equipes costumam mudar a base URL e a key, e assumem que todo o resto é idêntico. Isso geralmente é verdade para o esquema da requisição, mas nem sempre é verdade para tudo ao redor.

As áreas que valem a pena verificar antes de virar o tráfego são:

  • configurações de timeout no seu SDK ou cliente HTTP
  • allowlists de modelos na configuração da aplicação
  • dashboards de custo que assumem um único provedor
  • lógica de retry que foi ajustada para um upstream específico
  • quaisquer suposições hardcoded sobre headers de resposta ou rate limits

Se você auditar essas cinco áreas antes de alternar o tráfego de produção, a migração costuma ser tranquila.

Checklist de Migração

Use este checklist se quiser que a migração seja sem surpresas:

  1. Crie uma API key na LemonData.
  2. Altere o base_url ou baseURL.
  3. Execute um smoke test contra /v1/models.
  4. Teste uma chat completion, uma resposta via stream e um caminho de erro.
  5. Confirme se seus logs ainda capturam IDs de requisição e nomes de modelos.
  6. Verifique o faturamento após as primeiras chamadas para garantir que suas suposições de custo se mantêm.
  7. Só então mova os jobs em background e o tráfego de produção.

Erros Comuns

Erro 1: Hardcoding do inventário de modelos antigo

Algumas equipes validam IDs de modelos contra uma lista estática na configuração do app. Se você mantiver essa lista, o gateway funciona, mas sua própria aplicação rejeita nomes de modelos válidos antes mesmo da requisição ser enviada.

Erro 2: Tratar a migração apenas como uma troca de provedor

O benefício real não é apenas sair da OpenAI. O benefício real é mudar de uma arquitetura de provedor único para um modelo de gateway onde você pode adicionar Claude, Gemini, DeepSeek e outros sem precisar alterar o resto da sua aplicação novamente.

Erro 3: Pular testes de caminhos de erro

Uma finalização bem-sucedida prova que a API key funciona. Não prova que sua lógica de retry, parsing de erro ou observabilidade ainda fazem sentido após a mudança.

Se você estiver lançando uma aplicação voltada para o usuário, em vez de apenas um script, os próximos dois guias de implementação a serem lidos são o tutorial de chatbot com uma única key e o guia de rate limiting.

Migração de Integrações Comuns

Cursor

Settings → Models → OpenAI API Key:

  • API Key: sk-lemon-xxx
  • Base URL: https://api.lemondata.cc/v1

LangChain

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="gpt-4.1",
    api_key="sk-lemon-xxx",
    base_url="https://api.lemondata.cc/v1"
)

Vercel AI SDK

import { createOpenAI } from '@ai-sdk/openai';

const lemondata = createOpenAI({
  apiKey: 'sk-lemon-xxx',
  baseURL: 'https://api.lemondata.cc/v1',
});

const result = await generateText({
  model: lemondata('gpt-4.1'),
  prompt: 'Hello!',
});

LiteLLM

import litellm

response = litellm.completion(
    model="openai/gpt-4.1",
    messages=[{"role": "user", "content": "Hello!"}],
    api_key="sk-lemon-xxx",
    api_base="https://api.lemondata.cc/v1"
)

Verifique Sua Migração

Check de sanidade rápido após a mudança:

curl https://api.lemondata.cc/v1/models \
  -H "Authorization: Bearer sk-lemon-xxx" | head -c 200

Se você vir uma resposta JSON com objetos de modelo, está tudo certo.

FAQ

Meus prompts existentes funcionarão? Sim. A LemonData é totalmente compatível com a OpenAI, então os formatos de requisição e resposta permanecem os mesmos.

Preciso mudar os nomes dos modelos? Não. gpt-4.1, gpt-4o e gpt-4.1-mini funcionam como esperado. A LemonData também possui um sistema de resolução de modelos em três camadas: correspondência exata, busca por alias e correção fuzzy. Isso significa que mesmo nomes obsoletos como gpt-4-turbo ou erros de digitação como gpt4o geralmente ainda são resolvidos corretamente.

E quanto ao streaming? Funciona de forma idêntica. Formato SSE, mesma estrutura de chunks. Para protocolos nativos da Anthropic/Gemini, você recebe o formato SSE nativo de cada provedor (incluindo deltas de pensamento para extended thinking).

E quanto a function calling / tools? Totalmente suportado. Mesmo esquema, mesmo comportamento.

E quanto ao tratamento de erros? A LemonData retorna erros compatíveis com a OpenAI com campos adicionais amigáveis para agentes, como retryable, did_you_mean, suggestions e retry_after. O tratamento de erros padrão do OpenAI SDK ainda funciona porque esses campos são aditivos.

Posso voltar atrás? Sim. Basta reverter as duas linhas. Não há formato proprietário nem migração de dados para desfazer.

Comece aqui: lemondata.cc/r/devto-migration
Documentação completa da API: docs.lemondata.cc
Guia de início rápido: docs.lemondata.cc/quickstart

Share: