Best Embedding Models and APIs in 2026: OpenAI, Voyage, Cohere and Open Weights Compared

An embedding model turns text into a list of numbers so that similar meaning lands close together in that number space. That is the entire idea, and every product in this post is a variation on it. What changed in 2026 is the lineup: Voyage AI shipped a 4-series after MongoDB's $220 million acquisition closed, Google shipped a genuinely multimodal Gemini Embedding 2 for the cloud and a 308-million-parameter EmbeddingGemma for on-device use, Cohere pushed Embed v4 to a 128,000-token context window, and the open-weight models, Qwen3-Embedding chief among them, stopped being the budget option and started beating the APIs outright on public benchmarks.

If you built your embedding pipeline in 2024 on ada-002 or an early open model, most of this guide is new information. Every price below came from the provider's own pricing page in August 2026, and the similarity numbers later in this post came from a real model running on a laptop, not a made-up example.

What You're Actually Buying

Three things vary between embedding models, and they matter more than the marketing copy: the dimension count (how many numbers per vector, which drives your storage and search cost), the context window (how much text one embedding call can see at once), and whether it does one language or a hundred. A fourth property, Matryoshka Representation Learning, is worth knowing before you read a single spec sheet, because most 2026 models use it.

A Matryoshka-trained model packs the most important information into the first dimensions of its output vector, so you can truncate a 3072-dimension embedding down to 256 and keep most of the retrieval quality, cutting your storage and search cost by 12x with one line of code. OpenAI's text-embedding-3 models, Voyage's 4-series, and Qwen3-Embedding all support this natively, with a dimensions parameter or a slice operation. Not every model was trained this way, and truncating one that was not trained for it degrades quality faster, which is exactly what the experiment below shows.

Every model below is one of two shapes: a hosted API you call over HTTP and pay per token, or open weights you download and run yourself for free. The rest of this guide is organized that way, hosted first, then open weights, followed by a decision table and a real embedding computed locally.

Quick Comparison

The Hosted APIs

OpenAI: The Default, Still Cheap

The safe, unglamorous choice, and still the cheapest at the small tier. text-embedding-3-small and text-embedding-3-large have not moved in price since their January 2024 launch: $0.02 and $0.13 per million tokens, with the Batch API cutting both in half for anything that can wait 24 hours. The legacy text-embedding-ada-002 is still available at $0.10 per million but there is no reason to start a new project on it. Both current models support Matryoshka truncation through the dimensions parameter, down to a minimum of 512 for 3-small and 256 for 3-large.

If you have no reason to switch providers, this is still the safe default: cheapest at the small tier, an 8,191-token context that covers most chunking strategies, and the widest ecosystem of libraries that assume it.

Voyage: MongoDB's Retrieval Team, Repriced

200 million free tokens make it the cheapest model here to actually test. Voyage AI became part of MongoDB in February 2025 for $220 million, and rather than fold into a single MongoDB-only offering it kept shipping independently through voyage.ai and both major cloud marketplaces. The current lineup is voyage-4-large, voyage-4, voyage-4-lite, plus domain-specific models for code, law, and finance, all priced per million tokens with the first 200 million tokens free on every account.

voyage-4-large is $0.12 per million tokens with a 32,000-token context, four times OpenAI's window, which matters if you embed whole documents instead of small chunks. Every model in the 4-series, including the cheaper 4-lite, shares the same Matryoshka range: 1,024 dimensions by default, selectable down to 256 or up to 2,048, so the lite tier is a price cut rather than a smaller vector. Voyage has published benchmarks claiming voyage-3-large beat text-embedding-3-large by close to 10 percent across 100 retrieval datasets; treat any single vendor's own benchmark as directional, not proof, but the free 200 million tokens make it cheap to test that claim on your own data before committing.

Cohere: The Long-Context, Multimodal Option

16x the context window of OpenAI, in one model that also does images. Embed v4 is Cohere's answer to mixed-content search: one model for text, images, and mixed documents like PDFs, at $0.12 per million text tokens and $0.47 per million image tokens. Its headline spec is context length: 128,000 tokens against OpenAI's 8,191 and Voyage's 32,000, which changes what you can embed in a single call from a paragraph to a full contract.

Output dimensions are selectable at 256, 512, 1024, or the 1536 default, the same Matryoshka pattern as OpenAI and Voyage. If your corpus is genuinely mixed text and images, PDFs with charts, product listings with photos, this is the model built for that rather than one bolted on.

Gemini Embedding 2: Text, Image, Audio, and Video in One Model

The only model here that embeds video at all. Gemini Embedding 2 is Google's first embedding model to handle all five modalities natively: text, image, audio, video, and PDF, in over 100 languages. Pricing is per modality and the spread is large: $0.20 per million text tokens, $0.45 per million image tokens, $6.50 per million audio tokens, and $12.00 per million video tokens, with batch processing halving every rate.

Text-only, this is the most expensive API here at $0.20 per million against Voyage's $0.12 and OpenAI's $0.13. Its case is multimodal search where nothing else lets you embed video and text into the same vector space at all, so the comparison to text-only competitors on price alone misses the point of the product.

The Open Weights, and Why They Now Compete

Qwen3-Embedding: Apache 2.0, and Near the Top of the Leaderboard

Genuinely open, and it beats hosted APIs on public benchmarks. Qwen3-Embedding's model card states it ranked first on the MTEB multilingual leaderboard as of June 2025, scoring 70.58, and it is genuinely Apache 2.0, not the more restrictive license some aggregator sites report. It comes in 0.6B, 4B, and 8B sizes, supports over 100 natural and programming languages, and outputs Matryoshka embeddings configurable from 32 to 4,096 dimensions, with a 32,000-token context window.

Running the 8B variant needs a real GPU, but the 0.6B model is small enough for CPU inference and still competitive, which makes this the model worth trying first if you want to self-host and are not sure how much compute you can spare.

BGE-M3: The Workhorse

One model does dense, sparse, and keyword-style search all at once. BGE-M3 is MIT licensed, covers over 100 languages, and does something the API-first models here do not: it produces dense, sparse, and multi-vector (ColBERT-style) representations from the same model in one pass, so you can combine semantic and keyword-style retrieval without running two separate systems.

Most production RAG stacks that self-host default to BGE-M3 for exactly this reason: it is the reasonable, well-supported choice rather than the highest scorer on any single benchmark, and the license carries no restrictions at all.

EmbeddingGemma: Built to Run on the Device, Not a Server

Under 200MB of RAM, and it never has to call an API. EmbeddingGemma is Google's 308-million-parameter embedding model, built on Gemma 3 and released in September 2025, and it targets a use case none of the models above do: running entirely offline on a phone, laptop, or edge device with no API call and no GPU. Google's own numbers are specific about it: under 200MB of RAM with quantization, and embeddings generated in under 22 milliseconds on an EdgeTPU.

It supports over 100 languages, a 2,048-token context, and the same Matryoshka pattern as the larger models, selectable from 768 dimensions down to 128. One distinction worth getting right: it ships under Google's Gemma Terms of Use, not a permissive license like Qwen3-Embedding's Apache 2.0 or BGE-M3's MIT. That license permits commercial use but carries usage restrictions and a click-through agreement on Hugging Face, so check it before you assume it is a drop-in open-source dependency the way the other three are.

Nomic Embed v2: Small, Fast, Apache 2.0

No usage restrictions, and cheap enough to run at real scale. Nomic Embed v2 trades context length and dimension count for size: a 768-dimension, 512-token-context model built to run cheaply at scale, released under Apache 2.0. Against EmbeddingGemma it is the more permissively licensed option at a similar size; against Qwen3-Embedding-8B it will not out-benchmark a model more than ten times its size, but for high-volume, short-text workloads like search-as-you-type or tagging, a smaller model that is fast enough to run on commodity hardware is often the more practical choice than a bigger one you have to queue requests for.

Verified Locally: What Cosine Similarity Actually Measures

Every model in this post outputs vectors compared the same way. Here is the whole thing, run with sentence-transformers 5.x and a real open embedding model on a laptop CPU, no API key needed:

Python
Copy
from sentence_transformers import SentenceTransformer
import numpy as np

model = SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2")
sentences = [
    "The cat sat on the mat.",
    "A feline rested on the rug.",
    "The stock market fell sharply today.",
]
emb = model.encode(sentences, normalize_embeddings=True)

def cos(a, b):
    return float(np.dot(a, b))  # already normalized, so this is cosine similarity

print(f"sim(cat/feline)  = {cos(emb[0], emb[1]):.4f}")
print(f"sim(cat/stock)   = {cos(emb[0], emb[2]):.4f}")

Output:

text
Copy
sim(cat/feline)  = 0.5560
sim(cat/stock)   = 0.0747

Two sentences about a cat sitting somewhere score seven times higher on similarity than one about a cat and one about the stock market, despite sharing zero words with the first sentence beyond "The". That gap is the entire value proposition of every model in this post over a keyword match, which is why our Word Frequency Counter would find these two cat sentences almost entirely dissimilar (they share one function word) while a proper embedding model correctly reads them as close in meaning.

Now the Matryoshka claim, tested on the same three sentences by truncating the 384-dimension output down to 128 and 64 dimensions and re-normalizing:

text
Copy
Full 384 dims:      sim(cat/feline) = 0.5560   sim(cat/stock) = 0.0747
Truncated 128 dims:  sim(cat/feline) = 0.5622   sim(cat/stock) = 0.1356
Truncated 64 dims:   sim(cat/feline) = 0.6013   sim(cat/stock) = 0.2290

The cat/feline pair stays clearly higher than cat/stock at every size, but the gap narrows as dimensions drop, since MiniLM was not trained with a Matryoshka objective and this is a naive truncation rather than the trained kind. A model actually trained for it, like text-embedding-3 or Qwen3-Embedding, degrades far more gracefully, which is the entire point of training for it rather than truncating an arbitrary model and hoping.

How to Pick

Default choice, no strong constraints: text-embedding-3-small. Cheapest hosted option, native Matryoshka support, and the ecosystem assumes it.

You need more than 8,191 tokens of context per embedding: Cohere Embed v4 at 128,000 tokens, or Voyage at 32,000 if that is enough and you want the lower price.

Your corpus includes images or PDFs with real visual content: Cohere Embed v4 for text-plus-image, Gemini Embedding 2 if you also need audio or video in the same vector space.

You want to self-host and keep every option open: Qwen3-Embedding, genuinely Apache 2.0, competitive with the hosted APIs, and small enough at 0.6B to run without a serious GPU.

You need hybrid dense-plus-keyword search from one model: BGE-M3, MIT licensed, purpose-built for exactly that.

Embeddings need to run on-device, offline, with no server at all: EmbeddingGemma, built for exactly that at under 200MB of RAM, with Nomic Embed v2 as the more permissively licensed alternative if the Gemma terms are a problem for your use case.

High query volume, short text, cost-sensitive: Nomic Embed v2 or Voyage 4-lite, both built to be cheap at scale rather than to top a leaderboard.

Getting an Embedding Pipeline Right

1. Redact before you embed. Anything you send to a third-party API is leaving your infrastructure. Strip emails, keys, and account numbers first with our PII Redactor.
2. Deduplicate your corpus. Near-duplicate chunks waste embedding spend and crowd out genuinely different results in a retrieval query; catch exact repeats with our Remove Duplicate Lines before the more expensive step of embedding everything.
3. Read batch API output correctly. OpenAI's and Voyage's batch endpoints return JSON Lines, one JSON object per line rather than one array. Our NDJSON to JSON Converter turns that into a normal array for inspection.
4. Pick a chunk size that fits the context window you are actually paying for. An 8,191-token limit on OpenAI wasted on 200-token chunks is a design choice, not a constraint; check real token counts rather than estimating.
5. Spot-check a sample before embedding everything. Export a few hundred rows of text plus your intended metadata to a spreadsheet-friendly format with our JSON to CSV Converter and read them before running the full job.
6. Version your embeddings with your model choice. Vectors from two different models, or even two dimension settings of the same model, are not comparable. Store which model and dimension count produced each vector.

Conclusion

The gap between paying for embeddings and running them yourself narrowed sharply this year: Qwen3-Embedding is genuinely open, genuinely competitive, and genuinely free, which was not true of the open-weight options in 2024. The hosted APIs earned their keep elsewhere, in context length (Cohere's 128K), true multimodality (Gemini Embedding 2), and not having to manage GPU infrastructure at all (OpenAI, Voyage). Pick on the dimension you actually need, not on whichever benchmark number is easiest to find, and verify a candidate model against your own data with a free tier before committing a pipeline to it.

Related DevToolLab Tools

• Word Frequency Counter - See exactly why keyword matching misses what an embedding catches, by counting shared words between two sentences yourself.
• PII Redactor - Strip sensitive values from text before it leaves your infrastructure for a third-party embedding API.
• Remove Duplicate Lines - Cut near-duplicate rows out of a corpus before you pay to embed every one of them.
• NDJSON to JSON Converter - Turn a batch embedding API's JSON Lines output into a normal array you can inspect.

Related Guides

• Best Vector Databases in 2026 - where these embeddings actually get stored and searched
• Best RAG Platforms and Tools - the retrieval systems built on top of embedding search
• Best AI Fine-Tuning Platforms - when the answer is teaching a model behavior instead of retrieving facts
• LLM Evals Guide - measuring whether a retrieval pipeline is actually working, not just running

Prices, model lineups, and benchmark rankings change often. Verify current rates and scores on each provider's own page before committing to a model.