> 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/nodos-de-ia/cache-y-ahorro.md).

# Caché y ahorro

Cómo la entrada en caché baja el costo de los nodos de IA en Gemini y OpenAI, por qué Claude todavía no tiene caché, y formas prácticas de gastar menos créditos de Dapta.

Un nodo de IA con **Dapta AI** se cobra por los tokens que el modelo lee y escribe (ver [Créditos de los nodos de IA](https://docs.dapta.ai/dapta-docs-es/flow-studio/nodos-de-ia/creditos.md)). Esta página explica el descuento que recibes cuando el proveedor reutiliza parte de tu prompt, y los ajustes que más créditos ahorran.

***

## Qué es la caché

Muchos flujos envían casi el mismo prompt en cada ejecución: las mismas instrucciones y ejemplos, seguidos de un registro distinto cada vez. Google y OpenAI guardan el comienzo de un prompt reciente por un tiempo corto. Cuando una ejecución nueva empieza exactamente con el mismo texto, lo reutilizan en vez de leerlo de nuevo, y reportan esos tokens como **en caché**.

Dapta cobra los tokens en caché al precio de **entrada en caché** del modelo, que es mucho menor que el precio normal de entrada: 10 veces menor en la mayoría de los modelos Gemini y GPT, 20 veces menor en GPT-6.1 Sol, GPT-6.1 Terra y Gemini 4 Argon, y 2 veces menor en los modelos GPT-OSS. Ves los tokens en caché de cada ejecución en **Última ejecución**, junto a **Tokens de entrada** y **Tokens de salida**, y en `usage.cached_tokens` cuando **Detalle de la respuesta** está en **Respuesta + detalles**.

Tú no activas la caché, y Dapta tampoco la activa por ti: el proveedor decide, en cada ejecución, si puede reutilizar parte del prompt.

| Laboratorio       | Caché hoy      | Cuándo pasa                                                                                                                                                                                                                               |
| ----------------- | -------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Google Gemini** | Sí, automática | Cuando una ejecución empieza con el mismo texto que una ejecución reciente y ese texto es lo bastante largo. Google fija el mínimo por modelo, por ejemplo 2.048 tokens en Gemini 2.5 Flash y 4.096 en Gemini 3.8 Flash y Gemini 4 Argon. |
| **OpenAI**        | Sí, automática | Cuando el comienzo del prompt se repite y el prompt tiene al menos 1.024 tokens (GPT-5.6 y posteriores). OpenAI lo guarda al menos 30 minutos en esos modelos.                                                                            |
| **Claude**        | Todavía no     | Anthropic solo usa caché cuando la petición lo pide, y el nodo Claude hoy no lo pide. Todos los tokens de entrada se cobran al precio normal de entrada.                                                                                  |

{% hint style="info" %}
La caché aplica igual con **Dapta AI** y con **tu propia credencial**. Con tu propia credencial, el descuento aparece en la factura de tu proveedor en vez de en créditos de Dapta.
{% endhint %}

### Cuánto ahorra la caché: un ejemplo

Un flujo que envía un prompt de 10.000 tokens (instrucciones fijas y un documento de referencia, luego el registro) y recibe una respuesta de 500 tokens:

| Modelo                |   Sin caché | Primeros 8.000 tokens en caché |
| --------------------- | ----------: | -----------------------------: |
| GPT-5.6 Terra         | 52 créditos |                    24 créditos |
| Gemini 3.5 Flash-Lite |  9 créditos |                     5 créditos |

Con la caché, GPT-5.6 Terra lee 2.000 tokens a 4.000 créditos por millón, 8.000 a 400 y escribe 500 a 24.000: 23,2 créditos, redondeados hacia arriba a 24.

***

## Cómo ayudar a la caché

* **Pon primero lo que nunca cambia.** Escribe las instrucciones, reglas y ejemplos al comienzo del prompt o en la **Instrucción de sistema**, e inserta las variables de los pasos anteriores (`{{message}}`, `{{contact}}`) al final. El proveedor reutiliza el texto desde el comienzo del prompt hasta el punto donde cambia por primera vez.
* **Mantén esa primera parte idéntica.** Una fecha, un id de registro o un nombre cerca del comienzo cambia en cada ejecución y rompe la reutilización de todo lo que sigue.
* **Las ejecuciones seguidas aprovechan más la caché.** Un flujo que procesa un lote de registros se beneficia más que uno que corre una vez por hora.

***

## Formas de gastar menos créditos

#### 1. Elige el modelo más liviano que haga bien el trabajo

El modelo es lo que más mueve el costo. Para un prompt de 4.000 tokens y una respuesta de 500 tokens:

| Modelo                                        | Créditos por ejecución |
| --------------------------------------------- | ---------------------: |
| Gemini 2.5 Flash-Lite                         |                      2 |
| GPT-6 Luna                                    |                      2 |
| GPT-5.6 Luna                                  |                      3 |
| Gemini 3.5 Flash-Lite (por defecto en Gemini) |                      5 |
| Claude Haiku 5.5                              |                      7 |
| GPT-6.1 Terra                                 |                     13 |
| Claude Sonnet 5.5 (por defecto en Claude)     |                     26 |
| GPT-5.6 Terra (por defecto en OpenAI)         |                     28 |
| Gemini 4 Argon                                |                     52 |

Clasificar, extraer campos y hacer resúmenes cortos suele funcionar bien con los modelos livianos. Prueba tu prompt con un modelo liviano y unos cuantos registros reales, y sube solo si las respuestas no son lo bastante buenas.

#### 2. Mantén los prompts cortos y enfocados

Cada token de entrada se cobra en cada ejecución. Envía solo los campos que el modelo necesita, no un registro completo ni todo el historial de una conversación, y no repitas la misma instrucción dos veces.

#### 3. Pide respuestas cortas, en JSON o en Salida estructurada

Los tokens de la respuesta cuestan de 4 a 8 veces más que los de entrada, según el modelo. Pide exactamente lo que necesita el paso siguiente. Con **Salida** en **JSON** o **Estructurada**, el modelo devuelve solo los campos que defines, listos para usar, así que no necesitas un segundo paso de IA ni un nodo de código para limpiar una respuesta larga en texto. **Longitud máxima de la respuesta** pone un tope.

#### 4. Usa el razonamiento solo cuando la tarea lo necesita

**Razonamiento**, **Esfuerzo de razonamiento** y **Razonamiento extendido** se cobran como tokens de la respuesta. En GPT-5.6 Terra, 1.500 tokens de razonamiento llevan el ejemplo anterior de 28 a 64 créditos. Actívalos para razonamientos complejos, no para clasificar o extraer.

#### 5. Salta los registros que no necesitan IA

Pon una condición antes del nodo de IA para que solo corra con los registros que lo necesitan, como mensajes que no están vacíos o leads que todavía no están clasificados.

#### 6. Usa tu propia credencial

Con **Mi propia credencial**, Google, OpenAI o Anthropic te cobran el uso en tu propia cuenta, a su precio, y el nodo no usa créditos de Dapta. El **Modelo de respaldo** no está disponible con tu propia credencial.

***

## Revisa lo que gastas

* **Última ejecución**, en cada nodo, muestra los tokens y los créditos de su última ejecución.
* Con **Detalle de la respuesta** en **Respuesta + detalles**, guarda `costs.credits` y `usage` en una hoja para ver qué flujos usan más.
* Tu saldo y tu consumo están en **Billing**.

{% content-ref url="/pages/D9Wtzi7go6KMoDDpFXjr" %}
[Créditos de los nodos de IA](https://docs.dapta.ai/dapta-docs-es/flow-studio/nodos-de-ia/creditos.md)
{% endcontent-ref %}


---

# 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/nodos-de-ia/cache-y-ahorro.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.
