Venice API-alternatief Python: OpenAI SDK-instelling
Je kunt de officiële OpenAI Python SDK gebruiken voor deze API door de base URL, de sleutel en de modelnaam aan te passen. Hieronder staat werkende code voor elke veelvoorkomende taak.

Belangrijkste punten
- Installeer het openai-pakket, stel base_url in op https://api.veniceapialternative.com/v1 en model op uncensored.
- Streaming, tool calling en JSON-modus werken allemaal via de standaard SDK-aanroepen.
- Houd parallel werk op of onder 8 gelijktijdige verzoeken voor een volledige sleutel (2 voor de proefsleutel).
- Een 429 betekent rate_limited, concurrency of tijdelijke overbelasting; wacht en probeer het opnieuw.
Installeer en maak de eerste aanroep
Voor een venice api alternative python setup heb je geen speciale bibliotheek nodig. De service gebruikt het OpenAI chat-formaat, dus de standaard SDK werkt. Installeer het met pip install openai en verkrijg vervolgens een sleutel. Nieuwe gebruikers kunnen $0,50 aan proeftegoed claimen op de API-sleutelpagina na het aanmelden met Google of met e-mail en wachtwoord. Er is geen creditcard nodig.
Sla de sleutel op in een omgevingsvariabele in plaats van in je bronbestand. Maak vervolgens een client aan met de base URL en roep het model uncensored aan:
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)
De SDK verzendt Authorization: Bearer <key> voor je. Het usage-object toont het tokenverbruik voor prompt en completion, dat je later zult gebruiken voor kostenopvolging. Als de aanroep faalt met een authenticatiefout, controleer dan of de sleutel geen trailing newline heeft en of de base URL eindigt op /v1.
De parameters temperature, top_p, stop en seed, plus de frequency en presence penalties, worden doorgegeven aan het model, zodat je de sampling kunt afstellen zoals je dat elders zou doen. Laat max_tokens weg als je het model de beschikbare ruimte in het venster wilt laten gebruiken, of stel het in als je een harde limiet wilt voor de lengte van het antwoord (en daarmee de kosten).
Controleer de verbinding met de models endpoint
Voordat je iets bouwt, controleer je of het endpoint bereikbaar is. De tweede ondersteunde methode, GET /v1/models, geeft weer wat de sleutel kan gebruiken:
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")
Je zou uncensored moeten zien. Dat is het enige model ID, en het is de waarde die je in elk verzoek als model moet doorgeven. Als je een app overbrengt die selecteerde tussen meerdere modelnamen, vervang dan de selectielogica door een constante. Er is niets anders om tussen te kiezen.
De volledige parameterverwijzing staat op de documentatiepagina. Alleen tekstchat wordt ondersteund: geen afbeeldingen, audio, embeddings of fine-tuning, dus verwijder die aanroepen uit elke code die je meeneemt.
Streaming-antwoorden
Streaming retourneert tokens zodra ze worden geproduceerd, wat chatinterfaces sneller laat aanvoelen. Stel stream=True in en itereer over de chunks. Gebruiksgegevens komen aan het einde van de stream, dus controleer op chunks zonder keuzes:
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)
Eén detail is belangrijk voor capaciteitsplanning: een gestreamd verzoek houdt zijn concurrency-slot vast tot de stream eindigt. Als een gebruiker een stream opent en wegloopt zonder deze te sluiten, blijft dat slot bezet. Sluit streams aan de clientkant als de gebruiker vertrekt en stel een request-timeout in.
Tool calling en JSON-modus
Tool calling volgt de OpenAI-vorm. Je beschrijft functies in tools, het model retourneert tool_calls, je voert de functie uit en stuur het resultaat terug met role: "tool":
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)
Parseer altijd function.arguments met een try/except in productiecode, omdat een model af en toe ongeldige JSON kan genereren. JSON-modus helpt als je gestructureerde output wilt zonder tools:
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))
Vertel het model in de prompt welke sleutels je wilt. JSON-modus maakt de output geldige JSON, maar het kan je schema niet raden.
429-fouten en rate limits afhandelen
Een volledige sleutel staat 8 gelijktijdige verzoeken en 300 verzoeken per minuut toe. Een proefsleutel staat 2 gelijktijdige en 60 per minuut toe. Na het overschrijden van een limiet krijg je HTTP 429, en de foutcode vertelt je welke:
rate_limited: te veel verzoeken per minuut. Verlaag je tempo.concurrency: te veel verzoeken in uitvoering. Wacht tot sommige klaar zijn.- Een 429 met een
Retry-After: 5-header: tijdelijke overbelasting. Wacht 5 seconden en probeer het opnieuw.
De SDK probeert standaard een paar keer opnieuw en respecteert Retry-After. Voor zwaardere belasting voeg je je eigen wrapper toe en lees je de limietheaders. Je kunt het ruwe antwoord bereiken via with_raw_response:
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."))
Log X-Request-Id bij elke fout. Als je support contacteert, kan zij met die ID het exacte verzoek vinden. De X-Balance-USD-header geeft je het resterende tegoed zonder extra verzoek. Mislukte en geweigerde verzoeken worden niet in rekening gebracht.
Verzoeken parallel uitvoeren zonder de limiet te raken
Voor batchtaken gebruik je de async client en een semaphore die is afgestemd op je sleutel. Voor een volledige sleutel is 8 het maximum. Laat wat marge over als je ook live gebruikers bedient met dezelfde sleutel.
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())
Het tempo telt ook voor de limiet per minuut. Met 6 parallelle workers en 4 seconden per aanroep stuur je ongeveer 90 verzoeken per minuut, ver onder de 300. Als je aanroepen snel zijn, voeg dan een korte slaap of een token bucket toe zodat je de limiet niet in pieken overschrijdt.
Een bestaand Python-project verplaatsen
De meeste migraties zijn kleiner dan mensen verwachten. Als je code al een OpenAI(...)-client bouwt, verander je twee constructorargumenten en één string. Als je instellingen uit omgevingsvariabelen leest, kun je vaak de code helemaal niet aanpassen: het openai-pakket leest OPENAI_API_KEY en OPENAI_BASE_URL, dus het instellen van die twee in je shell of je .env-bestand wijst het hele programma naar het nieuwe endpoint.
Zoek vervolgens in je project naar deze items, omdat ze de gebruikelijke oorzaken van fouten zijn:
- Vastgecodeerde modelnamen. Vervang elke oude naam door
uncensored. Een grep opmodel=vindt de meeste. - Aanroepen naar andere endpoints. Afbeeldings-, audio-, embedding- en fine-tuningaanroepen hebben hier geen equivalent. Routeer ze naar een service die ze aanbiedt, of verwijder ze.
- Vendor-specifieke extra's. Extra requestvelden of aangepaste headers die bij je oude provider horen, kunnen fouten veroorzaken. Converteer ze naar het eenvoudige OpenAI-formaat.
- Tokenbudgetten. Het venster is 100.000 tokens voor prompt plus completion. Als je geschiedenis hebt ingekrompen om in een kleiner venster te passen, kun je nu meer bewaren, maar houd kosten in de gaten, omdat elk bewaard bericht aan elke beurt opnieuw wordt betaald.
Prompts verdienen een her-test. Een systeemprompt die voor het ene model werkte, kan een andere toon geven op een ander, dus voer je tien belangrijkste prompts uit en vergelijk de output met wat je verwacht voordat je levert.
Veelvoorkomende problemen en oplossingen
Een korte lijst met de fouten die het vaakst verschijnen wanneer mensen een nieuwe OpenAI-compatible endpoint vanuit Python aansluiten:
- 404 bij de eerste aanroep. De base URL mist
/v1, of heeft een extra padsegment. Het moet precies lezenhttps://api.veniceapialternative.com/v1. - 401 of authenticatiefout. De sleutel is verkeerd, heeft nog steeds aanhalingstekens van een gekopieerde
.env-regel, of is nooit geëxporteerd naar de shell die Python uitvoert. - Het verzoek hangt bij grote inputs. De maximale body is 8 MB. Een groot bestand in een prompt plakken kan dit overschrijden voordat je de tokenlimiet bereikt. Verdeel de tekst.
- Willekeurige 429's tijdens testen. Bij de proefsleutel heb je slechts 2 gelijktijdige verzoeken. Een testrunner die er vijf tegelijk afschiet, raakt de limiet. Voer tests achter elkaar uit, of laad op en gebruik een volledige sleutel.
- Afgekapt antwoord. Controleer
finish_reason. Een waarde vanlengthbetekent dat de output jemax_tokens-instelling raakte of het venster vulde. - Verschillende resultaten van run tot run. Geef
seeden een lagetemperaturedoor als je herhaalbare output voor tests nodig hebt.
Als er nog steeds iets vreemd lijkt, stuur dan de X-Request-Id-waarde naar support samen met de tijd van de aanroep.
Kostenraming in code
De prijs is $0,15 per 1M input-tokens en $0,50 per 1M output-tokens. Een kleine helper zet elke verbruiksblock om in dollars:
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))
Een aanroep met 2.000 prompt tokens en 500 completion tokens retourneert 0,00055. Voer er 1.000 uit en je geeft $0,55 uit. Het proeftegoed van $0,50 dekt ongeveer 909 dergelijke aanroepen. Na de proefperiode beginnen opwaarderingen bij $20 en tegoed verloopt nooit; de prijzenpagina geeft de bonusniveaus weer. Als je app afkomstig is van een chatbotproject met eigen valkuilen, behandelt het artikel over veelvoorkomende API-fouten er meerdere die hier ook van toepassing zijn.
Meer handleidingen
Vragen en antwoorden
Welk Python-pakket heb ik nodig?
Het officiële openai-pakket. Installeer het met pip, stel base_url in op https://api.veniceapialternative.com/v1, en gebruik model uncensored. Er is geen andere clientbibliotheek nodig.
Werkt streaming met de SDK?
Ja. Geef stream=True door en itereren over de chunks. Gebruik wordt aan het einde van de stream gerapporteerd.
Waarom krijg ik een 429-fout?
Ofwel heb je de limiet voor verzoeken per minuut overschreden (rate_limited), had je te veel gelijktijdige openstaande verzoeken (concurrency), of was de service kortstondig overbelast en stuurde hij Retry-After: 5. Wacht even en probeer het opnieuw.
Hoeveel gelijktijdige verzoeken kan ik uitvoeren?
Een volledige sleutel staat 8 gelijktijdige verzoeken en 300 per minuut toe. Een proefsleutel staat 2 gelijktijdige en 60 per minuut toe.
Kan ik LangChain of andere OpenAI-compatible tools gebruiken?
Elke client waarmee je een OpenAI-compatible base URL en sleutel kunt instellen, zou moeten werken. Gebruik dezelfde base URL en de modelnaam uncensored.