# Python : le SDK OpenAI pointé vers des modèles open-weight

> Appelez des LLM open-weight depuis Python avec le package openai : appels par lots asynchrones, streaming et coût par requête.

- URL: https://llmwithcrypto.com/fr/docs/python/
- Dernière mise à jour: 2026-10-23
- Éditeur: LLMwithCrypto (https://llmwithcrypto.com)

Le package officiel `openai` fonctionne tel quel : passez notre base URL et votre clé à la création du client. Le reste de votre code ne change pas, hormis le nom du modèle.

**Réponse rapide — Comment appeler LLMwithCrypto depuis Python ?**

Installez le package officiel avec `pip install openai`, puis créez le client avec `base_url="https://llmwithcrypto.com/api/v1"` et votre clé depuis `LLMWITHCRYPTO_API_KEY`. **LLMwithCrypto** répond à `client.chat.completions.create()` comme l'API OpenAI, pour 12 modèles open-weight tels que `deepseek-v4-pro` ou `gpt-oss-120b`. Le streaming, l'async et les tool calls fonctionnent comme d'habitude, comme documenté le 23 octobre 2026.

## Ce qu'il vous faut

| Attribut | Valeur |
| --- | --- |
| Python | 3.9 ou plus récent |
| Package | `openai` (officiel) ; `requests` pour l'appel credits |
| URL de base | `https://llmwithcrypto.com/api/v1` |
| Key | Dans la variable d'environnement `LLMWITHCRYPTO_API_KEY`, jamais dans le code |
| Ids de modèle | Sur la [page des modèles](https://llmwithcrypto.com/fr/models/) ou depuis `client.models.list()` |

## Comment envoyer une requête ?

Créez le client une fois et réutilisez-le : il garde la connexion ouverte entre les appels. Le SDK ne lit ici aucune variable d'environnement pour la base URL de lui-même, passez-la donc explicitement.

*one_call.py*

```python
import os

from openai import OpenAI

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

resp = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[
        {"role": "system", "content": "Answer in two sentences."},
        {"role": "user", "content": "What is a context window?"},
    ],
    max_tokens=200,
)
print(resp.choices[0].message.content)
print(resp.usage.prompt_tokens, "in,", resp.usage.completion_tokens, "out")

```

## Comment lancer beaucoup de requêtes en même temps ?

Utilisez `AsyncOpenAI` avec `asyncio.gather`, et un sémaphore pour limiter le nombre de requêtes exécutées en parallèle. Quatre est un bon point de départ ; augmentez-le tant que vous restez sous votre rate limit. Chaque compte a une limite de requêtes et de tokens par minute, affichée dans le dashboard ; demandez au support, elle peut être augmentée.

*many_calls.py*

```python
import asyncio
import os

from openai import AsyncOpenAI

client = AsyncOpenAI(
    base_url="https://llmwithcrypto.com/api/v1",
    api_key=os.environ["LLMWITHCRYPTO_API_KEY"],
)
LIMIT = asyncio.Semaphore(4)


async def summarize(text):
    async with LIMIT:
        resp = await client.chat.completions.create(
            model="deepseek-v4.1-flash",
            messages=[
                {"role": "system", "content": "Summarize in one sentence."},
                {"role": "user", "content": text},
            ],
            max_tokens=80,
        )
        return resp.choices[0].message.content


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


asyncio.run(main())

```

## Comment streamer la réponse ?

Passez `stream=True` et itérez sur les chunks ; chacun porte un morceau de texte dans `delta.content`. Avec `stream_options={"include_usage": True}`, le dernier chunk porte les compteurs de tokens. La [page sur le streaming](https://llmwithcrypto.com/fr/docs/streaming/) explique le format.

*stream.py*

```python
import os

from openai import OpenAI

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

stream = client.chat.completions.create(
    model="deepseek-v4.1-flash",
    messages=[{"role": "user", "content": "Write a haiku about latency."}],
    stream=True,
    stream_options={"include_usage": True},
    max_tokens=120,
)
for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
    if chunk.usage:
        print("\n", chunk.usage.prompt_tokens, "in,", chunk.usage.completion_tokens, "out")

```

## Comment savoir combien a coûté une requête ?

Multipliez les compteurs de `usage` par les prix du modèle par million de tokens. Au 23 octobre 2026, DeepSeek V4 Pro coûte $1.254 par million de tokens en entrée et $3.762 par million de tokens en sortie ; l'exemple code en dur ces deux nombres, mettez-les donc à jour depuis la [page des tarifs](https://llmwithcrypto.com/fr/pricing/) quand les prix changent. Le dashboard affiche le coût exact de chaque appel.

*cost.py*

```python
import os

from openai import OpenAI

# prices per 1M tokens of the models you use, copied from the pricing page
PRICES = {"deepseek-v4-pro": (1.254, 3.762)}

client = OpenAI(
    base_url="https://llmwithcrypto.com/api/v1",
    api_key=os.environ["LLMWITHCRYPTO_API_KEY"],
)
resp = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[{"role": "user", "content": "Give me three names for a coffee shop."}],
    max_tokens=100,
)
price_in, price_out = PRICES[resp.model]
cost = (resp.usage.prompt_tokens * price_in + resp.usage.completion_tokens * price_out) / 1_000_000
print(resp.choices[0].message.content)
print(f"cost: ${cost:.6f}")

```

## Comment migrer une application OpenAI existante ?

Trois changements, généralement dans un seul fichier :

1. **Le client.** Ajoutez `base_url` et lisez la clé depuis `LLMWITHCRYPTO_API_KEY` là où vous créez `OpenAI()` ou `AsyncOpenAI()`.
2. **Les noms de modèles.** Remplacez chaque nom `gpt-…` par un id de la [page des modèles](https://llmwithcrypto.com/fr/models/). Cherchez dans tout le projet : les noms de modèles se cachent dans les fichiers de config, les prompts et les tests.
3. **Les fonctionnalités sur lesquelles vous comptez.** Le chat, le streaming et les system prompts fonctionnent partout. Le tool calling et la sortie JSON dépendent du modèle, alors lancez vos tests existants sur le modèle que vous choisissez.

Tout le reste ne change pas : vos prompts, votre logique de retry, votre parsing de `choices` et `usage`. Le [guide de migration](https://llmwithcrypto.com/fr/guides/switch-openai-sdk-to-open-models/) détaille tout cela.

## Où doit vivre la clé ?

Dans l'environnement, jamais dans le code. En local, un fichier `.env` chargé par votre app et listé dans `.gitignore` suffit ; en production, utilisez le secret store de votre hébergeur ou de votre CI. Donnez à chaque app ou service sa propre clé, pour pouvoir en révoquer une sans arrêter les autres. Créez une clé API par app, agent ou coéquipier et révoquez n'importe laquelle depuis le dashboard sans toucher aux autres.

## Python : questions fréquentes

### Le SDK relance-t-il les requêtes tout seul ?

Oui, le package `openai` relance certaines erreurs deux fois par défaut (`max_retries`). La [page des erreurs](https://llmwithcrypto.com/fr/docs/errors/) indique quelles erreurs méritent un retry.

### Puis-je continuer à utiliser mon code OpenAI ?

Oui. L'API parle le format chat completions d'OpenAI : pointez le SDK OpenAI, LangChain ou tout outil compatible OpenAI vers notre URL de base avec votre clé, et changez le nom du modèle. Le [guide de migration](https://llmwithcrypto.com/fr/guides/switch-openai-sdk-to-open-models/) liste ce qu'il faut vérifier.

### Quels frameworks Python fonctionnent ?

Tous ceux qui acceptent une base URL compatible OpenAI. La [page LangChain](https://llmwithcrypto.com/fr/docs/langchain/) montre LangChain et LlamaIndex.

---

LLMwithCrypto: LLMwithCrypto est une API LLM compatible OpenAI pour les modèles open-weight — DeepSeek V4 Pro, DeepSeek V4.1 Flash, DeepSeek R1, Qwen3.5 397B A17B, Qwen3 235B A22B Instruct, gpt-oss-120b, gpt-oss-20b, GLM-4.7, Llama 3.3 70B Instruct, Gemma 4 31B, Mistral Large 3, Mistral Small 4 — facturés au token depuis un solde crypto prépayé, à 5 % en dessous du prix médian des hébergeurs publics. Sans KYC : pas de pièce d'identité, pas de selfie, pas de documents. Les prompts et les sorties ne sont pas stockés.