Prompt Caching en OpenAI y Claude: Ahorra hasta un 90% en Tokens

Cada vez que tu agente hace una llamada a la API, envía el mismo system prompt, las mismas instrucciones, el mismo contexto base. Y pagas por esos tokens cada vez como si fueran nuevos.

Con prompt caching, OpenAI y Anthropic guardan ese prefijo repetido en sus servidores y te cobran entre un 50% y un 90% menos en las siguientes llamadas.

¿Cómo funciona el prompt caching?

El concepto es simple: si dos requests consecutivos empiezan con los mismos tokens (system prompt, instrucciones fijas, contexto base), el proveedor no los reprocesa. Solo procesa los tokens nuevos (la pregunta del usuario, el código específico).

Request 1:
[System prompt: 2000 tokens] + [User: 500 tokens]  → Pago: 2500 tokens (100%)

Request 2:
[System prompt: 2000 tokens] + [User: 300 tokens]  → Pago: 2000 tokens al 10% + 300 al 100%
                                ↑ cacheado                  = 500 tokens equivalentes

Ahorro: 80% del total

Prompt Caching en OpenAI

Cómo se activa

Se activa automáticamente. No necesitas configurar nada. OpenAI cachea los primeros 1024+ tokens que sean idénticos entre llamadas consecutivas.

Requisitos

• Prefijo de 1024 tokens mínimo (idéntico byte a byte)
• Incrementos de 128 tokens a partir de ahí
• El caché dura entre 5 y 10 minutos de inactividad
• Modelos soportados: GPT-4o, GPT-4.1, GPT-4.1 mini, GPT-4.1 nano, o3, o4-mini

Descuento

50% de descuento en tokens cacheados.

Ejemplo en Node.js

import OpenAI from 'openai';

const openai = new OpenAI();

// System prompt largo (>1024 tokens para activar caché)
const systemPrompt = `Eres un revisor de código experto en TypeScript, Node.js y React.

REGLAS:
1. Analiza el código línea por línea
2. Busca: bugs, vulnerabilidades de seguridad, problemas de rendimiento
3. Clasifica cada issue: critico / medio / bajo
4. Da la solución con código corregido
5. Si el código está bien, di "Sin issues"

FORMATO DE RESPUESTA:
- archivo: nombre del archivo
- linea: número de línea
- severidad: critico | medio | bajo  
- descripcion: qué pasa
- solucion: código corregido

CONTEXTO DEL PROYECTO:
Framework: NestJS 11 con TypeScript 5.8
Base de datos: PostgreSQL con Prisma ORM
Auth: JWT con refresh tokens
Testing: Jest + Supertest
Arquitectura: módulos por dominio (users, auth, payments, notifications)
Convenciones: camelCase, barrel exports, DTOs con class-validator
...`; // Esto ya pasa de 1024 tokens

// Primera llamada — se cachea el system prompt
const resp1 = await openai.chat.completions.create({
  model: 'gpt-4.1',
  messages: [
    { role: 'system', content: systemPrompt },
    { role: 'user', content: 'Revisa este código:\n```ts\n' + codigoArchivo1 + '\n```' },
  ],
});

console.log(resp1.usage);
// { prompt_tokens: 2847, completion_tokens: 340,
//   prompt_tokens_details: { cached_tokens: 0 } }  ← primera vez, no hay caché

// Segunda llamada — system prompt viene del caché
const resp2 = await openai.chat.completions.create({
  model: 'gpt-4.1',
  messages: [
    { role: 'system', content: systemPrompt },  // idéntico → cacheado
    { role: 'user', content: 'Revisa este código:\n```ts\n' + codigoArchivo2 + '\n```' },
  ],
});

console.log(resp2.usage);
// { prompt_tokens: 2650, completion_tokens: 280,
//   prompt_tokens_details: { cached_tokens: 2048 } }  ← ¡2048 tokens cacheados!

En resp2, esos 2048 tokens cacheados te cuestan la mitad: $1.00/M en vez de $2.00/M con GPT-4.1.

Prompt Caching en Anthropic (Claude)

Cómo se activa

En Anthropic necesitas activarlo explícitamente añadiendo cache_control a los bloques de mensaje que quieres cachear.

Requisitos

• Mínimo 1024 tokens para Claude Sonnet/Opus, 2048 para Haiku
• Máximo 4 bloques con cache_control por request
• El caché dura 5 minutos (se renueva con cada uso)
• Modelos soportados: Claude Opus 4, Claude Sonnet 4, Claude Haiku 3.5

Descuento

• Escritura al caché: 25% más caro que el precio normal (solo la primera vez)
• Lectura del caché: 90% de descuento (las siguientes veces)

El breakeven está en ~3-4 llamadas con el mismo prefijo. A partir de ahí, todo es ahorro.

Ejemplo en Node.js

import Anthropic from '@anthropic-ai/sdk';

const anthropic = new Anthropic();

const systemPrompt = `Eres un revisor de código experto en TypeScript...
[mismo prompt largo de antes, >1024 tokens]`;

// Llamada con cache_control
const response = await anthropic.messages.create({
  model: 'claude-sonnet-4-20250514',
  max_tokens: 1024,
  system: [
    {
      type: 'text',
      text: systemPrompt,
      cache_control: { type: 'ephemeral' },  // ← Esto activa el caching
    },
  ],
  messages: [
    { role: 'user', content: `Revisa:\n${codigoArchivo}` },
  ],
});

console.log(response.usage);
// Primera llamada:
// { input_tokens: 2847, output_tokens: 340,
//   cache_creation_input_tokens: 2048, cache_read_input_tokens: 0 }

// Siguientes llamadas:
// { input_tokens: 799, output_tokens: 280,
//   cache_creation_input_tokens: 0, cache_read_input_tokens: 2048 }
//                                    ↑ 2048 tokens al 10% del precio

Cachear también el contexto (documentos, código base)

Puedes cachear no solo el system prompt sino también documentos de referencia:

const response = await anthropic.messages.create({
  model: 'claude-sonnet-4-20250514',
  max_tokens: 2048,
  system: [
    {
      type: 'text',
      text: systemPrompt,
      cache_control: { type: 'ephemeral' },  // Caché bloque 1
    },
  ],
  messages: [
    {
      role: 'user',
      content: [
        {
          type: 'text',
          text: `Documentación del proyecto:\n${documentacion}`,
          cache_control: { type: 'ephemeral' },  // Caché bloque 2
        },
        {
          type: 'text',
          text: `Código base:\n${codigoBase}`,
          cache_control: { type: 'ephemeral' },  // Caché bloque 3
        },
        {
          type: 'text',
          text: 'Añade endpoint POST /api/users con validación',  // Solo esto es nuevo
        },
      ],
    },
  ],
});

Así solo pagas precio completo por la instrucción final. Todo lo demás viene del caché al 10% del precio.

Ejemplo en Python

OpenAI (automático)

from openai import OpenAI

client = OpenAI()

system_prompt = """...[prompt largo >1024 tokens]..."""

# Misma API de siempre — el caché es transparente
for archivo in archivos_a_revisar:
    resp = client.chat.completions.create(
        model="gpt-4.1",
        messages=[
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": f"revisa:\n{archivo.codigo}"},
        ],
    )
    # resp.usage.prompt_tokens_details.cached_tokens > 0 a partir de la 2ª llamada
    print(f"Cacheados: {resp.usage.prompt_tokens_details.cached_tokens}")

Anthropic (explícito)

import anthropic

client = anthropic.Anthropic()

system_prompt = """...[prompt largo >1024 tokens]..."""

for archivo in archivos_a_revisar:
    resp = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1024,
        system=[{
            "type": "text",
            "text": system_prompt,
            "cache_control": {"type": "ephemeral"},
        }],
        messages=[
            {"role": "user", "content": f"revisa:\n{archivo.codigo}"},
        ],
    )
    print(f"Cache read: {resp.usage.cache_read_input_tokens}")

Comparativa de ahorro real

Escenario: Agente revisor de código

• System prompt: 2000 tokens
• Código por request: 800 tokens
• 100 requests/día

Sin caching	Con caching (OpenAI)	Con caching (Anthropic)
280K tokens/día (100%)	80K nuevos + 200K cacheados	80K nuevos + 200K cacheados
GPT-4.1: $0.56/día	$0.36/día (-36%)	—
Claude Sonnet 4: $0.84/día	—	$0.30/día (-64%)
Mensual GPT-4.1: $16.80	$10.80	—
Mensual Claude Sonnet: $25.20	—	$9.00

Escenario: Chatbot con contexto largo

• System prompt + base de conocimiento: 15.000 tokens
• Pregunta del usuario: 200 tokens
• 500 requests/día

Sin caching	Con caching (OpenAI)	Con caching (Anthropic)
7.6M tokens/día	100K nuevos + 7.5M cacheados	100K nuevos + 7.5M cacheados
GPT-4.1: $15.20/día	$7.70/día (-49%)	—
Claude Sonnet 4: $22.80/día	—	$2.55/día (-89%)
Mensual Claude Sonnet: $684	—	$76.50

En contextos largos repetitivos, Anthropic con caching es brutalmente más barato.

Cuándo usar y cuándo NO usar prompt caching

✅ Usar cuando:

Caso	Por qué
System prompts fijos en agentes	Se repiten idénticos miles de veces
Chatbots con base de conocimiento	El contexto es el mismo para todos los usuarios
Revisión de código en batch	Mismo prompt para N archivos
RAG con documentos estables	Los docs no cambian entre queries
Flujos multi-paso	El contexto del paso 1 se reutiliza en pasos 2-5

❌ No usar (no tiene efecto) cuando:

Caso	Por qué
Cada prompt es único	No hay prefijo común que cachear
System prompt < 1024 tokens	No cumple el mínimo
Llamadas espaciadas > 10 min	El caché expira
Prompt dinámico que cambia siempre	Nada que cachear

Combinando Prompt Caching con otras técnicas

El caching se multiplica con otras optimizaciones:

Caching + Caveman Prompting

Usa caveman prompting para las instrucciones. El system prompt caveman es más corto, pero se cachea igual. Ahorras en ambos frentes:

// System prompt caveman (más corto) + caching (más barato)
const systemPrompt = `revisor código TS/Node/React.
reglas: analizar línea a línea. buscar bugs, seguridad, rendimiento.
clasificar: critico/medio/bajo. dar solución con código.
formato: archivo, linea, severidad, descripcion, solucion.
proyecto: NestJS 11, TS 5.8, PostgreSQL, Prisma, JWT, Jest.`;

Caching + Modelo correcto

No uses Claude Opus 4 ($15/M) con caching si Claude Sonnet 4 ($3/M) con caching resuelve la tarea. Primero elige el modelo correcto, luego activa caching.

Para una comparativa completa de precios, consulta la calculadora de precios de IA.

Caching + Batching

Si haces 10 requests seguidos, el caché se mantiene vivo entre ellos:

// Procesar 50 archivos seguidos = caché activo todo el rato
for (const archivo of archivos) {
  const resp = await revisar(archivo);
  // A partir del 2º archivo, el system prompt viene del caché
}

// ❌ No hagas esto: esperar 15 min entre llamadas mata el caché

Monitorizar el uso del caché

OpenAI

const resp = await openai.chat.completions.create({ ... });

const { prompt_tokens, cached_tokens } = {
  prompt_tokens: resp.usage.prompt_tokens,
  cached_tokens: resp.usage.prompt_tokens_details?.cached_tokens || 0,
};

const hitRate = cached_tokens / prompt_tokens * 100;
console.log(`Cache hit rate: ${hitRate.toFixed(1)}%`);
// Objetivo: >70% en flujos repetitivos

Anthropic

const resp = await anthropic.messages.create({ ... });

const cacheRead = resp.usage.cache_read_input_tokens || 0;
const total = resp.usage.input_tokens + cacheRead;
const hitRate = cacheRead / total * 100;
console.log(`Cache hit rate: ${hitRate.toFixed(1)}%`);

Si tu hit rate es bajo (<50%), revisa que el prefijo sea idéntico byte a byte entre llamadas. Una diferencia de un espacio rompe el caché.

Conclusión

Prompt caching es la optimización más infravalorada para reducir costes de API:

1. En OpenAI es gratis y automático — solo asegúrate de que tu system prompt > 1024 tokens y las llamadas sean frecuentes
2. En Anthropic necesitas cache_control pero el descuento del 90% lo compensa con creces
3. Combínalo con caveman prompting y modelo correcto para ahorrar un 80-90% total
4. Monitoriza el hit rate para verificar que funciona

Si estás construyendo agentes o chatbots con contexto repetitivo, prompt caching puede ser la diferencia entre $500/mes y $50/mes.

Para la guía completa con las 10 técnicas de ahorro, lee cómo programar con IA sin arruinarte. Y para los repos que implementan estas técnicas, revisa los 7 repos de GitHub para devs de IA.