Alternative API Venice Python : Configuration du SDK OpenAI
Vous pouvez utiliser le SDK Python officiel OpenAI contre cette API en modifiant l'URL de base, la clé et le nom du modèle. Voici du code fonctionnel pour chaque tâche courante.

Points clés
- Installez le package openai, définissez base_url sur https://api.veniceapialternative.com/v1 et le modèle sur uncensored.
- Le streaming, l'appel d'outils et le mode JSON fonctionnent tous via les appels SDK standard.
- Maintenez le travail parallèle à un niveau inférieur ou égal à 8 requêtes concurrentes sur une clé complète (2 sur la clé d'essai).
- Un 429 signifie rate_limited, concurrency ou surcharge temporaire ; reculez et réessayez.
Installer et effectuer le premier appel
Pour une alternative API Venice Python, vous n'avez besoin d'aucune bibliothèque spéciale. Le service utilise le format de chat OpenAI, donc le SDK standard fonctionne. Installez-le avec pip install openai, puis obtenez une clé. Les nouveaux utilisateurs peuvent réclamer 0,50 $ de crédit d'essai sur la page clé API après s'être inscrits avec Google ou avec e-mail et mot de passe. Aucune carte n'est nécessaire.
Stockez la clé dans une variable d'environnement au lieu de votre fichier source. Créez ensuite un client avec l'URL de base et appelez le modèle uncensored :
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)
Le SDK envoie Authorization: Bearer <key> pour vous. L'objet usage affiche les tokens de prompt et de complétion, que vous utiliserez pour le suivi des coûts plus tard. Si l'appel échoue avec une erreur d'authentification, vérifiez que la clé ne contient pas de nouvelle ligne à la fin et que l'URL de base se termine par /v1.
Les paramètres temperature, top_p, stop et seed, ainsi que les pénalités de fréquence et de présence, sont transmis au modèle, vous pouvez donc ajuster l'échantillonnage de la même manière qu'ailleurs. Laissez max_tokens hors jeu si vous voulez que le modèle utilise tout l'espace restant dans la fenêtre, ou définissez-le lorsque vous voulez un plafond strict sur la longueur de la réponse et le coût.
Vérifiez la connexion avec l'endpoint des modèles
Avant de construire quoi que ce soit, confirmez que l'endpoint est accessible. La deuxième méthode prise en charge, GET /v1/models, liste ce que la clé peut utiliser :
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")
Vous devriez voir uncensored. C'est le seul ID de modèle, et c'est la valeur à passer en tant que model dans chaque requête. Si vous portez une application qui sélectionnait parmi plusieurs noms de modèles, remplacez la logique de sélection par une constante. Il n'y a rien d'autre à choisir entre.
La référence complète des paramètres se trouve sur la page de documentation. Seule la conversation textuelle est prise en charge : pas d'images, d'audio, d'embeddings ou de fine-tuning, donc supprimez ces appels de tout code que vous migrez.
Réponses en streaming
Le streaming renvoie les tokens au fur et à mesure de leur production, ce qui rend les interfaces de chat plus rapides. Définissez stream=True et itérez sur les chunks. L'utilisation arrive à la fin du flux, alors protégez-vous contre les chunks qui ne contiennent pas de choix :
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)
Un détail compte pour la planification de la capacité : une requête diffusée conserve son slot de concurrence jusqu'à la fin du flux. Si un utilisateur ouvre un flux et s'éloigne sans le fermer, ce slot reste occupé. Fermez les flux côté client lorsque l'utilisateur part, et définissez un délai d'expiration de la requête.
Appel d'outils et mode JSON
L'appel d'outils suit la forme OpenAI. Vous décrivez les fonctions dans tools, le modèle renvoie tool_calls, vous exécutez la fonction et renvoyez le résultat avec 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)
Analysez toujours function.arguments avec un try/except dans le code de production, car un modèle peut émettre du JSON malformé de temps en temps. Le mode JSON aide lorsque vous voulez une sortie structurée sans outils :
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))
Indiquez au modèle dans le prompt quelles clés vous souhaitez. Le mode JSON rend la sortie JSON valide, mais il ne peut pas deviner votre schéma.
Gestion des erreurs 429 et des limites de débit
Une clé complète permet 8 requêtes simultanées et 300 requêtes par minute. Une clé d'essai permet 2 requêtes simultanées et 60 par minute. Au-delà d'une limite, vous obtenez un HTTP 429, et le code d'erreur vous indique laquelle :
rate_limited: trop de requêtes par minute. Ralentissez.concurrency: trop de requêtes en cours. Attendez que certaines se terminent.- Une réponse 429 avec l'en-tête
Retry-After: 5: surcharge temporaire. Attendez 5 secondes et réessayez.
Le SDK réessaie déjà quelques fois par défaut et respecte Retry-After. Pour quelque chose de plus lourd, ajoutez votre propre wrapper et lisez les en-têtes de limite. Vous pouvez accéder à la réponse brute 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."))
Journalisez X-Request-Id avec chaque échec. Si vous contactez support, cet ID leur permet de trouver l'appel exact. L'en-tête X-Balance-USD vous donne le crédit restant sans requête supplémentaire. Les requêtes échouées et refusées ne sont pas facturées.
Exécution de requêtes en parallèle sans atteindre le plafond
Pour les tâches par lots, utilisez le client asynchrone et un sémaphore dimensionné à votre clé. Sur une clé complète, 8 est le plafond. Laissez une marge de manœuvre si vous servez également des utilisateurs en direct depuis la même clé.
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())
Le rythme compte aussi pour la limite par minute. Avec 6 travailleurs parallèles et 4 secondes par appel, vous envoyez environ 90 requêtes par minute, bien en dessous de 300. Si vos appels sont rapides, ajoutez une petite pause ou un seau de jetons pour ne pas dépasser la limite par rafales.
Migration d'un projet Python existant
La plupart des migrations sont plus petites que les gens ne le pensent. Si votre code construit déjà un client OpenAI(...), vous modifiez deux arguments du constructeur et une chaîne. Si vous lisez les paramètres depuis des variables d'environnement, vous pouvez souvent éviter de toucher au code : le package openai lit OPENAI_API_KEY et OPENAI_BASE_URL, donc définir ces deux variables dans votre shell ou votre fichier .env pointe tout le programme vers le nouvel endpoint.
Recherchez ensuite ces éléments dans votre projet, car ils sont les sources habituelles de rupture :
- Noms de modèles codés en dur. Remplacez chaque ancien nom par
uncensored. Un grep pourmodel=en trouve la plupart. - Appels à d'autres endpoints. Les appels image, audio, embedding et fine-tuning n'ont pas d'équivalent ici. Routez-les vers un service qui les propose, ou supprimez-les.
- Extras spécifiques au fournisseur. Les champs de requête supplémentaires ou les en-têtes personnalisés appartenant à votre ancien fournisseur peuvent provoquer des erreurs. Supprimez-les au format OpenAI standard.
- Budgets de tokens. La fenêtre est de 100 000 tokens pour le prompt plus la complétion. Si vous avez réduit l'historique pour s'adapter à une fenêtre plus petite, vous pouvez maintenant en garder plus, mais surveillez les coûts, car chaque message conservé est payé à nouveau à chaque tour.
Les prompts méritent un nouveau test. Un prompt système qui fonctionnait pour un modèle peut donner un ton différent sur un autre, donc exécutez vos dix prompts les plus importants et comparez la sortie avec ce à quoi vous vous attendez avant de livrer.
Problèmes courants et leurs solutions
Une courte liste des erreurs qui apparaissent le plus souvent lorsque les gens configurent un nouvel endpoint compatible OpenAI à partir de Python :
- 404 sur le premier appel. L'URL de base manque de
/v1, ou elle a un segment de chemin supplémentaire. Elle devrait lire exactementhttps://api.veniceapialternative.com/v1. - 401 ou erreur d'authentification. La clé est incorrecte, contient encore des guillemets autour d'elle provenant d'une ligne
.envcopiée, ou n'a jamais été exportée dans le shell qui exécute Python. - La requête se bloque sur les grandes entrées. Le corps maximum est de 8 Mo. Coller un fichier énorme dans un prompt peut le dépasser bien avant d'atteindre la limite de tokens. Divisez le texte.
- Erreurs 429 aléatoires lors des tests. Avec la clé d’essai, vous ne pouvez avoir que 2 requêtes simultanées. Un runner de tests qui en déclenche cinq à la fois déclenchera la limite. Exécutez les tests en série, ou rechargez votre compte et utilisez une clé complète.
- Réponses tronquées. Vérifiez
finish_reason. Une valeur delengthsignifie que la sortie a atteint votre paramètremax_tokensou a rempli la fenêtre. - Résultats différents d'une exécution à l'autre. Passez
seedet unetemperaturefaible si vous avez besoin d'une sortie reproductible pour les tests.
Si quelque chose semble encore incorrect, envoyez la valeur X-Request-Id à support ainsi que l’heure de l’appel.
Estimation des coûts dans le code
Le prix est de 0,15 $ par 1M de tokens d'entrée et de 0,50 $ par 1M de tokens de sortie. Un petit utilitaire transforme n'importe quel bloc d'utilisation en 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))
Un appel avec 2 000 tokens de prompt et 500 tokens de sortie retourne 0,00055. Exécutez-en 1 000 et vous dépensez 0,55 $. Le crédit d’essai de 0,50 $ couvre environ 909 appels de ce type. Après l’essai, les recharges démarrent à 20 $ et le crédit n’expire jamais ; la page des tarifs liste les paliers de bonus. Si votre application provient d’un projet de chatbot avec ses propres pièges, l’article sur les erreurs courantes en API couvre plusieurs de ces cas qui s’appliquent ici aussi.
Plus de guides
Questions et réponses
Quel package Python dois-je utiliser ?
Le package openai officiel. Installez-le avec pip, définissez base_url sur https://api.veniceapialternative.com/v1, et utilisez le modèle uncensored. Aucune autre bibliothèque cliente n'est requise.
Le streaming fonctionne-t-il avec le SDK ?
Oui. Passez stream=True et itérez sur les chunks. L'utilisation est rapportée à la fin du flux.
Pourquoi obtiens-je une erreur 429 ?
Vous avez soit dépassé la limite de requêtes par minute (rate_limited), soit ouvert trop de requêtes simultanément (concurrency), soit le service était brièvement surchargé et a envoyé Retry-After: 5. Attendez et réessayez.
Combien de requêtes simultanées puis-je exécuter ?
Une clé complète permet 8 requêtes simultanées et 300 par minute. Une clé d’essai permet 2 requêtes simultanées et 60 par minute.
Puis-je utiliser LangChain ou d'autres outils compatibles OpenAI ?
Tout client qui vous permet de définir une URL de base compatible OpenAI et une clé devrait fonctionner. Utilisez la même URL de base et le nom de modèle uncensored.