Preços de embeddings em 2026: Cohere Embed 5, Voyage 4, Mistral e mais

1. Os preços dos embeddings, modelo por modelo#

Um modelo de embeddings converte texto (e, em alguns casos, imagens) em vetores que são comparados por similaridade: é a base da busca semântica e dos sistemas de recuperação para RAG. A cobrança é por milhão de tokens processados, tanto ao indexar seus documentos quanto ao converter cada consulta. A tabela reúne os preços lidos nas páginas oficiais da Cohere, Voyage AI e Mistral em outubro de 2026.

A Cohere lançou o Embed 5 em 30 de setembro de 2026 em duas versões: Pro ($0,12 por milhão de tokens de texto) e Fast ($0,08), ambas com contexto de 128.000 tokens e entrada de texto, imagem e texto com imagem. A Voyage AI lista quatro modelos de texto e código a $0,02, $0,06, $0,12 e $0,12, com 200 milhões de tokens grátis. A Mistral cobra $0,10 pelo Mistral Embed e $0,15 pelo Codestral Embed. A Cohere não publica preço por token do Embed 4 na página de preços; por isso a tabela o marca como não publicado.

O intervalo de texto vai de $0,02 a $0,15 por milhão: uma diferença de 7,5 vezes. As células com traço indicam dados que não verificamos na página oficial do provedor. Antes de decidir, confirme o contexto e as dimensões do modelo concreto que você vai usar.

Documentação: Cohere: lançamento do Embed 5 ↗ · Cohere: documentação do Embed ↗ · Voyage AI: preços ↗ · Mistral: Mistral Embed ↗ · Mistral: Codestral Embed ↗

2. O custo oculto: armazenar os vetores#

O preço por token cobre só o cálculo dos vetores. Depois você precisa guardá-los e consultá-los, e esse custo depende das dimensões e do formato numérico. Um vetor float32 ocupa 4 bytes por dimensão; int8, um byte; e o formato binário, um bit.

A tabela mostra o espaço para 2 milhões de vetores. Com 1.024 dimensões em float32 são 8,192 GB; com 2.048 dimensões, o dobro. Passar para int8 divide o espaço por quatro e o formato binário o divide por 32. Como os bancos vetoriais costumam cobrar por memória ou disco, esse item pode superar o custo de indexar se o seu corpus crescer.

Documentação: Voyage AI: documentação de embeddings ↗

3. Exemplo calculado: indexar 2 milhões de trechos#

Suponha um corpus de 2 milhões de trechos de cerca de 400 tokens cada: 800 milhões de tokens no total. A função calcula o custo de indexá-los com cada modelo de texto e o espaço que os vetores de 1.024 dimensões ocupam em três formatos. Não inclui as consultas posteriores, cobradas por token como a indexação.

CHUNKS = 2_000_000
TOKENS_POR_CHUNK = 400
MILHOES = CHUNKS * TOKENS_POR_CHUNK / 1_000_000   # 800 milhões de tokens

PRECOS = {  # USD por milhão 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, preco in PRECOS.items():
    print(f"{modelo}: {MILHOES * preco:,.2f}")

def armazenamento_gb(vetores: int, dimensoes: int, bytes_por_dim: float = 4) -> float:
    return vetores * dimensoes * bytes_por_dim / 1e9

print("float32 1024:", f"{armazenamento_gb(CHUNKS, 1024):.3f} GB")
print("int8 1024:", f"{armazenamento_gb(CHUNKS, 1024, 1):.3f} GB")
print("binário 1024:", f"{armazenamento_gb(CHUNKS, 1024, 1 / 8):.3f} GB")

Indexar o corpus inteiro custa entre $16 (Voyage 4 Lite) e $120 (Codestral Embed): uma diferença de 7,5 vezes, a mesma que entre os preços por token. A Voyage desconta seus 200 milhões de tokens grátis: com eles, a Voyage 4 Lite cai para $12 e a Voyage 4 para $36. Armazenar 2 milhões de vetores de 1.024 dimensões ocupa 8,192 GB em float32, 2,048 GB em int8 e 0,256 GB em binário.

4. Dimensões e quantização: como baixar a fatura#

Os modelos recentes permitem reduzir o tamanho do vetor sem recalculá-lo do zero. O Cohere Embed 5 aceita dimensões de 256 a 2.048, formatos float, int8 e binário e embeddings do tipo Matryoshka, que concentram a informação útil nas primeiras dimensões. A Voyage 4 Lite aceita 256, 512, 1.024 (padrão) e 2.048 dimensões.

• Comece com as dimensões padrão e meça o recall; só reduza se a queda for aceitável para o seu caso.
• Teste o int8 primeiro: economiza três quartos do espaço. O binário economiza ainda mais, mas pode perder mais qualidade: meça antes de adotá-lo.
• Use dimensões menores como primeiro filtro barato e as completas para reordenar os melhores candidatos.
• Lembre que trocar de modelo obriga a reindexar tudo: vetores de modelos diferentes não são comparáveis entre si.

A Cohere informa que o Embed 5 Pro supera o Embed 4 em seus testes de recuperação sobre PDFs analisados (84,8 contra 78,6) e sobre imagens de página financeiras (77,0 contra 71,1). São resultados do provedor sobre seus próprios conjuntos de dados: servem como pista, não como garantia para o seu corpus.

Documentação: Cohere: lançamento do Embed 5 ↗ · Voyage AI: documentação de embeddings ↗

5. Como escolher conforme a necessidade#

A escolha certa depende mais dos seus dados que do preço de tabela: um modelo barato com recall ruim obriga a recuperar mais trechos e a pagar mais no modelo de linguagem que os lê. Use o preço para pré-selecionar e uma avaliação para decidir.

O comparador de embeddings da Codifly mostra preços, dimensões e limites dos modelos desta categoria lado a lado, com a data da última revisão.

Para se aprofundarPreços das APIs de IA em outubro de 2026: quanto custa cada modelo

6. Avalie com os seus dados e mantenha os números em dia#

O recall@k mede que fração dos trechos corretos aparece entre os k primeiros resultados. Com cerca de 200 a 500 consultas reais e suas respostas corretas, a função a seguir permite comparar modelos e dimensões com o mesmo critério antes de comprometer orçamento.

def recall_at_k(consultas, relevantes, buscar, k: int = 10) -> float:
    """consultas: lista de textos; relevantes: lista de conjuntos de ids corretos;
    buscar(texto, k) devolve os k ids mais próximos segundo o índice de vetores."""
    acertos = 0
    for texto, corretos in zip(consultas, relevantes):
        encontrados = set(buscar(texto, k))
        acertos += len(encontrados & corretos) / len(corretos)
    return acertos / len(consultas)

# Compare modelos e dimensões com as mesmas 200-500 consultas reais:
# 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))

• Anote a data de leitura de cada tarifa: os provedores publicam modelos novos com frequência, como o Cohere Embed 5 em 30 de setembro.
• Guarde os tokens faturados por modelo e por operação (indexação e consulta) para saber qual mudança de preço o afeta.
• Confirme na página oficial do provedor o preço vigente antes de assinar um compromisso de uso.

Para se aprofundarEmbeddings e RAG: projete a recuperação antes do prompt