Cómo Optimizar Costos de Tokens en LLMs: Guía Definitiva [2026]

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.

Tabla de Contenidos

1. ¿Por qué tus costos de IA son tan altos?
2. Los 6 principales consumidores de tokens
3. Estrategia 1: Model routing inteligente
4. Estrategia 2: Prompt caching
5. Estrategia 3: Gestión de contexto
6. Estrategia 4: Batch processing
7. Estrategia 5: Compression y summarization
8. Estrategia 6: Modelos locales para tareas básicas
9. Caso real: De $150 a $35/mes
10. Preguntas frecuentes

¿Por qué tus costos de IA son tan altos? {#por-que-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ñol
51000 tokens ≈ 4-5 párrafos de texto

Precios actuales (referencia)

Los 6 principales consumidores de tokens {#consumidores}

1. Contexto acumulado (40-50% del costo)

El problema:

1# Cada mensaje añade al historial
2conversation = []
3for i in range(50):  # 50 turnos de conversación
4    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 grande
2tool_result = """
3{
4  "results": [
5    {"title": "...", "content": "...", "metadata": {...}},
6    {"title": "...", "content": "...", "metadata": {...}},
7    # ... 20 resultados más
8  ]
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 request
7for query in user_queries:
8    client.chat.completions.create(
9        messages=[
10            {"role": "system", "content": SYSTEM_PROMPT},  # 5K tokens
11            {"role": "user", "content": query}  # 100 tokens
12        ]
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%)

6. Cache misses (5-10%)

Cuando el cache expira o no está configurado, pagas el prompt completo de nuevo.

Estrategia 1: Model routing inteligente {#model-routing}

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 simples
3    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 "

return "code"

return "medium"

def smart_completion(query):

complexity = classify_complexity(query)

model = get_optimal_model("generation", complexity)

return client.chat.completions.create(

model=model,

messages=[{"role": "user", "content": query}]

)

1### Ahorro típico
2 
3| Sin routing | Con routing | Ahorro |
4|-------------|-------------|--------|
5| Todo GPT-4o: $100 | Mix optimizado: $25 | 75% |
6 
7---
8 
9## Estrategia 2: Prompt caching {#prompt-caching}
10 
11### Anthropic Prompt Caching

from anthropic import Anthropic

client = Anthropic()

El system prompt largo se cachea

LONG_SYSTEM_PROMPT = """

[5,000 tokens de instrucciones detalladas]

"""

def cached_completion(user_query):

return client.messages.create(

model="claude-3-5-sonnet-20241022",

max_tokens=1024,

system=[{

"type": "text",

"text": LONG_SYSTEM_PROMPT,

"cache_control": {"type": "ephemeral"} # Cachear por 5 min

}],

messages=[{"role": "user", "content": user_query}]

)

Primera llamada: pagas 5,000 tokens de system

Siguientes 5 min: pagas ~500 tokens (90% descuento en cached)

1### Costos de cache en Anthropic
2 
3| Tipo | Costo |
4|------|-------|
5| Cache write | 1.25x precio normal |
6| Cache read | 0.1x precio normal (90% descuento) |
7| TTL | 5 minutos |
8 
9**Break-even:** Si usas el mismo prompt >2 veces en 5 min, el caching ahorra dinero.
10 
11### OpenAI Prompt Caching (automático)
12 
13OpenAI cachea automáticamente prompts >1024 tokens que se repiten exactamente:

Los primeros 1024+ tokens idénticos se cachean automáticamente

50% descuento en tokens cacheados

TTL: ~1 hora

1---
2 
3## Estrategia 3: Gestión de contexto {#contexto}
4 
5### Limitar historial de conversación

MAX_HISTORY_MESSAGES = 10

def get_trimmed_history(full_history):

if len(full_history) <= MAX_HISTORY_MESSAGES:

return full_history

# Mantener system + últimos N mensajes

return full_history[:1] + full_history[-MAX_HISTORY_MESSAGES:]

1### Summarizar conversaciones largas

def summarize_and_continue(conversation):

if count_tokens(conversation) < 10000:

return conversation

# Resumir todo excepto los últimos 5 mensajes

old_messages = conversation[:-5]

recent_messages = conversation[-5:]

summary = client.chat.completions.create(

model="gpt-4o-mini", # Modelo barato para resumir

messages=[{

"role": "user",

"content": f"Resume esta conversación en 200 palabras:\n{old_messages}"

}]

).choices[0].message.content

return [

{"role": "system", "content": f"Resumen previo: {summary}"}

] + recent_messages

1### Sliding window con overlap

def sliding_window_context(messages, window_size=8000, overlap=1000):

"""

Mantiene una ventana de contexto con overlap

para no perder información crítica en los bordes

"""

total_tokens = count_tokens(messages)

if total_tokens <= window_size:

return messages

# Calcular qué mensajes mantener

keep_tokens = window_size - overlap

kept_messages = []

current_tokens = 0

for msg in reversed(messages):

msg_tokens = count_tokens([msg])

if current_tokens + msg_tokens > keep_tokens:

break

kept_messages.insert(0, msg)

current_tokens += msg_tokens

return kept_messages

1---
2 
3## Estrategia 4: Batch processing {#batching}
4 
5### OpenAI Batch API (50% descuento)

Crear archivo de batch

batch_requests = [

{"custom_id": f"req-{i}", "method": "POST", "url": "/v1/chat/completions",

"body": {"model": "gpt-4o", "messages": [{"role": "user", "content": q}]}}

for i, q in enumerate(queries)

]

Subir y ejecutar

batch_file = client.files.create(

file=open("batch_requests.jsonl", "rb"),

purpose="batch"

)

batch_job = client.batches.create(

input_file_id=batch_file.id,

endpoint="/v1/chat/completions",

completion_window="24h" # Resultados en 24h

)

50% descuento vs llamadas individuales

1### Cuándo usar batching
2 
3| Escenario | Usar batch? |
4|-----------|-------------|
5| Procesamiento nocturno | ✅ Sí |
6| Análisis de dataset | ✅ Sí |
7| Chatbot en tiempo real | ❌ No |
8| Generación de contenido | ✅ Sí |
9| Respuestas urgentes | ❌ No |
10 
11---
12 
13## Estrategia 5: Compression y summarization {#compression}
14 
15### Comprimir outputs de herramientas

def compress_tool_output(raw_output, max_tokens=500):

"""Comprime outputs grandes de herramientas"""

if count_tokens(raw_output) <= max_tokens:

return raw_output

# Usar modelo barato para comprimir

compressed = client.chat.completions.create(

model="gpt-4o-mini",

messages=[{

"role": "user",

"content": f"""Extrae solo la información relevante de este output,

máximo {max_tokens} tokens:

{raw_output}"""

}],

max_tokens=max_tokens

)

return compressed.choices[0].message.content

1### Limitar longitud de outputs

response = client.chat.completions.create(

model="gpt-4o",

messages=[...],

max_tokens=500, # Limitar output

# Pedir concisión en el prompt

system="Responde de forma concisa, máximo 3 párrafos."

)

1### Output structurado (JSON mode)

JSON usa menos tokens que texto narrativo

response = client.chat.completions.create(

model="gpt-4o",

messages=[{

"role": "user",

"content": "Extrae nombre, email y teléfono de este texto: ..."

}],

response_format={"type": "json_object"}

)

Output: {"nombre": "Juan", "email": "...", "telefono": "..."}

vs narrativo: "El nombre es Juan, su email es ... y su teléfono..."

1---
2 
3## Estrategia 6: Modelos locales para tareas básicas {#modelos-locales}
4 
5### Ollama para tareas gratuitas

import ollama

def local_completion(prompt, model="llama3.1:8b"):

"""Usa modelo local para tareas simples - GRATIS"""

response = ollama.chat(

model=model,

messages=[{"role": "user", "content": prompt}]

)

return response['message']['content']

Tareas ideales para local:

- Clasificación simple

- Extracción de datos estructurados

- Traducciones básicas

- Resúmenes simples

1### Hybrid routing: local + cloud

def hybrid_completion(query, task_type):

# Tareas simples → modelo local (gratis)

if task_type in ["classify", "extract", "translate_simple"]:

return local_completion(query)

# Tareas complejas → cloud (pago)

return cloud_completion(query, model="gpt-4o")

1### Ahorro con modelos locales
2 
3| Tarea | Cloud (GPT-4o-mini) | Local (Llama 8B) |
4|-------|---------------------|------------------|
5| 10,000 clasificaciones | ~$5 | $0 |
6| 1,000 traducciones | ~$3 | $0 |
7| Costo hardware | - | ~$0.05/hora GPU |
8 
9---
10 
11## Caso real: De $150 a $35/mes {#caso-real}
12 
13### Escenario inicial
14 
15**Aplicación:** Chatbot de soporte con RAG
16**Volumen:** 50,000 consultas/mes
17**Costo inicial:** $150/mes
18 
19**Desglose del problema:**
20- 100% consultas con GPT-4: $80
21- Contexto completo cada vez: $40
22- Sin caching de prompts: $20
23- Outputs largos innecesarios: $10
24 
25### Optimizaciones aplicadas
26 
27**1. Model routing (ahorro: $50)**

• 70% consultas simples → GPT-4o-mini
• 20% consultas medias → Claude Haiku
• 10% consultas complejas → GPT-4o

1**2. Prompt caching (ahorro: $18)**

• System prompt de 3,000 tokens cacheado
• 90% de lecturas desde cache

1**3. Contexto limitado (ahorro: $30)**

• Máximo 10 mensajes de historial
• Resumen automático de conversaciones largas

1**4. Outputs controlados (ahorro: $17)**

• max_tokens=300 en lugar de 1000
• Instrucción de concisión en prompt

1### Resultado final
2 
3| Concepto | Antes | Después |
4|----------|-------|---------|
5| Costo modelos | $80 | $30 |
6| Costo contexto | $40 | $10 |
7| Costo prompts | $20 | $2 |
8| Costo outputs | $10 | $3 |
9| **Total** | **$150** | **$35** |
10 
11**Ahorro: 77%**
12 
13---
14 
15## Preguntas frecuentes {#faq}
16 
17### ¿El caching afecta la calidad de las respuestas?
18 
19**No.** El caching solo evita re-procesar tokens idénticos. El modelo genera la misma respuesta, solo que más barato.
20 
21### ¿Cuánto contexto es "demasiado"?
22 
23**Regla general:**
24- <10K tokens: Sin problema
25- 10-50K tokens: Monitorear costos
26- >50K tokens: Implementar gestión activa
27 
28Para la mayoría de chatbots, 5-10 mensajes de historial son suficientes.
29 
30### ¿Los modelos pequeños dan peores resultados?
31 
32**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.
33 
34### ¿Cómo mido mi consumo de tokens?

OpenAI

response = client.chat.completions.create(...)

print(f"Input: {response.usage.prompt_tokens}")

print(f"Output: {response.usage.completion_tokens}")

print(f"Total: {response.usage.total_tokens}")

Anthropic

print(f"Input: {response.usage.input_tokens}")

print(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:

• APIs de IA: Guía Completa
• RAG Explicado: Tutorial
• n8n vs Make vs Zapier

¿Quieres más tutoriales de desarrollo con IA? Visita Javadex.es para proyectos avanzados.

Síguenos:

• YouTube @JavadexAI
• TikTok @javadex