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

> Dokumentacja endpointu chat completions: każde pole body POST /api/v1/chat/completions, odpowiedź, powody zakończenia i zużycie tokenów. Zgodny z OpenAI.

- URL: https://llmwithcrypto.com/pl/docs/chat-completions/
- Ostatnia aktualizacja: 2026-10-23
- Wydawca: LLMwithCrypto (https://llmwithcrypto.com)

Jeden endpoint obsługuje każdy model. Przyjmuje to samo body co API chat completions OpenAI i zwraca ten sam obiekt, więc istniejąca integracja potrzebuje nowego base URL, nowego klucza i id modelu z naszej listy.

**Krótka odpowiedź — Jakie pola przyjmuje endpoint chat completions LLMwithCrypto?**

Przyjmuje body chat completions OpenAI: `model` i `messages` są wymagane; `max_tokens`, `temperature`, `top_p`, `stop`, `stream`, `stream_options`, `tools`, `tool_choice` i `response_format` są opcjonalne. **LLMwithCrypto** zwraca obiekt `chat.completion` z licznikiem `usage`, rozliczany za token z Twoich kredytów, zgodnie z dokumentacją z 23 października 2026. Tool calling i wyjście JSON zależą od modelu.

## Endpoint w skrócie

| Atrybut | Wartość |
| --- | --- |
| Metoda i URL | `POST https://llmwithcrypto.com/api/v1/chat/completions` |
| Uwierzytelnianie | Przekazujesz swój klucz API jako Bearer token w nagłówku Authorization, tak jak robi to OpenAI SDK |
| Body | JSON, `Content-Type: application/json` |
| Odpowiedź | obiekt `chat.completion` lub server-sent events z `stream: true` |
| Rozliczenia | Płacisz za token z salda: tokeny wejściowe i wyjściowe są liczone przez tokenizer danego modelu i rozliczane według ceny tego modelu za 1M tokenów. Wywołanie zakończone błędem nic nie kosztuje |
| Funkcje | Streaming działa na każdym modelu; tool calling i wyjście JSON zależą od tego, co obsługuje sam model |

## Utwórz chat completion

`POST /api/v1/chat/completions`

Wysyła rozmowę do jednego modelu i zwraca jego odpowiedź wraz z licznikami tokenów. Przykład zadaje DeepSeek V4 Pro krótkie pytanie z limitem 200 tokenów; id, czasy i liczniki w odpowiedzi są przykładowe.

Uwierzytelnianie: klucz API w nagłówku `Authorization: Bearer API_KEY`.

**Treść zapytania**

| Pole | Typ | Wymagane | Opis |
| --- | --- | --- | --- |
| `model` | string | Tak | Id modelu, np. `deepseek-v4-pro` lub `gpt-oss-120b`. `GET /api/v1/models` zwraca każde id, które może wywołać Twój klucz. |
| `messages` | object[] | Tak | Rozmowa, od najstarszej. Każdy element ma `role` (`system`, `user`, `assistant` lub `tool`) i ciąg `content`; wiadomości `tool` niosą też `tool_call_id`. |
| `max_tokens` | integer | Nie | Maksymalna liczba tokenów, jakich może użyć odpowiedź. Bez tego model może pisać, aż zapełni okno kontekstu, a Ty płacisz za każdy zapisany token. |
| `temperature` | number | Nie | 0 do 2. Niżej jest bardziej przewidywalnie, wyżej bardziej różnorodnie. Domyślna wartość zależy od modelu. |
| `top_p` | number | Nie | 0 do 1, próbkowanie nucleus. Zmieniaj `temperature` albo `top_p`, nie oba. |
| `stop` | string or string[] | Nie | Do 4 sekwencji, które kończą odpowiedź, gdy model je zapisze. Nie są wliczane do odpowiedzi. |
| `stream` | boolean | Nie | `true` wysyła odpowiedź jako server-sent events, kawałek po kawałku. Zobacz [streaming](https://llmwithcrypto.com/pl/docs/streaming/). |
| `stream_options` | object | Nie | `{"include_usage": true}` dodaje ostatnie zdarzenie z `usage` streamowanego wywołania. |
| `tools` | object[] | Nie | Funkcje, o których wywołanie model może Cię poprosić, w formacie OpenAI. Działa na modelach obsługujących tool calling. Zobacz [tool calling](https://llmwithcrypto.com/pl/docs/tool-calling/). |
| `tool_choice` | string or object | Nie | `auto` (domyślnie, gdy ustawiono `tools`), `none`, `required` lub `{"type": "function", "function": {"name": "…"}}`. |
| `response_format` | object | Nie | `{"type": "json_object"}` prosi o poprawny obiekt JSON, na modelach, które to obsługują. W prompcie napisz, co ma zawierać JSON. |

*Przykład: 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
}
```

*Przykład: 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
}
```

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

## Jak zapisać messages?

Za każdym razem wysyłaj całą rozmowę, od najstarszej wiadomości: API nie przechowuje pamięci między wywołaniami i nic z Twoich promptów nie jest zapisywane. Nie przechowujemy Twoich promptów ani odpowiedzi modelu: gdy odpowiedź zostanie wysłana, jej tekst znika. Każde wywołanie zostawia jedną linię logu z czasem, kontem, modelem i liczbą tokenów, usuwaną po 30 dniach.

- **`system`**: instrukcje, które nadają ramy każdej odpowiedzi, takie jak ton, język czy format wyjścia. Umieść jedną na początku.
- **`user`**: to, o co prosi osoba lub Twój program.
- **`assistant`**: wcześniejsze odpowiedzi modelu, żeby mógł kontynuować rozmowę.
- **`tool`**: wynik funkcji, którą model poprosił Cię o uruchomienie, wraz z `tool_call_id`, które Ci podał.

Każda wiadomość liczy się jako tokeny wejściowe, więc długie historie kosztują więcej przy każdej turze. Skracaj lub streszczaj stare tury, gdy rozmowa rośnie.

## Jak długie może być zapytanie?

Wejście i wyjście razem muszą zmieścić się w oknie kontekstu modelu. Według stanu na 23 października 2026 DeepSeek V4 Pro odczytuje do 1M tokenów, gpt-oss-120b do 128K, a Qwen3 235B do 256K; [strona modeli](https://llmwithcrypto.com/pl/models/) wymienia je wszystkie.

Zapytanie, które się nie mieści, wraca jako `400` z kodem `context_length_exceeded` i nic nie kosztuje. Ustaw `max_tokens` tak, aby prompt plus najdłuższa akceptowana przez Ciebie odpowiedź mieściły się w oknie.

## Co mówi mi finish_reason?

| `finish_reason` | Znaczenie | Co zrobić |
| --- | --- | --- |
| `stop` | Model zakończył odpowiedź lub zapisał jedną z Twoich sekwencji `stop` | Nic: odpowiedź jest kompletna |
| `length` | Odpowiedź osiągnęła `max_tokens` lub okno kontekstu | Zwiększ `max_tokens` lub poproś o krótszą odpowiedź |
| `tool_calls` | Model chce, żebyś uruchomił jedną lub więcej funkcji | Uruchom je i odeślij wyniki, zobacz [wywoływanie narzędzi](https://llmwithcrypto.com/pl/docs/tool-calling/) |

## Które parametry OpenAI nie są obsługiwane?

Pola z powyższej tabeli to cały kontrakt. Inne z OpenAI API, takie jak `n` (kilka odpowiedzi na wywołanie), `logprobs`, `audio` czy dane wejściowe w postaci obrazów, nie są obsługiwane: wysyłaj tylko pola wymienione tutaj. Modele są tekstowe; żaden z nich nie przyjmuje obrazów przez ten endpoint.

Pole `model` przyjmuje tylko identyfikatory z naszej listy. Nie sprzedajemy dostępu do GPT, Claude, Gemini ani Grok: ich twórcy zabraniają odsprzedaży dostępu do API bez ich zgody, a my jej nie mamy.

## Chat completions: najczęstsze pytania

### Czy istnieje starszy endpoint completions?

Nie. Istnieje tylko format chat; pojedynczy prompt to tablica `messages` z jedną wiadomością `user`.

### Ile kosztuje wywołanie?

Płacisz za token z salda: tokeny wejściowe i wyjściowe są liczone przez tokenizer danego modelu i rozliczane według ceny tego modelu za 1M tokenów. Wywołanie zakończone błędem nic nie kosztuje. Ceny poszczególnych modeli są na [stronie cennika](https://llmwithcrypto.com/pl/pricing/).

### Czy mogę zobaczyć swoje poprzednie zapytania?

Nie, celowo. Nie przechowujemy Twoich promptów ani odpowiedzi modelu: gdy odpowiedź zostanie wysłana, jej tekst znika. Każde wywołanie zostawia jedną linię logu z czasem, kontem, modelem i liczbą tokenów, usuwaną po 30 dniach.

### Dlaczego moja odpowiedź urwała się w połowie?

`finish_reason` jest wtedy `length`: odpowiedź osiągnęła `max_tokens`. Zwiększ ją, w granicach okna kontekstu modelu.

---

LLMwithCrypto: LLMwithCrypto to zgodne z OpenAI API LLM dla modeli z otwartymi wagami — 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 — płatne za token z przedpłaconego salda kryptowalutowego, o 5% poniżej mediany ceny publicznych hostów. Bez KYC: bez dowodu, bez selfie, bez dokumentów. Prompty i odpowiedzi nie są przechowywane.
