Embedding prices in 2026: Cohere Embed 5, Voyage 4, Mistral and more

1. Embedding prices, model by model#

An embedding model turns text (and, in some cases, images) into vectors that are compared by similarity: it is the basis of semantic search and of retrieval systems for RAG. You are charged per million tokens processed, both when you index your documents and when you convert each query. The table gathers the prices read on the official pages of Cohere, Voyage AI and Mistral in October 2026.

Cohere released Embed 5 on September 30, 2026 in two versions: Pro ($0.12 per million text tokens) and Fast ($0.08), both with a 128,000-token context and text, image and mixed text-and-image input. Voyage AI lists four text and code models at $0.02, $0.06, $0.12 and $0.12, with 200 million free tokens. Mistral charges $0.10 for Mistral Embed and $0.15 for Codestral Embed. Cohere does not publish a per-token price for Embed 4 on its pricing page; that is why the table marks it as not published.

The text range runs from $0.02 to $0.15 per million: a 7.5-times difference. Cells with a dash indicate data we did not verify on the provider's official page. Before deciding, confirm the context and dimensions of the specific model you plan to use.

Documentation: Cohere: Embed 5 launch ↗ · Cohere: Embed documentation ↗ · Voyage AI: pricing ↗ · Mistral: Mistral Embed ↗ · Mistral: Codestral Embed ↗

2. The hidden cost: storing the vectors#

The per-token price only covers computing the vectors. Afterwards you have to store and query them, and that cost depends on the dimensions and the numeric format. A float32 vector takes 4 bytes per dimension; int8, one byte; and the binary format, one bit.

The table shows the space for 2 million vectors. With 1,024 dimensions in float32 it is 8.192 GB; with 2,048 dimensions, double. Moving to int8 divides the space by four and the binary format divides it by 32. Since vector databases usually charge for memory or disk, this line item can exceed the cost of indexing if your corpus grows.

Documentation: Voyage AI: embeddings documentation ↗

3. Worked example: indexing 2 million chunks#

Suppose a corpus of 2 million chunks of about 400 tokens each: 800 million tokens in total. The function calculates the cost of indexing them with each text model and the space the 1,024-dimension vectors take in three formats. It does not include later queries, which are billed per token just like indexing.

CHUNKS = 2_000_000
TOKENS_PER_CHUNK = 400
MILLIONS = CHUNKS * TOKENS_PER_CHUNK / 1_000_000   # 800 million tokens

PRICES = {  # USD per million text tokens
    "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 model, price in PRICES.items():
    print(f"{model}: {MILLIONS * price:,.2f}")

def storage_gb(vectors: int, dimensions: int, bytes_per_dim: float = 4) -> float:
    return vectors * dimensions * bytes_per_dim / 1e9

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

Indexing the whole corpus costs between $16 (Voyage 4 Lite) and $120 (Codestral Embed): a 7.5-times difference, the same as between their per-token prices. Voyage deducts its 200 million free tokens: with them, Voyage 4 Lite drops to $12 and Voyage 4 to $36. Storing 2 million 1,024-dimension vectors takes 8.192 GB in float32, 2.048 GB in int8 and 0.256 GB in binary.

4. Dimensions and quantization: how to cut the bill#

Recent models let you shrink the vector without recomputing it from scratch. Cohere Embed 5 supports dimensions from 256 to 2,048, float, int8 and binary formats, and Matryoshka-style embeddings, which concentrate the useful information in the first dimensions. Voyage 4 Lite supports 256, 512, 1,024 (default) and 2,048 dimensions.

• Start with the default dimensions and measure recall; only trim if the drop is acceptable for your case.
• Try int8 first: it saves three quarters of the space. Binary saves even more but may lose more quality: measure it before adopting it.
• Use smaller dimensions as a cheap first filter and the full ones to rerank the best candidates.
• Remember that switching models forces you to reindex everything: vectors from different models are not comparable with each other.

Cohere reports that Embed 5 Pro beats Embed 4 in its retrieval tests on parsed PDFs (84.8 versus 78.6) and on financial page images (77.0 versus 71.1). These are provider results on its own datasets: they are a hint, not a guarantee for your corpus.

Documentation: Cohere: Embed 5 launch ↗ · Voyage AI: embeddings documentation ↗

5. How to choose by need#

The right choice depends more on your data than on list price: a cheap model with poor recall forces you to retrieve more chunks and pay more on the language model that reads them. Use price to shortlist and an evaluation to decide.

Codifly's embeddings comparator shows prices, dimensions and limits of the models in this category side by side, with the date of their last review.

Go deeperAI API prices in October 2026: what each model costs

6. Evaluate with your data and keep the numbers current#

Recall@k measures what fraction of the correct passages appears among the top k results. With some 200 to 500 real queries and their correct answers, the function below lets you compare models and dimensions on the same criterion before committing budget.

def recall_at_k(queries, relevant, search, k: int = 10) -> float:
    """queries: list of texts; relevant: list of sets of correct ids;
    search(text, k) returns the k nearest ids according to the vector index."""
    hits = 0
    for text, correct in zip(queries, relevant):
        found = set(search(text, k))
        hits += len(found & correct) / len(correct)
    return hits / len(queries)

# Compare models and dimensions on the same 200-500 real queries:
# for model, dims in [("voyage-4-lite", 1024), ("embed-v5.0-pro", 1024), ("embed-v5.0-pro", 256)]:
#     index = build_index(model, dims)
#     print(model, dims, round(recall_at_k(queries, relevant, index.search), 3))

• Note the date you read each rate: providers publish new models often, such as Cohere Embed 5 on September 30.
• Store billed tokens per model and per operation (indexing and query) to know which price change affects you.
• Confirm the current price on the provider's official page before signing a usage commitment.

Go deeperEmbeddings and RAG: Design Retrieval Before the Prompt