LemonData logoLemonData

Paramètres

Langue
Blog

Migrer d'OpenAI vers LemonData en 5 minutes

L
LemonData
·26 février 2026·525 vues
Migrer d'OpenAI vers LemonData en 5 minutes

Passer de l'API officielle d'OpenAI à LemonData ne nécessite que deux changements de lignes. Votre code existant, vos prompts et vos noms de modèles fonctionnent tous tels quels. Vous accédez également à plus de 300 modèles via OpenAI, Anthropic, Google, DeepSeek et plus encore, avec la même API key.

Si vous comparez les choix de passerelles avant de migrer, lisez le comparatif de prix et la comparaison entre OpenRouter et LemonData. Si votre équipe a besoin d'un guide spécifique à une région, le guide pour les développeurs en Chine couvre les aspects de paiement et opérationnels.

La version courte

  1. Inscrivez-vous sur lemondata.cc et récupérez une API key (vous recevez 1 $ de crédit gratuit)
  2. Remplacez votre base_url et votre api_key
  3. Terminé. Tout le reste reste identique.

Python (OpenAI SDK)

# Avant : OpenAI officiel
from openai import OpenAI
client = OpenAI(api_key="sk-openai-xxx")

# Après : LemonData (changez 2 lignes)
from openai import OpenAI
client = OpenAI(
    api_key="sk-lemon-xxx",
    base_url="https://api.lemondata.cc/v1"
)

# Tout le reste reste identique
response = client.chat.completions.create(
    model="gpt-4.1",
    messages=[{"role": "user", "content": "Hello!"}]
)
print(response.choices[0].message.content)

Streaming, function calling, vision : tout fonctionne de manière identique. Le SDK Python d'OpenAI envoie des requêtes vers n'importe quel base_url que vous lui indiquez.

Node.js (OpenAI SDK)

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

// Après : LemonData (changez 2 lignes)
import OpenAI from 'openai';
const openai = new OpenAI({
  apiKey: 'sk-lemon-xxx',
  baseURL: 'https://api.lemondata.cc/v1',
});

// Tout le reste reste identique
const completion = await openai.chat.completions.create({
  model: 'gpt-4.1',
  messages: [{ role: 'user', content: 'Hello!' }],
});
console.log(completion.choices[0].message.content);

Note : c'est baseURL (camelCase) dans le SDK Node.js, pas base_url.

curl

# Avant : OpenAI officiel
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"}]}'

# Après : LemonData (changez l'URL et la clé)
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"}]}'

Même chemin d'endpoint, même corps de requête, même format de réponse.

L'approche par variables d'environnement

Si votre code lit des variables d'environnement (ce qu'il devrait faire), vous n'avez même pas besoin de toucher au code :

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

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

Le SDK OpenAI lit automatiquement OPENAI_API_KEY et OPENAI_BASE_URL depuis l'environnement. Zéro modification de code.

Ce que vous obtenez après la migration

Une fois sur LemonData, vous conservez une compatibilité totale avec OpenAI et accédez à des fonctionnalités supplémentaires :

Plus de 300 modèles, une seule API key

Votre code OpenAI existant fonctionne désormais avec Claude, Gemini, DeepSeek, Mistral et des centaines d'autres. Dans de nombreux cas, la seule chose à changer est le paramètre model :

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

# Claude Sonnet 4.6 (Anthropic): $3.00/$15.00 par 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 par 1M tokens (utilisez "deepseek-chat" ou l'alias "deepseek-v3")
response = client.chat.completions.create(model="deepseek-chat", messages=messages)

La redondance multi-canaux signifie que si un fournisseur en amont rencontre des problèmes, la passerelle redirige automatiquement vers un canal alternatif. Aucune modification de code n'est nécessaire.

Accès au protocole natif (Optionnel)

Si vous souhaitez utiliser les modèles Anthropic ou Google avec leurs pleines capacités natives (extended thinking, prompt caching avec cache_control, Google search grounding), LemonData supporte leurs protocoles natifs via la même base URL :

# Anthropic natif : utilisez le SDK Anthropic
# Extended thinking, cache_control, Citations fonctionnent tous nativement
from anthropic import Anthropic
client = Anthropic(
    api_key="sk-lemon-xxx",
    base_url="https://api.lemondata.cc"  # Pas de /v1. Le SDK Anthropic ajoute lui-même /v1/messages.
)

# Google Gemini natif : utilisez le SDK Google
# Search grounding, grounding_metadata fonctionnent tous nativement
from google import genai
client = genai.Client(
    api_key="sk-lemon-xxx",
    http_options={"base_url": "https://api.lemondata.cc"}  # Pas de suffixe de chemin. Le SDK ajoute lui-même /v1beta/models/...
)

C'est entièrement optionnel. L'endpoint compatible OpenAI fonctionne pour tous les modèles. Mais si vous avez besoin de l'extended thinking d'Anthropic ou du grounding de Google, l'accès au protocole natif vous offre ces fonctionnalités sans perte de conversion de format.

Ce qui change généralement lors de la migration

La plupart des migrations sont techniquement simples mais opérationnellement négligées. Les équipes changent souvent la base URL et la clé, puis supposent que tout le reste est identique. C'est généralement vrai pour le schéma de requête, mais pas toujours pour tout ce qui l'entoure.

Les points à vérifier avant de basculer le trafic sont :

  • paramètres de timeout dans votre SDK ou client HTTP
  • listes d'autorisation de modèles (allowlists) dans la configuration de l'application
  • tableaux de bord de coûts qui supposent un fournisseur unique
  • logique de retry (tentatives) ajustée pour un fournisseur spécifique
  • toute hypothèse codée en dur sur les en-têtes de réponse ou les rate limits

Si vous auditez ces cinq domaines avant de basculer le trafic de production, la migration se déroule généralement sans incident.

Checklist de migration

Utilisez cette checklist si vous voulez que la migration reste sans surprise :

  1. Créez une API key LemonData.
  2. Changez base_url ou baseURL.
  3. Effectuez un smoke test rapide sur /v1/models.
  4. Testez une chat completion, une réponse streamée et un cas d'erreur.
  5. Confirmez que vos logs capturent toujours les IDs de requête et les noms de modèles.
  6. Vérifiez la facturation après les premiers appels pour vous assurer que vos hypothèses de coûts tiennent toujours.
  7. Seulement après, déplacez les tâches de fond et le trafic de production.

Erreurs courantes

Erreur 1 : Coder en dur l'ancien inventaire de modèles

Certaines équipes valident les IDs de modèles par rapport à une liste statique dans la config de l'application. Si vous gardez cette liste, la passerelle fonctionne mais votre propre application rejette les noms de modèles valides avant l'envoi de la requête.

Erreur 2 : Considérer la migration comme un simple changement de fournisseur

Le véritable avantage n'est pas seulement de quitter OpenAI. C'est de passer d'une architecture à fournisseur unique à un modèle de passerelle où vous pouvez ajouter Claude, Gemini, DeepSeek et d'autres sans modifier à nouveau le reste de votre application.

Erreur 3 : Sauter les tests de cas d'erreur

Une complétion réussie prouve que l'API key fonctionne. Cela ne prouve pas que votre logique de retry, votre analyse d'erreurs ou votre observabilité sont toujours pertinentes après le changement.

Si vous déployez une application destinée aux utilisateurs plutôt qu'un simple script, les deux prochains guides d'implémentation à lire sont le tutoriel de chatbot à clé unique et le guide sur le rate limiting.

Migration d'intégrations courantes

Cursor

Paramètres → Modèles → 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"
)

Vérifiez votre migration

Vérification rapide après le basculement :

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

Si vous voyez une réponse JSON avec des objets de modèles, tout est bon.

FAQ

Mes prompts existants fonctionneront-ils ? Oui. LemonData est entièrement compatible avec OpenAI, donc les formats de requête et de réponse restent les mêmes.

Dois-je changer les noms de modèles ? Non. gpt-4.1, gpt-4o et gpt-4.1-mini fonctionnent tous comme prévu. LemonData dispose également d'un système de résolution de modèles à trois niveaux : correspondance exacte, recherche d'alias et correction floue. Cela signifie que même les noms obsolètes comme gpt-4-turbo ou les fautes de frappe comme gpt4o sont généralement résolus correctement.

Qu'en est-il du streaming ? Fonctionne de manière identique. Format SSE, même structure de chunks. Pour les protocoles natifs Anthropic/Gemini, vous obtenez le format SSE natif de chaque fournisseur (y compris les deltas de réflexion pour l'extended thinking).

Qu'en est-il du function calling / tools ? Entièrement supporté. Même schéma, même comportement.

Qu'en est-il de la gestion des erreurs ? LemonData renvoie des erreurs compatibles avec OpenAI avec des champs supplémentaires adaptés aux agents tels que retryable, did_you_mean, suggestions et retry_after. La gestion d'erreurs standard du SDK OpenAI fonctionne toujours car ces champs sont additifs.

Puis-je revenir en arrière ? Oui. Changez à nouveau les deux lignes. Il n'y a pas de format propriétaire ni de migration de données à annuler.

Commencez ici : lemondata.cc/r/devto-migration
Documentation API complète : docs.lemondata.cc
Guide de démarrage rapide : docs.lemondata.cc/quickstart

Share: