The best embedding models in November 2026 are Voyage AI's voyage-4-large ($0.12 per million tokens), which ranks first on the MTEB leaderboard's retrieval benchmark (RTEB), and Microsoft's open-weight harrier-oss-v1-27b, which ranks first on the multilingual MTEB with a mean score of 74.27. For most new search and RAG projects, OpenAI's text-embedding-3-small at $0.02 is still the sensible default to test first.
The right pick depends on your languages, your documents and how many vectors you store, and leaderboard gaps of one or two points rarely survive contact with real data. Below are the current leaders with their prices, dimensions and maximum input, the open-weight options, and a 30-minute recipe with code to compare candidates on your own queries. All scores were read from the MTEB leaderboard on 5 November 2026, and prices are each provider's list price per million input tokens.
What are embedding models?
An embedding model turns a piece of text into a fixed-length list of numbers, a vector, so that texts with similar meaning end up close together. You embed your documents once, store the vectors in a vector database, embed each user query at search time, and return the documents whose vectors are nearest to the query (usually by cosine similarity). That is the retrieval step of RAG, and it also powers semantic search, deduplication, clustering and classification.
Text embedding models are priced on input tokens only, since they produce no text. Three numbers describe each one in practice:
- Maximum input: the longest text one call can embed, from 2,048 tokens (gemini-embedding-001) to 128,000 (Cohere Embed 5). Longer text is cut off or rejected, so it sets your chunk size.
- Dimensions: the length of each vector, from 384 to 5,376 in the tables below. More dimensions means more storage and slower search.
- Quality: how often the right document lands in the top results, which is what MTEB and RTEB try to measure.
Vectors from different models can't be compared. Switching models means re-embedding every document, so the choice matters more than it looks.
Best embedding models at a glance
- Best retrieval from an API: voyage-4-large ($0.12), first on RTEB Multilingual. Cohere's embed-v5.0-pro ($0.12, released 30 September 2026) is the alternative if you need 128K-token inputs or images.
- Low-cost default: text-embedding-3-small ($0.02, 1,536 dimensions) or voyage-4-lite ($0.02, with 200 million free tokens).
- Google stack: gemini-embedding-001 ($0.15) is the highest-ranked API model with complete multilingual MTEB results; gemini-embedding-2 ($0.20) adds images, audio, video and PDFs.
- Self-hosted, highest scores: harrier-oss-v1-27b (MIT license) or Qwen3-Embedding-8B (Apache 2.0).
- Self-hosted retrieval: NVIDIA's Nemotron-3-Embed-8B, second on RTEB.
- On a laptop or CPU: harrier-oss-v1-0.6b (MIT) or EmbeddingGemma 2 (Apache 2.0).
- Code search: voyage-code-4 ($0.12), released 13 August 2026 for coding agents.

The MTEB leaderboard in November 2026
The Massive Text Embedding Benchmark (MTEB) runs each model through the same tasks and publishes the results. Its leaderboard features three boards on its home page: Multilingual (MTEB v2, also called MMTEB: 131 tasks across more than 250 languages), English (MTEB v2: 41 tasks) and RTEB Multilingual (30 retrieval-only tasks in legal, finance, code and healthcare).
Three things to know before reading the tables:
- The Rank column is a Borda count across tasks, not the mean score, so a model with a higher mean can sit lower. As GitHub discussion #3706 explains, missing tasks count as zero, which is why API models with incomplete runs (OpenAI's among them) rank low.
- The Zero-shot column shows how much of the benchmark a model did not train on. Several English leaders show 43% to 51%, meaning they trained on data from about half of the test tasks.
- Retr. is the average retrieval score (nDCG@10). For search and RAG it matters more than the overall mean, which also averages classification and clustering.
Multilingual (MTEB v2), top ranks on 5 November 2026
| Rank | Model | Mean (Task) | Retrieval | Size | Dimensions | Max input | License or price |
|---|---|---|---|---|---|---|---|
| 1 | harrier-oss-v1-27b (Microsoft) | 74.27 | 78.27 | 27B | 5,376 | 32,768 | MIT |
| 2 | KaLM-Embedding-Gemma3-12B-2511 (Tencent) | 72.32 | 75.66 | 11.8B | 3,840 | 32,768 | Tencent community license |
| 3 | llama-embed-nemotron-8b (NVIDIA) | 69.46 | 68.69 | 7.5B | 4,096 | 32,768 | NVIDIA license |
| 4 | Qwen3-Embedding-8B (Alibaba) | 70.58 | 70.88 | 7.6B | up to 4,096 | 32,768 | Apache 2.0 |
| 5 | gemini-embedding-001 (Google) | 68.37 | 67.71 | not disclosed | up to 3,072 | 2,048 | $0.15 |
| 6 | Qwen3-Embedding-4B | 69.45 | 69.60 | 4.0B | up to 2,560 | 32,768 | Apache 2.0 |
| 10 | harrier-oss-v1-0.6b | 69.01 | 70.75 | 0.6B | 1,024 | 32,768 | MIT |
| 20 | Qwen3-Embedding-0.6B | 64.34 | 64.65 | 0.6B | up to 1,024 | 32,768 | Apache 2.0 |
| 45 | text-embedding-3-large (OpenAI) | incomplete | 59.32 | not disclosed | up to 3,072 | 8,192 | $0.13 |
| 50 | voyage-3.5 (previous Voyage generation) | 58.46 | 64.01 | not disclosed | 1,024 | 32,000 | $0.06 |
Microsoft released the harrier-oss-v1 family on 30 March 2026, and its model card lists 32,768 tokens as the maximum input (the leaderboard lists 131,072 for the 27B model). Gemini Embedding 001 is the only API model in the top ten. OpenAI's text-embedding-3 models have no complete MTEB v2 run, so the retrieval column is the fair comparison: 59.32 for text-embedding-3-large against 67.71 for gemini-embedding-001.
English (MTEB v2)
The English board is where the zero-shot column matters most. The first-ranked model, ingot-8b-r3 (mean 75.98), is gated on Hugging Face under a proprietary license. Second and third (Jasper-Token-Compression-600M and QZhou-Embedding) show 48% zero-shot. The best fully zero-shot results come from Qwen3-Embedding-8B (rank 5, mean 75.22, retrieval 69.44) and gemini-embedding-001 (rank 9, mean 73.30, retrieval 64.35), both at 95%.
Retrieval only: RTEB
RTEB was built to resist overfitting by mixing public and private datasets. On 14 January 2026 the maintainers removed the private column because Voyage, which co-developed RTEB, had access to the private data. The page now shows ranks with mostly blank means. On 5 November 2026 the order was:
| RTEB rank | Model | Price per 1M tokens | Max input | Dimensions |
|---|---|---|---|---|
| 1 | voyage-4-large (2,048 dimensions) | $0.12 | 32,000 | 256 to 2,048 |
| 2 | Nemotron-3-Embed-8B (NVIDIA, open weights) | self-hosted | 32,768 | 4,096 |
| 3 | Octen-Embedding-8B (open weights) | self-hosted | 32,768 | 4,096 |
| 5 | embed-v5.0-pro (Cohere) | $0.12 | 128,000 | 256 to 2,048 |
| 13 | voyage-4 | $0.06 | 32,000 | 256 to 2,048 |
| 14 | gemini-embedding-001 | $0.15 | 2,048 | 128 to 3,072 |
| 15 | embed-v5.0-fast (Cohere) | $0.08 | 128,000 | 256 to 2,048 |
| 17 | Qwen3-Embedding-8B | self-hosted | 32,768 | up to 4,096 |
| 23 | voyage-4-lite | $0.02 | 32,000 | 256 to 2,048 |
| 41 | text-embedding-3-large | $0.13 | 8,192 | up to 3,072 |
| 56 | text-embedding-3-small | $0.02 | 8,192 | up to 1,536 |
NVIDIA's launch post (16 July 2026) reports 78.5% on RTEB for Nemotron-3-Embed-8B in its own evaluation. Given the history, treat Voyage's first place as strong but not independent evidence, and test it against one of the open models.
Hosted embedding APIs: price, dimensions and max input

| Model | Price per 1M tokens | Batch price | Max input | Dimensions | Notes |
|---|---|---|---|---|---|
| text-embedding-3-small (OpenAI) | $0.02 | $0.01 | 8,192 | 1,536 default, shorter on request | Normalized vectors |
| text-embedding-3-large (OpenAI) | $0.13 | $0.065 | 8,192 | 3,072 default, shorter on request | |
| gemini-embedding-001 (Google) | $0.15 | $0.075 | 2,048 | 128 to 3,072 | Text only, task_type parameter |
| gemini-embedding-2 (Google) | $0.20 text, $0.45 images | $0.10 text | 8,192 | 128 to 3,072 | Text, images, video, audio, PDF |
| voyage-4-large (Voyage AI) | $0.12 | 33% off | 32,000 | 256, 512, 1,024, 2,048 | 200M free tokens |
| voyage-4 | $0.06 | 33% off | 32,000 | same | 200M free tokens |
| voyage-4-lite | $0.02 | 33% off | 32,000 | same | 200M free tokens |
| voyage-code-4 | $0.12 | 33% off | 32,000 | same | Code retrieval |
| embed-v5.0-pro (Cohere) | $0.12 text, $0.40 images | 128,000 | 256 to 2,048 | Text, images, PDF pages | |
| embed-v5.0-fast (Cohere) | $0.08 text, $0.40 images | 128,000 | 256 to 2,048 | Shares Pro's vector space |
Sources: OpenAI pricing and embeddings guide, Gemini API pricing and embeddings docs, Voyage pricing on MongoDB's docs and the Voyage Batch API post, Cohere's Embed 5 announcement and model docs. OpenAI's and Google's batch modes cost half; Voyage's batch takes up to 12 hours and costs a third less.
What these prices mean in practice: embedding a 100-million-token corpus costs $2 with text-embedding-3-small or voyage-4-lite, $12 with voyage-4-large or embed-v5.0-pro, $13 with text-embedding-3-large and $15 with gemini-embedding-001. For voyage-4-large the first 200 million tokens are free, so that corpus costs nothing. Embedding is rarely the large line on a RAG bill; the LLM API cost per month post works through a RAG example where embeddings come to $0.14 of a $1,370 month.
Two newer features change the math:
- Shared embedding spaces. All Voyage 4 models produce compatible vectors, so you can embed documents once with voyage-4-large and queries with voyage-4-lite (Voyage 4 announcement, 15 January 2026). Cohere's Embed 5 Pro and Fast work the same way. Google warns the opposite for its own models: gemini-embedding-001 and gemini-embedding-2 vectors are incompatible, so upgrading means re-embedding everything.
- Shorter vectors. Every API model above lets you request fewer dimensions. Google's embeddings guide shows MTEB scores barely moving from 1,536 down to 768 dimensions (68.17 to 67.99), with a sharper drop at 128 (63.31).
Open-weight embedding models
Open weights let you embed on your own GPUs, keep data in your own network, and fine-tune on your domain. The license matters more than the score for commercial use.
| Model | Released | License | Parameters | Dimensions | Max input | MMTEB v2 mean |
|---|---|---|---|---|---|---|
| harrier-oss-v1-27b | 30 Mar 2026 | MIT | 27B | 5,376 | 32,768 | 74.27 |
| Qwen3-Embedding-8B | 3 Jun 2025 | Apache 2.0 | 7.6B | 32 to 4,096 | 32,768 | 70.58 |
| Nemotron-3-Embed-8B | 16 Jul 2026 | OpenMDW-1.1 | about 8B | 4,096, can be sliced | 32,768 | not run |
| harrier-oss-v1-0.6b | 30 Mar 2026 | MIT | 0.6B | 1,024 | 32,768 | 69.01 |
| harrier-oss-v1-270m | 30 Mar 2026 | MIT | 270M | 640 | 32,768 | 66.55 |
| Qwen3-Embedding-0.6B | 3 Jun 2025 | Apache 2.0 | 0.6B | 32 to 1,024 | 32,768 | 64.34 |
| EmbeddingGemma 2 | 14 Sep 2026 | Apache 2.0 | 270M text, 740M with all encoders | 128 to 768 | 8,192 | 60.52 |
| voyage-4-nano | 15 Jan 2026 | Apache 2.0 | 340M | 256 to 2,048 | 32,000 | not run |
| BAAI/bge-m3 | Jan 2024 | MIT | 568M | 1,024 | 8,192 | incomplete |
Dates are the model card's release date or announcement, otherwise the Hugging Face upload date. A few notes from the model cards:
- Qwen3-Embedding expects a one-sentence task instruction on queries (not documents). Its card says leaving it out can cost about 1% to 5% in retrieval.
- Nemotron-3-Embed-8B is marked ready for commercial use and needs
query:andpassage:prefixes. A 1B version, Nemotron-3-Embed-1B, ranks 16th on RTEB. - EmbeddingGemma 2 embeds text, images, video and audio into 768 dimensions, and loads as a 270M text-only model if you drop the vision and audio encoders. Its card reports 61.36 on multilingual MTEB; the leaderboard shows 60.52.
- voyage-4-nano shares the Voyage 4 vector space, so you can prototype locally and switch queries or documents to the paid API later without re-embedding.
- Jina's v5 text models score well (jina-embeddings-v5-text-nano is 21st on multilingual MTEB at 212M parameters) but carry a CC-BY-NC-4.0 license, which bars commercial use.
For a quick start, harrier-oss-v1-0.6b or Qwen3-Embedding-0.6B runs on a single consumer GPU or a laptop. On multilingual MTEB, harrier-oss-v1-0.6b scores 69.01, about five points below its 27B sibling at a 45th of the size.
How to pick an embedding model
Leaderboards narrow the field; these constraints usually decide it.
- Languages. If your users write in more than English, read the multilingual board and test with real non-English queries. Many models favor documents in the query's language even when a better answer exists in another, which a commenter quoted below calls same-language bias.
- Document length. If your chunks run past 2,048 tokens, gemini-embedding-001 is out. Past 8,192, OpenAI is out. Voyage (32,000) and Cohere Embed 5 (128,000) take whole documents, though smaller chunks often retrieve better.
- Domain. Code, legal and finance text behave differently from web pages. Use RTEB's per-domain views and a domain model such as voyage-code-4 where one exists.
- Storage and latency. A 3,072-dimension float vector is 12 KB. Multiply by your chunk count before you choose.
- Where data may go. Self-hosting keeps text inside your network; the zero data retention guide covers which hosted APIs keep nothing.
- Lock-in. Every switch is a full re-embed, so prefer a family with smaller compatible models (Voyage 4, Cohere Embed 5) or open weights you control.

| Vector format | Bytes per vector | 10 million chunks |
|---|---|---|
| 3,072 dimensions, float32 | 12,288 | 122.88 GB |
| 1,536 dimensions, float32 | 6,144 | 61.44 GB |
| 1,024 dimensions, float32 | 4,096 | 40.96 GB |
| 768 dimensions, float32 | 3,072 | 30.72 GB |
| 1,024 dimensions, int8 | 1,024 | 10.24 GB |
| 1,024 dimensions, binary | 128 | 1.28 GB |
Vector databases add index overhead on top, and many keep vectors in memory, so the 12x gap between the first and fifth rows is often worth a point or two of retrieval quality.
How to evaluate embedding models on your own data in 30 minutes
Public benchmarks don't contain your documents or your users' questions. A small private test answers the only question that matters: which model puts the right chunk in the top 10 for your queries.
- Export 500 to 5,000 chunks from your real corpus, chunked the way production will chunk them.
- Write or collect 50 to 100 real queries (search logs, support tickets) and mark the chunk or chunks that answer each one. This is most of the 30 minutes.
- Embed the chunks and queries with each candidate, using the model's query and document instructions.
- Rank chunks by cosine similarity and compute recall@10, MRR@10 and nDCG@10.
- Pick the model with the best recall@10 at a price and dimension count you can live with, then re-run when a new model ships.
The script below scores any number of candidates. Metrics are plain Python; local models use sentence-transformers (6.2.0, released 21 October 2026) and API models use the OpenAI SDK, which works with any OpenAI-compatible embeddings endpoint.
import json, math, os
from openai import OpenAI
from sentence_transformers import SentenceTransformer
# data: chunks.jsonl -> {"id": "...", "text": "..."}
# queries.jsonl -> {"query": "...", "relevant": ["chunk-id", ...]}
chunks = [json.loads(l) for l in open("chunks.jsonl")]
queries = [json.loads(l) for l in open("queries.jsonl")]
ids = [c["id"] for c in chunks]
def unit(v):
n = math.sqrt(sum(x * x for x in v)) or 1.0
return [x / n for x in v]
def rank(q_vecs, d_vecs, k=10):
docs = [unit(d) for d in d_vecs]
out = []
for q in q_vecs:
q = unit(q)
s = [sum(a * b for a, b in zip(q, d)) for d in docs]
out.append(sorted(range(len(docs)), key=lambda i: -s[i])[:k])
return out
def score(ranked, relevant, k=10):
r = mrr = ndcg = 0.0
for top, rel in zip(ranked, relevant):
hits = [1 if ids[i] in rel else 0 for i in top[:k]]
r += sum(hits) / len(rel)
mrr += next((1 / (i + 1) for i, h in enumerate(hits) if h), 0.0)
idcg = sum(1 / math.log2(i + 2) for i in range(min(len(rel), k)))
ndcg += sum(h / math.log2(i + 2) for i, h in enumerate(hits)) / idcg
n = len(ranked)
return {"recall@10": round(r / n, 3), "mrr@10": round(mrr / n, 3), "ndcg@10": round(ndcg / n, 3)}
def api_embedder(model, base_url=None, key_env="OPENAI_API_KEY", **extra):
client = OpenAI(base_url=base_url, api_key=os.environ[key_env])
def embed(texts, is_query):
out = []
for i in range(0, len(texts), 256): # stay under per-request input limits
resp = client.embeddings.create(model=model, input=texts[i:i + 256], **extra)
out += [d.embedding for d in resp.data]
return out
return embed
def local_embedder(name, **kw):
m = SentenceTransformer(name, **kw)
def embed(texts, is_query):
f = m.encode_query if is_query else m.encode_document # applies the model's prompts
return f(texts, batch_size=32).tolist()
return embed
CANDIDATES = {
"text-embedding-3-small": api_embedder("text-embedding-3-small"),
"text-embedding-3-large@1024": api_embedder("text-embedding-3-large", dimensions=1024),
"Qwen3-Embedding-0.6B": local_embedder("Qwen/Qwen3-Embedding-0.6B"),
"harrier-oss-v1-0.6b": local_embedder("microsoft/harrier-oss-v1-0.6b"),
}
relevant = [set(q["relevant"]) for q in queries]
for name, embed in CANDIDATES.items():
d = embed([c["text"] for c in chunks], is_query=False)
q = embed([x["query"] for x in queries], is_query=True)
print(name, score(rank(q, d), relevant))
The metric functions were run on a hand-checked toy set before publishing. For a corpus beyond about 20,000 chunks, swap the pure-Python ranking for numpy or your vector database's own search. Two habits keep the test honest: write the queries before looking at any model's results, and include questions your current search gets wrong. If two models land within a point of recall@10, choose on price, dimensions and license.
What developers report
- A Hacker News commenter who built a retrieval model said MTEB rankings mislead: "those benchmarks are gamed and they don't reflect real-world performance well" (Hacker News, 10 Oct 2026, link)
- On Microsoft's open release, another commenter noted that harrier "tops the MTEB leaderboard for the largest model (27b)" and that the 0.6B and 270M versions lead their sizes (Hacker News, 7 Apr 2026, link)
- A developer of a 23M-parameter model reported about 22 documents and 120 queries per second on a 2-vCPU server, a reminder that small models are often fast enough for CPU serving (Hacker News, 15 Jan 2026, link)
- The MTEB maintainers, explaining why RTEB's private results were hidden, called Voyage's access to that data "an undeniable structural advantage" (MTEB GitHub issue #3934, 14 Jan 2026, link)
- Google's embedding docs say performance "is not strictly tied to the size of the embedding dimension" (Gemini API embeddings guide, checked 5 Nov 2026, link)
Using embedding models through Aight
Aight documents POST /v1/embeddings alongside chat completions, behind one OpenAI-compatible key. Its models page lists three embedding models at the makers' list prices: text-embedding-3-small ($0.02), text-embedding-3-large ($0.13) and gemini-embedding-001 ($0.15, 2,048-token input). That suits teams that already call chat models through Aight and want embeddings on the same balance, with a per-key monthly cap.
Where another route works better: Aight documents no batch endpoint, so a large one-off indexing job costs half as much through OpenAI's or Google's Batch API. Voyage 4, Cohere Embed 5, gemini-embedding-2 and the open-weight models above aren't in Aight's catalog, and voyage-4-lite's 200 million free tokens beat any paid route for a first index. Every recharge adds 10% extra balance, about $0.94 per $1 of list-price usage after the 3% processing fee outside India. The best LLM API guide and one API key for every model cover the chat side.
import os
from openai import OpenAI
client = OpenAI(base_url="https://api.getaight.ai/v1", api_key=os.environ["AIGHT_API_KEY"]) # sk-aight-...
resp = client.embeddings.create(model="text-embedding-3-small",
input=["How do I reset my password?", "Billing FAQ"])
print(len(resp.data), len(resp.data[0].embedding))
In the evaluation script, api_embedder("text-embedding-3-small", base_url="https://api.getaight.ai/v1", key_env="AIGHT_API_KEY") points a candidate at the same endpoint.
FAQ
What is the best embedding model for RAG?
For hosted retrieval, voyage-4-large leads RTEB at $0.12 per million tokens, with Cohere's embed-v5.0-pro close behind at the same price. If cost matters more, text-embedding-3-small or voyage-4-lite at $0.02 is the place to start. Run the 30-minute test above before committing, because domain and language change the order.
Is OpenAI's text-embedding-3-small still good in 2026?
It is still one of the two lowest-priced hosted models at $0.02 per million tokens, with 8,192-token inputs and 1,536 dimensions. It is no longer near the top of any leaderboard: it ranks 56th on RTEB, against 23rd for voyage-4-lite at the same price. It remains a reasonable default where you already use OpenAI, but test voyage-4-lite beside it.
What is the best open-source embedding model?
On multilingual MTEB, harrier-oss-v1-27b (MIT) has the top score, 74.27, and Qwen3-Embedding-8B (Apache 2.0) the best fully zero-shot result among 8B models. For retrieval specifically, NVIDIA's Nemotron-3-Embed-8B ranks second on RTEB. For small hardware, harrier-oss-v1-0.6b, Qwen3-Embedding-0.6B and EmbeddingGemma 2 are the practical choices.
How many dimensions does an embedding need?
Usually 768 to 1,024. Google's MTEB figures show 768 dimensions within 0.2 points of 1,536, and all the API models above let you request shorter vectors. Test your chosen size in the evaluation, since a 3,072-dimension index costs four times the storage of a 768-dimension one.
Can you switch embedding models without re-embedding?
Only inside a family that shares one vector space: Voyage 4 (including the open voyage-4-nano) and Cohere Embed 5 Pro and Fast. Everywhere else, including moving from gemini-embedding-001 to gemini-embedding-2, you must re-embed every document. Keep the source text and chunk IDs so a re-embed is a batch job, not a migration.
Is the MTEB leaderboard reliable?
It is the best shared reference, with caveats: ranks are Borda counts that punish incomplete runs, some top English models trained on about half the test data, and RTEB's private results are hidden after a fairness dispute. Use it to shortlist three models, not to pick one.
Sources
- MTEB: leaderboard (Multilingual v2, English v2 and RTEB Multilingual pages, read 5 Nov 2026), mteb on GitHub, issue #3934 on RTEB's private column, discussion #3706 on ranking
- OpenAI: Pricing, Embeddings guide, text-embedding-3-large, Batch API
- Google: Gemini API pricing, Embeddings, Gemini Embedding 2 announcement, EmbeddingGemma 2
- Voyage AI and MongoDB: Billing and prices, Text embedding models, Voyage 4, Batch API, voyage-code-4, voyage-4-nano
- Cohere: Embed 5 announcement, Embed models, Pricing
- Microsoft: harrier-oss-v1-27b
- NVIDIA: Nemotron-3-Embed-8B, Nemotron 3 Embed ranks first on RTEB
- Alibaba Qwen: Qwen3-Embedding-8B
- Other model cards: Octen-Embedding-8B, KaLM-Embedding-Gemma3-12B-2511, jina-embeddings-v5-text-small, BAAI/bge-m3, ingot-8b-r3
- Sentence Transformers: SentenceTransformer reference, sentence-transformers on PyPI
- Hacker News: MTEB scores thread, Harrier release thread, Local RAG thread
- Aight: Models and pricing, API reference, Refund policy
Checked on 5 November 2026.