Best LLM API Guide
LLM-API nutzen: Erste Anfrage bis Streaming
Eine LLM-API zu nutzen bedeutet, eine JSON-Liste von Nachrichten über HTTPS zu senden und die Antwort zu lesen. Dieser Leitfaden führt dich von einem Schlüssel zu einer ersten Anfrage, dann zu Streaming, JSON-Ausgabe und Tool-Aufrufen.
Aktualisiert:

Wichtige Punkte
- Der Endpunkt ist OpenAI-kompatibel: Ändere die Base URL und den Schlüssel, behalte dein SDK.
- Verwende die Modell-ID uncensored und sende POST an /v1/chat/completions.
- Streaming, JSON-Modus und Tool-Calling werden alle unterstützt.
- Ein 429 bedeutet, dass du langsamer werden musst; lies den Fehlercode, um zu wissen, warum.
Was ein LLM-API-Aufruf ist
Wenn du dich fragst, wie man LLM-API-Dienste überhaupt nutzt, ist die Idee simpel. Du sendst einen HTTPS-POST mit einer Liste von Nachrichten. Jede Nachricht hat eine Rolle (system, user oder assistant) und einen Text. Der Server führt das Modell aus und sendet die nächste Assistant-Nachricht zurück. Das ist der gesamte Vertrag.
Das Modell hat zwischen Aufrufen keinen Speicher. Wenn du eine Konversation willst, sendest du die früheren Nachrichten jedes Mal erneut. Deshalb wachsen Prompts, deshalb steigen die Kosten mit ihnen und deshalb ist das 100.000-Token-Kontextfenster wichtig: Es ist die Grenze für Prompt plus Antwort zusammen.
Dieser Dienst spricht das gleiche Protokoll wie die OpenAI Chat Completions API. Jedes OpenAI-SDK oder ein kompatibler Client funktioniert, sobald du zwei Dinge änderst: die Base URL und den Schlüssel. Nur Text geht ein und kommt heraus. Es gibt keine Bild-, Audio- oder Videogenerierung und keinen Embedding-Endpunkt.
Einige Begriffe werden im restlichen Leitfaden verwendet. Ein Token ist ein Textstück, durchschnittlich etwa drei Viertel eines englischen Wortes. Input-Token sind alles, was du sendest, und Output-Token sind das, was das Modell schreibt. Du zahlst für beides zu unterschiedlichen Sätzen, und die Antwort sagt dir genau, wie viele von jedem es verwendet hat. Eine Base URL ist die Adresse, die dein Client jedem Pfad voranstellt, und ein API-Schlüssel ist das Geheimnis, das beweist, dass die Anfrage von dir stammt. Wenn du diese vier Begriffe kennst, ist der Rest Routine.
Schritt 1: Schlüssel besorgen und drei Werte notieren
Erstelle ein Konto mit Google oder mit E-Mail und Passwort und öffne die API-Schlüssel-Seite. Dort kannst du deinen Schlüssel kopieren und das Testguthaben von 0,50 $ mit einem Klick beanspruchen. Für das Testguthaben wird keine Karte benötigt.
Du brauchst drei Werte für jede Anfrage:
- Base URL:
https://api.bestllmapi.com/v1 - Modell-ID:
uncensored - Auth-Header:
Authorization: Bearer YOUR_KEY
Checke den Schlüssel nicht in die Versionsverwaltung ein. Lege ihn in einer Umgebungsvariable wie LLM_API_KEY ab und lies ihn von dort. Jeder, der den Schlüssel hat, kann dein Guthaben ausgeben.
Schritt 2: Sende eine erste Anfrage mit curl
Curl ist die schnellste Überprüfung, dass alles funktioniert, bevor eine Bibliothek im Spiel ist.
export LLM_API_KEY="paste-your-key-here"
curl https://api.bestllmapi.com/v1/chat/completions \
-H "Authorization: Bearer $LLM_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "uncensored",
"messages": [
{"role": "system", "content": "You are a concise assistant."},
{"role": "user", "content": "Explain what a token is in two sentences."}
],
"temperature": 0.7
}'
Die Antwort ist JSON. Der Text steht unter choices[0].message.content, und ein usage-Objekt listet Prompt- und Completion-Token auf, wofür du zahlst. Du kannst auch Modelle mit GET https://api.bestllmapi.com/v1/models auflisten; du solltest uncensored sehen.
Die Antwort-Header helfen auch weiter. X-Request-Id identifiziert den Aufruf, wenn du den Support kontaktierst, und X-Balance-USD zeigt, was noch auf deinem Konto übrig ist.
Antwort lesen und Parameter wählen
Eine Antwort hat ein paar Felder, die du kennen solltest, bevor du Parsing-Code schreibst. choices ist eine Liste, und du willst fast immer das erste Element. Darin enthält message.content den Text, und finish_reason sagt dir, warum das Modell aufgehört hat. Ein Wert von stop bedeutet, dass es natürlich beendet wurde. Ein Wert von length bedeutet, dass es dein max_tokens-Limit erreicht oder das Fenster erschöpft hat, also kann die Antwort mitten im Satz abgeschnitten sein.
Das usage-Objekt gibt Prompt-Token, Completion-Token und eine Gesamtzahl an. Logge diese ab dem ersten Tag für jeden Aufruf. Sie sind die einzige zuverlässige Möglichkeit zu lernen, was deine App wirklich kostet, und sie machen es einfach, einen Fehler zu erkennen, der dasselbe lange Prompt zweimal sendet.
Parameter zu wählen ist meistens eine Frage der Aufgabenart. Für Extraktion, Klassifizierung und Code verwende eine niedrige Temperatur wie 0,2, damit dieselbe Eingabe nahezu dieselbe Ausgabe liefert. Für Brainstorming und Geschichten gibt 0,8 bis 1,0 mehr Vielfalt. Ändere einen Wert nach dem anderen und verwende seed, wenn du wiederholbare Vergleiche zwischen zwei Prompt-Versionen willst.
Schritt 3: OpenAI-SDK in Python oder Node nutzen
In der Praxis wirst du eine Bibliothek nutzen. Installiere sie in Python mit pip install openai und verweise sie auf die neue Base URL.
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.bestllmapi.com/v1",
api_key=os.environ["LLM_API_KEY"],
)
resp = client.chat.completions.create(
model="uncensored",
messages=[
{"role": "system", "content": "You are a concise assistant."},
{"role": "user", "content": "Give me three names for a hiking app."},
],
temperature=0.8,
max_tokens=200,
)
print(resp.choices[0].message.content)
print(resp.usage.prompt_tokens, resp.usage.completion_tokens)
Die Node-Version ist fast identisch. Installiere mit npm install openai.
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://api.bestllmapi.com/v1",
apiKey: process.env.LLM_API_KEY,
});
const resp = await client.chat.completions.create({
model: "uncensored",
messages: [{ role: "user", content: "Give me three names for a hiking app." }],
});
console.log(resp.choices[0].message.content);
max_tokens ist optional. Wenn du es weglässt, kann die Antwort alles verwenden, was im 100.000-Token-Fenster übrig ist, also setze es, wenn du kurze Antworten willst. Die Sampling-Einstellungen temperature, top_p, stop, seed und die Penalties werden an das Modell durchgereicht.
Schritt 4: Antwort streamen
Ohne Streaming starrt dein Benutzer auf einen leeren Bildschirm, bis die ganze Antwort fertig ist. Mit stream: true sendet der Server Tokens über Server-Sent Events, sobald sie produziert werden, und die Nutzungsgesamtwerte kommen am Ende an.
import os
from openai import OpenAI
client = OpenAI(base_url="https://api.bestllmapi.com/v1", api_key=os.environ["LLM_API_KEY"])
stream = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Write a short product description for a desk lamp."}],
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)
Eine Sache, an die du dich erinnern solltest: Eine gestreamte Anfrage hält ihren Concurrency-Slot bis zum Ende des Streams. Ein voller Schlüssel erlaubt 8 gleichzeitige Anfragen, ein Test-Schlüssel 2. Wenn ein Benutzer den Tab schließt, schließe den Stream auch auf deiner Seite, sonst bleibt der Slot belegt.
Eine Konversation am Laufen halten
Da die API keinen Speicher hat, ist eine Chat-App eine Schleife, die an eine Liste anhängt. Das folgende Muster ist der Kern fast jedes Chatbots.
import os
from openai import OpenAI
client = OpenAI(base_url="https://api.bestllmapi.com/v1", api_key=os.environ["LLM_API_KEY"])
messages = [{"role": "system", "content": "You are a friendly travel planner."}]
while True:
user_text = input("You: ")
if user_text.strip().lower() in ("quit", "exit"):
break
messages.append({"role": "user", "content": user_text})
resp = client.chat.completions.create(model="uncensored", messages=messages)
answer = resp.choices[0].message.content
messages.append({"role": "assistant", "content": answer})
print("Bot:", answer)
Jeder Durchlauf sendet die ganze Liste erneut, also steigen die Kosten pro Runde, während der Chat länger wird. Der Preis ist 0,15 $ pro 1 Mio. Input-Token und 0,50 $ pro 1 Mio. Output-Token. Eine Runde mit 2.000 Input-Token und 400 Output-Token kostet 2.000 / 1.000.000 x 0,15 $ = 0,0003 $ plus 400 / 1.000.000 x 0,50 $ = 0,0002 $, also 0,0005 $. Bei dieser Rate deckt das Testguthaben von 0,50 $ etwa 1.000 Runden.
Wenn die Liste lang wird, lösche die ältesten User- und Assistant-Nachrichten, behalte aber die Systemnachricht oben. Oder bitte das Modell, eine kurze Zusammenfassung der frühen Runden zu schreiben und ersetze sie dadurch.
Schritt 5: JSON-Modus und Tool-Calling
Wenn dein Code die Antwort parsen muss, bitte um JSON. Setze response_format auf {"type": "json_object"} und sage auch "JSON" im Prompt, damit das Modell weiß, welche Form du willst.
import os, json
from openai import OpenAI
client = OpenAI(base_url="https://api.bestllmapi.com/v1", api_key=os.environ["LLM_API_KEY"])
resp = client.chat.completions.create(
model="uncensored",
response_format={"type": "json_object"},
messages=[
{"role": "system", "content": "Reply only with JSON."},
{"role": "user", "content": "Extract name and city: 'Maria lives in Lisbon.' Use keys name and city."},
],
)
print(json.loads(resp.choices[0].message.content))
Tool-Calling lässt das Modell deinen Code eine Funktion ausführen lassen. Du beschreibst die Funktion in tools; das Modell antwortet mit einem tool_calls-Eintrag statt Text; du führst die Funktion aus und sendest das Ergebnis mit role: "tool" zurück.
import os, json
from openai import OpenAI
client = OpenAI(base_url="https://api.bestllmapi.com/v1", api_key=os.environ["LLM_API_KEY"])
tools = [{
"type": "function",
"function": {
"name": "get_order_status",
"description": "Look up 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, tool_choice="auto"
)
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"}
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)
Modelle produzieren manchmal fehlerhafte Argumente, also packe json.loads in einen try-Block im echten Code und sende einen Fehler als Tool-Ergebnis zurück, wenn das Parsing fehlschlägt.
Wenn etwas schiefgeht
Die meisten Probleme am ersten Tag sind einer dieser.
- 401 oder Authentifizierungsfehler: der Schlüssel fehlt, hat einen Tippfehler oder der Header ist nicht in der Form
Bearer KEY. - 404: die Base URL fehlt
/v1, oder du hast den falschen Pfad aufgerufen. Der Chat-Pfad ist/v1/chat/completions. - 429 mit Code
rate_limited: du hast das Anfragen-pro-Minute-Limit überschritten (300 auf einem vollen Schlüssel, 60 auf einem Test-Schlüssel). - 429 mit Code
concurrency: zu viele Anfragen gleichzeitig (8 auf einem vollen Schlüssel, 2 auf einem Test-Schlüssel). Reihe deine Aufrufe in eine Warteschlange ein. - 429 mit
Retry-After: 5: temporäre Überlastung. Warte fünf Sekunden und versuche es erneut. - Anfrage zu groß: das Body-Limit liegt bei 8 MB, und Prompt plus Antwort müssen in 100.000 Token passen.
Fehlgeschlagene oder abgelehnte Anfragen werden nicht berechnet, also kostet sorgfältiges Wiederholen nichts extra. Für jeden Fehlercode und weitere Beispiele lies die Dokumentation und sieh dir Preise an, um zu schätzen, was eine Arbeitslast bei 0,15 $ pro 1 Mio. Input-Token und 0,50 $ pro 1 Mio. Output-Token kostet.
Höflich im Code wiederholen
Ein Skript, das viele Anfragen sendet, trifft irgendwann auf ein 429. Die Lösung ist ein kleiner Retry-Wrapper, der wartet und es erneut versucht. Diese Version respektiert die von der API bei temporärer Überlastung angeforderte fünfsekündige Pause.
import os, time
from openai import OpenAI, RateLimitError
client = OpenAI(base_url="https://api.bestllmapi.com/v1", api_key=os.environ["LLM_API_KEY"])
def ask(prompt, tries=5):
for attempt in range(tries):
try:
r = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": prompt}],
)
return r.choices[0].message.content
except RateLimitError:
time.sleep(5 * (attempt + 1))
raise RuntimeError("still rate limited after retries")
print(ask("List three uses for a paperclip."))
Wenn du viele Anfragen parallel ausführst, begrenze die Worker-Anzahl auf dein Concurrency-Limit. Ein Thread-Pool von 8 passt zu einem vollen Schlüssel, und 2 zu einem Test-Schlüssel. Darüber hinaus zu gehen, erzeugt nur concurrency-Fehler.
Weitere Anleitungen
Fragen und Antworten
Brauche ich ein spezielles SDK?
Nein. Jedes OpenAI-SDK oder ein OpenAI-kompatibler Client funktioniert. Setze die Base URL auf https://api.bestllmapi.com/v1, verwende deinen Schlüssel und stelle das Modell auf uncensored.
Kann ich es testen, bevor ich bezahle?
Ja. Neue Nutzer können 0,50 $ kostenloses Testguthaben mit einem Klick auf der API-Schlüssel-Seite beanspruchen. Es erfordert keine Kreditkarte und ist 7 Tage lang gültig.
Merkt sich die API frühere Nachrichten?
Nein. Sende den Konversationsverlauf in der messages-Liste bei jeder Anfrage. Prompt plus Antwort müssen in das 100.000-Token-Fenster passen.
Was bedeutet ein 429-Fehler?
Du hast ein Limit erreicht. Der Code rate_limited bedeutet zu viele Anfragen pro Minute, concurrency bedeutet zu viele gleichzeitig, und ein Retry-After-Header bedeutet kurze Überlastung.
Dein Schlüssel ist nur ein Formular entfernt
Erstelle ein Konto, kopiere den Schlüssel, ändere die Base URL. Das ist die gesamte Einrichtung.