DE ▾

Unzensierte AI API-Alternative für Entwickler

https://api.veniceapialternative.com/v1

veniceapialternative.com

Venice-API-Alternative Python: OpenAI-SDK-Einrichtung

Du kannst das offizielle OpenAI Python SDK gegen diese API verwenden, indem du die Base URL, den Schlüssel und den Modellnamen änderst. Unten findest du funktionierenden Code für jede gängige Aufgabe.

Aktualisiert

Band aus Codeblöcken, die von einem Terminal zu einem Cloud-Server fließen, zur Veranschaulichung der Python-API-Einrichtung

Wichtige Punkte

  • Installiere das openai-Paket, setze base_url auf https://api.veniceapialternative.com/v1 und das Modell auf uncensored.
  • Streaming, Function Calling und JSON-Modus funktionieren alle über die Standard-SDK-Aufrufe.
  • Halte parallele Anfragen bei einem vollständigen Schlüssel auf maximal 8 gleichzeitige Anfragen (2 beim Test-Schlüssel).
  • Ein 429-Fehler bedeutet rate_limited, Parallelität oder temporäre Überlastung; warte und versuche es erneut.

Installation und erster Aufruf

Für eine venice api alternative python setup benötigst du keine spezielle Bibliothek. Der Dienst spricht das OpenAI-Chat-Format, daher funktioniert das Standard-SDK. Installiere es mit pip install openai und hole dir danach einen Schlüssel. Neue Nutzer können nach der Anmeldung mit Google oder mit E-Mail und Passwort $0,50 Testguthaben auf der API-Schlüssel-Seite beanspruchen. Eine Karte wird nicht benötigt.

Speichere den Schlüssel in einer Umgebungsvariable statt in deiner Quelldatei. Erstelle dann einen Client mit der Base URL und rufe das Modell uncensored auf:

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.veniceapialternative.com/v1",
    api_key=os.environ["UNCENSORED_API_KEY"],
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You are a concise writing assistant."},
        {"role": "user", "content": "Give me three opening lines for a noir story."},
    ],
    temperature=0.8,
)

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

Das SDK sendet Authorization: Bearer <key> für dich. Das usage-Objekt zeigt Prompt- und Completion-Token an, die du später zur Kostenverfolgung verwendest. Wenn der Aufruf mit einem Authentifizierungsfehler fehlschlägt, überprüfe, ob der Schlüssel keine nachgestellte Leerzeile hat und die base URL mit /v1 endet.

Die Parameter temperature, top_p, stop und seed sowie die frequency- und presence-Strafen werden an das Modell weitergegeben, sodass du die Abtastung genau wie anderswo anpassen kannst. Lass max_tokens weg, wenn du möchtest, dass das Modell den im Fenster verbleibenden Platz nutzt, oder setze es, wenn du eine harte Grenze für Antwortlänge und Kosten setzen möchtest.

Überprüfe die Verbindung mit dem Endpunkt für Modelle

Bevor du irgendetwas erstellst, stelle sicher, dass der Endpunkt erreichbar ist. Die zweite unterstützte Methode, GET /v1/models, listet auf, was der Schlüssel verwenden kann:

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.veniceapialternative.com/v1",
    api_key=os.environ["UNCENSORED_API_KEY"],
)

for m in client.models.list():
    print(m.id, m.id == "uncensored")

Du solltest uncensored sehen. Das ist die einzige Modell-ID und der Wert, den du in jeder Anfrage als model übergibst. Wenn du eine App portierst, die zwischen mehreren Modellnamen auswählte, ersetze die Auswahlogik durch eine Konstante. Es gibt nichts anderes zur Auswahl.

Die vollständige Parameterreferenz findest du auf der Dokumentationsseite. Nur Text-Chat wird unterstützt: keine Bilder, Audio, Embeddings oder Fine-Tuning, also entferne diese Aufrufe aus jedem Code, den du migrierst.

Streaming-Antworten

Streaming gibt Tokens zurück, sobald sie erzeugt werden, was Chat-Oberflächen schneller wirken lässt. Setze stream=True und iteriere über die Chunks. Die Nutzungsinformationen stehen am Ende des Streams, also prüfe auf Chunks ohne Optionen:

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.veniceapialternative.com/v1",
    api_key=os.environ["UNCENSORED_API_KEY"],
)

stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Describe a rainy harbor town in 120 words."}],
    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("\n", chunk.usage)

Ein Detail ist für die Kapazitätsplanung wichtig: Eine gestreamte Anfrage belegt ihren Concurrency-Slot, bis der Stream endet. Wenn ein Benutzer einen Stream öffnet und ohne ihn zu schließen geht, bleibt dieser Slot belegt. Schließe Streams auf Client-Seite, wenn der Benutzer geht, und setze einen Anfrage-Timeout.

Tool Calling und JSON-Modus

Tool Calling folgt der OpenAI-Struktur. Du beschreibst Funktionen in tools, das Modell gibt tool_calls zurück, du führst die Funktion aus und sendest das Ergebnis mit role: "tool" zurück:

import json
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.veniceapialternative.com/v1",
    api_key=os.environ["UNCENSORED_API_KEY"],
)

tools = [{
    "type": "function",
    "function": {
        "name": "roll_dice",
        "description": "Roll a die with the given number of sides",
        "parameters": {
            "type": "object",
            "properties": {"sides": {"type": "integer"}},
            "required": ["sides"],
        },
    },
}]

messages = [{"role": "user", "content": "Roll a twenty-sided die for the next encounter."}]
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 = {"value": 14, "sides": args["sides"]}
    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)

Parst in Produktionscode immer function.arguments mit einem try/except, da ein Modell gelegentlich ungültiges JSON ausgibt. Der JSON-Modus hilft, wenn du strukturierte Ausgaben ohne Tools möchtest:

import json
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.veniceapialternative.com/v1",
    api_key=os.environ["UNCENSORED_API_KEY"],
)

r = client.chat.completions.create(
    model="uncensored",
    response_format={"type": "json_object"},
    messages=[
        {"role": "system", "content": "Reply with a JSON object with keys name, mood and hook."},
        {"role": "user", "content": "Invent a tavern keeper for a fantasy campaign."},
    ],
)
print(json.loads(r.choices[0].message.content))

Teile dem Modell im Prompt mit, welche Schlüssel du möchtest. Der JSON-Modus macht die Ausgabe zu gültigem JSON, kann dein Schema aber nicht erraten.

Umgang mit 429-Fehlern und Ratenlimits

Ein Voll-Key erlaubt 8 gleichzeitige Anfragen und 300 Anfragen pro Minute. Ein Test-Key erlaubt 2 gleichzeitige und 60 pro Minute. Wird ein Limit überschritten, erhältst du HTTP 429, und der Fehlercode sagt dir, welches Limit erreicht wurde:

  • rate_limited: zu viele Anfragen pro Minute. Verlangsame.
  • concurrency: zu viele Anfragen im Flug. Warte, bis einige beendet sind.
  • Ein 429 mit einem Retry-After: 5-Header: temporäre Überlastung. Warte 5 Sekunden und versuche es erneut.

Das SDK wiederholt standardmäßig einige Male und respektiert Retry-After. Für alles Weitere füge deinen eigenen Wrapper hinzu und lies die Limit-Header aus. Du kannst die Rohantwort über with_raw_response erreichen:

import os
import time
import openai
from openai import OpenAI

client = OpenAI(
    base_url="https://api.veniceapialternative.com/v1",
    api_key=os.environ["UNCENSORED_API_KEY"],
    max_retries=0,
)

def ask(prompt, attempts=4):
    for n in range(attempts):
        try:
            raw = client.chat.completions.with_raw_response.create(
                model="uncensored",
                messages=[{"role": "user", "content": prompt}],
            )
            print("balance:", raw.headers.get("X-Balance-USD"),
                  "request id:", raw.headers.get("X-Request-Id"))
            return raw.parse().choices[0].message.content
        except openai.RateLimitError as e:
            wait = int(e.response.headers.get("Retry-After", 2 ** n))
            time.sleep(wait)
    raise RuntimeError("still rate limited after retries")

print(ask("Name three plot twists for a heist story."))

Protokolliere X-Request-Id bei jedem Fehler. Wenn du den Support kontaktierst, ermöglicht diese ID ihnen, den genauen Aufruf zu finden. Der X-Balance-USD-Header gibt dir das verbleibende Guthaben ohne zusätzliche Anfrage aus. Fehlgeschlagene und abgelehnte Anfragen werden nicht berechnet.

Anfragen parallel ausführen, ohne die Grenze zu erreichen

Verwende für Batch-Jobs den asynchronen Client und einen Semaphore, der auf deinen Schlüssel zugeschnitten ist. Bei einem vollständigen Schlüssel ist 8 die Obergrenze. Lass etwas Spielraum, wenn du auch Live-Benutzer vom selben Schlüssel bedienst.

import asyncio
import os
from openai import AsyncOpenAI

client = AsyncOpenAI(
    base_url="https://api.veniceapialternative.com/v1",
    api_key=os.environ["UNCENSORED_API_KEY"],
)
gate = asyncio.Semaphore(6)

async def summarize(text):
    async with gate:
        r = await client.chat.completions.create(
            model="uncensored",
            messages=[{"role": "user", "content": "Summarize in one sentence: " + text}],
            max_tokens=80,
        )
        return r.choices[0].message.content

async def main():
    docs = ["First long text ...", "Second long text ...", "Third long text ..."]
    for line in await asyncio.gather(*(summarize(d) for d in docs)):
        print(line)

asyncio.run(main())

Das Tempo ist auch für das pro Minute geltende Limit wichtig. Bei 6 parallelen Workern und 4 Sekunden pro Aufruf sendest du etwa 90 Anfragen pro Minute, weit unter 300. Wenn deine Aufrufe schnell sind, füge eine kurze Pause oder einen Token-Bucket hinzu, damit du das Limit nicht in Bursts überschreitest.

Ein bestehendes Python-Projekt migrieren

Die meisten Migrationen sind kleiner, als man erwartet. Wenn dein Code bereits einen OpenAI(...)-Client erstellt, änderst du zwei Konstruktorenargumente und eine Zeichenkette. Wenn du Einstellungen aus Umgebungsvariablen liest, kannst du den Code oft gar nicht anfassen: Das openai-Paket liest OPENAI_API_KEY und OPENAI_BASE_URL, sodass das Setzen dieser beiden in deiner Shell oder deiner .env-Datei das gesamte Programm auf den neuen Endpunkt ausrichtet.

Suche dann in deinem Projekt nach diesen Elementen, da sie die üblichen Fehlerquellen sind:

  • Hart codierte Modellnamen. Ersetze jeden alten Namen durch uncensored. Ein grep nach model= findet die meisten davon.
  • Aufrufe zu anderen Endpunkten. Aufrufe für Bild, Audio, Embedding und Fine-Tuning haben hier kein Äquivalent. Leite sie zu einem Dienst weiter, der sie anbietet, oder entferne sie.
  • Anbieterspezifische Extras. Zusätzliche Anfragefelder oder benutzerdefinierte Header, die zu deinem alten Anbieter gehören, können Fehler verursachen. Reduziere sie auf das reine OpenAI-Format.
  • Token-Budgets. Das Kontextfenster umfasst 100.000 Token für Prompt plus Antwort. Wenn du die Historie gekürzt hast, um in ein kleineres Fenster zu passen, kannst du nun mehr behalten, behalte aber die Kosten im Auge, denn jede beibehaltene Nachricht wird bei jedem Durchlauf erneut berechnet.

Prompts verdienen eine erneute Überprüfung. Ein System-Prompt, der für ein Modell funktioniert hat, kann bei einem anderen einen anderen Ton erzeugen, also führe deine zehn wichtigsten Prompts aus und vergleiche die Ausgabe mit deinen Erwartungen, bevor du veröffentlichst.

Häufige Probleme und deren Lösungen

Eine kurze Liste der Fehler, die am häufigsten auftreten, wenn Leute einen neuen OpenAI-kompatiblen Endpunkt aus Python einrichten:

  • 404 beim ersten Aufruf. Die Basis-URL enthält kein /v1 oder hat ein zusätzliches Pfadsegment. Sie sollte exakt so lauten: https://api.veniceapialternative.com/v1.
  • 401 oder Authentifizierungsfehler. Der Schlüssel ist falsch, hat immer noch Anführungszeichen von einer kopierten .env-Zeile oder wurde nie in die Shell exportiert, die Python ausführt.
  • Die Anfrage hängt bei großen Eingaben. Die maximale Nutzlast beträgt 8 MB. Das Einfügen einer riesigen Datei in einen Prompt kann diesen Wert lange vor Erreichen des Token-Limits überschreiten. Teile den Text auf.
  • Zufällige 429-Fehler während der Tests. Beim Test-Key hast du nur 2 gleichzeitige Anfragen. Ein Test-Runner, der fünf gleichzeitig auslöst, löst das Limit aus. Führe Tests sequenziell durch, oder lade auf und verwende einen Voll-Key.
  • Abgeschnittene Antworten. Prüfe finish_reason. Ein Wert von length bedeutet, dass die Ausgabe dein max_tokens-Setting erreicht oder das Fenster gefüllt hat.
  • Unterschiedliche Ergebnisse von Lauf zu Lauf. Übergebe seed und eine niedrige temperature, wenn du wiederholbare Ausgaben für Tests benötigst.

Wenn etwas immer noch falsch aussieht, sende den X-Request-Id-Wert zusammen mit der Zeit des Aufrufs an den Support.

Kosten in Code abschätzen

Der Preis beträgt $0,15 pro 1M Eingabe-Token und $0,50 pro 1M Ausgabe-Token. Ein kleiner Helfer wandelt jeden Nutzungsbereich in Dollar um:

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.veniceapialternative.com/v1",
    api_key=os.environ["UNCENSORED_API_KEY"],
)

def cost_usd(usage):
    return (usage.prompt_tokens * 0.15 + usage.completion_tokens * 0.50) / 1_000_000

r = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Write a limerick about a lighthouse."}],
)
print(round(cost_usd(r.usage), 6))

Ein Aufruf mit 2.000 Prompt-Token und 500 Antwort-Token ergibt 0,00055. Führe 1.000 davon aus, und du gibst $0,55 aus. Das Testguthaben von $0,50 deckt etwa 909 solcher Aufrufe ab. Nach der Testphase beginnen Aufladungen bei $20 und das Guthaben verfällt nie; die Preisseite listet die Bonusstufen auf. Wenn deine App aus einem Chatbot-Projekt stammt, das seine eigenen Fallstricke hat, behandelt der Artikel über häufige API-Fehler mehrere, die hier ebenfalls zutreffen.

Fragen und Antworten

Welches Python-Paket benötige ich?

Das offizielle openai-Paket. Installiere es mit pip, setze base_url auf https://api.veniceapialternative.com/v1, und verwende das Modell uncensored. Keine weitere Client-Bibliothek ist erforderlich.

Funktioniert das Streaming mit dem SDK?

Ja. Übergebe stream=True und iteriere über die Chunks. Die Nutzung wird am Ende des Streams gemeldet.

Warum erhalte ich einen 429-Fehler?

Entweder hast du das Ratenlimit (rate_limited) überschritten, zu viele parallele Anfragen gleichzeitig geöffnet (concurrency) oder der Dienst war kurzzeitig überlastet und hat Retry-After: 5 gesendet. Warte kurz und versuche es erneut.

Wie viele parallele Anfragen kann ich gleichzeitig ausführen?

Ein vollständiger Schlüssel erlaubt 8 gleichzeitige Anfragen und 300 pro Minute. Ein Test-Schlüssel erlaubt 2 gleichzeitige und 60 pro Minute.

Kann ich LangChain oder andere OpenAI-kompatible Tools verwenden?

Jeder Client, der es dir ermöglicht, eine OpenAI-kompatible Basis-URL und einen Schlüssel festzulegen, sollte funktionieren. Verwende die gleiche Basis-URL und den Modellnamen uncensored.

Dein Schlüssel ist nur ein Formular entfernt

Erstelle ein Konto, kopiere den Schlüssel, ändere die Basis-URL. Das ist die gesamte Einrichtung.

API-Schlüssel erhalten