> For the complete documentation index, see [llms.txt](https://docs.dapta.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.dapta.ai/dapta-docs-es/flow-studio/nodes/nodo-openai.md).

# Nodo OpenAI

Agrega el nodo OpenAI a un flujo, úsalo con Dapta AI o tu propia clave de OpenAI, elige un modelo GPT, adjunta archivos y define cómo vuelve la respuesta.

El **nodo OpenAI** permite que un flujo llame a un modelo GPT de OpenAI — resumir un texto, clasificar un mensaje, extraer campos de texto libre, leer un PDF o una imagen, o redactar una respuesta — y usar el resultado en los pasos siguientes.

{% hint style="info" %}
**¿Usas un nodo de IA anterior?** Los flujos creados antes de estos nodos pueden seguir usando los nodos de IA anteriores de Gemini, Claude u OpenAI, que ahora muestran **Este nodo está deprecado**. Los nodos anteriores de Gemini y Claude se cobran en créditos de Dapta desde el 15 de septiembre de 2026, y el nodo anterior de OpenAI ya no recibe mantenimiento. Reemplázalos por este nodo.
{% endhint %}

***

**📘 Lo que aprenderás en este documento:**

* **Paso 1:** Agregar el nodo
* **Paso 2:** Elegir la **Conexión** — quién paga el modelo
* **Paso 3:** Elegir un **Modelo**
* **Paso 4:** Escribir tu **Prompt**
* **Paso 5:** Agregar adjuntos (opcional)
* **Paso 6:** Ajustar los **Parámetros** (opcional)
* **Paso 7:** Elegir la **Salida**
* **Paso 8:** Ejecutar el flujo y revisar la **Última ejecución**

***

#### ➕ Paso 1: Agregar el nodo

> Dentro de un flujo, ve a **Actions**, busca **OpenAI** y arrastra el nodo de IA de OpenAI al lienzo. Conecta la flecha del paso anterior al nodo y haz clic en el nodo para abrir su configuración.

La configuración está agrupada en secciones, de arriba abajo: **Conexión**, **Modelo**, **Prompt**, **Attachments**, **Parámetros** y **Salida**. En cualquier campo de texto, escribe `{` para insertar una variable de un paso anterior.

***

#### 🔌 Paso 2: Elegir la Conexión — quién paga el modelo

> Abre el menú **Conexión**. Hay dos formas de ejecutar el nodo:

* **Dapta AI** — la opción por defecto. Funciona sin configurar nada y usa tus [créditos de Dapta](/dapta-docs-es/mi-cuenta/como-funcionan-los-creditos-en-dapta.md). Los créditos se miden sobre el modelo que realmente responde, según cuánto texto lee y escribe.
* **Mi propia credencial** — se ejecuta con tu propia cuenta de OpenAI. OpenAI te factura ese uso y no consume tus créditos de Dapta. Elige tu credencial en el campo que aparece o agrega una nueva: el diálogo **Credencial de OpenAI** pide un **Nombre** y tu **Clave secreta**, que se guarda cifrada con las credenciales de tu workspace. Crea la clave en [la plataforma de OpenAI](https://platform.openai.com/api-keys).

La línea debajo del menú te dice cómo se cobra el nodo con el modelo que elegiste.

***

#### 🧠 Paso 3: Elegir un Modelo

> Abre el menú **Modelo** y elige el modelo que escribe la respuesta.

Los modelos están agrupados en **Recomendados**, **Open source** (modelos GPT-OSS alojados por Dapta, normalmente la opción de menor costo) y **Avanzados** (los modelos más capaces de OpenAI — los más pesados usan muchos más créditos). El modelo por defecto del nodo, **GPT-5.4**, aparece marcado como **Por defecto**.

Cada modelo muestra tres medidores — **razonamiento**, **velocidad** y **precio** (más barras significa más inteligente, más rápido o más créditos por ejecución) — y, una vez elegido, si admite **Razonamiento** y **Salida estructurada**. Las opciones de los pasos siguientes se adaptan a lo que puede hacer el modelo elegido.

{% hint style="warning" %}
Si un modelo que guardaste se retira, el nodo te lo indica y te pide elegir un reemplazo. Dapta nunca cambia tu modelo sin avisarte.
{% endhint %}

***

#### ✍️ Paso 4: Escribir tu Prompt

> En **Prompt**, dile a la IA qué hacer con tus propias palabras. Escribe `{` para insertar una variable de un paso anterior; **Shift+Enter** agrega una línea nueva.

Por ejemplo: *"Clasifica este mensaje como ventas, soporte u otro, y explica por qué en una frase: {{message}}"*.

Debajo del prompt hay dos extras opcionales:

* **Instrucción de sistema (opcional)** — un rol o reglas que la IA siempre sigue, como *"Eres un agente de soporte amable"*. La mayoría de los flujos solo necesita el prompt.
* **Agregar mensaje** — agrega un intercambio de ejemplo para enseñarle a la IA el estilo y el formato que quieres. Define el **Rol** de cada mensaje como **Usuario** (tú) o **Modelo** (una respuesta de ejemplo de la IA) y escribe su **Contenido**.

***

#### 📎 Paso 5: Agregar adjuntos (opcional)

> En la sección **Attachments**, pega el link de un archivo — sirve un link de Google Drive o Google Docs — o inserta una variable con un link de un paso anterior. Haz clic en **Agregar adjunto** para sumar otro archivo.

* Hasta **5 archivos por ejecución**, de **15 MB** cada uno y **20 MB** en total.
* Archivos compatibles: **PDF**, **Word (.docx)**, **PNG**, **JPG**, **WebP** y **GIF**. Si tienes un `.doc` antiguo, guárdalo primero como `.docx` o PDF.
* Usa un link directo al archivo. Un link que abre una página de vista previa, o un link temporal que ya venció, no se puede leer.

{% hint style="info" %}
Los links escritos dentro del prompt se leen como texto, no se abren. Para que la IA lea un archivo, agrégalo en **Attachments**.
{% endhint %}

***

#### 🎛️ Paso 6: Ajustar los Parámetros (opcional)

> Despliega **Parámetros** solo si lo necesitas. Los valores por defecto funcionan bien para la mayoría de los flujos.

* **Creatividad** — qué tan variada es la respuesta (la temperatura del modelo). Los modelos GPT-5 no la aceptan, así que el control solo aparece con los modelos que sí, como los GPT-OSS.
* **Longitud máxima de la respuesta** — lo más largo que puede escribir el modelo, en tokens (un token es más o menos una palabra corta). Déjalo vacío para que el modelo use toda su longitud, que es lo recomendado.
* **Esfuerzo de razonamiento** — los modelos GPT-5 piensan antes de responder. Actívalo y elige **Ninguno**, **Bajo**, **Medio** (el valor por defecto), **Alto** o **Extra alto**: más esfuerzo da respuestas más inteligentes, pero más lentas y con más créditos.
* **Autorizar respaldo** — disponible solo con **Dapta AI**. Si el modelo está ocupado o falla, el nodo reintenta automáticamente con el **Modelo de respaldo** que elijas, que puede ser de cualquier laboratorio de IA disponible en Dapta. Los créditos solo miden el modelo que realmente se ejecutó.

***

#### 📤 Paso 7: Elegir la Salida

> Abre el menú **Salida** para decidir cómo vuelve la respuesta.

| Salida                 | Qué recibe el flujo                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| ---------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **JSON (Recomendado)** | La opción por defecto. La respuesta llega ya convertida a JSON, sin necesidad de un nodo de código extra.                                                                                                                                                                                                                                                                                                                                                                                                                               |
| **Texto**              | La respuesta como texto plano. La opción más simple, y funciona con todos los modelos.                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| **Estructurada**       | Campos listos para usar que tú defines. Haz clic en una plantilla en **Empieza desde una plantilla** — **Extraer datos de contacto**, **Leer JSON**, **Clasificar** o **Extraer lista** — o arma los tuyos en **Campos**: dale a cada campo un nombre y un tipo (**Texto**, **Número**, **Sí / no**, **Lista**, **Grupo de campos** o **Una opción de una lista**), márcalo como **Obligatorio** si la IA siempre debe llenarlo y agrega una **+ nota** para explicarlo. Activa **Devuelve una lista** cuando esperas varios elementos. |

JSON y Estructurada solo están disponibles con modelos que admiten **Salida estructurada**.

Con **JSON**, **Si el JSON no es válido** define qué pasa cuando el modelo devuelve un JSON dañado: **Devolver vacío (null)** (la opción por defecto — el flujo continúa con un valor vacío), **Devolver el texto tal cual** (el flujo continúa con el texto sin convertir) o **Detener con un error** (el nodo falla y el manejo de errores de tu flujo toma el control).

**Detalle de la respuesta** define cuánto de la respuesta recibe el flujo:

* **Respuesta + detalles** — la opción por defecto. El flujo recibe `answer`, `json`, `usage` y `costs.credits`, los mismos campos para todos los modelos. Escribe `{` en cualquier campo posterior para elegirlos.
* **Respuesta cruda** — la respuesta completa del proveedor, sin cambios. Sus campos varían según el proveedor.

***

#### ▶️ Paso 8: Ejecutar el flujo y revisar la Última ejecución

> Guarda el flujo y ejecútalo. Después de una ejecución, el nodo muestra la sección **Última ejecución**.

**Última ejecución** muestra el **Modelo** que realmente respondió (con el respaldo activado, puede ser el modelo de respaldo), el **Proveedor**, los **Tokens de entrada**, los **Tokens de salida**, los tokens **En caché** (el texto en caché cuesta menos créditos) y los **Créditos** que usó la ejecución. También te avisa cuando la ejecución usó el modelo de respaldo o cuando el modelo se detuvo antes de terminar.

***

#### 🛠️ Solución de problemas

| Mensaje                                                      | Qué hacer                                                                                                                         |
| ------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------- |
| El modelo de IA está ocupado o no disponible en este momento | Suele ser temporal del lado del proveedor. Inténtalo de nuevo en un momento o activa **Autorizar respaldo**.                      |
| La API key de este nodo no está funcionando                  | Revisa la credencial conectada en **Mi propia credencial**: la clave puede faltar, estar vacía o haber sido rechazada por OpenAI. |
| La respuesta del modelo no fue JSON válido                   | Inténtalo de nuevo, cambia **Si el JSON no es válido** o cambia la **Salida** a **Texto**.                                        |
| El modelo se detuvo antes de terminar                        | Sube la **Longitud máxima de la respuesta** o ajusta el prompt.                                                                   |
| Ese archivo es muy pesado                                    | Cada archivo puede pesar hasta 15 MB, y 20 MB en total.                                                                           |
| Ese link abre una página de vista previa, no el archivo      | Usa un link de descarga directa.                                                                                                  |
| Este modelo no puede leer archivos o imágenes                | Elige otro modelo o quita los adjuntos.                                                                                           |


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.dapta.ai/dapta-docs-es/flow-studio/nodes/nodo-openai.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
