Cohere vs Google vs Voyage vs OpenAI Embeddings: Which Should You Use?

Cohere, Google, Voyage AI and OpenAI all sell capable embedding APIs, but they are no longer interchangeable. They differ on price, input limits, supported media, data terms and how recently the models were updated.

My recommendation for most new text RAG projects is Voyage voyage-4. It offers the best overall balance of price, long input limits and retrieval evidence. If retrieval quality matters more than cost, test voyage-4-large against Cohere embed-v5.0-pro, which costs the same.

For a quick decision:

These picks are my judgement, not the result of a new benchmark. I did not run the tests quoted here, and most of the strong claims come from vendors testing their own models. Specifications and prices come from official documentation checked on 5 November 2026. Pricing changes often, so confirm it before you commit.

If you are still deciding whether to use a closed API at all, read open source vs closed source embedding models first.

Side-by-side comparison#

This table shows the main model from each vendor. Other tiers are covered in the vendor sections below.

Price comparison#

Here is a worked example: one million chunks of 400 tokens (400 million tokens to index) plus one million queries a month averaging 30 tokens (30 million query tokens).

Voyage's first 200 million tokens are free, which would halve its standard indexing cost in this example, though the free tokens do not apply to batch usage. Batch figures for OpenAI and Voyage are calculated from their stated percentages. OpenAI states its discount in the Batch API guide, and its pricing page has no separate embedding batch row.

The price of embedding is rarely the deciding factor. Vector storage, reranking and answer generation usually matter more. Dimensions have a direct effect on storage, as this raw size for one million vectors shows, before index overhead and metadata:

Shortening vectors often costs little. Google reports MTEB scores of 68.17 at 1,536 dimensions, 67.99 at 768 and 66.19 at 256. In Techsy's test, text-embedding-3-large scored 0.86 at 3,072 dimensions and 0.83 at 1,024. I would start at 1,024 or 1,536 and only go higher if your evaluation shows a clear benefit. To estimate a full system budget, use my RAG cost calculator.

Retrieval quality: what the evidence says#

There is no neutral head-to-head test that covers all four current flagships. The evidence below is useful, but each source has real limits.

I draw four conclusions:

1. Voyage has the broadest support. It leads its own test, stays close to the top in Cohere's test and led the independent Techsy test.
2. Embed 5 looks strong but is unproven outside Cohere. It launched on 30 September 2026, and I did not find an independent test of it yet.
3. text-embedding-3-large is no longer the quality leader. Competitors' tests show larger gaps than independent ones, but no test I found puts it first.
4. The retrieval pipeline can matter more than the model. In a financial documents study, text-embedding-3-large scored an nDCG@10 of 0.466 alone, 0.551 in a hybrid with BM25 and 0.683 with Cohere reranking added. BM25 alone scored 0.515.

That last result covers a single embedding model on financial data, but the lesson generalizes well: test hybrid search and reranking before spending weeks on an embedding migration.

OpenAI: simple and familiar, but ageing#

OpenAI offers text-embedding-3-small and text-embedding-3-large. Both were released in January 2024, and they remain its newest embedding models on the current pricing page.

Strengths:

• Very simple to use, because there is no query or document mode to get wrong.
• text-embedding-3-small costs $0.02 per million tokens and is a sound baseline.
• Wide framework support, plus a Batch API that takes up to 50,000 embedding inputs per batch.
• Available through Azure as well as OpenAI's own API.

Weaknesses:

• A limit of 8,192 tokens per input.
• Text only.
• No built-in quantized output or first-party reranker.
• text-embedding-3-large costs more than voyage-4-large and Embed 5 Pro, but it is older and scores lower in the tests above.

Verdict: Use text-embedding-3-small as a cheap baseline or where OpenAI is already approved. I would not pick text-embedding-3-large for a new project without testing voyage-4 first. If your existing system performs well, there is no urgency to migrate.

Voyage AI: the best default for text retrieval#

Voyage has focused on embeddings and reranking, and MongoDB acquired the company in February 2025. Its current lineup is also the most specialized of the four:

Strengths:

• Voyage's own test puts voyage-4 just 1.87% behind voyage-4-large at half the price. That claim needs checking on your data, but it is why I call voyage-4 the best value.
• 32,000-token inputs, four vector sizes and several quantized formats.
• 200 million free tokens on current models, which covers many evaluations entirely.
• Documented support for asymmetric retrieval, which embeds documents with a large model and queries with a smaller one.
• Inexpensive first-party reranking: rerank-3 at $0.05 and rerank-3-lite at $0.02 per million tokens.
• Also available through MongoDB Atlas, which is convenient if your data is already there.

Weaknesses:

• Training use is an opt-out, not an opt-in, so an administrator needs to act before you send sensitive data. See data handling.
• Per-request token limits vary by model. voyage-4-large allows 120K tokens per request, so large backfills need careful batching.
• Batch inference is still in public preview, and images and video need the separate voyage-multimodal-3.5 model.

Verdict: My default for text-heavy RAG. Start with voyage-4, and use voyage-4-large when an evaluation shows the extra quality matters.

Cohere: best fit for document-heavy enterprise work#

Cohere's Embed 5 comes in Pro ($0.12 per million text tokens) and Fast ($0.08), both priced at $0.40 per million image tokens. Older models include embed-v4.0 and the v3 family, whose 512-token limit makes them poor choices for new work.

Strengths:

• A 128K-token limit, and inputs that can mix text and images, which suits PDFs and slides.
• In Cohere's own fused text-and-image test, Pro scored 82.3 against 61.3 for Gemini Embedding 2.
• Pro and Fast share an embedding space, so you can index with Pro and embed live queries with Fast. In Cohere's chart, Fast handled 377.3 documents per second against 159.7 for Pro.
• int8 and binary output.
• Strong reranking: the financial study above saw a large gain using rerank-v4.0-pro, and rerank-v5.0-pro is now the recommended model.
• Model Vault, Microsoft Foundry, Amazon SageMaker and private deployments, and zero data retention for approved customers.

Weaknesses:

• The quality claims for Embed 5 have not been independently confirmed.
• The /embed endpoint accepts up to 96 inputs per call, and the rate limit is 2,000 inputs a minute, so backfills need planning.
• The models table lists Embed Jobs for v4 and v3 but not Embed 5, so confirm your bulk-indexing path. I found no published batch discount.
• Its public pricing page has no embedding row. The Embed 5 prices come from the launch post, so confirm them before budgeting.
• input_type is required, and using the wrong value is a common source of poor results.

Verdict: First choice to test for PDFs, slides and regulated enterprise deployments. For plain text, it is a serious rival to voyage-4-large, but I would want the result from your own evaluation first.

Google: widest range of media, highest text price#

gemini-embedding-2 places text, images, audio, video and PDF pages in a single vector space. The older text-only gemini-embedding-001 costs $0.15 and has an earliest listed shutdown date of 14 May 2028, so I would not start new work on it.

Strengths:

• The only single model here that covers audio and video along with text and images.
• Strong cross-language result in the independent Chinese-English test above, though that used the preview version.
• 50% batch discount and a free tier for experiments.
• Automatic normalization when you shorten vectors, and available through both the Gemini API and Vertex AI.

Weaknesses:

• The highest text price of these models, with a limit of 8,192 tokens.
• PDF inputs are limited to six pages per file, and the docs say over-limit inputs are silently truncated.
• Free-tier content can be used to improve Google's products. Paid-tier content is not.
• Its task handling differs from gemini-embedding-001, which is easy to get wrong in a migration.

Those task differences are more than a footnote. gemini-embedding-2 does not support the task_type field, so retrieval needs prompt prefixes such as task: search result | query: {content}. Passing several items directly in contents also returns one combined embedding, not one per item. A careless migration can therefore produce vectors that look fine but search badly.

Verdict: Choose it when you need audio or video search, or when your team is committed to Google Cloud. For plain text, it is hard to justify over voyage-4 without a strong result on your own data.

The same embedding call in each SDK#

Each API handles queries and documents differently. These examples embed one document and one query, and I checked the parameter names against the current Python SDKs, but did not call the live APIs.

OpenAI#

from openai import OpenAI

client = OpenAI()

response = client.embeddings.create(
    model="text-embedding-3-small",
    input=["To reset your password, open account settings."],
    dimensions=1024,
)
vector = response.data[0].embedding

Queries and documents use the same call.

Voyage AI#

import voyageai

client = voyageai.Client()

documents = client.embed(
    ["To reset your password, open account settings."],
    model="voyage-4",
    input_type="document",
    output_dimension=1024,
).embeddings

query = client.embed(
    ["How can I reset my password?"],
    model="voyage-4",
    input_type="query",
    output_dimension=1024,
).embeddings[0]

Cohere#

import cohere

client = cohere.ClientV2()

documents = client.embed(
    model="embed-v5.0-pro",
    input_type="search_document",
    texts=["To reset your password, open account settings."],
    output_dimension=1024,
    embedding_types=["float"],
).embeddings.float_

# Pro and Fast share an embedding space, so queries can use the faster model.
query = client.embed(
    model="embed-v5.0-fast",
    input_type="search_query",
    texts=["How can I reset my password?"],
    output_dimension=1024,
    embedding_types=["float"],
).embeddings.float_[0]

Google#

from google import genai
from google.genai import types

client = genai.Client()
config = types.EmbedContentConfig(output_dimensionality=1536)


def embed(texts: list[str]) -> list[list[float]]:
    # One Content per text. A bare list would return one combined embedding.
    contents = [types.Content(parts=[types.Part(text=text)]) for text in texts]
    response = client.models.embed_content(
        model="gemini-embedding-2", contents=contents, config=config
    )
    return [item.values for item in response.embeddings]


documents = embed(["title: none | text: To reset your password, open account settings."])
query = embed(["task: search result | query: How can I reset my password?"])[0]

Google recommends 768, 1,536 or 3,072 dimensions, which is why this example does not use 1,024.

Data handling and deployment#

These summaries cover standard API use. Enterprise contracts can differ, and this is not legal advice, so have the current terms reviewed for sensitive data.

Three actions are easy to miss:

• Voyage: only an organization admin with a payment method on file can opt out in the dashboard. Do it before sending real data, and note that this FAQ describes Voyage-hosted endpoints rather than Atlas.
• Cohere: switch off training use under Data Controls in dashboard settings. The commitments apply to paying customers, and trial keys fall under separate terms.
• Google: do not use the free tier with confidential or personal data.

Recommendations by use case#

Customer support or internal knowledge base. Start with voyage-4. Add hybrid search and rerank-3-lite or rerank-3, then test them against text-embedding-3-small as a cheap baseline.

Legal, finance or other high-stakes text. Test voyage-4-large, embed-v5.0-pro, and the relevant voyage-law-2 or voyage-finance-2 model. Cohere reports strong finance scores for Embed 5, so this is a real contest. Measure critical failures as well as averages.

Scanned PDFs, slides and reports with charts. Test embed-v5.0-pro first, then gemini-embedding-2 and voyage-multimodal-3.5. Use real page images rather than clean parsed text.

Audio and video libraries. Use gemini-embedding-2, and plan for its 180-second audio and 120-second video limits by splitting longer media into segments. Watch the media token prices, which are far higher than text.

Code search. Start with voyage-code-4.

Long documents. Keep using chunks. Try voyage-context-4 when chunks lose meaning without their surrounding document, and compare it against standard chunks.

Strict budgets at scale. Compare voyage-4-lite and text-embedding-3-small, both at $0.02. Use batch endpoints for indexing where your provider offers them, and consider quantized vectors to cut storage.

Already on MongoDB Atlas. Evaluate Voyage first, through Atlas or its own API. Already committed to Google Cloud or Azure? Include the options your cloud makes easy, since approval and procurement are real costs.

How to test them on your own data#

A useful comparison can be small. Collect 50 to 200 real queries, record which chunks should be retrieved, then calculate recall. This function works with any provider:

import numpy as np


def recall_at_k(embed_documents, embed_query, chunks, cases, k=10):
    """chunks: {chunk_id: text}. cases: [{"query": str, "relevant": set_of_chunk_ids}]."""
    ids = list(chunks)
    documents = np.array(embed_documents([chunks[i] for i in ids]), dtype=np.float32)
    documents /= np.linalg.norm(documents, axis=1, keepdims=True)

    hits = 0.0
    for case in cases:
        query = np.array(embed_query(case["query"]), dtype=np.float32)
        query /= np.linalg.norm(query)
        top = np.argsort(documents @ query)[::-1][:k]
        retrieved = {ids[i] for i in top}
        hits += len(retrieved & case["relevant"]) / len(case["relevant"])
    return hits / len(cases)

Run the same cases for each provider, using its document and query settings from the examples above. Then follow these rules:

• Use real queries, including misspellings, exact codes, other languages and questions with no answer.
• Keep chunks identical across models, then separately test whether long-context models benefit from larger chunks.
• Compare at the same dimension, at least once, as well as at each model's default.
• Report query-level failures, not just the average. A small average gain may hide a critical regression.
• Measure latency from your own region, at your real concurrency.
• Add BM25, hybrid and reranking so that you can tell whether a new embedding model is really the most valuable change.

With around 100 queries, differences of a few points are usually noise. My RAG evaluation guide explains how to build a stronger test set.

How to migrate between providers#

Vectors from different vendors cannot share an index. Treat a move as a controlled data migration:

1. Store the provider, model, dimension and preprocessing version with each vector.
2. Build a new index or vector field and re-embed from the source text.
3. Keep writing new content to both indexes until the switch.
4. Replay your evaluation set, then compare live results in shadow mode.
5. Switch traffic gradually and keep the old index until rollback is no longer needed.

Budget for rate limits as well as cost. My vector database guide covers the storage side of this process.

Frequently asked questions#

Which embedding API is the best overall?#

For most new text RAG projects, I would start with Voyage voyage-4. There is no universal winner, though: Cohere is the stronger candidate for mixed documents, and Google for audio and video.

Is Voyage better than OpenAI embeddings?#

The available tests favour voyage-4-large over text-embedding-3-large, by a wide margin in Voyage's own test and by 0.89 to 0.86 in a small independent one, which is within noise. Voyage also offers longer inputs and quantized outputs at a slightly lower price. Your own data should settle it.

Is Cohere Embed 5 better than Voyage 4?#

In Cohere's own ViDoRe V3 test, Embed 5 Pro scored 85.8 against 83.7 for voyage-4-large. That test focuses on visual documents and comes from the vendor, and I did not find independent confirmation. Both cost $0.12 per million text tokens, so test both.

Is Gemini Embedding 2 worth the higher price?#

For audio, video or mixed media in one index, it can be. For text-only retrieval, I would want a clear win on my own evaluation to justify paying more than three times the price of voyage-4.

Should I still use OpenAI text-embedding-3-small?#

Yes, when you want a cheap, simple baseline or OpenAI is already approved. It costs $0.02 per million tokens. Test voyage-4-lite at the same price if longer inputs would help.

Does Google's free tier work for production?#

I would avoid it for anything confidential, because free-tier content can be used to improve Google's products. It is useful for experiments with non-sensitive data.

How many dimensions should I use?#

Start at 1,024, or 1,536 with Gemini. Go higher only if your evaluation shows a meaningful improvement, since storage and memory grow with dimension.

Do I need a reranker as well?#

Often, and it is worth testing early. In the financial study above, hybrid search plus a reranker improved nDCG@10 from 0.466 to 0.683, far beyond the differences between most embedding models in the tests here.

A practical implementation path#

Start with voyage-4 and a cheap baseline, using the same chunks and real queries. Add hybrid search and a reranker, then test voyage-4-large or embed-v5.0-pro only if the result still falls short. Sort out your data settings before any real content leaves your systems.

If you need help choosing and integrating these, I build custom RAG systems with model evaluation, ingestion pipelines, access rules and source citations. Tell me about your documents and goals.