Guide d'intégration API sans censure : inscription, vérification, première requête

Liste de contrôle préalable

Vérifiez ces points pour éviter les retours en arrière.

• Une adresse email fonctionnelle pour l'inscription.
• Environnement requis : Python 3, JDK 15+ (utilisant les blocs de texte), Go, ou PHP avec l'extension curl.
• Vous devez être majeur (18 ans+). Le service est réservé aux adultes.
• Ce service propose uniquement du dialogue textuel : pas de vecteurs, images, audio ou fine-tuning.
• Conservez la clé dans une variable d'environnement, pas dans le code source.

Endpoint : https://api.wushenchaapi.com/v1. Format compatible avec les complétions de chat OpenAI.

Délais : inscription (1 min), installation (variable), première requête (< 30 s). Si délai dépassé, consultez la liste de dépannage.

Inscription et obtention de la clé

Accédez à /get-api-key/ et inscrivez-vous. La clé s'affiche immédiatement. Copiez-la.

1. Une seule clé par compte.
2. Vous pouvez la régénérer, mais l'ancienne devient invalide immédiatement. Déployez la nouvelle avant de changer en production.
3. $0.50 de crédit d'essai gratuit pour 7 jours, sans paiement.
4. À l'expiration ou à l'épuisement du crédit, les requêtes retournent une erreur no_credit (402). Rechargez votre crédit prépayé pour continuer. Ce n'est pas un abonnement et le solde n'expire pas.

Définissez la variable d'environnement : macOS/Linux export API_KEY=VOTRE_CLE ; Windows PowerShell $env:API_KEY="VOTRE_CLE". Les exemples lisent API_KEY.

Étape 1 : Vérifier la connectivité via /v1/models

Ne lancez pas encore de conversation. Effectuez d'abord un GET à coût nul pour valider l'URL, le réseau et la clé :

复制curl https://api.wushenchaapi.com/v1/models \
  -H "Authorization: Bearer $API_KEY"

Réponse 200 avec la liste des modèles (un seul uncensored) signifie succès. 401 indique une clé invalide ou absente. Timeout : vérifiez le réseau. Séparez les problèmes de connectivité de ceux du corps de la requête.

Python : requests

Pas besoin de SDK. Un simple requests.post suffit. Points clés : définissez timeout ; vérifiez r.ok avant d'accéder à choices ; les erreurs retournent {"error":{"code":...,"message":...}}.

复制import os
import requests

url = "https://api.wushenchaapi.com/v1/chat/completions"
headers = {
    "Authorization": "Bearer " + os.environ["API_KEY"],
    "Content-Type": "application/json",
}
payload = {
    "model": "uncensored",
    "messages": [{"role": "user", "content": "用两句话描述一场雨夜里的追逐戏。"}],
    "max_tokens": 300,
}
r = requests.post(url, headers=headers, json=payload, timeout=120)
print(r.status_code)
data = r.json()
if r.ok:
    print(data["choices"][0]["message"]["content"])
    print(data["usage"])
else:
    print(data["error"]["code"], data["error"]["message"])

En cas de succès, usage contient prompt_tokens et completion_tokens. Affichez-les pour suivre les coûts.

Analyse détaillée du corps de la requête

Les quatre langages envoient le même JSON. Comprenez-le pour l'adapter facilement.

Champ	Obligatoire	Description
model	Oui	Fixe à uncensored.
messages	Oui	Tableau d'objets avec role (system, user, assistant) et content.
max_tokens	Non	Fenêtre de contexte : 2048 par défaut, maximum 16 000. Ajustez-la vous-même pour les longs textes.
temperature / top_p / stop	Non	Paramètres standards de sampling, transmis tels quels.
stream	Non	Lorsque stream est true, le streaming via SSE est activé.

Lisez trois champs de la réponse : choices[0].message.content pour le contenu, choices[0].finish_reason pour la raison de fin, et usage pour l'utilisation des tokens. Lisez-les tous pour une intégration complète.

Deux limites strictes : le corps de la requête ne dépasse pas 8 MB, et la limite de débit est de 300 requêtes par minute et par clé API. Limitez le nombre de requêtes simultanées pour les tâches par lots.

Java : java.net.http

JDK 11+ inclut HttpClient sans dépendances. L'exemple utilise les blocs de texte de JDK 15 pour écrire du JSON ; utilisez des chaînes ou une bibliothèque JSON pour les versions inférieures.

复制import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;

public class Demo {
    public static void main(String[] args) throws Exception {
        String key = System.getenv("API_KEY");
        String body = """
            {"model":"uncensored",
             "messages":[{"role":"user","content":"写一段两百字以内的悬疑小说开头。"}],
             "max_tokens":400}
            """;
        HttpRequest req = HttpRequest.newBuilder(
                URI.create("https://api.wushenchaapi.com/v1/chat/completions"))
            .timeout(Duration.ofSeconds(120))
            .header("Authorization", "Bearer " + key)
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build();
        HttpResponse<String> resp = HttpClient.newHttpClient()
            .send(req, HttpResponse.BodyHandlers.ofString());
        System.out.println(resp.statusCode());
        System.out.println(resp.body());
    }
}

Astuce : si le contenu contient du texte chinois, BodyPublishers.ofString encode en UTF-8 par défaut. En production, utilisez HttpClient en singleton.

Go : net/http

La bibliothèque standard Go suffit. Évitez http.DefaultClient sans timeout : si le serveur distant ne répond pas, le goroutine reste bloqué indéfiniment.

复制package main

import (
	"bytes"
	"fmt"
	"io"
	"net/http"
	"os"
	"time"
)

func main() {
	body := []byte(`{"model":"uncensored","messages":[{"role":"user","content":"给一个反派角色写三句独白。"}],"max_tokens":300}`)
	req, err := http.NewRequest("POST", "https://api.wushenchaapi.com/v1/chat/completions", bytes.NewReader(body))
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "Bearer "+os.Getenv("API_KEY"))
	req.Header.Set("Content-Type", "application/json")

	client := &http.Client{Timeout: 120 * time.Second}
	resp, err := client.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	out, _ := io.ReadAll(resp.Body)
	fmt.Println(resp.StatusCode, string(out))
}

Lisez le corps de la réponse avec io.ReadAll avant de le parser. Pour un traitement structuré, définissez une struct correspondante et utilisez encoding/json pour la désérialisation. Les champs sont choices, message, content et usage.

PHP : curl

Utilisez l'extension curl de PHP. N'oubliez pas d'ajouter JSON_UNESCAPED_UNICODE à json_encode, sinon le chinois sera converti en \uXXXX. Cela fonctionne, mais c'est difficile à lire lors du débogage.

复制<?php
$payload = [
    "model" => "uncensored",
    "messages" => [["role" => "user", "content" => "写一首八行的现代诗，主题是末班地铁。"]],
    "max_tokens" => 300,
];
$ch = curl_init("https://api.wushenchaapi.com/v1/chat/completions");
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 120,
    CURLOPT_HTTPHEADER => [
        "Authorization: Bearer " . getenv("API_KEY"),
        "Content-Type: application/json",
    ],
    CURLOPT_POSTFIELDS => json_encode($payload, JSON_UNESCAPED_UNICODE),
]);
$res = curl_exec($ch);
if ($res === false) {
    die("curl 错误: " . curl_error($ch) . "\n");
}
$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);
echo $status, "\n";
$data = json_decode($res, true);
echo $data["choices"][0]["message"]["content"] ?? $res, "\n";

Distinguez deux types d'échec : un retour de false pour curl_exec indique un problème de couche réseau ; un retour de contenu avec un code d'état différent de 200 indique un problème de couche API, il faut alors lire error.code.

Pièges courants lors du premier appel

• 401 : Header écrit Authorization: clé, manquant le préfixe Bearer ; ou variable d'environnement non active dans le terminal.
• 404 : Le chemin manque /v1 ou chat/completions est mal orthographié.
• 400 : JSON invalide ou prompt dépassant la limite de 100,000 tokens avec max_tokens.
• 402 : Solde épuisé ou crédit d'essai expiré.
• Sortie tronquée : max_tokens vaut 2048 par défaut, le maximum par appel est de 16 000. Augmentez-le explicitement pour les longs textes.
• Vous voulez le streaming : Ajoutez "stream": true au corps de la requête. La réponse est au format SSE et un bloc de données contenant usage est ajouté automatiquement à la fin.

Une fois que cela fonctionne, passez à l'écriture des prompts pour améliorer la qualité des sorties. En cas d'erreur, consultez le manuel de débogage des codes d'erreur. La documentation complète des paramètres est disponible dans la documentation et les tarifs sur la page des prix.

Une fois que cela fonctionne, ajoutez trois éléments avant la mise en production

L'exemple du tutoriel est une version minimale fonctionnelle. Pour l'intégrer dans un service, vous devez au moins ajouter ces trois éléments.

1. Délai d'expiration. L'exemple définit 120 secondes car la génération de longs textes est lente. Si votre application attend de manière synchrone, réduisez ce délai selon la tolérance de votre interface et utilisez le streaming pour afficher le texte au fur et à mesure.
2. Gestion des erreurs. Les erreurs 401, 402 et 403 ne se résolvent pas en réessayant ; il faut générer une alerte ou informer l'utilisateur. Les erreurs 429 et 503 justifient une stratégie de backoff. La mise en œuvre est détaillée dans le manuel de débogage.
3. Suivi de la consommation. Enregistrez une ligne de journal avec les données usage de chaque réponse. Notez uniquement les chiffres et n'écrivez pas le contenu de l'utilisateur dans les logs. Cela servira pour la facturation mensuelle et l'analyse des consommations anormales.

Un mot sur la gestion des clés : il n'y a qu'une seule clé. En cas de fuite, vous devez la régénérer, ce qui déconnectera immédiatement tous les services qui l'utilisent. Ne la dispersez pas dans plusieurs scripts ou configurations de serveurs ; centralisez-la dans un seul gestionnaire de clés pour éviter les oublis lors du changement.

Enfin, les limites de contenu : les contenus pour adultes légaux, les fictions et les sujets controversés ne sont pas bloqués. Cependant, les contenus sexuels impliquant des mineurs sont systématiquement bloqués avec un code 403, y compris dans les fictions et le jeu de rôle. Si votre application s'adresse à des adultes, il est recommandé d'ajouter une vérification de l'âge lors de l'inscription.

Voici une séquence de vérification à coller près de votre écran : la clé est-elle dans les variables d'environnement ? Les modèles répondent-ils ? Le corps de la requête est-il un JSON valide ? Le modèle est-il sans censure ? max_tokens est-il suffisant ? finish_reason dans la réponse est-il stop ou length ? La consommation (usage) est-elle enregistrée ? Si les sept points sont validés, l'intégration est terminée.