# Endpoint chat completions : POST /api/v1/chat/completions

> Référence de l'endpoint chat completions : champs du body de POST /api/v1/chat/completions, réponse et finish reasons. Compatible OpenAI.

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

Un seul endpoint répond pour tous les modèles. Il prend le même body que l'API chat completions d'OpenAI et renvoie le même objet, une intégration existante a donc besoin d'une nouvelle URL de base, d'une nouvelle clé et d'un id de modèle de notre liste.

**Réponse rapide — Quels champs accepte l'endpoint chat completions de LLMwithCrypto ?**

Il accepte le body chat completions d'OpenAI : `model` et `messages` sont requis ; `max_tokens`, `temperature`, `top_p`, `stop`, `stream`, `stream_options`, `tools`, `tool_choice` et `response_format` sont facultatifs. **LLMwithCrypto** renvoie un objet `chat.completion` avec un décompte `usage`, facturé au token sur votre solde de crédits, comme documenté le 23 octobre 2026. Le tool calling et la sortie JSON dépendent du modèle.

## L'endpoint en un coup d'œil

| Attribut | Valeur |
| --- | --- |
| Méthode et URL | `POST https://llmwithcrypto.com/api/v1/chat/completions` |
| Authentification | Passez votre clé API en Bearer token dans l'en-tête Authorization, comme le fait le SDK OpenAI |
| Body | JSON, `Content-Type: application/json` |
| Réponse | Objet `chat.completion`, ou server-sent events avec `stream: true` |
| Facturation | Vous payez au token depuis votre solde : les tokens d'entrée et de sortie sont comptés par le tokenizer du modèle lui-même et facturés au prix de ce modèle par 1M de tokens. Un appel qui se termine par une erreur ne coûte rien |
| Fonctionnalités | Le streaming fonctionne sur tous les modèles ; le tool calling et la sortie JSON suivent ce que chaque modèle prend lui-même en charge |

## Créer une complétion de chat

`POST /api/v1/chat/completions`

Envoie une conversation à un modèle et renvoie sa réponse avec les décomptes de tokens. L'exemple pose une courte question à DeepSeek V4 Pro avec une limite de 200 tokens ; les ids, heures et décomptes de la réponse sont illustratifs.

Authentification : clé API dans l'en-tête `Authorization: Bearer API_KEY`.

**Corps de la requête**

| Champ | Type | Obligatoire | Description |
| --- | --- | --- | --- |
| `model` | string | Oui | L'id du modèle, par exemple `deepseek-v4-pro` ou `gpt-oss-120b`. `GET /api/v1/models` renvoie tous les ids que votre clé peut appeler. |
| `messages` | object[] | Oui | La conversation, du plus ancien au plus récent. Chaque élément a un `role` (`system`, `user`, `assistant` ou `tool`) et une chaîne `content` ; les messages `tool` portent aussi un `tool_call_id`. |
| `max_tokens` | integer | Non | Le nombre maximal de tokens que la réponse peut utiliser. Sans cela, le modèle peut écrire jusqu'à remplir sa fenêtre de contexte, et vous payez chaque token qu'il écrit. |
| `temperature` | number | Non | De 0 à 2. Plus bas est plus prévisible, plus haut plus varié. La valeur par défaut dépend du modèle. |
| `top_p` | number | Non | De 0 à 1, échantillonnage nucleus. Modifiez `temperature` ou `top_p`, pas les deux. |
| `stop` | string or string[] | Non | Jusqu'à 4 séquences qui terminent la réponse quand le modèle les écrit. Elles ne sont pas incluses dans la réponse. |
| `stream` | boolean | Non | `true` envoie la réponse en server-sent events, morceau par morceau. Voir [le streaming](https://llmwithcrypto.com/fr/docs/streaming/). |
| `stream_options` | object | Non | `{"include_usage": true}` ajoute un dernier événement avec le `usage` d'un appel streamé. |
| `tools` | object[] | Non | Fonctions que le modèle peut vous demander d'appeler, au format OpenAI. Fonctionne sur les modèles qui prennent en charge le tool calling. Voir [le tool calling](https://llmwithcrypto.com/fr/docs/tool-calling/). |
| `tool_choice` | string or object | Non | `auto` (par défaut quand `tools` est défini), `none`, `required`, ou `{"type": "function", "function": {"name": "…"}}`. |
| `response_format` | object | Non | `{"type": "json_object"}` demande un objet JSON valide, sur les modèles qui le prennent en charge. Indiquez dans votre prompt ce que le JSON doit contenir. |

*Exemple: a short answer from DeepSeek V4 Pro*

```json
{
  "model": "deepseek-v4-pro",
  "messages": [
    {
      "role": "system",
      "content": "Answer in two sentences."
    },
    {
      "role": "user",
      "content": "What is a context window?"
    }
  ],
  "max_tokens": 200
}
```

*Exemple: a JSON object from gpt-oss-120b, low temperature*

```json
{
  "model": "gpt-oss-120b",
  "messages": [
    {
      "role": "user",
      "content": "Return {\"city\": string, \"country\": string} for the Eiffel Tower."
    }
  ],
  "response_format": {
    "type": "json_object"
  },
  "temperature": 0.2,
  "max_tokens": 100
}
```

**Réponse** `200`

```json
{
  "id": "chatcmpl-8f2c41d0a7b94e1c",
  "object": "chat.completion",
  "created": 1792742400,
  "model": "deepseek-v4-pro",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "A context window is the maximum number of tokens a model can read and write in one request. Anything beyond it must be cut or summarized before the call."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 27,
    "completion_tokens": 34,
    "total_tokens": 61
  }
}
```

*curl*

```bash
curl -s "https://llmwithcrypto.com/api/v1/chat/completions" \
  -H "Authorization: Bearer $LLMWITHCRYPTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-pro",
    "messages": [
      {"role": "system", "content": "Answer in two sentences."},
      {"role": "user", "content": "What is a context window?"}
    ],
    "max_tokens": 200
  }'
```

*Python*

```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")
```

*Node.js*

```javascript
import OpenAI from 'openai';

const client = new OpenAI({
  baseURL: 'https://llmwithcrypto.com/api/v1',
  apiKey: process.env.LLMWITHCRYPTO_API_KEY,
});

const resp = await 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,
});
console.log(resp.choices[0].message.content);
console.log(resp.usage.prompt_tokens, 'in,', resp.usage.completion_tokens, 'out');
```

## Comment rédiger les messages ?

Envoyez toute la conversation à chaque fois, en commençant par le message le plus ancien : l'API ne garde aucune mémoire entre les appels, et rien de vos prompts n'est stocké. Nous ne stockons ni vos prompts ni les réponses du modèle : une fois une réponse envoyée, son texte a disparu. Chaque appel laisse une ligne de log avec l'heure, le compte, le modèle et le nombre de tokens, supprimée après 30 jours.

- **`system`** : les instructions qui cadrent chaque réponse, comme le ton, la langue ou le format de sortie. Placez-en une en haut.
- **`user`** : ce que la personne ou votre programme demande.
- **`assistant`** : les réponses précédentes du modèle, pour qu'il puisse poursuivre la conversation.
- **`tool`** : le résultat d'une fonction que le modèle vous a demandé d'exécuter, avec le `tool_call_id` qu'il vous a donné.

Chaque message compte comme des tokens d'entrée, donc un long historique coûte plus cher à chaque tour. Tronquez ou résumez les anciens tours quand une conversation s'allonge.

## Quelle est la longueur maximale d'une requête ?

L'entrée et la sortie ensemble doivent tenir dans la fenêtre de contexte du modèle. Au 23 octobre 2026, DeepSeek V4 Pro lit jusqu'à 1M tokens, gpt-oss-120b jusqu'à 128K et Qwen3 235B jusqu'à 256K ; la [page des modèles](https://llmwithcrypto.com/fr/models/) les liste tous.

Une requête qui ne tient pas revient en `400` avec le code `context_length_exceeded` et ne coûte rien. Définissez `max_tokens` pour que le prompt plus la réponse la plus longue que vous acceptez reste dans la fenêtre.

## Que m'indique finish_reason ?

| `finish_reason` | Signification | Que faire |
| --- | --- | --- |
| `stop` | Le modèle a terminé sa réponse, ou a écrit l'une de vos séquences `stop` | Rien : la réponse est complète |
| `length` | La réponse a atteint `max_tokens` ou la fenêtre de contexte | Augmentez `max_tokens`, ou demandez une réponse plus courte |
| `tool_calls` | Le modèle veut que vous exécutiez une ou plusieurs fonctions | Exécutez-les et renvoyez les résultats, voir [appel d'outils](https://llmwithcrypto.com/fr/docs/tool-calling/) |

## Quels paramètres OpenAI ne sont pas pris en charge ?

Les champs du tableau ci-dessus constituent tout le contrat. D'autres de l'API OpenAI, comme `n` (plusieurs réponses par appel), `logprobs`, `audio` ou les entrées d'images, ne sont pas pris en charge : n'envoyez que les champs listés ici. Les modèles sont des modèles texte ; aucun ne prend d'images via cet endpoint.

Le champ `model` n'accepte que les ids de notre liste. Nous ne vendons pas d'accès à GPT, Claude, Gemini ou Grok : leurs éditeurs interdisent la revente d'accès API sans leur autorisation, et nous ne l'avons pas.

## Chat completions : questions fréquentes

### Existe-t-il un endpoint completions historique ?

Non. Seul le format chat existe ; un prompt unique est un tableau `messages` avec un message `user`.

### Combien coûte un appel ?

Vous payez au token depuis votre solde : les tokens d'entrée et de sortie sont comptés par le tokenizer du modèle lui-même et facturés au prix de ce modèle par 1M de tokens. Un appel qui se termine par une erreur ne coûte rien. Les prix par modèle sont sur la [page des tarifs](https://llmwithcrypto.com/fr/pricing/).

### Puis-je voir mes requêtes passées ?

Non, par conception. Nous ne stockons ni vos prompts ni les réponses du modèle : une fois une réponse envoyée, son texte a disparu. Chaque appel laisse une ligne de log avec l'heure, le compte, le modèle et le nombre de tokens, supprimée après 30 jours.

### Pourquoi ma réponse s'est-elle arrêtée en cours ?

`finish_reason` vaut alors `length` : la réponse a atteint `max_tokens`. Augmentez-le, dans la fenêtre de contexte du modèle.

---

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.
