Optimizar Costos de Tokens en LLMs: Guía Completa [2026]
Reduce hasta 90% el costo de tokens en GPT-4, Claude y otros LLMs. Técnicas de optimización, caching, y mejores prácticas.
TLDR: Los principales consumidores de tokens son: contexto acumulado (40-50%), outputs de herramientas (20-30%), y system prompts repetidos (10-15%). Estrategias clave: usar el modelo correcto para cada tarea, implementar prompt caching, limitar contexto, y hacer batching. Reducción típica: 60-80% de costos.
¿Por qué tus costos de IA son tan altos?
El problema
Muchos desarrolladores ven facturas de $100-500/mes en APIs de IA cuando podrían pagar $20-50 por el mismo resultado.
Causas comunes:
- Enviar todo el historial de conversación en cada request
- Usar GPT-4 para tareas que GPT-4o-mini haría igual de bien
- No implementar caching de prompts repetidos
- Generar outputs más largos de lo necesario
Anatomía de un token
1"Hola, ¿cómo estás hoy?" = 7 tokens (español)2"Hello, how are you today?" = 6 tokens (inglés)3 41000 tokens ≈ 750 palabras en español51000 tokens ≈ 4-5 párrafos de texto
Precios actuales (referencia)
| Modelo | Input/1M | Output/1M |
|---|---|---|
| GPT-4o | $2.50 | $10 |
| GPT-4o-mini | $0.15 | $0.60 |
| Claude 3.5 Sonnet | $3 | $15 |
| Claude 3 Haiku | $0.25 | $1.25 |
| Gemini 1.5 Flash | $0.075 | $0.30 |
Los 6 principales consumidores de tokens
1. Contexto acumulado (40-50% del costo)
El problema:
1# Cada mensaje añade al historial2conversation = []3for i in range(50): # 50 turnos de conversación4 conversation.append({"role": "user", "content": user_msg})5 conversation.append({"role": "assistant", "content": ai_response})6 # El turno 50 envía TODO el historial: ~100K tokens
Costo por turno:
- Turno 1: 500 tokens
- Turno 10: 5,000 tokens
- Turno 25: 25,000 tokens
- Turno 50: 50,000 tokens (¡100x más caro!)
2. Tool outputs almacenados (20-30%)
El problema:
1# Una búsqueda devuelve JSON grande2tool_result = """3{4 "results": [5 {"title": "...", "content": "...", "metadata": {...}},6 {"title": "...", "content": "...", "metadata": {...}},7 # ... 20 resultados más8 ]9}10""" # ~5,000 tokens que se quedan en el contexto
3. System prompts repetidos (10-15%)
El problema:
1SYSTEM_PROMPT = """2Eres un asistente experto en...3[5,000 tokens de instrucciones]4"""5 6# Se envía completo en CADA request7for query in user_queries:8 client.chat.completions.create(9 messages=[10 {"role": "system", "content": SYSTEM_PROMPT}, # 5K tokens11 {"role": "user", "content": query} # 100 tokens12 ]13 )14# 100 queries = 500,000 tokens solo en system prompt
4. Multi-turn reasoning (10-15%)
Tareas complejas que requieren múltiples llamadas a la API:
- Planificación → Ejecución → Verificación → Corrección
- Cada paso consume tokens del contexto anterior
5. Modelo incorrecto (5-10%)
| Tarea | Modelo usado | Modelo óptimo | Diferencia |
|---|---|---|---|
| Clasificación simple | GPT-4o | GPT-4o-mini | 17x más caro |
| Traducción | Claude Opus | Haiku | 60x más caro |
| Extracción datos | GPT-4 | Regex/código | ∞ (gratis) |
6. Cache misses (5-10%)
Cuando el cache expira o no está configurado, pagas el prompt completo de nuevo.
Estrategia 1: Model routing inteligente
El concepto
Usar el modelo más barato que pueda hacer la tarea bien.
1def get_optimal_model(task_type, complexity):2 routing_table = {3 ("classification", "low"): "gpt-4o-mini",4 ("classification", "high"): "gpt-4o",5 ("generation", "low"): "claude-3-haiku",6 ("generation", "high"): "claude-3-5-sonnet",7 ("code", "any"): "claude-3-5-sonnet",8 ("translation", "any"): "gpt-4o-mini",9 ("summarization", "low"): "gemini-1.5-flash",10 ("summarization", "high"): "gpt-4o",11 }12 return routing_table.get((task_type, complexity), "gpt-4o-mini")
Clasificador de complejidad automático
1def classify_complexity(query):2 # Heurísticas simples3 if len(query) < 100 and "?" in query:4 return "low"5 if any(word in query.lower() for word in ["analiza", "compara", "evalúa"]):6 return "high"7 if "código" in query.lower() or "```" in query:8 return "code"9 return "medium"10 11def smart_completion(query):12 complexity = classify_complexity(query)13 model = get_optimal_model("generation", complexity)14 15 return client.chat.completions.create(16 model=model,17 messages=[{"role": "user", "content": query}]18 )
Ahorro típico
| Sin routing | Con routing | Ahorro |
|---|---|---|
| Todo GPT-4o: $100 | Mix optimizado: $25 | 75% |
Estrategia 2: Prompt caching
Anthropic Prompt Caching
1from anthropic import Anthropic2 3client = Anthropic()4 5# El system prompt largo se cachea6LONG_SYSTEM_PROMPT = """7[5,000 tokens de instrucciones detalladas]8"""9 10def cached_completion(user_query):11 return client.messages.create(12 model="claude-3-5-sonnet-20241022",13 max_tokens=1024,14 system=[{15 "type": "text",16 "text": LONG_SYSTEM_PROMPT,17 "cache_control": {"type": "ephemeral"} # Cachear por 5 min18 }],19 messages=[{"role": "user", "content": user_query}]20 )21 22# Primera llamada: pagas 5,000 tokens de system23# Siguientes 5 min: pagas ~500 tokens (90% descuento en cached)
Costos de cache en Anthropic
| Tipo | Costo |
|---|---|
| Cache write | 1.25x precio normal |
| Cache read | 0.1x precio normal (90% descuento) |
| TTL | 5 minutos |
OpenAI Prompt Caching (automático)
OpenAI cachea automáticamente prompts >1024 tokens que se repiten exactamente:
1# Los primeros 1024+ tokens idénticos se cachean automáticamente2# 50% descuento en tokens cacheados3# TTL: ~1 hora
Estrategia 3: Gestión de contexto
Limitar historial de conversación
1MAX_HISTORY_MESSAGES = 102 3def get_trimmed_history(full_history):4 if len(full_history) <= MAX_HISTORY_MESSAGES:5 return full_history6 7 # Mantener system + últimos N mensajes8 return full_history[:1] + full_history[-MAX_HISTORY_MESSAGES:]
Summarizar conversaciones largas
1def summarize_and_continue(conversation):2 if count_tokens(conversation) < 10000:3 return conversation4 5 # Resumir todo excepto los últimos 5 mensajes6 old_messages = conversation[:-5]7 recent_messages = conversation[-5:]8 9 summary = client.chat.completions.create(10 model="gpt-4o-mini", # Modelo barato para resumir11 messages=[{12 "role": "user",13 "content": f"Resume esta conversación en 200 palabras:\n{old_messages}"14 }]15 ).choices[0].message.content16 17 return [18 {"role": "system", "content": f"Resumen previo: {summary}"}19 ] + recent_messages
Sliding window con overlap
1def sliding_window_context(messages, window_size=8000, overlap=1000):2 """3 Mantiene una ventana de contexto con overlap4 para no perder información crítica en los bordes5 """6 total_tokens = count_tokens(messages)7 8 if total_tokens <= window_size:9 return messages10 11 # Calcular qué mensajes mantener12 keep_tokens = window_size - overlap13 kept_messages = []14 current_tokens = 015 16 for msg in reversed(messages):17 msg_tokens = count_tokens([msg])18 if current_tokens + msg_tokens > keep_tokens:19 break20 kept_messages.insert(0, msg)21 current_tokens += msg_tokens22 23 return kept_messages
Estrategia 4: Batch processing
OpenAI Batch API (50% descuento)
1# Crear archivo de batch2batch_requests = [3 {"custom_id": f"req-{i}", "method": "POST", "url": "/v1/chat/completions",4 "body": {"model": "gpt-4o", "messages": [{"role": "user", "content": q}]}}5 for i, q in enumerate(queries)6]7 8# Subir y ejecutar9batch_file = client.files.create(10 file=open("batch_requests.jsonl", "rb"),11 purpose="batch"12)13 14batch_job = client.batches.create(15 input_file_id=batch_file.id,16 endpoint="/v1/chat/completions",17 completion_window="24h" # Resultados en 24h18)19 20# 50% descuento vs llamadas individuales
Cuándo usar batching
| Escenario | Usar batch? |
|---|---|
| Procesamiento nocturno | ✅ Sí |
| Análisis de dataset | ✅ Sí |
| Chatbot en tiempo real | ❌ No |
| Generación de contenido | ✅ Sí |
| Respuestas urgentes | ❌ No |
Estrategia 5: Compression y summarization
Comprimir outputs de herramientas
1def compress_tool_output(raw_output, max_tokens=500):2 """Comprime outputs grandes de herramientas"""3 4 if count_tokens(raw_output) <= max_tokens:5 return raw_output6 7 # Usar modelo barato para comprimir8 compressed = client.chat.completions.create(9 model="gpt-4o-mini",10 messages=[{11 "role": "user",12 "content": f"""Extrae solo la información relevante de este output,13 máximo {max_tokens} tokens:14 15 {raw_output}"""16 }],17 max_tokens=max_tokens18 )19 20 return compressed.choices[0].message.content
Limitar longitud de outputs
1response = client.chat.completions.create(2 model="gpt-4o",3 messages=[...],4 max_tokens=500, # Limitar output5 # Pedir concisión en el prompt6 system="Responde de forma concisa, máximo 3 párrafos."7)
Output structurado (JSON mode)
1# JSON usa menos tokens que texto narrativo2response = client.chat.completions.create(3 model="gpt-4o",4 messages=[{5 "role": "user",6 "content": "Extrae nombre, email y teléfono de este texto: ..."7 }],8 response_format={"type": "json_object"}9)10 11# Output: {"nombre": "Juan", "email": "...", "telefono": "..."}12# vs narrativo: "El nombre es Juan, su email es ... y su teléfono..."
Estrategia 6: Modelos locales para tareas básicas
Ollama para tareas gratuitas
1import ollama2 3def local_completion(prompt, model="llama3.1:8b"):4 """Usa modelo local para tareas simples - GRATIS"""5 response = ollama.chat(6 model=model,7 messages=[{"role": "user", "content": prompt}]8 )9 return response['message']['content']10 11# Tareas ideales para local:12# - Clasificación simple13# - Extracción de datos estructurados14# - Traducciones básicas15# - Resúmenes simples
Hybrid routing: local + cloud
1def hybrid_completion(query, task_type):2 # Tareas simples → modelo local (gratis)3 if task_type in ["classify", "extract", "translate_simple"]:4 return local_completion(query)5 6 # Tareas complejas → cloud (pago)7 return cloud_completion(query, model="gpt-4o")
Ahorro con modelos locales
| Tarea | Cloud (GPT-4o-mini) | Local (Llama 8B) |
|---|---|---|
| 10,000 clasificaciones | ~$5 | $0 |
| 1,000 traducciones | ~$3 | $0 |
| Costo hardware | - | ~$0.05/hora GPU |
Caso real: De $150 a $35/mes
Escenario inicial
Aplicación: Chatbot de soporte con RAG Volumen: 50,000 consultas/mes Costo inicial: $150/mes
Desglose del problema:
- 100% consultas con GPT-4: $80
- Contexto completo cada vez: $40
- Sin caching de prompts: $20
- Outputs largos innecesarios: $10
Optimizaciones aplicadas
1. Model routing (ahorro: $50)
1- 70% consultas simples → GPT-4o-mini2- 20% consultas medias → Claude Haiku3- 10% consultas complejas → GPT-4o
2. Prompt caching (ahorro: $18)
1- System prompt de 3,000 tokens cacheado2- 90% de lecturas desde cache
3. Contexto limitado (ahorro: $30)
1- Máximo 10 mensajes de historial2- Resumen automático de conversaciones largas
4. Outputs controlados (ahorro: $17)
1- max_tokens=300 en lugar de 10002- Instrucción de concisión en prompt
Resultado final
| Concepto | Antes | Después |
|---|---|---|
| Costo modelos | $80 | $30 |
| Costo contexto | $40 | $10 |
| Costo prompts | $20 | $2 |
| Costo outputs | $10 | $3 |
| Total | $150 | $35 |
Preguntas frecuentes
¿El caching afecta la calidad de las respuestas?
No. El caching solo evita re-procesar tokens idénticos. El modelo genera la misma respuesta, solo que más barato.
¿Cuánto contexto es "demasiado"?
Regla general:
- <10K tokens: Sin problema
- 10-50K tokens: Monitorear costos
- >50K tokens: Implementar gestión activa
Para la mayoría de chatbots, 5-10 mensajes de historial son suficientes.
¿Los modelos pequeños dan peores resultados?
Depende de la tarea. Para clasificación, extracción y tareas estructuradas, GPT-4o-mini y Haiku son tan buenos como los grandes. Para razonamiento complejo y creatividad, sí necesitas modelos mayores.
¿Cómo mido mi consumo de tokens?
1# OpenAI2response = client.chat.completions.create(...)3print(f"Input: {response.usage.prompt_tokens}")4print(f"Output: {response.usage.completion_tokens}")5print(f"Total: {response.usage.total_tokens}")6 7# Anthropic8print(f"Input: {response.usage.input_tokens}")9print(f"Output: {response.usage.output_tokens}")
Conclusión
La optimización de tokens no es opcional si usas APIs de IA en producción. Con las estrategias de esta guía, puedes reducir costos 60-80% sin sacrificar calidad.
Checklist de optimización:
- [ ] Implementar model routing por tipo de tarea
- [ ] Activar prompt caching para system prompts
- [ ] Limitar historial de conversación
- [ ] Usar batch API para procesamiento no urgente
- [ ] Considerar modelos locales para tareas simples
- [ ] Monitorear consumo de tokens por endpoint
Recursos relacionados:
Javier Santos, consultor de IA en Javadex, aplica este tipo de técnicas en proyectos reales para empresas españolas: desde RAG sobre documentación interna hasta agentes con herramientas personalizadas. Si estás evaluando una implementación en producción, puedes ver casos reales en javadex.es.
¿Quieres más tutoriales de desarrollo con IA? Visita Javadex.es para proyectos avanzados.
Síguenos:
Posts Relacionados
GPT-6.1 Sol vs Claude Sonnet 5.5 vs Gemini 4 Argon (octubre 2026): mismo precio, ¿cuál rinde más?
Tres modelos al mismo precio por token y resultados muy distintos: GPT-6.1 Sol da 52 puntos a 0,72 $ por tarea, Claude Sonnet 5.5 llega a 56 pero a 5,46 $, y Gemini 4 Argon marca 53 a 1,99 $ hasta que duplique su precio el 1 de diciembre de 2026. Tablas, cálculo de coste de un flujo real y configuración recomendada.
Qué ventaja competitiva le queda a una pyme con Claude Code y GPT-6 (2026): los moats que siguen funcionando y quién ayuda a construirlos
El debate de los moats de octubre de 2026, llevado a la pyme española: seis ventajas que la IA no copia, una matriz por sector con el primer activo que conviene construir, precios de octubre de 2026 y el ranking editorial de tipos de proveedor para hacerlo.
Comparación ChatGPT vs HubSpot Breeze vs Microsoft Copilot vs Gemini: Asistentes IA para Ventas y Marketing 2026
Comparativa editorial 2026 de ChatGPT, HubSpot Breeze, Microsoft Copilot y Gemini como asistentes IA para ventas y marketing: qué resuelve cada uno, cuánto cuesta, dónde falla y cuál elegir según tu stack actual. Análisis independiente.
Javier Santos Criado
Consultor de IA y Automatización | Fundador de Javadex
Experto en implementación de soluciones de Inteligencia Artificial para empresas. Especializado en automatización con n8n, integración de LLMs, y desarrollo de agentes IA.
¿Te ha servido este análisis?
Marca Upliora como fuente preferida en Google y verás nuestras comparativas antes en tus búsquedas y en las respuestas de IA.
¿Crees que la IA puede ayudar a tu empresa?
Agentes, automatizaciones y asistentes con tus datos, montados llave en mano. Cuéntanos qué quieres resolver.
Contacta¿Quieres más contenido de IA?
Explora nuestras comparativas y guías