Precios de embeddings en 2026: Cohere Embed 5, Voyage 4, Mistral y más

1. Los precios de los embeddings, modelo por modelo#

Un modelo de embeddings convierte texto (y, en algunos casos, imágenes) en vectores que se comparan por similitud: es la base de la búsqueda semántica y de los sistemas de recuperación para RAG. Se cobra por millón de tokens procesados, tanto al indexar tus documentos como al convertir cada consulta. La tabla reúne los precios leídos en las páginas oficiales de Cohere, Voyage AI y Mistral en octubre de 2026.

Cohere publicó Embed 5 el 30 de septiembre de 2026 en dos versiones: Pro ($0,12 por millón de tokens de texto) y Fast ($0,08), ambas con contexto de 128.000 tokens y entrada de texto, imagen y texto con imagen. Voyage AI lista cuatro modelos de texto y código a $0,02, $0,06, $0,12 y $0,12, con 200 millones de tokens gratis. Mistral cobra $0,10 por Mistral Embed y $0,15 por Codestral Embed. Cohere no publica un precio por token de Embed 4 en su página de precios; por eso la tabla lo marca como no publicado.

El rango de texto va de $0,02 a $0,15 por millón: una diferencia de 7,5 veces. Las celdas con guion indican datos que no verificamos en la página oficial del proveedor. Antes de decidir, confirma el contexto y las dimensiones del modelo concreto que vayas a usar.

Documentación: Cohere: lanzamiento de Embed 5 ↗ · Cohere: documentación de Embed ↗ · Voyage AI: precios ↗ · Mistral: Mistral Embed ↗ · Mistral: Codestral Embed ↗

2. El costo oculto: almacenar los vectores#

El precio por token solo cubre el cálculo de los vectores. Después tienes que guardarlos y consultarlos, y ese costo depende de las dimensiones y del formato numérico. Un vector float32 ocupa 4 bytes por dimensión; int8, un byte; y el formato binario, un bit.

La tabla muestra el espacio para 2 millones de vectores. Con 1.024 dimensiones en float32 son 8,192 GB; con 2.048 dimensiones, el doble. Pasar a int8 divide el espacio entre cuatro y el formato binario lo divide entre 32. Como las bases vectoriales suelen cobrar por memoria o por disco, esta partida puede superar al costo de indexar si tu corpus crece.

Documentación: Voyage AI: documentación de embeddings ↗

3. Ejemplo calculado: indexar 2 millones de fragmentos#

Supongamos un corpus de 2 millones de fragmentos de unos 400 tokens cada uno: 800 millones de tokens en total. La función calcula el costo de indexarlos con cada modelo de texto y el espacio que ocupan los vectores de 1.024 dimensiones en tres formatos. No incluye las consultas posteriores, que se cobran por token igual que la indexación.

CHUNKS = 2_000_000
TOKENS_POR_CHUNK = 400
MILLONES = CHUNKS * TOKENS_POR_CHUNK / 1_000_000   # 800 millones de tokens

PRECIOS = {  # USD por millón de tokens de texto
    "Voyage 4 Lite": 0.02, "Voyage 4": 0.06, "Cohere Embed 5 Fast": 0.08, "Mistral Embed": 0.10,
    "Cohere Embed 5 Pro": 0.12, "Voyage 4 Large": 0.12, "Codestral Embed": 0.15,
}
for modelo, precio in PRECIOS.items():
    print(f"{modelo}: {MILLONES * precio:,.2f}")

def almacenamiento_gb(vectores: int, dimensiones: int, bytes_por_dim: float = 4) -> float:
    return vectores * dimensiones * bytes_por_dim / 1e9

print("float32 1024:", f"{almacenamiento_gb(CHUNKS, 1024):.3f} GB")
print("int8 1024:", f"{almacenamiento_gb(CHUNKS, 1024, 1):.3f} GB")
print("binario 1024:", f"{almacenamiento_gb(CHUNKS, 1024, 1 / 8):.3f} GB")

Indexar todo el corpus cuesta entre $16 (Voyage 4 Lite) y $120 (Codestral Embed): una diferencia de 7,5 veces, la misma que entre sus precios por token. Voyage descuenta sus 200 millones de tokens gratis: con ellos, Voyage 4 Lite baja a $12 y Voyage 4 a $36. El almacenamiento de 2 millones de vectores de 1.024 dimensiones pesa 8,192 GB en float32, 2,048 GB en int8 y 0,256 GB en binario.

4. Dimensiones y cuantización: cómo bajar la factura#

Los modelos recientes permiten reducir el tamaño del vector sin recalcularlo desde cero. Cohere Embed 5 admite dimensiones de 256 a 2.048, formatos float, int8 y binario, y embeddings tipo Matryoshka, que concentran la información útil en las primeras dimensiones. Voyage 4 Lite admite 256, 512, 1.024 (por defecto) y 2.048 dimensiones.

• Empieza con las dimensiones por defecto y mide el recall; solo recorta si la caída es aceptable para tu caso.
• Prueba int8 primero: ahorra tres cuartas partes del espacio. El binario ahorra aún más, pero puede perder más calidad: mídelo antes de adoptarlo.
• Usa dimensiones menores como primer filtro barato y las completas para reordenar los mejores candidatos.
• Recuerda que cambiar de modelo obliga a reindexar todo: los vectores de modelos distintos no son comparables entre sí.

Cohere reporta que Embed 5 Pro supera a Embed 4 en sus pruebas de recuperación sobre PDF analizados (84,8 frente a 78,6) y sobre imágenes de página financieras (77,0 frente a 71,1). Son resultados del proveedor sobre sus propios conjuntos de datos: sirven como pista, no como garantía para tu corpus.

Documentación: Cohere: lanzamiento de Embed 5 ↗ · Voyage AI: documentación de embeddings ↗

5. Cómo elegir según la necesidad#

La elección correcta depende más de tus datos que del precio de lista: un modelo barato con mal recall te obliga a recuperar más fragmentos y a pagar más en el modelo de lenguaje que los lee. Usa el precio para preseleccionar y una evaluación para decidir.

El comparador de embeddings de Codifly muestra precios, dimensiones y límites de los modelos de esta categoría lado a lado, con la fecha de su última revisión.

Para profundizarPrecios de las APIs de IA en octubre de 2026: cuánto cuesta cada modelo

6. Evalúa con tus datos y mantén las cifras al día#

El recall@k mide qué fracción de los pasajes correctos aparece entre los k primeros resultados. Con unas 200 a 500 consultas reales y sus respuestas correctas, la función siguiente te permite comparar modelos y dimensiones con el mismo criterio antes de comprometer presupuesto.

def recall_at_k(consultas, relevantes, buscar, k: int = 10) -> float:
    """consultas: lista de textos; relevantes: lista de conjuntos de ids correctos;
    buscar(texto, k) devuelve los k ids más cercanos según el índice de vectores."""
    aciertos = 0
    for texto, correctos in zip(consultas, relevantes):
        encontrados = set(buscar(texto, k))
        aciertos += len(encontrados & correctos) / len(correctos)
    return aciertos / len(consultas)

# Compara modelos y dimensiones con las mismas 200-500 consultas reales:
# for modelo, dims in [("voyage-4-lite", 1024), ("embed-v5.0-pro", 1024), ("embed-v5.0-pro", 256)]:
#     indice = construir_indice(modelo, dims)
#     print(modelo, dims, round(recall_at_k(consultas, relevantes, indice.buscar), 3))

• Anota la fecha de lectura de cada tarifa: los proveedores publican modelos nuevos con frecuencia, como Cohere Embed 5 el 30 de septiembre.
• Guarda los tokens facturados por modelo y por operación (indexación y consulta) para saber qué cambio de precio te afecta.
• Confirma en la página oficial del proveedor el precio vigente antes de firmar un compromiso de uso.

Para profundizarEmbeddings y RAG: diseña la recuperación antes del prompt