Blog

Best embedding models in November 2026: MTEB and RTEB scores next to price per 1M tokens

Ramashankar S · · Updated · 19 min read

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.
Decision guide: the best embedding model for each job, with an alternative, prices and leaderboard scores

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

RankModelMean (Task)RetrievalSizeDimensionsMax inputLicense or price
1harrier-oss-v1-27b (Microsoft)74.2778.2727B5,37632,768MIT
2KaLM-Embedding-Gemma3-12B-2511 (Tencent)72.3275.6611.8B3,84032,768Tencent community license
3llama-embed-nemotron-8b (NVIDIA)69.4668.697.5B4,09632,768NVIDIA license
4Qwen3-Embedding-8B (Alibaba)70.5870.887.6Bup to 4,09632,768Apache 2.0
5gemini-embedding-001 (Google)68.3767.71not disclosedup to 3,0722,048$0.15
6Qwen3-Embedding-4B69.4569.604.0Bup to 2,56032,768Apache 2.0
10harrier-oss-v1-0.6b69.0170.750.6B1,02432,768MIT
20Qwen3-Embedding-0.6B64.3464.650.6Bup to 1,02432,768Apache 2.0
45text-embedding-3-large (OpenAI)incomplete59.32not disclosedup to 3,0728,192$0.13
50voyage-3.5 (previous Voyage generation)58.4664.01not disclosed1,02432,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 rankModelPrice per 1M tokensMax inputDimensions
1voyage-4-large (2,048 dimensions)$0.1232,000256 to 2,048
2Nemotron-3-Embed-8B (NVIDIA, open weights)self-hosted32,7684,096
3Octen-Embedding-8B (open weights)self-hosted32,7684,096
5embed-v5.0-pro (Cohere)$0.12128,000256 to 2,048
13voyage-4$0.0632,000256 to 2,048
14gemini-embedding-001$0.152,048128 to 3,072
15embed-v5.0-fast (Cohere)$0.08128,000256 to 2,048
17Qwen3-Embedding-8Bself-hosted32,768up to 4,096
23voyage-4-lite$0.0232,000256 to 2,048
41text-embedding-3-large$0.138,192up to 3,072
56text-embedding-3-small$0.028,192up 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

Hosted embedding API prices per 1M tokens, with max input, dimensions and leaderboard position
ModelPrice per 1M tokensBatch priceMax inputDimensionsNotes
text-embedding-3-small (OpenAI)$0.02$0.018,1921,536 default, shorter on requestNormalized vectors
text-embedding-3-large (OpenAI)$0.13$0.0658,1923,072 default, shorter on request
gemini-embedding-001 (Google)$0.15$0.0752,048128 to 3,072Text only, task_type parameter
gemini-embedding-2 (Google)$0.20 text, $0.45 images$0.10 text8,192128 to 3,072Text, images, video, audio, PDF
voyage-4-large (Voyage AI)$0.1233% off32,000256, 512, 1,024, 2,048200M free tokens
voyage-4$0.0633% off32,000same200M free tokens
voyage-4-lite$0.0233% off32,000same200M free tokens
voyage-code-4$0.1233% off32,000sameCode retrieval
embed-v5.0-pro (Cohere)$0.12 text, $0.40 images128,000256 to 2,048Text, images, PDF pages
embed-v5.0-fast (Cohere)$0.08 text, $0.40 images128,000256 to 2,048Shares 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.

ModelReleasedLicenseParametersDimensionsMax inputMMTEB v2 mean
harrier-oss-v1-27b30 Mar 2026MIT27B5,37632,76874.27
Qwen3-Embedding-8B3 Jun 2025Apache 2.07.6B32 to 4,09632,76870.58
Nemotron-3-Embed-8B16 Jul 2026OpenMDW-1.1about 8B4,096, can be sliced32,768not run
harrier-oss-v1-0.6b30 Mar 2026MIT0.6B1,02432,76869.01
harrier-oss-v1-270m30 Mar 2026MIT270M64032,76866.55
Qwen3-Embedding-0.6B3 Jun 2025Apache 2.00.6B32 to 1,02432,76864.34
EmbeddingGemma 214 Sep 2026Apache 2.0270M text, 740M with all encoders128 to 7688,19260.52
voyage-4-nano15 Jan 2026Apache 2.0340M256 to 2,04832,000not run
BAAI/bge-m3Jan 2024MIT568M1,0248,192incomplete

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: and passage: 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.

  1. 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.
  2. 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.
  3. 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.
  4. Storage and latency. A 3,072-dimension float vector is 12 KB. Multiply by your chunk count before you choose.
  5. Where data may go. Self-hosting keeps text inside your network; the zero data retention guide covers which hosted APIs keep nothing.
  6. 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.
Raw vector storage for 10 million chunks at different dimensions and precisions
Vector formatBytes per vector10 million chunks
3,072 dimensions, float3212,288122.88 GB
1,536 dimensions, float326,14461.44 GB
1,024 dimensions, float324,09640.96 GB
768 dimensions, float323,07230.72 GB
1,024 dimensions, int81,02410.24 GB
1,024 dimensions, binary1281.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.

  1. Export 500 to 5,000 chunks from your real corpus, chunked the way production will chunk them.
  2. 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.
  3. Embed the chunks and queries with each candidate, using the model's query and document instructions.
  4. Rank chunks by cosine similarity and compute recall@10, MRR@10 and nDCG@10.
  5. 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

Checked on 5 November 2026.