> ## 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.

# Solicitud y uso de la API de OpenAI Chat Completion

> OpenAI generation 集成指南 - XHuoAPI

OpenAI ChatGPT es un sistema de diálogo AI muy potente, que puede generar respuestas fluidas y naturales en cuestión de segundos al ingresar una palabra clave. ChatGPT se destaca en la industria por su excelente capacidad de comprensión y generación de lenguaje, y hoy en día, ChatGPT ya se utiliza ampliamente en diversas industrias y campos, su influencia es cada vez más notable. Ya sea en conversaciones diarias, escritura creativa, o consultas profesionales, programación de código, ChatGPT puede proporcionar una asistencia inteligente asombrosa, mejorando enormemente la eficiencia y creatividad del trabajo humano.

Este documento describe principalmente el proceso de uso de la API de OpenAI Chat Completion, que nos permite utilizar fácilmente la función de diálogo de OpenAI ChatGPT.

## Proceso de Solicitud

Para usar la API de OpenAI Chat Completion, primero puedes ir a la página de [OpenAI Chat Completion API](https://api.xhuoapi.ai/documents/1bcf3bba-102b-495d-9bba-47cd96717e45) y hacer clic en el botón "Acquire" para obtener las credenciales necesarias para la solicitud:

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

Si aún no has iniciado sesión o registrado, serás redirigido automáticamente a la página de inicio de sesión que te invita a registrarte e iniciar sesión. Después de iniciar sesión o registrarte, serás redirigido automáticamente a la página actual.

En la primera solicitud, se te otorgará un crédito gratuito, lo que te permitirá usar esta API de forma gratuita.

## Uso Básico

A continuación, puedes completar el contenido correspondiente en la interfaz, como se muestra en la imagen:

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

Al usar esta interfaz por primera vez, necesitamos completar al menos tres contenidos: uno es `authorization`, que se puede seleccionar directamente en la lista desplegable. Otro parámetro es `model`, `model` es la categoría del modelo de OpenAI ChatGPT que elegimos usar, aquí tenemos principalmente 20 modelos, los detalles se pueden ver en los modelos que proporcionamos. El último parámetro es `messages`, `messages` es un array de nuestras preguntas, que representa que se pueden subir múltiples preguntas a la vez, cada pregunta contiene `role` y `content`, donde `role` indica el rol del preguntador, y hemos proporcionado tres identidades: `user`, `assistant`, `system`. El otro `content` es el contenido específico de nuestra pregunta.

También puedes notar que a la derecha hay un código de llamada correspondiente generado, puedes copiar el código y ejecutarlo directamente, o simplemente hacer clic en el botón "Try" para realizar pruebas.

Parámetros opcionales comunes:

* `max_tokens`: limita el número máximo de tokens en una sola respuesta.
* `temperature`: aleatoriedad en la generación, entre 0-2, cuanto mayor sea el valor, más disperso será.
* `n`: cuántas respuestas candidatas generar a la vez.
* `response_format`: configuración del formato de respuesta.

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

Después de la llamada, encontramos que el resultado devuelto es el siguiente:

```json theme={null}
{
  "id": "chatcmpl-Cmd6uwSxN75F4PAdQSFEO8f2QPs4E",
  "object": "chat.completion",
  "created": 1765706120,
  "model": "gpt-5.2",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "¡Hola! ¿En qué puedo ayudarte hoy?",
        "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
}
```

El resultado devuelto tiene varios campos, que se describen a continuación:

* `id`, el ID de la tarea de diálogo generada, utilizado para identificar de manera única esta tarea de diálogo.
* `model`, el modelo de OpenAI ChatGPT seleccionado.
* `choices`, la información de respuesta que ChatGPT proporciona para la pregunta.
* `usage`: información estadística sobre los tokens para esta pregunta y respuesta.

Donde `choices` contiene la información de respuesta de ChatGPT, dentro de `choices` se puede observar como se muestra en la imagen.

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

Se puede ver que el campo `content` dentro de `choices` contiene el contenido específico de la respuesta de ChatGPT.

## Respuesta en Flujo

Esta interfaz también admite respuestas en flujo, lo cual es muy útil para la integración en páginas web, ya que permite mostrar el contenido palabra por palabra.

Si deseas que la respuesta se devuelva en flujo, puedes cambiar el parámetro `stream` en el encabezado de la solicitud a `true`.

El cambio se muestra en la imagen, pero el código de llamada necesita tener los cambios correspondientes para admitir respuestas en flujo.

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

Después de cambiar `stream` a `true`, la API devolverá los datos JSON correspondientes línea por línea, y a nivel de código, necesitamos hacer los cambios necesarios para obtener los resultados línea por línea.

Código de ejemplo de llamada en Python:

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

El efecto de salida es el siguiente:

```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": "Hola", "role": "assistant"}, "index": 0}], "created": 1721007348, "id": "chatcmpl-YzczYjVhNjhjMzMwNDQ5MDkyNGYzOGZjZGE1ZGQ5OGU", "model": "gpt-4", "object": "chat.completion.chunk", "recipient": "all"}

data: {"choices": [{"delta": {"content": " allí", "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": " ¿Cómo", "role": "assistant"}, "index": 0}], "created": 1721007348, "id": "chatcmpl-YzczYjVhNjhjMzMwNDQ5MDkyNGYzOGZjZGE1ZGQ5OGU", "model": "gpt-4", "object": "chat.completion.chunk", "recipient": "all"}

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

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

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

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

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

data: {"choices": [{"delta": {"content": " hoy", "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]

```

Se puede ver que la respuesta contiene muchos `data`, donde `data` contiene `choices`, que es el contenido de la respuesta más reciente, consistente con el contenido introducido anteriormente. `choices` es el contenido de respuesta nuevo, que puede ser integrado en su sistema. Al mismo tiempo, el final de la respuesta en flujo se determina según el contenido de `data`; si el contenido es `[DONE]`, significa que la respuesta en flujo ha terminado por completo. El resultado de `data` tiene varios campos, que se describen a continuación:

* `id`, el ID que genera la tarea de conversación actual, utilizado para identificar de manera única esta tarea de conversación.
* `model`, el modelo seleccionado de OpenAI ChatGPT.
* `choices`, la información de respuesta que ChatGPT proporciona en respuesta a la consulta.

JavaScript también es compatible, por ejemplo, el código de llamada en flujo de Node.js es el siguiente:

```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: "hola" }],
    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));
```

Ejemplo de código en Java:

```java theme={null}
JSONObject jsonObject = new JSONObject();
jsonObject.put("model", "gpt-4");
jsonObject.put("messages", [{"role":"user","content":"hola"}]);
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())
```

Otros lenguajes pueden ser reescritos de manera similar, el principio es el mismo.

## Diálogo en múltiples rondas

Si desea integrar la función de diálogo en múltiples rondas, necesita cargar múltiples consultas en el campo `messages`, ejemplos específicos de múltiples consultas se muestran en la imagen a continuación:

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

Código de llamada de ejemplo en Python:

```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":"Hola"},{"role":"assistant","content":"¡Hola! ¿Cómo puedo asistirte hoy?"},{"role":"user","content":"¿Qué dije justo ahora?"}]
}

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

A través de la carga de múltiples preguntas, se puede lograr fácilmente un diálogo en múltiples rondas, obteniendo la siguiente respuesta:

```json theme={null}
{
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Dijiste, \"Hola.\""
      },
      "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
  }
}
```

Se puede ver que la información contenida en `choices` es consistente con el contenido de uso básico, que incluye el contenido específico de la respuesta de ChatGPT a múltiples diálogos, lo que permite responder a las preguntas correspondientes según el contenido de múltiples diálogos.

## Integración con OpenAI-Python

El servicio de API de OpenAI Chat Completion tiene como upstream el servicio oficial de OpenAI, que se puede consultar en el [OpenAI-Python](https://github.com/openai/openai-python) oficial. Este artículo presentará brevemente cómo utilizar el servicio proporcionado oficialmente.

1. Primero, necesitas configurar un entorno local de `Python`, este proceso se puede buscar en Google.
2. Descarga e instala un entorno de desarrollo, como el editor VSCode.
3. Configura las variables de entorno de `OpenAI`.

* En la carpeta del proyecto, crea un archivo llamado `.env` y guárdalo.
* Contenido del archivo `.env`:

```json theme={null}
OPENAI_API_KEY="sk-xxx"
OPENAI_BASE_URL="https://api.xhuoapi.ai/v1/openai"  # Recordatorio: si usas la clave de OpenAI oficial, no uses esta dirección.
```

Reemplaza `sk-xxx` con tu propia clave. `OPENAI_BASE_URL` es la interfaz de proxy para acceder a OpenAI.

4. Instala los paquetes de dependencias del proyecto.

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

El comando en Mac OS es:

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

5. Crea un archivo de código fuente de ejemplo.

Supongamos que creamos un código de ejemplo `index.py`, cuyo contenido es el siguiente:

```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": "hola",
        }
    ],
    model="gpt-4",
)

print(response.text)
```

## Modelo en línea

Los modelos gpt-3.5-browsing y gpt-4-browsing son diferentes de otros modelos, ya que pueden realizar búsquedas en línea según las preguntas y devolver los resultados de búsqueda ajustados adecuadamente. Este artículo demostrará la función en línea a través de un ejemplo específico, y luego podrás completar el contenido correspondiente en la interfaz de API de OpenAI Chat Completion, como se muestra en la imagen:

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

Al mismo tiempo, puedes notar que a la derecha hay un código de llamada correspondiente generado, que puedes copiar y ejecutar directamente, o puedes hacer clic en el botón "Probar" para realizar pruebas.

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

Después de la llamada, encontramos que el resultado devuelto es el siguiente:

```json theme={null}
{
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Para las últimas noticias en China hoy, puedes consultar los principales sitios de noticias como:\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\nEstas fuentes tendrán información actualizada sobre los eventos actuales en China."
      },
      "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
  }
}
```

Se puede ver que la información de respuesta en `choices` se obtuvo a través de consultas en línea y también se proporcionaron enlaces relevantes. La información de respuesta en `choices` debe ser renderizada utilizando la sintaxis de `markdown` para obtener la mejor experiencia, lo que también refleja la poderosa ventaja de la función en línea de nuestro modelo.

## Modelo visual

gpt-4o es un modelo de lenguaje grande multimodal desarrollado por OpenAI, que ha aumentado la capacidad de comprensión visual sobre la base de GPT-4. Este modelo puede procesar simultáneamente entradas de texto e imagen, logrando una comprensión y generación cruzada de modalidades.

El procesamiento de texto utilizando el modelo gpt-4o es consistente con el contenido de uso básico mencionado anteriormente. A continuación, se presentará brevemente cómo utilizar la capacidad de procesamiento de imágenes del modelo.

La capacidad de procesamiento de imágenes del modelo gpt-4o se utiliza principalmente añadiendo un campo `type` al contenido original de `content`, a través del cual se puede saber si lo que se está subiendo es texto o imagen, permitiendo así utilizar la capacidad de procesamiento de imágenes del modelo gpt-4o. A continuación, se describen dos formas de invocar esta función utilizando Curl y Python.

* Método de script 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": "¿Qué hay en esta imagen?"
          },
          {
            "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"
            }
          }
        ]
      }
    ]
  }'
```

* Método de script 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": "¿Qué hay en esta imagen?"
                },
                {
                    "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)
````

Luego se puede obtener el siguiente resultado, donde la información de los campos es consistente con el texto anterior, específicamente como sigue:

```json theme={null}
{
  "id": "chatcmpl-123",
  "object": "chat.completion",
  "created": 1677652288,
  "model": "gpt-4-vision-preview",
  "system_fingerprint": "fp_44709d6fcb",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "\n\nEsta imagen muestra un paseo de madera que se extiende a través de un exuberante pantano verde."
      },
      "logprobs": null,
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 9,
    "completion_tokens": 12,
    "total_tokens": 21
  }
}
```

Se puede ver que el contenido de la respuesta se basa en la imagen para responder, por lo que a través de las dos formas anteriores se puede utilizar fácilmente la capacidad de procesamiento de texto e imagen del modelo gpt-4-vision.

Además de gpt-4o, hay un modelo de menor costo llamado gpt-4o-mini. gpt-4o-mini es la última generación de modelos de lenguaje a gran escala desarrollada por OpenAI, que no solo tiene una respuesta rápida, sino que también es más barato y admite múltiples modalidades. El uso de la función de visión se puede consultar en el contenido del uso del modelo gpt-4o anterior.

## Modelo de dibujo GPT-4o

Ejemplo de solicitud:

```json theme={null}
{
  "model": "gpt-4o-image",
  "messages": [
    {
      "role": "user",
      "content": [
        {
          "type": "text",
          "text": "Genera una imagen al estilo de Ghibli y con un sombrero"
        },
        {
          "type": "file_url",
          "file_url": {
            "url": "https://cdn.xhuoapi.ai/qzx2z1.png"
          }
        }
      ]
    }
  ],
  "stream": false
}
```

Ejemplo de resultado:

```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\": \"Una joven con cabello negro largo que lleva un vestido blanco de pie en un entorno al aire libre escénico. La imagen está en el estilo de la animación de Studio Ghibli, con colores suaves y detalles delicados. Ella lleva un sombrero lindo y elegante, con una sonrisa cálida y alegre. El fondo muestra una vegetación exuberante y una atmósfera pacífica, con la luz del sol filtrándose a través de los árboles.\",\n  \"size\": \"1024x1024\"\n}\n\n\n![file-96TSnzJ6MipkZwCmmYEZSA](https://filesystem.site/cdn/20250412/s8EFrYVqeRWc5SfTmF1SbgBS2WFGXb.webp)\n[Descargar⏬](https://filesystem.site/cdn/download/20250412/s8EFrYVqeRWc5SfTmF1SbgBS2WFGXb.webp)\n\nAquí está la imagen creada al estilo de Studio Ghibli, que presenta a una joven con un vestido blanco y un sombrero elegante en un entorno al aire libre escénico. La atmósfera suave y cálida se captura con detalles suaves y colores vibrantes."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 70,
    "completion_tokens": 17,
    "total_tokens": 87
  }
}
```

## Manejo de errores

Al llamar a la API, si se encuentra un error, la API devolverá el código de error correspondiente y la información. Por ejemplo:

* `400 token_mismatched`: Solicitud incorrecta, posiblemente debido a parámetros faltantes o inválidos.
* `400 api_not_implemented`: Solicitud incorrecta, posiblemente debido a parámetros faltantes o inválidos.
* `401 invalid_token`: No autorizado, token de autorización inválido o faltante.
* `429 too_many_requests`: Demasiadas solicitudes, ha superado el límite de tasa.
* `500 api_error`: Error interno del servidor, algo salió mal en el servidor.

### Ejemplo de respuesta de error

```
{
  "success": false,
  "error": {
    "code": "api_error",
    "message": "la recuperación falló"
  },
  "trace_id": "2cf86e86-22a4-46e1-ac2f-032c0f2a4e89"
}
```

## Conclusión

A través de este documento, ha aprendido cómo utilizar la API de OpenAI Chat Completion para implementar fácilmente la funcionalidad de conversación de OpenAI ChatGPT. Esperamos que este documento le ayude a integrar y utilizar mejor esta API. Si tiene alguna pregunta, no dude en ponerse en contacto con nuestro equipo de soporte técnico.
