FR ▾

API LLM sans censure compatible OpenAIuncensoredapis.com

AccueilAgents

Testeur d'API compatible OpenAI : vérifiez n'importe quel point de terminaison

Terminal envoyant des requêtes de test à un cube de passerelle API, chacun retournant une coche verte

Vous n'avez pas besoin d'un testeur d'API compatible OpenAI spécial pour vérifier un endpoint. Quatre requêtes et un court script Python vous indiquent si une URL de base se comporte réellement comme l'API OpenAI.

Mis à jour le

Points clés

  1. Commencez par GET /v1/models, puis une complétion de chat minimale.
  2. Testez le streaming et consultez les métriques d'utilisation à la fin du flux.
  3. Envoyez intentionnellement des requêtes incorrectes pour voir à quoi ressemblent les erreurs.
  4. Un seul script peut exécuter toutes les vérifications et afficher succès ou échec.

Les quatre vérifications essentielles

De nombreux services prétendent être compatibles OpenAI. Certains copient uniquement la route chat, d'autres modifient le format des erreurs, d'autres encore omettent les détails du streaming. Un testeur devrait confirmer ce sur quoi votre code client s'appuie :

  1. Authentification et découverte : GET /v1/models avec une clé Bearer.
  2. Une complétion de chat minimale : POST /v1/chat/completions.
  3. Streaming : le même appel avec stream: true.
  4. Erreurs : ce qui est renvoyé pour une clé incorrecte, un nom de modèle invalide et un corps de requête mal formé.

Les exemples ci-dessous utilisent l'endpoint de ce site, https://api.uncensoredapis.com/v1, et le modèle uncensored. Remplacez par l'URL de base et le modèle de ce que vous testez. Si vous n'avez pas encore de clé, créez-en une ici ; les nouveaux comptes peuvent réclamer un crédit d'essai de 0,50 $ sans carte.

Vérification 1 : lister les modèles avec curl

export API_KEY="sk-your-key"
curl -s -w "\nHTTP %{http_code}\n" \
  https://api.uncensoredapis.com/v1/models \
  -H "Authorization: Bearer $API_KEY"

Attendez-vous à un HTTP 200 et à un objet JSON avec un tableau data. Chaque élément possède un id. Ici, l'ID que vous utiliserez partout est uncensored. Cet appel vérifie le DNS, le TLS, le préfixe du chemin et la clé ; s'il échoue, il n'y a pas lieu de tester autre chose. Les causes habituelles sont l'absence de /v1 dans l'URL de base, un slash final en trop ou une clé collée avec un saut de ligne.

Test 2 : une requête de chat minimale

curl -s https://api.uncensoredapis.com/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"uncensored","messages":[{"role":"user","content":"Reply with the word ok."}]}'

Dans la réponse, vérifiez choices[0].message.content, finish_reason et l'objet usage avec les compteurs de tokens de prompt et de complétion. Utilisez aussi les en-têtes : ajoutez -i et recherchez X-Request-Id, X-Balance-USD, X-RateLimit-Limit-Requests et X-RateLimit-Limit-Concurrency. Ils sont pratiques pour la journalisation et le suivi des coûts plus tard. Le même service accepte aussi POST /v1/responses, ce que couvre l'explication de la référence API.

Vérification 3 : un script Python qui teste tout

Curl est bien pour un premier aperçu, mais un script que vous pouvez relancer après chaque modification est préférable. Celui-ci utilise le package officiel openai et affiche chaque test.

import sys
from openai import OpenAI, AuthenticationError, NotFoundError, RateLimitError

BASE = "https://api.uncensoredapis.com/v1"
MODEL = "uncensored"
client = OpenAI(base_url=BASE, api_key=sys.argv[1])

def check(name, fn):
    try:
        print("PASS", name, "-", fn())
    except Exception as e:
        print("FAIL", name, "-", type(e).__name__, e)

def models():
    ids = [m.id for m in client.models.list().data]
    assert MODEL in ids, ids
    return ids

def chat():
    r = client.chat.completions.create(
        model=MODEL, messages=[{"role": "user", "content": "Say ok."}])
    assert r.choices[0].message.content
    return r.usage.total_tokens

def stream():
    parts, usage = [], None
    for c in client.chat.completions.create(
            model=MODEL, stream=True,
            messages=[{"role": "user", "content": "Count to five."}]):
        if c.choices and c.choices[0].delta.content:
            parts.append(c.choices[0].delta.content)
        usage = getattr(c, "usage", None) or usage
    assert parts
    return f"{len(parts)} chunks, usage={usage}"

def bad_model():
    try:
        client.chat.completions.create(
            model="no-such-model", messages=[{"role": "user", "content": "hi"}])
    except NotFoundError as e:
        return "NotFoundError " + str(e.status_code)
    except Exception as e:
        return type(e).__name__
    raise AssertionError("bad model name was accepted")

for n, f in [("models", models), ("chat", chat), ("stream", stream), ("bad model", bad_model)]:
    check(n, f)

Exécutez-le avec python tester.py sk-your-key. La vérification du modèle défectueux enregistre toute classe d'erreur levée par votre SDK, ce qui est en soi une information utile. Si le service accepte un nom de modèle inconnu, il est probablement en cours de routage ou de redirection ; vous devriez vérifier comment cela fonctionne.

Vérification 4 : gestion des erreurs

Votre application rencontrera des erreurs, alors observez-les délibérément.

  • Clé incorrecte : modifiez un caractère dans la clé. Attendez-vous à un HTTP 401 et à un corps d'erreur JSON, pas à une page HTML.
  • Corps mal formé : envoyez {"model":"uncensored"} sans messages. Attendez-vous à un 4xx avec un message lisible.
  • Limites de débit : cette API renvoie 429 avec le code rate_limited pour les requêtes par minute et concurrency pour trop de requêtes simultanées. Une surcharge temporaire renvoie aussi 429, avec Retry-After: 5.

Un bon client traite le 429 comme un signal pour attendre et réessayer, et les 4xx autres que le 429 comme un bug à corriger. Écrivez la règle de réessai une fois et testez-la en lançant dix requêtes en même temps. Les limites par type de clé figurent sur la page erreurs et limites de débit.

Les lacunes de compatibilité à rechercher

Réussir les quatre tests est un bon début. Voici les endroits où les clones diffèrent le plus souvent, alors testez chacun si votre application en dépend :

  • Paramètres : envoyez temperature, top_p, stop, seed et les pénalités. Certains serveurs les ignorent silencieusement. Exécutez le même prompt trois fois avec un seed fixe et une température basse et comparez les sorties.
  • Rôles des messages : testez d'abord un message system, puis une longue histoire multi-tours. Vérifiez que le message système modifie bien le comportement.
  • Appels d'outils : demandez un appel à une fonction que vous définissez, puis renvoyez le résultat en tant que message role: "tool". En mode streaming, les tool_calls arrivent par morceaux que vous devez concaténer.
  • Mode JSON : définissez response_format sur {"type":"json_object"} et analysez 20 réponses.
  • Taille du corps : cette API accepte des corps jusqu'à 8 Mo. Une requête dépassant la limite doit échouer avec un 4xx clair, pas rester bloquée.

Notez chaque écart que vous trouvez et décidez si votre code peut le contourner. Gardez les notes à côté du script, car la prochaine fois que le fournisseur publiera une mise à jour, vous voudrez relancer les mêmes vérifications et comparer. Si vous testez plusieurs fournisseurs, exécutez le script identique contre chacun et gardez les sorties dans un tableau, afin que les différences soient visibles d'un coup d'œil plutôt qu'enterrées dans la mémoire. Un paramètre manquant est généralement inoffensif. Un format d'erreur différent ou un streaming cassé ne l'est généralement pas.

Ce que la réussite ne prouve pas

Une exécution verte montre la compatibilité du protocole. Elle ne dit rien sur la qualité des réponses, la vitesse sous charge ou le prix. Ceux-ci nécessitent des tests séparés sur vos propres prompts. Deux ajouts rapides valent la peine d'être faits : une requête avec un prompt long proche de votre taille réelle (cet endpoint a une fenêtre de contexte de 100 000 tokens), et une requête d'appel d'outil si votre application utilise des agents.

Gardez également à l'esprit ce contre quoi vous testez. Ce service héberge un seul modèle à poids ouverts, ajusté pour répondre sans refus de contenu pour une utilisation adulte légale. Il est uniquement textuel et n'est pas l'API officielle d'aucun fournisseur de modèle. Les prix sont de 0,15 $ par 1 M de tokens d'entrée et de 0,50 $ par 1 M de tokens de sortie, indiqués sur la page des tarifs, et les requêtes échouées ne sont pas facturées, de sorte que des exécutions de test répétées coûtent très peu. La documentation liste tous les paramètres pris en charge.

Questions et réponses

Existe-t-il un outil en ligne pour tester un endpoint compatible OpenAI ?

Tout client HTTP convient : curl, Postman ou un court script avec le SDK OpenAI. L'avantage d'un script est que vous pouvez le relancer après chaque modification.

Quelle URL de base dois-je configurer dans le SDK ?

Utilisez l'URL complète incluant /v1, par exemple https://api.uncensoredapis.com/v1. N'ajoutez pas /chat/completions, car le SDK l'ajoute à la fin.

Pourquoi obtiens-je un 404 sur une requête qui semble correcte ?

La cause la plus fréquente est une URL de base sans /v1 ou avec un chemin doublé. Vérifiez-le avec un GET à /v1/models en premier.

Comment vérifier mon solde restant pendant les tests ?

Lisez l'en-tête X-Balance-USD sur n'importe quelle réponse, ou appelez GET /v1/balance.

Votre clé n'est qu'à un formulaire d'ici

Créez un compte, copiez la clé, modifiez l'URL de base. C'est toute la configuration.