Poradnik integracji API bez cenzury: rejestracja, weryfikacja, pierwsze wywołanie

Checklista przed rozpoczęciem

Przejrzyj ją, aby uniknąć cofania się w trakcie pracy.

• Działająca skrzynka e-mail do rejestracji.
• Na Twoim komputerze zainstalowana jest dowolna z tych środowisk: Python 3, JDK 15 lub nowszy (przykłady używają bloków tekstowych), Go lub PHP z rozszerzeniem curl.
• Musisz mieć ukończone 18 lat. Usługa przeznaczona jest wyłącznie dla osób dorosłych.
• Potrzebujesz czystej konwersacji tekstowej. Oferujemy tylko jeden model — brak wektorów, obrazów, głosu czy fine-tuningu.
• Przechowuj klucz w zmiennych środowiskowych. Nie wpisuj go do kodu źródłowego i nie wysyłaj do repozytorium.

Interfejs jest prosty: adres https://api.wushenchaapi.com/v1. Format jest kompatybilny z OpenAI chat completions, więc Twoje stare zapytania zadziałają bez zmian.

Szacowany czas: rejestracja zajmie minutę, instalacja środowiska zależy od Twojego komputera, pierwsze zapytanie trwa do 30 sekund. Jeśli wynik nie wróci szybciej, sprawdź sieć lub klucz (patrz lista błędów na końcu). Kolejność: najpierw models, potem chat; najpierw synchronicznie, potem strumieniowanie. Potwierdzaj każdy krok przed przejściem dalej.

Zarejestruj się i uzyskaj klucz

Otwórz /get-api-key/ i zarejestruj się e-mailem i hasłem. Klucz pojawi się od razu po rejestracji — skopiuj go. Ważne szczegóły:

1. Konto ma tylko jeden klucz.
2. Możesz go wygenerować ponownie, ale stary klucz traci ważność natychmiast. Wdroż nową wartość przed zmianą na produkcji.
3. Nowe konto otrzymuje $0.50 kredytu próbnego ważnego przez 7 dni. Nie podajesz danych płatniczych.
4. Po wyczerpaniu lub wygaśnięciu kredytu otrzymasz błąd 402 z kodem no_credit. Doładuj przedpłacony kredyt, aby kontynuować. To nie subskrypcja — saldo nie wygasa.

Ustaw klucz w zmiennej środowiskowej: na macOS / Linux wykonaj export API_KEY=Twój klucz, a w Windows PowerShell użyj $env:API_KEY="Twój klucz". Wszystkie poniższe przykłady odczytują wartość ze zmiennej API_KEY.

Krok 1: Weryfikacja łączności przez /v1/models

Nie wysyłaj jeszcze rozmowy. Najpierw wykonaj zapytanie GET bez kosztów, aby sprawdzić adres, sieć i klucz API:

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

Status 200 i lista modeli (tylko uncensored) oznaczają sukces. Błąd 401 oznacza błędny lub brakujący klucz. Przekroczenie czasu to problem z siecią/proxy. Rozdzielenie problemów z łącznością od ciała zapytania oszczędza czas.

Python: requests

Bez SDK wystarczy requests.post. Ustaw timeout; sprawdź r.ok przed choices; błąd to {"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"])

W przypadku sukcesu w usage znajdziesz pola prompt_tokens i completion_tokens. W trakcie dewelopmentu zalecamy ich wypisywanie, aby mieć kontrolę nad kosztami.

Analiza pól ciała zapytania

Wszystkie języki wysyłają ten sam JSON. Zrozum go, a implementacja w dowolnym języku będzie jedynie adaptacją.

Pole	Wymagane	Opis
model	Tak	Ustal na uncensored.
messages	Tak	Tablica obiektów z role i content. role przyjmuje: system, user, assistant.
max_tokens	Nie	Domyślnie 2048, limit 16,000. Zwiększ ręcznie dla dłuższych tekstów.
temperature / top_p / stop	Nie	Standardowe parametry próbkowania, przesyłane bez zmian.
stream	Nie	Gdy ustawione na true, używane jest strumieniowanie przez SSE.

W odpowiedzi najczęściej czytasz trzy pola: choices[0].message.content to treść, choices[0].finish_reason informuje, czy odpowiedź zakończyła się poprawnie, czy została ucięta z powodu limitu długości, a usage to zużycie tokenów w tym zapytaniu. Przeczytaj wszystkie trzy, aby w pełni zintegrować się z API.

Pamiętaj o limitach: ciało zapytania ≤ 8 MB, limit zapytań 300/min na klucz API. Nie wysyłaj równoległych zapytań masowo.

Java: java.net.http

HttpClient jest dostępny od JDK 11 i nie wymaga żadnych dodatkowych zależności. Poniższy przykład używa bloków tekstowych JDK 15 do tworzenia JSON-a; w starszych wersjach możesz użyć konkatenacji ciągów lub biblioteki do serializacji JSON, z której korzystasz na co dzień.

复制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());
    }
}

Wskazówka: gdy treść zawiera znaki chińskie, BodyPublishers.ofString domyślnie koduje dane w UTF-8, więc nie musisz robić nic dodatkowego. W środowisku produkcyjnym traktuj HttpClient jako singleton i go ponownie używaj, zamiast tworzyć go przy każdym zapytaniu.

Go: net/http

Standardowa biblioteka Go również wystarcza. Kluczowe jest nie używanie http.DefaultClient bez ustawienia limitu czasu, ponieważ w przypadku zawieszenia się serwera po drugiej stronie goroutine będzie wisieć w nieskończoność.

复制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))
}

Przed parsowaniem przeczytaj ciało odpowiedzi za pomocą io.ReadAll. Jeśli potrzebujesz przetwarzania strukturalnego, zdefiniuj odpowiednią strukturę i użyj encoding/json do deserializacji. Pola to choices, message, content, usage.

PHP: curl

W PHP użyj rozszerzenia curl. Pamiętaj, aby w json_encode dodać flagę JSON_UNESCAPED_UNICODE, inaczej znaki chińskie zostaną zamienione na format \uXXXX. Działa to poprawnie, ale trudniej czytać w trakcie debugowania.

复制<?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";

Rozróżnij dwa rodzaje błędów: curl_exec zwracające false oznacza problem warstwy sieciowej; zwrócenie treści, ale z kodem stanu innym niż 200, oznacza problem warstwy interfejsu – przeczytaj error.code.

Najczęstsze błędy przy pierwszym wywołaniu

• 401: Nagłówek ma postać Authorization: klucz API, ale brakuje przedrostka Bearer ; lub zmienna środowiskowa nie została wczytana w nowym oknie terminala.
• 404: Brak /v1 w ścieżce lub literówka w chat/completions.
• 400: Nieprawidłowy format JSON lub przekroczono limit 100,000 tokenów przez dodanie max_tokens do promptu.
• 402: Brak środków lub wygaśnięcie kredytu próbnego.
• Odpowiedź została ucięta: max_tokens domyślnie wynosi 2048, a maksymalna wartość to 16 000. Przy długich tekstach musisz jawnie zwiększyć ten limit.
• Chcesz strumieniowanie: Dodaj "stream": true do ciała zapytania. Odpowiedź będzie w formacie SSE, a na końcu automatycznie zostanie dodany blok danych z usage.

Po pomyślnym uruchomieniu przejdź do Pisania promptów, aby poprawić jakość outputu. W przypadku błędów skorzystaj z przewodnika po kodach błędów. Pełny opis parametrów znajdziesz w dokumentacji, a ceny na stronie z cenami.

Po przetestowaniu, przed wdrożeniem, dodaj trzy elementy

Przykłady z poradnika to minimalna wersja do działania. Aby wdrożyć kod w usłudze, dodaj przynajmniej te trzy elementy.

1. Limit czasu (timeout). W przykładach ustawiono go na 120 sekund, ponieważ generowanie długich tekstów trwa długo. Jeśli Twoja usługa oczekuje synchronicznie, skróć limit czasu zgodnie z tolerancją Twojej aplikacji i połącz to ze strumieniowaniem, aby użytkownik mógł widzieć tekst od razu.
2. Przekierowanie błędów. Błędy 401, 402 i 403 nie wymagają ponowienia — zawiadom użytkownika lub system. Retry z backoffem stosuj tylko do 429 i 503. Szczegóły w podręczniku rozwiązywania problemów.
3. Rejestrowanie zużycia. Przy każdej odpowiedzi zapisuj w logach wartość usage. Zapisuj tylko liczby, nie zapisuj treści użytkownika w logach. Będzie to potrzebne do rozliczeń na koniec miesiąca i do analizy nieprawidłowego zużycia.

Jeszcze jedna uwaga dotycząca zarządzania kluczami: klucz jest jeden, a po jego utracie można go tylko wygenerować ponownie. Wygenerowanie nowego klucza spowoduje natychmiastowe odcięcie wszystkich usług, które go używają. Nie rozrzucaj go po wielu skryptach i konfiguracjach na różnych serwerach. Skup go w jednym miejscu, aby łatwiej było go zmienić bez ryzyka, że coś przeoczysz.

Ostatnia kwestia to granice treści: treści dla dorosłych, fikcja literacka i kontrowersyjne tematy nie są odrzucane, ale treści o charakterze seksualnym z udziałem małoletnich są zawsze blokowane i zwracany jest kod 403, również w przypadku fikcji i odgrywania ról. Jeśli Twoja aplikacja jest przeznaczona dla użytkowników dorosłych, zalecamy dodanie potwierdzenia wieku w procesie rejestracji.

Oto ostateczna lista kontrolna do samodzielnego sprawdzenia, którą możesz nawet przykleić obok monitora: Czy klucz jest w zmiennych środowiskowych? Czy endpoint models działa? Czy ciało zapytania jest poprawnym JSON-em? Czy model to uncensored? Czy max_tokens jest wystarczający? Czy finish_reason w odpowiedzi to stop, czy length? Czy usage zostało zapisane? Jeśli wszystkie siedem punktów jest zielonych, integracja jest zakończona.