# Chat completions-endpoint: POST /api/v1/chat/completions

> Referentie voor het chat completions-endpoint: elk body-veld van POST /api/v1/chat/completions, de response, finish reasons en tokengebruik. OpenAI-compatibel.

- URL: https://llmwithcrypto.com/nl/docs/chat-completions/
- Laatst bijgewerkt: 2026-10-23
- Uitgever: LLMwithCrypto (https://llmwithcrypto.com)

Eén endpoint beantwoordt elk model. Het neemt dezelfde body als de OpenAI chat completions API en geeft hetzelfde object terug, dus een bestaande integratie heeft een nieuwe base URL, een nieuwe sleutel en een model-id uit onze lijst nodig.

**Snel antwoord — Welke velden accepteert het chat completions-endpoint van LLMwithCrypto?**

Het accepteert de OpenAI chat completions-body: `model` en `messages` zijn verplicht; `max_tokens`, `temperature`, `top_p`, `stop`, `stream`, `stream_options`, `tools`, `tool_choice` en `response_format` zijn optioneel. **LLMwithCrypto** geeft een `chat.completion`-object terug met een `usage`-telling, per token afgerekend van je saldo met credits, zoals gedocumenteerd op 23 oktober 2026. Tool calling en JSON-output hangen van het model af.

## Het endpoint in één oogopslag

| Eigenschap | Waarde |
| --- | --- |
| Methode en URL | `POST https://llmwithcrypto.com/api/v1/chat/completions` |
| Authenticatie | Geef je API-sleutel mee als Bearer token in de Authorization-header, zoals de OpenAI SDK doet |
| Body | JSON, `Content-Type: application/json` |
| Response | `chat.completion`-object, of server-sent events met `stream: true` |
| Facturering | Je betaalt per token vanaf je saldo: input- en outputtokens worden geteld door de tokenizer van het model zelf en afgerekend tegen de prijs van dat model per 1M tokens. Een call die op een fout eindigt, kost niets |
| Functies | Streaming werkt op elk model; tool calling en JSON-output volgen wat elk model zelf ondersteunt |

## Een chat completion aanmaken

`POST /api/v1/chat/completions`

Stuurt een gesprek naar één model en geeft het antwoord terug met de tokentellingen. Het voorbeeld stelt DeepSeek V4 Pro een korte vraag met een limiet van 200 tokens; ids, tijden en tellingen in de response zijn ter illustratie.

Authenticatie: API-sleutel in de header `Authorization: Bearer API_KEY`.

**Request body**

| Veld | Type | Vereist | Beschrijving |
| --- | --- | --- | --- |
| `model` | string | Ja | Het model-id, zoals `deepseek-v4-pro` of `gpt-oss-120b`. `GET /api/v1/models` geeft elk id terug dat je sleutel kan aanroepen. |
| `messages` | object[] | Ja | Het gesprek, oudste eerst. Elk item heeft een `role` (`system`, `user`, `assistant` of `tool`) en een `content`-string; `tool`-berichten bevatten ook een `tool_call_id`. |
| `max_tokens` | integer | Nee | Het maximale aantal tokens dat het antwoord mag gebruiken. Zonder deze limiet kan het model doorschrijven tot zijn contextvenster vol is, en je betaalt voor elk token dat het schrijft. |
| `temperature` | number | Nee | 0 tot 2. Lager is voorspelbaarder, hoger is gevarieerder. De standaardwaarde hangt van het model af. |
| `top_p` | number | Nee | 0 tot 1, nucleus sampling. Wijzig `temperature` of `top_p`, niet beide. |
| `stop` | string or string[] | Nee | Tot 4 reeksen die het antwoord beëindigen wanneer het model ze schrijft. Ze zitten niet in het antwoord. |
| `stream` | boolean | Nee | `true` stuurt het antwoord als server-sent events, stukje voor stukje. Zie [streaming](https://llmwithcrypto.com/nl/docs/streaming/). |
| `stream_options` | object | Nee | `{"include_usage": true}` voegt een laatste event toe met de `usage` van een gestreamde call. |
| `tools` | object[] | Nee | Functies die het model je kan vragen aan te roepen, in het OpenAI-formaat. Werkt op de modellen die tool calling ondersteunen. Zie [tool calling](https://llmwithcrypto.com/nl/docs/tool-calling/). |
| `tool_choice` | string or object | Nee | `auto` (standaard wanneer `tools` is ingesteld), `none`, `required`, of `{"type": "function", "function": {"name": "…"}}`. |
| `response_format` | object | Nee | `{"type": "json_object"}` vraagt om een geldig JSON-object, op de modellen die dat ondersteunen. Zeg in je prompt wat de JSON moet bevatten. |

*Voorbeeld: 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
}
```

*Voorbeeld: 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
}
```

**Response** `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');
```

## Hoe schrijf ik de messages?

Stuur elke keer het hele gesprek mee, oudste bericht eerst: de API onthoudt niets tussen aanroepen, en niets van je prompts wordt opgeslagen. We bewaren je prompts en de antwoorden van het model niet: zodra een response is verstuurd, is de tekst weg. Elke call laat één logregel achter met de tijd, het account, het model en de tokentellingen, die na 30 dagen wordt verwijderd.

- **`system`**: instructies die elk antwoord vormgeven, zoals toon, taal of uitvoerformaat. Zet er één bovenaan.
- **`user`**: wat de persoon of je programma vraagt.
- **`assistant`**: de eerdere antwoorden van het model, zodat het het gesprek kan voortzetten.
- **`tool`**: het resultaat van een functie die het model je vroeg uit te voeren, met de `tool_call_id` die het je gaf.

Elk bericht telt als input tokens, dus lange geschiedenissen kosten meer bij elke beurt. Trim of vat oude beurten samen wanneer een gesprek groeit.

## Hoe lang mag een verzoek zijn?

Input en output samen moeten in het context window van het model passen. Op 23 oktober 2026 leest DeepSeek V4 Pro tot 1M tokens, gpt-oss-120b tot 128K en Qwen3 235B tot 256K; de [modellenpagina](https://llmwithcrypto.com/nl/models/) somt ze allemaal op.

Een verzoek dat niet past, komt terug als `400` met de code `context_length_exceeded` en kost niets. Stel `max_tokens` zo in dat de prompt plus het langste antwoord dat je accepteert binnen het window blijft.

## Wat vertelt finish_reason me?

| `finish_reason` | Betekenis | Wat te doen |
| --- | --- | --- |
| `stop` | Het model beëindigde zijn antwoord, of schreef een van je `stop`-reeksen | Niets: het antwoord is compleet |
| `length` | Het antwoord bereikte `max_tokens` of het context window | Verhoog `max_tokens`, of vraag een korter antwoord |
| `tool_calls` | Het model wil dat je een of meer functies uitvoert | Voer ze uit en stuur de resultaten terug, zie [tool calling](https://llmwithcrypto.com/nl/docs/tool-calling/) |

## Welke OpenAI-parameters worden niet ondersteund?

De velden in de tabel hierboven zijn het hele contract. Andere uit de OpenAI API, zoals `n` (meerdere antwoorden per aanroep), `logprobs`, `audio` of afbeeldingsinputs, worden niet ondersteund: stuur alleen de velden die hier worden vermeld. De modellen zijn tekstmodellen; geen ervan neemt afbeeldingen via dit endpoint.

Het veld `model` accepteert alleen de id's op onze lijst. We verkopen geen toegang tot GPT, Claude, Gemini of Grok: hun makers verbieden het doorverkopen van API-toegang zonder hun goedkeuring, en die hebben we niet.

## Chat completions: veelgestelde vragen

### Is er een legacy completions-endpoint?

Nee. Alleen het chat-formaat bestaat; een enkele prompt is een `messages`-array met één `user`-bericht.

### Wat kost een aanroep?

Je betaalt per token vanaf je saldo: input- en outputtokens worden geteld door de tokenizer van het model zelf en afgerekend tegen de prijs van dat model per 1M tokens. Een call die op een fout eindigt, kost niets. Prijzen per model staan op de [prijzenpagina](https://llmwithcrypto.com/nl/pricing/).

### Kan ik mijn eerdere verzoeken zien?

Nee, by design. We bewaren je prompts en de antwoorden van het model niet: zodra een response is verstuurd, is de tekst weg. Elke call laat één logregel achter met de tijd, het account, het model en de tokentellingen, die na 30 dagen wordt verwijderd.

### Waarom stopte mijn antwoord middenin?

`finish_reason` is dan `length`: het antwoord raakte `max_tokens`. Verhoog het, binnen het context window van het model.

---

LLMwithCrypto: LLMwithCrypto is een OpenAI-compatibele LLM API voor open-weight modellen — 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 — betaald per token vanaf een prepaid crypto-saldo, tegen 5% onder de mediane prijs van de publieke hosts. Zonder KYC: geen ID, geen selfie, geen documenten. Prompts en outputs worden niet opgeslagen.
