> ## Documentation Index
> Fetch the complete documentation index at: https://docs.xhuoapi.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Wniosek i użycie OpenAI Chat Completion API

> OpenAI generation 集成指南 - XHuoAPI

OpenAI ChatGPT to bardzo potężny system AI do rozmów, który potrafi w ciągu kilku sekund wygenerować płynne i naturalne odpowiedzi na wprowadzone zapytania. ChatGPT wyróżnia się w branży dzięki swoim doskonałym zdolnościom rozumienia i generowania języka, a obecnie jest szeroko stosowany w różnych branżach i dziedzinach, a jego wpływ staje się coraz bardziej znaczący. Niezależnie od tego, czy chodzi o codzienne rozmowy, kreatywne pisanie, czy profesjonalne doradztwo i programowanie, ChatGPT może zapewnić zdumiewające wsparcie inteligentne, znacznie zwiększając wydajność i kreatywność ludzi.

Dokument ten głównie opisuje proces korzystania z OpenAI Chat Completion API, dzięki któremu możemy łatwo korzystać z funkcji rozmowy oficjalnego OpenAI ChatGPT.

## Proces aplikacji

Aby korzystać z OpenAI Chat Completion API, najpierw można przejść na stronę [OpenAI Chat Completion API](https://api.xhuoapi.ai/documents/1bcf3bba-102b-495d-9bba-47cd96717e45) i kliknąć przycisk „Acquire”, aby uzyskać potrzebne poświadczenia do żądania:

![](https://cdn.xhuoapi.ai/nyq0xz.png)

Jeśli nie jesteś zalogowany lub zarejestrowany, automatycznie zostaniesz przekierowany na stronę logowania, aby zarejestrować się i zalogować, a po zalogowaniu lub rejestracji automatycznie wrócisz na bieżącą stronę.

Podczas pierwszej aplikacji otrzymasz darmowy limit, który pozwala na bezpłatne korzystanie z tego API.

## Podstawowe użycie

Następnie możesz wypełnić odpowiednie treści na interfejsie, jak pokazano na obrazku:

<p>
  <img src="https://cdn.xhuoapi.ai/jqgg1t.png" width="400" className="m-auto" />
</p>

Podczas pierwszego korzystania z tego interfejsu musimy wypełnić co najmniej trzy pola: jedno to `authorization`, które można wybrać bezpośrednio z rozwijanej listy. Kolejnym parametrem jest `model`, który oznacza wybór modelu OpenAI ChatGPT z oficjalnej strony, mamy tutaj głównie 20 modeli, szczegóły można zobaczyć w dostarczonych modelach. Ostatnim parametrem jest `messages`, który jest tablicą naszych zapytań, oznaczającą możliwość przesyłania wielu zapytań jednocześnie, gdzie każde zapytanie zawiera `role` i `content`, przy czym `role` oznacza rolę pytającego, a my oferujemy trzy tożsamości: `user`, `assistant`, `system`. Drugim `content` jest konkretna treść naszego zapytania.

Możesz również zauważyć, że po prawej stronie znajduje się odpowiedni kod do wywołania, który możesz skopiować i uruchomić, lub możesz bezpośrednio kliknąć przycisk „Try”, aby przetestować.

Często używane opcjonalne parametry:

* `max_tokens`: ogranicza maksymalną liczbę tokenów w pojedynczej odpowiedzi.
* `temperature`: generuje losowość, w zakresie od 0 do 2, im wyższa wartość, tym bardziej rozproszone odpowiedzi.
* `n`: ile kandydatów odpowiedzi generować jednocześnie.
* `response_format`: ustawienia formatu odpowiedzi.

<p>
  <img src="https://cdn.xhuoapi.ai/mthuu2.png" width="400" className="m-auto" />
</p>

Po wywołaniu zauważamy, że wynik zwrotny wygląda następująco:

```json theme={null}
{
  "id": "chatcmpl-Cmd6uwSxN75F4PAdQSFEO8f2QPs4E",
  "object": "chat.completion",
  "created": 1765706120,
  "model": "gpt-5.2",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Hello! What can I help you with today?",
        "refusal": null,
        "annotations": []
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 7,
    "completion_tokens": 13,
    "total_tokens": 20,
    "prompt_tokens_details": {
      "cached_tokens": 0,
      "audio_tokens": 0
    },
    "completion_tokens_details": {
      "reasoning_tokens": 0,
      "audio_tokens": 0,
      "accepted_prediction_tokens": 0,
      "rejected_prediction_tokens": 0
    }
  },
  "service_tier": "default",
  "system_fingerprint": null
}
```

Wynik zwrotny zawiera wiele pól, które są opisane poniżej:

* `id`, identyfikator generowanego zadania rozmowy, używany do unikalnej identyfikacji tego zadania.
* `model`, wybrany model OpenAI ChatGPT.
* `choices`, informacje o odpowiedziach ChatGPT na zapytania.
* `usage`: statystyki dotyczące tokenów dla tej sesji pytań i odpowiedzi.

Wśród nich `choices` zawiera informacje o odpowiedziach ChatGPT, a w nim `choices` to odpowiedzi ChatGPT, co można zobaczyć na obrazku.

<p>
  <img src="https://cdn.xhuoapi.ai/4t1ev7.png" width="400" className="m-auto" />
</p>

Można zauważyć, że pole `content` w `choices` zawiera konkretną treść odpowiedzi ChatGPT.

## Odpowiedzi strumieniowe

Ten interfejs obsługuje również odpowiedzi strumieniowe, co jest bardzo przydatne w integracji z stronami internetowymi, umożliwiając wyświetlanie efektu literowego.

Aby uzyskać odpowiedzi strumieniowe, można zmienić parametr `stream` w nagłówku żądania na `true`.

Zmiana jak na obrazku, jednak kod wywołania musi być odpowiednio zmieniony, aby obsługiwał odpowiedzi strumieniowe.

<p>
  <img src="https://cdn.xhuoapi.ai/24scd4.png" width="400" className="m-auto" />
</p>

Po zmianie `stream` na `true`, API będzie zwracać odpowiednie dane JSON w wierszach, a na poziomie kodu musimy wprowadzić odpowiednie zmiany, aby uzyskać wyniki w wierszach.

Przykładowy kod wywołania w Pythonie:

```python theme={null}
import requests

url = "https://api.xhuoapi.ai/v1/openai/chat/completions"

headers = {
    "accept": "application/json",
    "authorization": "Bearer {token}",
    "content-type": "application/json"
}

payload = {
    "model": "gpt-4",
    "messages": [{"role":"user","content":"hello"}],
    "stream": True
}

response = requests.post(url, json=payload, headers=headers)
print(response.text)
```

Efekt wyjściowy wygląda następująco:

```json theme={null}
data: {"choices": [{"delta": {"role": "assistant"}, "index": 0}], "created": 1721007348, "id": "chatcmpl-YzczYjVhNjhjMzMwNDQ5MDkyNGYzOGZjZGE1ZGQ5OGU", "model": "gpt-4", "object": "chat.completion.chunk", "recipient": "all"}

data: {"choices": [{"delta": {"content": "Cześć", "role": "assistant"}, "index": 0}], "created": 1721007348, "id": "chatcmpl-YzczYjVhNjhjMzMwNDQ5MDkyNGYzOGZjZGE1ZGQ5OGU", "model": "gpt-4", "object": "chat.completion.chunk", "recipient": "all"}

data: {"choices": [{"delta": {"content": " tam", "role": "assistant"}, "index": 0}], "created": 1721007348, "id": "chatcmpl-YzczYjVhNjhjMzMwNDQ5MDkyNGYzOGZjZGE1ZGQ5OGU", "model": "gpt-4", "object": "chat.completion.chunk", "recipient": "all"}

data: {"choices": [{"delta": {"content": "!", "role": "assistant"}, "index": 0}], "created": 1721007348, "id": "chatcmpl-YzczYjVhNjhjMzMwNDQ5MDkyNGYzOGZjZGE1ZGQ5OGU", "model": "gpt-4", "object": "chat.completion.chunk", "recipient": "all"}

data: {"choices": [{"delta": {"content": " Jak", "role": "assistant"}, "index": 0}], "created": 1721007348, "id": "chatcmpl-YzczYjVhNjhjMzMwNDQ5MDkyNGYzOGZjZGE1ZGQ5OGU", "model": "gpt-4", "object": "chat.completion.chunk", "recipient": "all"}

data: {"choices": [{"delta": {"content": " mogę", "role": "assistant"}, "index": 0}], "created": 1721007348, "id": "chatcmpl-YzczYjVhNjhjMzMwNDQ5MDkyNGYzOGZjZGE1ZGQ5OGU", "model": "gpt-4", "object": "chat.completion.chunk", "recipient": "all"}

data: {"choices": [{"delta": {"content": " ci", "role": "assistant"}, "index": 0}], "created": 1721007348, "id": "chatcmpl-YzczYjVhNjhjMzMwNDQ5MDkyNGYzOGZjZGE1ZGQ5OGU", "model": "gpt-4", "object": "chat.completion.chunk", "recipient": "all"}

data: {"choices": [{"delta": {"content": " pomóc", "role": "assistant"}, "index": 0}], "created": 1721007348, "id": "chatcmpl-YzczYjVhNjhjMzMwNDQ5MDkyNGYzOGZjZGE1ZGQ5OGU", "model": "gpt-4", "object": "chat.completion.chunk", "recipient": "all"}

data: {"choices": [{"delta": {"content": " dzisiaj", "role": "assistant"}, "index": 0}], "created": 1721007348, "id": "chatcmpl-YzczYjVhNjhjMzMwNDQ5MDkyNGYzOGZjZGE1ZGQ5OGU", "model": "gpt-4", "object": "chat.completion.chunk", "recipient": "all"}

data: {"choices": [{"delta": {"content": "?", "role": "assistant"}, "index": 0}], "created": 1721007348, "id": "chatcmpl-YzczYjVhNjhjMzMwNDQ5MDkyNGYzOGZjZGE1ZGQ5OGU", "model": "gpt-4", "object": "chat.completion.chunk", "recipient": "all"}

data: {"choices": [{"delta": {"role": "assistant"}, "index": 0}], "created": 1721007348, "id": "chatcmpl-YzczYjVhNjhjMzMwNDQ5MDkyNGYzOGZjZGE1ZGQ5OGU", "model": "gpt-4", "object": "chat.completion.chunk", "recipient": "all"}

data: {"choices": [{"delta": {"role": "assistant"}, "finish_reason": "stop", "index": 0}], "created": 1721007349, "id": "chatcmpl-YzczYjVhNjhjMzMwNDQ5MDkyNGYzOGZjZGE1ZGQ5OGU", "model": "gpt-4", "object": "chat.completion.chunk", "recipient": "all"}

data: [DONE]

```

Można zauważyć, że odpowiedź zawiera wiele `data`, a `data` wewnątrz `choices` to najnowsza treść odpowiedzi, zgodna z wcześniej przedstawioną treścią. `choices` to nowa treść odpowiedzi, którą można zintegrować z systemem. Zakończenie strumieniowej odpowiedzi można ocenić na podstawie zawartości `data`; jeśli zawartość to `[DONE]`, oznacza to, że strumieniowa odpowiedź została zakończona. Zwracane wyniki `data` mają wiele pól, które są opisane poniżej:

* `id`, identyfikator generowanego zadania rozmowy, używany do unikalnego oznaczenia tego zadania.
* `model`, wybrany model OpenAI ChatGPT.
* `choices`, informacje o odpowiedzi ChatGPT na zadane pytanie.

JavaScript również jest obsługiwany, na przykład kod do strumieniowego wywołania w Node.js wygląda następująco:

```javascript theme={null}
const options = {
  method: "post",
  headers: {
    accept: "application/json",
    authorization: "Bearer {token}",
    "content-type": "application/json",
  },
  body: JSON.stringify({
    model: "gpt-4",
    messages: [{ role: "user", content: "cześć" }],
    stream: true,
  }),
};

fetch("https://api.xhuoapi.ai/v1/openai/chat/completions", options)
  .then((response) => response.json())
  .then((response) => console.log(response))
  .catch((err) => console.error(err));
```

Przykład kodu w Javie:

```java theme={null}
JSONObject jsonObject = new JSONObject();
jsonObject.put("model", "gpt-4");
jsonObject.put("messages", [{"role":"user","content":"cześć"}]);
jsonObject.put("stream", true);
MediaType mediaType = "application/json; charset=utf-8".toMediaType();
RequestBody body = jsonObject.toString().toRequestBody(mediaType);
Request request = new Request.Builder()
  .url("https://api.xhuoapi.ai/v1/openai/chat/completions")
  .post(body)
  .addHeader("accept", "application/json")
  .addHeader("authorization", "Bearer {token}")
  .addHeader("content-type", "application/json")
  .build();

OkHttpClient client = new OkHttpClient();
Response response = client.newCall(request).execute();
System.out.print(response.body!!.string())
```

Inne języki można dostosować samodzielnie, zasada jest taka sama.

## Wieloetapowa rozmowa

Jeśli chcesz zintegrować funkcję wieloetapowej rozmowy, musisz przesłać wiele pytań w polu `messages`, konkretne przykłady wielu pytań są pokazane na poniższym obrazku:

<p>
  <img src="https://cdn.xhuoapi.ai/oz4mar.png" width="400" className="m-auto" />
</p>

Przykład wywołania w Pythonie:

```python theme={null}
import requests

url = "https://api.xhuoapi.ai/v1/openai/chat/completions"

headers = {
    "accept": "application/json",
    "authorization": "Bearer {token}",
    "content-type": "application/json"
}

payload = {
    "model": "gpt-4",
    "messages": [{"role":"user","content":"Cześć"},{"role":"assistant","content":"Cześć! Jak mogę Ci dzisiaj pomóc?"},{"role":"user","content":"Co powiedziałem przed chwilą?"}]
}

response = requests.post(url, json=payload, headers=headers)
print(response.text)
```

Przez przesłanie wielu pytań, można łatwo zrealizować wieloetapową rozmowę, co może dać następującą odpowiedź:

```json theme={null}
{
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Powiedziałeś: \"Cześć.\""
      },
      "finish_reason": "stop"
    }
  ],
  "created": 1721323012,
  "id": "chatcmpl-NWZmOTA5MDlkZjBjNDRjNGEwMzRjYzA5NmM1MzQwMWY",
  "model": "gpt-4",
  "object": "chat.completion.chunk",
  "recipient": "all",
  "usage": {
    "prompt_tokens": 31,
    "completion_tokens": 6,
    "total_tokens": 37
  }
}
```

Można zauważyć, że informacje zawarte w `choices` są zgodne z podstawowym użyciem, zawierają one konkretne odpowiedzi ChatGPT na wiele rozmów, co pozwala na odpowiadanie na odpowiednie pytania na podstawie wielu treści rozmowy.

## Integracja z OpenAI-Python

Usługa OpenAI Chat Completion API jest oparta na oficjalnej usłudze OpenAI, szczegóły można znaleźć w oficjalnym [OpenAI-Python](https://github.com/openai/openai-python), w tym artykule krótko omówimy, jak korzystać z oficjalnie dostarczonej usługi.

1. Najpierw należy zbudować lokalne środowisko `Python`, ten proces można wyszukać w Google.
2. Zainstaluj i skonfiguruj środowisko deweloperskie, na przykład zainstaluj edytor VSCode.
3. Skonfiguruj zmienne środowiskowe `OpenAI`.

* W folderze projektu utwórz plik o nazwie `.env` i zapisz
* Zawartość pliku `.env`:

```json theme={null}
OPENAI_API_KEY="sk-xxx"
OPENAI_BASE_URL="https://api.xhuoapi.ai/v1/openai"  # Przypominam: jeśli używasz klucza OpenAI z oficjalnej strony, nie używaj tego adresu.
```

Zastąp `sk-xxx` swoim kluczem. `OPENAI_BASE_URL` to adres do proxy API OpenAI.

4. Zainstaluj zależności projektu

```shell theme={null}
pip install openai
```

W systemie Mac OS polecenie to:

```shell theme={null}
pip3 install openai
```

5. Utwórz przykładowy plik źródłowy

Załóżmy, że stworzyliśmy przykładowy kod `index.py`, którego zawartość jest następująca:

```python theme={null}
import os
from openai import OpenAI

client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))

response = client.chat.completions.create(
    messages=[
        {
            "role": "user",
            "content": "cześć",
        }
    ],
    model="gpt-4",
)

print(response.text)
```

## Model z dostępem do internetu

Modele gpt-3.5-browsing i gpt-4-browsing różnią się od innych modeli, mogą one przeprowadzać wyszukiwanie w internecie na podstawie zadanych pytań i odpowiednio dostosowywać wyniki wyszukiwania, aby je zwrócić. W artykule tym zaprezentujemy funkcję dostępu do internetu na konkretnym przykładzie, a następnie można wypełnić odpowiednie treści w interfejsie OpenAI Chat Completion API, jak pokazano na obrazku:

<p>
  <img src="https://cdn.xhuoapi.ai/249829.png" width="400" className="m-auto" />
</p>

Można również zauważyć, że po prawej stronie znajduje się odpowiedni kod do wywołania, który można skopiować i uruchomić, lub można bezpośrednio kliknąć przycisk „Wypróbuj”, aby przetestować.

<p>
  <img src="https://cdn.xhuoapi.ai/s8gxoo.png" width="400" className="m-auto" />
</p>

Po wywołaniu odkrywamy, że zwrócone wyniki są następujące:

```json theme={null}
{
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Aby uzyskać najnowsze wiadomości w Chinach dzisiaj, możesz sprawdzić główne strony informacyjne, takie jak:\n\n- [BBC News China](https://www.bbc.com/news/world/asia/china)\n- [CNN China News](https://edition.cnn.com/china)\n- [Reuters China](https://www.reuters.com/news/archive/china-news)\n\nTe źródła będą miały aktualne informacje na temat bieżących wydarzeń w Chinach."
      },
      "finish_reason": "stop"
    }
  ],
  "created": 1721009347,
  "id": "chatcmpl-YzA0M2RjZDVkYThlNDkxNTkzOThmZWQ4OGMzNzdhNzA",
  "model": "gpt-4-browsing",
  "object": "chat.completion.chunk",
  "recipient": "all",
  "usage": {
    "prompt_tokens": 325,
    "completion_tokens": 82,
    "total_tokens": 407
  }
}
```

Można zauważyć, że informacje odpowiedzi w `choices` są oparte na wynikach wyszukiwania w internecie i zawierają odpowiednie linki. Informacje odpowiedzi w `choices` powinny być renderowane za pomocą składni `markdown`, aby uzyskać najlepsze doświadczenie, co również podkreśla potężną zaletę funkcji dostępu do internetu w naszym modelu.

## Model wizualny

gpt-4o to wielomodalny model językowy opracowany przez OpenAI, który na podstawie GPT-4 zyskał zdolność rozumienia wizualnego. Model ten może jednocześnie przetwarzać tekst i obrazy, osiągając zrozumienie i generowanie w różnych modalnościach.

Przetwarzanie tekstu w modelu gpt-4o jest zgodne z podstawowym użyciem opisanym powyżej, poniżej krótko omówimy, jak korzystać z możliwości przetwarzania obrazów tego modelu.

Wykorzystanie możliwości przetwarzania obrazów w modelu gpt-4o polega głównie na dodaniu pola `type` do istniejącej treści `content`, dzięki któremu można określić, czy przesyłany jest tekst, czy obraz, co pozwala na wykorzystanie zdolności przetwarzania obrazów modelu gpt-4o. Poniżej omówimy, jak wywołać tę funkcję za pomocą Curl i Pythona.

* Metoda skryptu Curl

```
curl -X POST 'https://api.xhuoapi.ai/v1/openai/chat/completions' \
-H 'accept: application/json' \
-H 'authorization: Bearer {token}' \
-H 'content-type: application/json' \
-d '{
    "model": "gpt-4o",
    "messages": [
      {
        "role": "user",
        "content": [
          {
            "type": "text",
            "text": "Co jest na tym obrazie?"
          },
          {
            "type": "image_url",
            "image_url": {
              "url": "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg"
            }
          }
        ]
      }
    ]
  }'
```

* Metoda skryptu Python

````
```python
import requests

url = "https://api.xhuoapi.ai/v1/openai/chat/completions"

headers = {
    "accept": "application/json",
    "authorization": "Bearer {token}",
    "content-type": "application/json"
}

payload = {
    "model": "gpt-4o",
    "messages": [
        {
            "role": "user",
            "content": [
                {
                    "type": "text", "text": "Co jest na tym obrazie?"
                },
                {
                    "type": "image_url",
                    "image_url": {
                        "url": "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg"
                    }
                },
            ],
        }
    ]
}

response = requests.post(url, json=payload, headers=headers)
print(response.text)
````

Można zobaczyć, że odpowiedź jest oparta na obrazie, dlatego za pomocą powyższych dwóch sposobów można łatwo wykorzystać zdolności przetwarzania tekstu i obrazu modelu gpt-4-vision.

Oprócz gpt-4o, istnieje również tańszy model, zwany gpt-4o-mini. gpt-4o-mini to najnowsza generacja dużego modelu językowego opracowanego przez OpenAI, który nie tylko działa szybko, ale także jest tańszy i obsługuje multimodalność. Funkcje wizji można znaleźć w treści dotyczącej użycia modelu gpt-4o.

## Model rysunkowy GPT-4o

Przykład żądania:

```json theme={null}
{
  "model": "gpt-4o-image",
  "messages": [
    {
      "role": "user",
      "content": [
        {
          "type": "text",
          "text": "Wygeneruj obraz w stylu Ghibli i dodaj kapelusz"
        },
        {
          "type": "file_url",
          "file_url": {
            "url": "https://cdn.xhuoapi.ai/qzx2z1.png"
          }
        }
      ]
    }
  ],
  "stream": false
}
```

Przykład wyniku:

```json theme={null}
{
  "id": "chatcmpl-89CXTr5EHi7WgiO3qSzWxvmqwfryP",
  "object": "chat.completion.chunk",
  "model": "gpt-4o-image",
  "created": 1744395060,
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "{\n  \"prompt\": \"Młoda kobieta z długimi czarnymi włosami w białej sukience stojąca w malowniczym otoczeniu na świeżym powietrzu. Obraz jest w stylu animacji Studio Ghibli, z miękkimi kolorami i delikatnymi detalami. Ma na sobie uroczy, stylowy kapelusz, z ciepłym i radosnym uśmiechem. Tło pokazuje bujną zieleń i spokojną atmosferę, z promieniami słońca filtrującymi przez drzewa.\",\n  \"size\": \"1024x1024\"\n}\n\n\n![file-96TSnzJ6MipkZwCmmYEZSA](https://filesystem.site/cdn/20250412/s8EFrYVqeRWc5SfTmF1SbgBS2WFGXb.webp)\n[Ściągnij⏬](https://filesystem.site/cdn/download/20250412/s8EFrYVqeRWc5SfTmF1SbgBS2WFGXb.webp)\n\nOto obraz stworzony w stylu Studio Ghibli, przedstawiający młodą kobietę w białej sukience i stylowym kapeluszu w malowniczym otoczeniu na świeżym powietrzu. Miła, ciepła atmosfera została uchwycona z delikatnymi detalami i żywymi kolorami."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 70,
    "completion_tokens": 17,
    "total_tokens": 87
  }
}
```

## Obsługa błędów

Podczas wywoływania API, jeśli wystąpi błąd, API zwróci odpowiedni kod błędu i informacje. Na przykład:

* `400 token_mismatched`: Złe żądanie, prawdopodobnie z powodu brakujących lub nieprawidłowych parametrów.
* `400 api_not_implemented`: Złe żądanie, prawdopodobnie z powodu brakujących lub nieprawidłowych parametrów.
* `401 invalid_token`: Nieautoryzowany, nieprawidłowy lub brakujący token autoryzacyjny.
* `429 too_many_requests`: Zbyt wiele żądań, przekroczono limit szybkości.
* `500 api_error`: Błąd wewnętrzny serwera, coś poszło nie tak na serwerze.

### Przykład odpowiedzi błędu

```
{
  "success": false,
  "error": {
    "code": "api_error",
    "message": "pobieranie nie powiodło się"
  },
  "trace_id": "2cf86e86-22a4-46e1-ac2f-032c0f2a4e89"
}
```

## Wnioski

Dzięki tej dokumentacji zrozumiałeś, jak łatwo wykorzystać OpenAI Chat Completion API do realizacji funkcji czatu OpenAI ChatGPT. Mamy nadzieję, że ta dokumentacja pomoże Ci lepiej zintegrować i korzystać z tego API. W razie jakichkolwiek pytań, skontaktuj się z naszym zespołem wsparcia technicznego.
