El caché de prompts puede reducir a una fracción el costo de la entrada repetida, pero Claude, OpenAI y Gemini lo aplican de forma distinta. Compara puntos de corte, tiempos de vida, costos de escritura y tamaños mínimos, con un ejemplo de costos paso a paso y los errores que impiden los aciertos de caché.
Cada solicitud que envías a un modelo de lenguaje (LLM) empieza con el mismo ritual caro. El prompt de sistema, las definiciones de herramientas, la documentación pegada y los ejemplos few-shot se vuelven a leer, token a token, a precio completo, aunque nada de eso haya cambiado desde la última llamada. El caché de prompts pone fin a ese desperdicio. El proveedor guarda la forma procesada de tu prefijo repetido y cobra una fracción del precio normal de entrada cuando la siguiente solicitud lo reutiliza. Piensa en el mise en place de un restaurante: el cocinero pica los chalotes una vez antes del servicio, y cada pedido después se arma con recipientes ya preparados.
Claude, OpenAI y Gemini ofrecen la misma idea, pero no coinciden en casi nada más: quién decide qué se guarda en caché, cuánto dura, cuánto cuesta escribirlo y cuán grande debe ser un prompt para calificar. Este artículo alinea los tres con cifras de su documentación actual, para que elijas una configuración y evites los errores que apagan el caché en silencio.
Cuando un modelo lee tu prompt, realiza trabajo real por cada token antes de poder escribir la primera palabra de la respuesta. Ese trabajo es idéntico cada vez que el inicio del prompt es idéntico. El caché de prompts permite que el proveedor conserve el resultado de ese trabajo durante una ventana corta y lo reutilice, de modo que la parte repetida se procesa una sola vez y después se factura con descuento.
Imagina un catálogo de fichas. El proveedor archiva el prefijo procesado bajo una huella digital de su contenido exacto. La siguiente solicitud que produzca la misma huella saca el cajón en lugar de reconstruir su contenido desde cero.
El caché funciona desde el primer token hacia adelante. La parte en caché tiene que coincidir exactamente y sin interrupciones con el inicio de tu solicitud, y la primera diferencia termina la coincidencia. Todo lo que venga después de ese punto se procesa y se factura al precio normal.
Esa única regla define el consejo de todos los proveedores. Pon arriba el contenido que nunca cambia y empuja al final todo lo que sí cambia (la pregunta del usuario, la fecha actual, los fragmentos recuperados). Una buena sección superior suele incluir:
💡 Comprobación rápida: si imprimieras dos solicitudes y marcaras lo que comparten, la parte marcada debe ser un bloque sólido que empiece en el primer carácter. Un párrafo compartido en medio no cuenta.
Tres cosas mejoran cuando se reutiliza el prefijo:
Los bucles de agentes, las preguntas y respuestas sobre documentos, los historiales largos de chat y los clasificadores con una rúbrica extensa son los que más se benefician. Un prompt que cambia cada vez no obtiene nada.
Claude te da el control más directo de los tres. Tú decides dónde termina el prefijo cacheable y cuánto tiempo debe vivir.
Marcas un bloque de contenido con cache_control de tipo ephemeral, y todo lo que va desde el inicio de la solicitud hasta ese bloque, incluido, se convierte en el prefijo en caché. El orden es fijo: primero las herramientas, luego el sistema y después los mensajes. Puedes definir hasta cuatro puntos de corte, y la API devuelve un error 400 si intentas colocar un quinto de nivel de bloque.
También existe un modo automático. Añade un único campo cache_control en el nivel superior de la solicitud, y el sistema aplica el punto de corte al último bloque cacheable y luego lo desplaza a medida que crece la conversación.
{
"model": "claude-opus-5-5",
"cache_control": { "type": "ephemeral" },
"system": "Long, stable instructions go here...",
"messages": [
{ "role": "user", "content": "Today's question" }
]
}
Un detalle da problemas a las sesiones largas de agentes. Cuando el sistema busca una entrada anterior coincidente, revisa como máximo 20 posiciones hacia atrás desde cada punto de corte. Si un turno añade muchos bloques, la entrada previa puede quedar fuera de esa ventana, y la solución es un segundo punto de corte colocado antes en el prompt.
La duración predeterminada es de 5 minutos, y cada acierto renueva el temporizador sin costo. Si tu tráfico llega en ráfagas lentas, puedes optar por una hora con "ttl": "1h" a un precio de escritura más alto.
| Concepto | Multiplicador | Ejemplo con Opus 5.5 (por millón de tokens) |
|---|---|---|
| Entrada base | 1x | $4.00 |
| Escritura en caché de 5 minutos | 1.25x | $5.00 |
| Escritura en caché de 1 hora | 2x | $8.00 |
| Lectura en caché | 0.05x en este modelo | $0.20 |
La mayoría de los modelos de Claude leen de la caché a 0.1x del precio base de entrada. Los niveles Opus 5.5 y Sonnet 5.5 leen a 0.05x, y algunos niveles más nuevos bajan aún más.
El umbral depende del modelo, y ha cambiado mucho entre generaciones:
💡 Fallo silencioso: un prompt más corto que el mínimo se procesa sin caché, y no se devuelve ningún error. La única señal es un campo de caché que se queda en cero.
La historia de OpenAI tiene dos capítulos. Durante mucho tiempo el caché fue completamente automático. Con GPT-5.6 ganó puntos de corte y un costo de escritura, lo que lo hace parecerse mucho más a Claude.
En GPT-5.5 y GPT-5.5 Pro, el sistema coloca puntos de corte implícitos cada 2,048 tokens, y la retención se configura con prompt_cache_retention, limitado a 24h. Los modelos anteriores, como GPT 5.4, GPT 5.1, GPT 5 y GPT 4.1, admiten tanto la retención in_memory, que suele durar unos 5 a 10 minutos de inactividad, como la opción extendida 24h.
La tarifa de entrada en caché depende del modelo, pero en estas versiones no hay cargo extra de escritura. Eso hace que probar el caché no tenga costo. El peor escenario es que pagues el precio normal.
GPT-5.6 y posteriores cambiaron las reglas, y la nueva configuración se parece más a la de Claude:
prompt_cache_options.mode configurado en implicit, un punto de corte cae al final del último mensaje elegible. Con explicit, marcas tú cada punto de corte usando prompt_cache_breakpoint.prompt_cache_options.ttl acepta un solo valor, 30m, que además es el predeterminado.{
"model": "YOUR_GPT_5_6_MODEL",
"prompt_cache_options": { "mode": "explicit" },
"input": [
{
"role": "developer",
"content": [{
"type": "input_text",
"text": "Stable rubric and instructions...",
"prompt_cache_breakpoint": { "mode": "explicit" }
}]
},
{ "role": "user", "content": "The changing part of the request" }
]
}
Los tres niveles actuales de la plataforma son GPT 5.6 Terra, GPT 5.6 Luna y GPT 5.6 Sol. Revisa la tabla de precios vigente de cada nivel antes de presupuestar, porque OpenAI publica algunos niveles con tarifas de lectura en caché más bajas.
Google ofrece dos mecanismos separados, y se facturan de forma distinta. Uno funciona por su cuenta. El otro es un objeto que creas y gestionas tú.
El caché implícito está activado por defecto en todos los modelos Gemini 2.5 y posteriores. No cambias ningún código. Si una solicitud comparte un prefijo común con una anterior, puede obtener un acierto, y el ahorro se aplica automáticamente.
Los mínimos son de 2,048 tokens para Gemini 2.5 Flash y 2.5 Pro, y de 4,096 tokens para Gemini 3.5 Flash, sus hermanos Flash más nuevos y Gemini 3.1 Pro. Los consejos del propio Google coinciden exactamente con la regla del prefijo: pon el contenido grande y común al principio, y envía las solicitudes con prefijos similares juntas en el tiempo.
Sin embargo, no hay garantía en ninguna solicitud concreta. El caché implícito es oportunista, y por eso algunos equipos pasan a la versión explícita.
Con el caché explícito creas un objeto de caché y luego diriges las solicitudes hacia él.
cache = client.caches.create(
model="gemini-2.5-flash",
config=types.CreateCachedContentConfig(
system_instruction="Long, stable instructions...",
contents=[big_document],
ttl="3600s",
),
)
response = client.models.generate_content(
model="gemini-2.5-flash",
contents="Today's question",
config=types.GenerateContentConfig(cached_content=cache.name),
)
La duración predeterminada es de una hora, y puedes definir la tuya con ttl, por ejemplo "300s". Después puedes cambiar el ttl o el expire_time, pero nada más de la caché. La facturación tiene tres partes: los tokens reutilizados a una tarifa reducida, el almacenamiento por token-hora mientras exista la caché, y el precio normal de todo lo que queda fuera de ella. Los cachés explícitos tienen un mínimo de 2,048 tokens en los modelos 2.5 y de 4,096 en la línea 3.x. La Interactions API solo admite el tipo implícito.
Google ha publicado descuentos por reutilización de entre 75% y 90% según la generación del modelo, así que confirma la cifra de tu modelo en la página de precios vigente.
| Característica | Claude | OpenAI (GPT-5.6 y posteriores) | Gemini |
|---|---|---|---|
| Cómo se activa | Puntos de corte cache_control, o un campo único de nivel superior para el modo automático | Implícito por defecto, o puntos de corte explícitos | Implícito por defecto, más objetos de caché explícitos |
| Duración | 5 minutos, o 1 hora si lo pides | 30 minutos | El implícito no está garantizado. El explícito dura 1 hora por defecto |
| Costo de escritura | 1.25x por 5 minutos, 2x por 1 hora | 1.25x | Precio normal de entrada en el implícito. Almacenamiento por token-hora en el explícito |
| Costo de lectura | 0.1x en la mayoría de los modelos, 0.05x en Opus 5.5 y Sonnet 5.5 | 0.1x | Tarifa reducida, definida por modelo |
| Prefijo mínimo | De 512 a 4,096 tokens según el modelo | 1,024 tokens visibles | 2,048 en la 2.5, 4,096 en los modelos más nuevos |
| Control | Hasta 4 puntos de corte | Modo implícito o explícito | Objeto de caché con un TTL que tú defines |
Usa las cifras de Claude para verificar el punto de equilibrio. Una sola escritura de 5 minutos a 1.25x más una lectura a 0.1x cuesta 1.35x. Dos llamadas sin caché cuestan 2x. Así que una sola reutilización ya amortiza la escritura. La opción de 1 hora escribe a 2x, de modo que necesitas dos lecturas antes de que supere a no usar caché.
Ahora hagamos el cálculo a mayor escala. Toma un prompt de sistema de 20,000 tokens enviado 1,000 veces al día a la tarifa base de Opus 5.5, que es de $4 por millón de tokens:
Los mensajes del usuario y la salida del modelo se facturan igual en ambos casos, así que este cálculo aísla el ahorro en el prefijo. En los modelos antiguos de OpenAI, que no tienen cargo de escritura, la cuenta es todavía más sencilla. En Gemini, la ruta explícita suma horas de almacenamiento a la factura, así que un caché que permanece inactivo la mayor parte del día puede costar más de lo que ahorra.
La mayoría de las configuraciones de caché que fallan no son problemas del proveedor. Vienen de tres malos hábitos.
El error clásico es una línea como "Hora actual: 14:32:07" cerca del inicio del prompt de sistema. El prefijo cambia en cada solicitud, así que nunca puede coincidir. Anthropic documenta la misma trampa con un punto de corte colocado en un bloque que contiene una marca de tiempo y un mensaje del usuario: la caché nunca acierta, porque no se escribió ninguna entrada en una posición anterior. La solución es mover el punto de corte al último bloque que se mantiene idéntico entre solicitudes y poner la línea que cambia después de él.
El orden forma parte de la huella digital. Barajar las definiciones de herramientas, ordenar de otra forma una lista de documentos recuperados o serializar JSON con un nuevo orden de campos generan un prefijo nuevo. En Claude, un cambio en un nivel invalida ese nivel y todo lo que viene después: si editas la definición de una herramienta, se descartan los cachés de herramientas, sistema y mensajes. Añadir o quitar imágenes invalida el caché de mensajes. Mantén las listas de herramientas en un orden fijo y serialízalas siempre de la misma manera.
Una duración de 5 minutos no ayuda a un trabajo que envía una solicitud cada diez minutos. Cada llamada paga el precio de escritura y nunca ve una lectura. En ese caso tienes tres opciones: pasar a la duración de 1 hora en Claude, enviar una solicitud ligera de mantenimiento antes de que venza el temporizador, o agrupar el trabajo para que las solicitudes lleguen juntas.
💡 Regla práctica: ajusta la duración del caché a la pausa entre solicitudes, no a la duración de la sesión.
No confíes en una configuración hasta que la respuesta confirme que funcionó. Cada proveedor informa de la actividad de caché en el bloque de uso de la respuesta.
| Proveedor | Dónde mirar |
|---|---|
| Claude | usage.cache_creation_input_tokens y usage.cache_read_input_tokens |
| OpenAI | usage.input_tokens_details.cached_tokens y, en GPT-5.6 y posteriores, cache_write_tokens |
| Gemini | El recuento de tokens en caché en usage_metadata |
En Claude, el campo input_tokens cuenta solo los tokens posteriores al último punto de corte, no el prompt completo. El total real es cache_read_input_tokens + cache_creation_input_tokens + input_tokens, así que calcula tu tasa de aciertos a partir de esa suma.
Registra tres números por solicitud: tokens en caché leídos, tokens escritos y tokens facturados completos. Luego vigila dos señales. Un recuento de lecturas que se queda en cero después de la segunda solicitud idéntica significa que el prefijo cambia o está por debajo del mínimo. Un recuento de escrituras que sube en cada solicitud significa que la duración vence antes de que llegue la siguiente llamada.
Los interruptores del caché están en la API de cada proveedor, así que el lugar para ajustarlos es tu código. Picasso IA resulta útil un paso antes, cuando decides qué debe decir el prefijo estable:
Un prompt congelado también es estable, que es exactamente lo que necesita un caché.
Las fotografías de este artículo se hicieron todas con P Image, cada una a partir de un único prompt descriptivo sobre lente, luz y textura. Tú puedes hacer lo mismo en unos minutos. Prueba Seedream 4.5 para un detalle nítido en 4K, Flux 2 Pro para el realismo fotográfico, Imagen 4 para escenas naturales o Nano Banana Pro para resultados pulidos.
Escribe un prompt que nombre el sujeto, la luz y la lente, ejecútalo, luego cambia un detalle y vuelve a ejecutarlo. La forma más rápida de hacerte una idea de cómo se comporta un modelo es empezar a experimentar con tus propias imágenes en Picasso IA hoy mismo.
Elige tu idioma
