API OpenAI pour les développeurs : utilisez un endpoint compatible

Le résumé

La plupart des guides sur l'API OpenAI pour les développeurs supposent un seul fournisseur et une seule facture. Le format de transport, cependant, n'est que du JSON sur HTTPS, et beaucoup de code client, de frameworks et d'outils peuvent parler à n'importe quel serveur qui l'implémente. Ce site héberge un tel serveur. Vous gardez votre SDK, changez l'URL de base, remplacez par une clé de ce site, et définissez le modèle sur uncensored.

C'est toute la migration pour une application typique. Voici la liste de vérification, et le reste de la page détaille chaque étape.

1. Créez un compte et réclamez le crédit d'essai sur la page de clé API.
2. Définissez l'URL de base sur https://api.openaigatewayapi.com/v1.
3. Envoyez la clé en tant que Authorization: Bearer <key>. Les SDK le font pour vous lorsque vous passez api_key.
4. Utilisez uncensored comme ID de modèle dans chaque requête.
5. Gérez les erreurs HTTP 429 avec une courte tentative de réessai, comme indiqué vers la fin.

Deux points de terminaison existent : POST /v1/chat/completions et GET /v1/models. Le service est textuel uniquement. Il n'y a pas de génération d'images ou d'audio, pas d'embeddings et pas d'ajustement fin, donc si votre application appelle ces fonctionnalités, elles auront besoin d'un autre fournisseur.

Vérifiez la connexion avec curl

Avant de toucher à votre application, confirmez que la clé fonctionne. L'endpoint des modèles est le test le moins cher, car il ne génère aucun token.

Copyexport API_KEY="paste-your-key-here"

curl https://api.openaigatewayapi.com/v1/models \
  -H "Authorization: Bearer $API_KEY" | grep -o uncensored

Le grep affiche l'ID de modèle uncensored si la liste le contient ; supprimez le grep pour voir la liste JSON complète. Si vous obtenez un 401, la clé est incorrecte ou manque le préfixe Bearer. Envoyez maintenant une vraie requête :

Copycurl https://api.openaigatewayapi.com/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uncensored",
    "messages": [
      {"role": "system", "content": "You are a concise technical assistant."},
      {"role": "user", "content": "Explain idempotency keys in two sentences."}
    ],
    "temperature": 0.4
  }'

La réponse contient les objets usuels choices et usage. Elle inclut également des en-têtes intéressants à journaliser : X-Request-Id pour les questions de support, X-Balance-USD pour votre crédit restant, et les deux en-têtes X-RateLimit-Limit-* qui indiquent vos plafonds de requête et de concurrence.

Python avec le package openai officiel

En Python, vous ne touchez que le constructeur du client. Tout ce qui suit est le code que vous avez déjà.

Copyfrom openai import OpenAI

client = OpenAI(
    base_url="https://api.openaigatewayapi.com/v1",
    api_key="paste-your-key-here",
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You write short, accurate release notes."},
        {"role": "user", "content": "Summarise: added retry logic, fixed timeout bug."},
    ],
    temperature=0.5,
    max_tokens=200,
)

print(resp.choices[0].message.content)
print(resp.usage.prompt_tokens, resp.usage.completion_tokens)

Lisez la clé depuis une variable d'environnement dans le code réel. L'exemple la code en dur uniquement pour garder l'extrait court. max_tokens est facultatif ici ; si vous l'omettez, la complétion peut utiliser tout ce qui reste de la fenêtre de contexte de 100 000 tokens (prompt plus complétion ensemble). Le définir de toute façon est un moyen peu coûteux de limiter le coût sur une génération débridée.

Diffusion en continu

Le streaming utilise les Server-Sent Events et le même drapeau stream=True que vous connaissez. Les chiffres d'utilisation arrivent à la fin du flux, donc le dernier morceau peut avoir une liste choices vide.

Copyfrom openai import OpenAI

client = OpenAI(base_url="https://api.openaigatewayapi.com/v1", api_key="paste-your-key-here")

stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "List five edge cases for a date parser."}],
    stream=True,
)

for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
    if getattr(chunk, "usage", None):
        print("\ntokens:", chunk.usage.total_tokens)

Un détail compte pour la planification de la capacité. Une requête en streaming occupe son slot de concurrence jusqu'à la fin du flux, pas jusqu'au premier token. Si un client abandonne un flux sans le fermer, ce slot reste occupé plus longtemps que prévu.

Exemple Node.js

Le SDK Node prend les mêmes deux paramètres sous des noms différents.

Copyimport OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.openaigatewayapi.com/v1",
  apiKey: process.env.GATEWAY_KEY,
});

const completion = await client.chat.completions.create({
  model: "uncensored",
  messages: [
    { role: "user", content: "Write a regex that matches ISO 8601 dates, and explain it." },
  ],
  temperature: 0.3,
});

console.log(completion.choices[0].message.content);

Si vous utilisez un framework qui a sa propre intégration OpenAI, recherchez un champ appelé URL de base, API base ou point de terminaison dans ses paramètres. Coller la même URL là suffit généralement. Les interfaces de chat, les frameworks d'agents et les plugins d'éditeur suivent principalement ce modèle. Les paramètres d'échantillonnage tels que temperature, top_p, stop, seed et les pénalités de fréquence et de présence sont transmis au modèle.

Appel d'outils et mode JSON

Deux fonctionnalités décident si un modèle s'intègre dans une application réelle : appeler vos fonctions et retourner des données que vous pouvez analyser. Les deux sont pris en charge.

Appel de fonctions

Vous déclarez les outils avec tools, forcez éventuellement un choix avec tool_choice, et renvoyez les résultats en tant que messages avec role: "tool". Les réponses en streaming livrent tool_calls par morceaux, comme avec le format standard.

Copyimport json
from openai import OpenAI

client = OpenAI(base_url="https://api.openaigatewayapi.com/v1", api_key="paste-your-key-here")

tools = [{
    "type": "function",
    "function": {
        "name": "get_order_status",
        "description": "Look up the status of an order by its ID.",
        "parameters": {
            "type": "object",
            "properties": {"order_id": {"type": "string"}},
            "required": ["order_id"],
        },
    },
}]

messages = [{"role": "user", "content": "Where is order A-1042?"}]
first = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
msg = first.choices[0].message

if msg.tool_calls:
    call = msg.tool_calls[0]
    args = json.loads(call.function.arguments)
    result = {"order_id": args["order_id"], "status": "shipped"}  # your real lookup here
    messages.append(msg)
    messages.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps(result)})
    final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
    print(final.choices[0].message.content)

Validez toujours les arguments avant d'agir dessus. Le modèle produit du JSON qui correspond à votre schéma la plupart du temps, pas tout le temps, donc traitez call.function.arguments comme n'importe quelle entrée non fiable.

Mode JSON

Pour les tâches d'extraction et de classification, demandez un objet JSON et dites-le également dans le prompt. Mentionner JSON dans les instructions donne de meilleurs résultats que de se fier uniquement au drapeau.

Copyfrom openai import OpenAI
import json

client = OpenAI(base_url="https://api.openaigatewayapi.com/v1", api_key="paste-your-key-here")

resp = client.chat.completions.create(
    model="uncensored",
    response_format={"type": "json_object"},
    messages=[
        {"role": "system", "content": "Reply with JSON only: {\"sentiment\": string, \"topics\": [string]}."},
        {"role": "user", "content": "The docs are clear but the rate limits caught me off guard."},
    ],
)
data = json.loads(resp.choices[0].message.content)
print(data)

Limites, erreurs et tentatives

Une clé complète permet 8 requêtes simultanées et 300 requêtes par minute. La clé d'essai permet 2 requêtes simultanées et 60 par minute. Le corps de requête maximum est de 8 MB. Dépasser une limite vous donne un HTTP 429, et le code d'erreur vous indique quelle limite a été dépassée.

Code d'erreur	Signification	Que faire
rate_limited	Trop de requêtes par minute	Ralentissez le producteur ou répartissez le travail sur la minute
concurrency	Trop de requêtes à la fois	Réduisez votre nombre de travailleurs à 8 ou moins, ou 2 sur une clé d'essai
429 avec Retry-After: 5	Surcharge temporaire	Attendez les secondes données et réessayez

Les SDK réessayent déjà certaines erreurs. Ajoutez votre propre gestion pour 429 afin qu'une rafale ne fasse pas planter un travail par lots :

Copyimport time
from openai import OpenAI, RateLimitError

client = OpenAI(
    base_url="https://api.openaigatewayapi.com/v1",
    api_key="paste-your-key-here",
    max_retries=0,
)

def ask(prompt, attempts=5):
    for i in range(attempts):
        try:
            r = client.chat.completions.create(
                model="uncensored",
                messages=[{"role": "user", "content": prompt}],
            )
            return r.choices[0].message.content
        except RateLimitError as e:
            wait = float(e.response.headers.get("retry-after", 2 ** i))
            time.sleep(wait)
    raise RuntimeError("still rate limited after retries")

Les requêtes échouées ou refusées ne sont pas facturées, donc une boucle de réessais ne double pas votre facture. Un sémaphore dimensionné à votre limite de concurrence est la manière la plus propre de rester sous le plafond dans le code asynchrone.

Déplacer une application existante

Si vous avez une application fonctionnelle, ne mettez pas les nouvelles valeurs en dur. Mettez l'URL de base, la clé et le nom du modèle dans des variables d'environnement afin que vous puissiez basculer entre les environnements sans déploiement. Cela vous permet également d'exécuter la même suite de tests contre deux backends et de comparer les sorties côte à côte.

Copyimport os
from openai import OpenAI

client = OpenAI(
    base_url=os.environ.get("LLM_BASE_URL", "https://api.openaigatewayapi.com/v1"),
    api_key=os.environ["LLM_API_KEY"],
)
MODEL = os.environ.get("LLM_MODEL", "uncensored")

def complete(messages, **kw):
    return client.chat.completions.create(model=MODEL, messages=messages, **kw)

Ensuite, travaillez à travers une routine de migration courte :

1. Exécutez votre ensemble de prompts existants sur le nouvel endpoint et lisez les sorties vous-même. Les vérifications automatiques détectent les cassures de format, pas le ton.
2. Vérifiez que tout code analysant du JSON passe toujours avec response_format défini, et gardez une solution de repli qui supprime le texte étranger autour de l'objet.
3. Mesurez le nombre réel de tokens depuis usage, car un modèle différent tokenise le texte différemment et vos anciennes estimations peuvent être fausses.
4. Définissez votre pool de travailleurs à 8 ou moins afin que le cap de concurrence ne soit jamais la première chose à échouer sous la charge.
5. Déployez sur une petite part de trafic, surveillez le taux 429 et les journaux d'erreurs, puis élargissez.

Les équipes oublient souvent le prompt système dans ce processus. Les prompts écrits pour inciter un modèle sujet aux refus à se comporter contiennent généralement des lignes de prudence qui ne sont pas nécessaires ici et peuvent encombrer la sortie. Relisez les vôtres et supprimez ce qui ne fait plus rien.

Ce qu'il faut savoir avant de changer

La compatibilité couvre le format de requête et de réponse. Cela ne fait pas de ce service l'API officielle de tout fabricant de modèle. Le service exécute un modèle à poids ouverts, hébergé par un fournisseur indépendant et optimisé pour répondre sans refus de contenu pour un usage adulte conforme à la loi. Ce n'est pas un routeur entre fournisseurs, donc vous ne trouverez pas de menu d'autres modèles derrière lui. Le contenu sexuel impliquant des mineurs n'est pas autorisé, et cette limite ne peut pas être modifiée.

Prévoyez votre architecture autour de trois différences pratiques par rapport à une grande plateforme multi-modèles :

• Un seul modèle. L'ID est uncensored. Si votre code change de modèle par tâche, unifiez cela à une seule valeur.
• Texte uniquement. Supprimez tout appel d'image, d'audio ou d'embedding du chemin qui mène à cet endpoint.
• Le comportement des prompts diffère. Un modèle différent interprète les instructions différemment, donc relancez vos prompts et tests après le changement. Affinez les prompts système lorsque la sortie dévie.

Les prompts ne sont pas utilisés pour l'entraînement. Pour la liste complète des paramètres, consultez la documentation de l'API. Si vous estimez vos dépenses, la page des tarifs liste les tarifs par token : $0,15 par 1M de tokens d'entrée et $0,50 par 1M de tokens de sortie, facturés à partir du crédit prépayé sans abonnement. Les recharges vont de $20 à $500 et le crédit n'expire jamais. Si vous pesez le pour et le contre d'une couche proxy devant plusieurs services, la page sur les passerelles LLM couvre quand cet élément supplémentaire est rentable.

Plus de guides

• OpenAI Gateway API expliquée en termes simples
• Tarification de l'OpenAI Gateway API : exemples de coûts réels
• Passerelle LLM : analyse des coûts par rapport à la complexité