Embedding Model Leaderboard November 2026: MTEB Scores, Dimensions, Context Length and Price for OpenAI, Cohere, Voyage, Gemini, Qwen3 and BGE Compared

Embedding Model Leaderboard November 2026: MTEB Scores, Dimensions, Context Length and Price for OpenAI, Cohere, Voyage, Gemini, Qwen3 and BGE Compared

Embedding Model Leaderboard November 2026: MTEB Scores, Dimensions, Context Length and Price for OpenAI, Cohere, Voyage, Gemini, Qwen3 and BGE Compared

There is no longer one embedding model leaderboard. There are at least three, and in November 2026 they disagree about who is winning. Microsoft says its Harrier model tops multilingual MTEB v2. NVIDIA says Nemotron 3 Embed tops the retrieval-only RTEB board. Cohere says Embed 5 Pro tops visual-document retrieval, and Voyage says voyage-4-large beats everyone on its RTEB run. All four claims can be true at once, because each vendor picks the scoreboard it wins. This embedding model leaderboard does not crown a champion. It lines up 16 current API and open-weight models on the facts that do not depend on who ran the test: dimensions, Matryoshka support, context length, licence and price per million tokens. Every published score sits next to its source and date. You leave with a sourced comparison table, storage-cost arithmetic and a decision guide by use case.

What this covers: the three scoreboards and why they diverge, the November 2026 spec-and-price table, shared embedding spaces (the biggest architectural change of 2026), storage math, what changed since our Q2 2026 benchmark, methodology caveats, a decision matrix, and an FAQ.

Living benchmark. Last verified: 17 November 2026. Every figure below was re-fetched from a model card, vendor documentation or an official pricing page on that date, unless marked otherwise.

Context and Background

For most of 2023 and 2024, “the leaderboard” meant the Massive Text Embedding Benchmark (MTEB) on Hugging Face. MTEB averaged scores across classification, clustering, pair classification, reranking, retrieval, semantic textual similarity and summarisation tasks. It was mostly English. A single average number became the de facto ranking, and model cards started leading with it.

That single number broke down for two reasons. First, MTEB grew into MMTEB, the Massive Multilingual Text Embedding Benchmark. The MMTEB paper (arXiv 2502.13595) describes over 500 quality-controlled tasks across more than 250 languages, plus downsampled benchmark variants that preserve rankings at lower compute cost. “MTEB score” now needs a qualifier: English v2, multilingual v2, code, or a retrieval subset. A number without the qualifier is not comparable to anything.

Second, the public tasks leaked into training data. Hugging Face and the MTEB maintainers responded on 1 October 2025 by launching RTEB, the Retrieval Embedding Benchmark. RTEB mixes open datasets with private datasets that the maintainers hold back and evaluate themselves. The launch post frames the motivation as “teaching to the test”: when training data overlaps evaluation sets, scores inflate. RTEB covers 20 languages and domains such as law, healthcare, code and finance, and uses NDCG@10 as its default metric.

Since then, vendors have also built their own suites. Cohere publishes ViDoRe V3 and finance retrieval results. Voyage evaluates on all 29 RTEB datasets it can access and reports relative gains. Perplexity reports internal query-to-document tests. These suites are useful, but each is chosen by the party being measured.

We covered the 2026 open-weight landscape in our open source embedding models benchmark, and the API incumbents in our embedding models benchmark for OpenAI, Cohere, Voyage and BGE. This post is the cross-cutting view: API and open models in one table, with price and storage cost treated as first-class columns rather than footnotes.

The November 2026 Embedding Model Leaderboard: Three Scoreboards, One Table

The direct answer: no single model leads every embedding leaderboard in November 2026. Harrier-OSS-v1-27B leads multilingual MTEB v2 by Microsoft’s April figures, Nemotron 3 Embed 8B leads RTEB by NVIDIA’s July figures, and Cohere Embed 5 Pro leads Cohere’s visual-document suite. Pick by licence, modality and cost, then test on your own queries.

Embedding model leaderboard flow showing how MTEB, RTEB and vendor benchmarks feed a shortlist that is then tested on a golden set and costed
Figure 1: How a new embedding model reaches production. Three scoreboards feed vendor claims, which should only ever produce a shortlist. Your own golden set and a cost model make the final call.

Figure 1 shows the pipeline this post recommends. A new model gets scored on one or more of three boards: multilingual MTEB v2, RTEB, or a vendor’s private suite. Those scores reach you as model-card claims with a date attached. The claims should narrow the field to three candidates, not pick the winner. Two parallel checks then decide: retrieval quality on a golden set of your real queries, and the cost of embedding and storing your corpus at production scale.

Scoreboard one: multilingual MTEB v2 rewards breadth

Multilingual MTEB v2 averages across a broad task mix. Microsoft’s Bing team reports Harrier-OSS-v1-27B at 74.3 averaged over 131 tasks, first place as of 6 April 2026. The same post puts the 0.6B variant at 69.0 and the 270M variant at 66.5. For comparison, the Qwen3-Embedding-8B card still cites 70.58 on the same multilingual board, dated 5 June 2025. That is a 3.7-point gap, which is large on an average of over a hundred tasks.

Breadth is the strength and the weakness here. A model that improves at bitext mining or classification moves the average even if its retrieval does not change. If you are building retrieval-augmented generation (RAG), the retrieval column matters more than the headline mean. Qwen’s own table shows this: Qwen3-Embedding-8B scores 70.88 on the multilingual retrieval column and 81.08 on semantic textual similarity. Those are very different numbers from the 70.58 headline.

Scoreboard two: RTEB rewards retrieval generalisation

RTEB measures only retrieval, and part of its data is private. NVIDIA’s Nemotron 3 Embed 8B card reports 78.46 average NDCG@10 on 16 RTEB tasks and claims first place on the multilingual RTEB board as of 16 July 2026. It also reports 75.45 on MMTEB retrieval. Voyage reports voyage-4-large results across all 29 RTEB datasets but only as relative gains: 3.87% over gemini-embedding-001, 8.20% over Cohere Embed v4 and 14.05% over OpenAI text-embedding-3-large.

Notice the dataset counts. NVIDIA reports 16 tasks, Voyage 29 datasets, and the RTEB launch post lists roughly 33 open and private datasets. These are not the same evaluation. RTEB is the better signal for RAG than a broad MTEB mean, but only when two scores come from the same RTEB snapshot.

Scoreboard three: vendor suites reward a specific workload

Cohere’s Embed 5 announcement of 30 September 2026 reports ViDoRe V3 averages in RCP-nDCG@10 across eight domains. Embed 5 Pro scores 85.8, Embed 5 Fast 84.5, Voyage 4 Large 83.7, Gemini Embedding 2 83.2, Cohere Embed 4 77.0 and OpenAI text-embedding-3-large 75.5. The metric reranks a fixed candidate set rather than searching a full corpus, so absolute gaps may shrink or grow in real deployments.

Vendor suites are the most relevant scores when your workload matches the suite. If you index scanned financial filings, Cohere’s finance numbers (FinanceBench 80.1, FinQA 90.0 for Pro) are closer to your problem than any MTEB average. However, no vendor publishes a suite on which it loses, so treat these as upper bounds on relative advantage.

Why the table matters more than the rank

Ranks on any embedding model leaderboard move monthly. Dimensions, context length, licence and price move only when a vendor ships a new version. Those four properties decide your storage bill, your chunking strategy and whether legal will approve the model at all. That is why the table in the next section leads with specs and puts scores in a sourced column at the end.

The Full Embedding Model Leaderboard Table: Specs, Prices and Sourced Scores

The embedding model leaderboard table below covers every model in this comparison. “Not reported” means we could not find the figure on a primary source on 17 November 2026. Prices are list prices for text input per million tokens on the vendor’s own API. Open-weight models have no per-token price because you pay for the GPU instead.

API models

Model Released Max tokens Default dims (options) Matryoshka Price per 1M text tokens Published score (source, date)
OpenAI text-embedding-3-large Jan 2024 8,192 3072 (shortening via dimensions) Shortening supported $0.13 MTEB 64.6 (OpenAI docs, original MTEB average)
OpenAI text-embedding-3-small Jan 2024 8,192 1536 (shortening via dimensions) Shortening supported $0.02 MTEB 62.3 (OpenAI docs)
Cohere embed-v5.0-pro 30 Sep 2026 128k 2048 (256 to 1536) Yes $0.12 text, $0.40 image ViDoRe V3 85.8 RCP-nDCG@10 (Cohere, Sep 2026); MTEB not reported
Cohere embed-v5.0-fast 30 Sep 2026 128k 2048 (256 to 1536) Yes $0.08 text, $0.40 image ViDoRe V3 84.5 (Cohere, Sep 2026)
Cohere embed-v4.0 2025 128k 1536 (256, 512, 1024) Yes Not verified on primary page ViDoRe V3 77.0 (Cohere, Sep 2026)
voyage-4-large 15 Jan 2026 32,000 1024 (256, 512, 2048) Yes $0.12 RTEB relative only (Voyage, Jan 2026)
voyage-4 15 Jan 2026 32,000 1024 (256, 512, 2048) Yes $0.06 1.87% below voyage-4-large on RTEB (Voyage)
voyage-4-lite 15 Jan 2026 32,000 1024 (256, 512, 2048) Yes $0.02 4.80% below voyage-4-large on RTEB (Voyage)
Gemini Embedding 2 Preview 10 Mar 2026 8,192 3072 (128 to 3072) Yes $0.20, batch $0.10 ViDoRe V3 83.2 (Cohere’s run, Sep 2026); Google MTEB not reported on pages we read
gemini-embedding-001 GA 14 Jul 2025 2,048 3072 (1536, 768) Yes $0.15, batch $0.075 MMTEB 68.37 for experimental build (Qwen card, May 2025)

Sources: OpenAI embeddings guide and model pages; Cohere Embed docs and the Embed 5 blog; Voyage embeddings docs and Voyage pricing; Gemini Embedding 2 model page and Gemini API pricing. All fetched 17 November 2026.

A few notes on the API rows. OpenAI’s embeddings guide still calls the text-embedding-3 pair its “newest and most performant embedding models,” so no successor has shipped as of this check. The MTEB figures OpenAI quotes date from the original 2024 English benchmark and are not comparable with MTEB v2 numbers. Voyage’s batch API takes 33% off list price, and the first 200 million tokens on the 4-series are free. Gemini Embedding 2 also prices other inputs: $0.45 per million image tokens, $6.50 for audio and $12.00 for video at standard rates. Cohere’s pricing page did not render its embedding figures in our fetch, so Embed 5 prices come from Cohere’s own launch post and Embed 4’s price is left unverified.

Open-weight models

Model Released Params Max tokens Dims (options) Licence Published score (source, date)
Harrier-OSS-v1-27B 7 Apr 2026 27B 32,768 5376 MIT MMTEB v2 74.3, 131 tasks (Microsoft, 6 Apr 2026)
Nemotron 3 Embed 8B 16 Jul 2026 ~8B 32,768 4096 (slice to 2048, 1024) OpenMDW-1.1 RTEB 78.46, MMTEB retrieval 75.45 (NVIDIA, Jul 2026)
Qwen3-Embedding-8B Jun 2025 8B 32K 4096 (32 to 4096) Apache 2.0 MMTEB 70.58, MTEB Eng v2 75.22 (Qwen, 5 Jun 2025)
Qwen3-Embedding-0.6B Jun 2025 0.6B 32K 1024 (32 to 1024) Apache 2.0 MMTEB 64.33, MTEB Eng v2 70.70 (Qwen)
pplx-embed-v1-4B 26 Feb 2026 4B 32K 2560 (MRL) MIT MMTEB v2 retrieval avg nDCG@10 69.66 at int8 (Perplexity)
jina-embeddings-v5-text-small 18 Feb 2026 677M 32,768 1024 (32 to 1024) CC BY-NC 4.0 MTEB Eng v2 71.7, MMTEB 67.7 (Jina)
EmbeddingGemma 2 Oct 2026 ~740M total 8,192 768 (512, 256, 128) Apache 2.0 MMTEB v2 61.36, MTEB Eng v2 68.46, MTEB code 78.68 (Google card)
voyage-4-nano 15 Jan 2026 ~0.3B 32,000 2048 per HF card (1024, 512, 256) Apache 2.0 Not reported as an aggregate
BGE-M3 2024 Not stated on card 8,192 1024 MIT Aggregate MTEB not reported on card
Snowflake Arctic Embed L v2.0 4 Dec 2024 568M 8,192 1024 (256) Apache 2.0 BEIR 55.6 NDCG@10 (Snowflake)
Nomic Embed Text v2 MoE 2025 475M total, 305M active 512 768 (256) Apache 2.0 BEIR 52.86, MIRACL 65.80 (Nomic)

Sources: the Hugging Face model cards for each model, the Microsoft Bing blog and the Perplexity pplx-embed post. All fetched 17 November 2026.

Two discrepancies deserve flagging. Voyage’s API documentation lists 1024 as the default dimension for the 4-series, while the voyage-4-nano Hugging Face card lists 2048 as its default. If you mix the hosted and self-hosted models, set the dimension explicitly. Also, the pplx-embed score is labelled by Perplexity as “MTEB (Multilingual, v2), avg nDCG@10,” which reads as a retrieval average rather than the full task mean. Do not compare it directly with Harrier’s 74.3.

How to read the score column

Read every score in an embedding model leaderboard as “this vendor, on this subset, on this date.” The cleanest like-for-like pair in the table is Harrier-OSS-v1-27B at 74.3 versus Qwen3-Embedding-8B at 70.58, both full multilingual MTEB v2 means. Even that pair is ten months apart, and the leaderboard has added submissions in between. Every other row compares across benchmark versions, subsets or metrics.

We tried to read the live leaderboard directly. The MTEB leaderboard has moved to a new JavaScript front end at mteb-leaderboard.hf.space with a separate backend service. On 17 November 2026 neither the Hugging Face Space page nor the app shell exposed a ranking table to our fetch. We therefore quote no live rank. If you need the current order, open the leaderboard in a browser, select the benchmark version explicitly, and note the date.

Deeper Analysis: Shared Embedding Spaces, Storage Math and What Changed

The specs table hides the most important architectural shift of 2026. Two vendors now sell model families that share one vector space across sizes. That changes how you should think about cost, because the expensive model and the cheap model no longer have to be the same model.

Asymmetric retrieval in an embedding model leaderboard context, with a large model indexing documents and a small model embedding queries into the same vector space
Figure 2: Asymmetric retrieval with a shared embedding space. Documents are embedded once with the large model; queries use a smaller, cheaper, faster model that writes into the same space.

Figure 2 shows the pattern. The document corpus passes through the large model once, at indexing time. Every query passes through a small model, potentially millions of times a day. Because both models write into one vector space, approximate nearest neighbour (ANN) search compares them directly. A reranker and the LLM sit downstream as usual.

Voyage 4 and Embed 5 make asymmetric retrieval a product feature

Voyage announced the 4-series on 15 January 2026 with the explicit promise that all four models produce compatible embeddings. Its launch post describes voyage-4-large as a mixture-of-experts (MoE) model, meaning only a subset of its parameters run per token, and says serving costs are 40% lower than comparable dense models. You can index with voyage-4-large at $0.12 per million tokens and query with voyage-4-lite at $0.02.

Cohere followed on 30 September 2026 with Embed 5 Pro and Fast in a shared space. Cohere published the quality cost of mixing tiers, normalised to Pro-for-both at 100. Fast queries against a Pro corpus scored 98.4. Fast for both scored 96.6. Cohere also measured Fast at 377.3 documents per second against 159.7 for Pro, roughly 2.4 times the throughput.

The economics follow from the ratio of query tokens to document tokens. A typical enterprise corpus is embedded once and re-embedded rarely. Queries are short but endless. If query volume dominates your token bill, a shared space lets you put the premium model where it matters most, on documents, and the cheap one on the hot path. The 1.6-point loss in Cohere’s own test is the price of that trade, and you should measure it on your data rather than assume it.

Storage cost math

Storage often costs more than embedding. A vector’s raw size is dimensions times bytes per dimension. A float32 dimension takes 4 bytes, int8 takes 1 byte, and binary takes one bit. The worked example below is illustrative, using a hypothetical corpus of 10 million chunks and ignoring index overhead such as HNSW graph links.

Configuration Bytes per vector 10M vectors, raw
4096 dims, float32 (Qwen3-8B or Nemotron full) 16,384 ~164 GB
3072 dims, float32 (text-embedding-3-large or Gemini default) 12,288 ~123 GB
2048 dims, float32 (Embed 5 or voyage-4 at 2048) 8,192 ~82 GB
1024 dims, float32 4,096 ~41 GB
1024 dims, int8 1,024 ~10 GB
1024 dims, binary 128 ~1.3 GB
256 dims, int8 256 ~2.6 GB

Illustrative arithmetic, not a measurement. Real indexes add graph or quantiser overhead.

The spread from top to bottom is more than a hundredfold. That is why Matryoshka support and native quantisation now matter as much as leaderboard rank. Matryoshka Representation Learning (MRL) trains a model so that the first k dimensions of a vector are themselves a usable embedding. You can truncate and re-normalise without retraining. Our Matryoshka embeddings architecture guide covers the mechanism in depth.

Here is the same arithmetic as a short script you can adapt to your own corpus size and token counts.

def storage_gb(n_vectors, dims, bytes_per_dim):
    return n_vectors * dims * bytes_per_dim / 1e9

def embed_cost_usd(n_chunks, tokens_per_chunk, usd_per_million):
    return n_chunks * tokens_per_chunk / 1e6 * usd_per_million

N = 10_000_000          # illustrative corpus size
TOK = 500               # illustrative tokens per chunk
for name, dims, bpd in [("3072 f32", 3072, 4), ("1024 int8", 1024, 1), ("1024 binary", 1024, 1/8)]:
    print(name, round(storage_gb(N, dims, bpd), 1), "GB")

# List prices fetched 2026-11-17, text input, USD per 1M tokens
for name, price in [("voyage-4-lite", 0.02), ("text-embedding-3-small", 0.02),
                    ("embed-v5.0-fast", 0.08), ("embed-v5.0-pro", 0.12),
                    ("voyage-4-large", 0.12), ("gemini-embedding-2", 0.20)]:
    print(name, round(embed_cost_usd(N, TOK, price)), "USD one-off")

With 10 million chunks of 500 tokens, the corpus is 5 billion tokens. At list price that costs about $100 with voyage-4-lite or text-embedding-3-small, $400 with Embed 5 Fast, $600 with Embed 5 Pro or voyage-4-large, and $1,000 with Gemini Embedding 2 at the standard rate. Batch pricing halves Gemini’s figure to $500 and takes a third off Voyage. These are one-off indexing costs, again illustrative. Compare them with the monthly cost of keeping 123 GB of float32 vectors in RAM, and the storage line usually wins.

Storage pipeline for an embedding model leaderboard comparison showing Matryoshka truncation, re-normalisation and float32, int8 or binary quantisation before rescoring
Figure 3: The storage-reduction pipeline. Truncate with Matryoshka, re-normalise, quantise to int8 or binary for the hot index, and rescore the top candidates at higher precision.

Figure 3 shows the standard production pattern. The full vector is truncated to 1024 or 512 dimensions and re-normalised to unit length. NVIDIA’s Nemotron card explicitly requires L2 re-normalisation after slicing. The truncated vector is stored as int8 or binary in the hot in-memory index. The top few hundred candidates are then rescored against higher-precision vectors kept on cheaper storage. Our deep dive on HNSW, DiskANN and IVF-PQ index internals explains how each index type handles the quantised tier.

Vendors now publish quantisation results directly. Perplexity reports that binary pplx-embed vectors lose under 1.6 points on the 4B model but 2 to 4 points on the 0.6B model. Snowflake reports Arctic Embed L v2.0 losing 0.18% on BEIR when truncated from 1024 to 256 dimensions, and it compresses vectors to 128 bytes with 4-bit quantisation. Cohere recommends 1024-dimensional int8 as the default balance for Embed 5. The pattern is consistent: larger models tolerate aggressive compression better.

What changed since our Q2 2026 benchmark

Our Q2 2026 open-weight benchmark was written in May 2026. Since then the board has moved in four ways.

First, commercially licensed open weights caught up with restrictive ones. In May, the strongest NVIDIA embedder in common guides was NV-Embed-v2 under a non-commercial licence. Nemotron 3 Embed arrived on 16 July 2026 under OpenMDW-1.1, which its card describes as ready for commercial use. Nemotron 3.5 Embed followed on 20 October 2026 and added image inputs on documents. Its card reports ViDoRe V3 NDCG@10 of 61.47 for image-plus-text documents.

Second, the multimodal API race went mainstream. Cohere Embed 5 shipped on 30 September 2026 with 128k context and fused text-and-image inputs. Google’s Gemini Embedding 2, previewed on 10 March 2026, embeds text, images, video, audio and PDFs into one space.

Third, small open models became multimodal too. Google’s EmbeddingGemma 2 arrived in October 2026 at about 740 million parameters, including optional vision and audio encoders. Its card reports MTEB code v1 at 78.68, up from 68.76 for the first version, while multilingual MTEB moved only from 61.15 to 61.36. It also moved to Apache 2.0.

Fourth, the leaderboard itself changed. RTEB is now where retrieval claims get made, and the MTEB leaderboard has a new front end. Several models that matter, such as Harrier, pplx-embed, Jina v5 and Voyage 4, shipped between January and April. Our May post predated some of the later ones, so this table is the first time we list them together with prices.

Decision matrix by workload

The matrix below combines the spec table with the benchmark claims. It is opinion grounded in the sourced figures, not a measured result.

Workload First pick Runner-up Why
Text RAG, managed API, cost-sensitive voyage-4-lite queries over voyage-4-large index text-embedding-3-small Shared space; $0.02 per million on the query path
Scanned PDFs, slides, financial filings Cohere Embed 5 Pro Gemini Embedding 2 Leads Cohere’s ViDoRe V3 and finance suites; 128k context
Self-hosted, commercial, quality-first Nemotron 3 Embed 8B Qwen3-Embedding-8B Top RTEB claim, OpenMDW-1.1; Qwen is Apache 2.0
Multilingual breadth, self-hosted Harrier-OSS-v1-27B Qwen3-Embedding-8B Top MMTEB v2 claim, MIT; but 27B params and 5376 dims
Hybrid dense plus sparse search BGE-M3 Arctic Embed L v2.0 Dense, sparse and multi-vector from one pass
On-device or CPU EmbeddingGemma 2 Qwen3-Embedding-0.6B Apache 2.0, 768 dims down to 128, multimodal
Video and audio search Gemini Embedding 2 EmbeddingGemma 2 Native audio and video inputs

Decision tree for choosing from the embedding model leaderboard by licence, hosting, modality and device constraints
Figure 4: A decision tree for the November 2026 embedding model leaderboard. Licence and hosting constraints eliminate most of the field before quality enters the conversation.

Figure 4 encodes the same logic as a tree. The first question is whether you need weights you can use commercially and host yourself. If yes, the next split is device class: on-device workloads go to small models, server workloads go to the large open families. If you can use an API, the split is modality. Visually rich documents go to the multimodal APIs, and plain text goes to the cheapest shared-space family that passes your golden-set test.

Trade-offs, Gotchas, and What Goes Wrong

Benchmark contamination is real and asymmetric. RTEB exists because public retrieval sets leak into training mixes. A model that scores far higher on public MTEB retrieval than on RTEB’s private split is telling you something. Few vendors publish both, so you usually cannot check. Weight RTEB and your own golden set above public averages.

Big dimensions are a recurring tax. Harrier-27B emits 5376 dimensions, and Nemotron and Qwen3-8B emit 4096. That is 21 KB and 16 KB per float32 vector. A 1.3-point leaderboard edge rarely justifies four times the memory of a 1024-dimensional model. Truncate with Matryoshka where supported, and measure the loss on your data. Harrier’s card does not mention MRL, so do not assume truncation works.

Context length is not chunk size. Cohere Embed 5 accepts 128k tokens, and many open models accept 32k. Embedding a whole document into one vector still averages away detail, and retrieval granularity suffers. Long context helps with late chunking and contextual embeddings, which our RAG chunking strategies guide covers. It does not replace chunking.

Vector spaces are not portable. Moving from gemini-embedding-001 to Gemini Embedding 2, or from Embed 4 to Embed 5, means re-embedding the whole corpus. Shared spaces exist only within a family, such as Voyage 4 or Embed 5. Budget re-indexing time and cost before you migrate.

Licences hide in the details. Jina v5 text models are CC BY-NC 4.0. Nemotron uses OpenMDW-1.1 rather than Apache 2.0. EmbeddingGemma 2 is Apache 2.0, but the first EmbeddingGemma used the Gemma terms. Read the licence on the model card at the commit you deploy, not the summary on a leaderboard row.

Instruction prompts change scores. Qwen3-Embedding expects a one-sentence task instruction on queries. Its card says omitting it can cost 1% to 5%. A team that benchmarks without the instruction will under-rate the model, so follow each card’s query format exactly.

Prices move. Our prices were fetched on 17 November 2026. OpenAI’s own community forum has threads about mismatches between its model pages and its pricing page. Check the vendor’s page on the day you sign a budget.

Practical Recommendations

Start with constraints, not an embedding model leaderboard rank. Licence, data residency and modality eliminate more candidates than any leaderboard. Once you have three survivors, build a golden set of 200 to 500 real queries with labelled relevant chunks, and measure recall and NDCG at your production top-k. Our guide to RAG retrieval evaluation with recall@k, NDCG and golden sets shows how to build that pipeline.

For API users on text-only workloads, test the shared-space trick first. Indexing with voyage-4-large and querying with voyage-4-lite is cheap to try and easy to reverse. For visually rich documents, compare Embed 5 Pro and Gemini Embedding 2 on a sample of your own PDFs, because vendor suites diverge most here. For self-hosting, Nemotron 3 Embed 8B and Qwen3-Embedding-8B are the default pair to test. Add BGE-M3 if you depend on sparse retrieval.

Plan storage before you pick a winner. Decide your target dimensions and quantisation up front, then evaluate every candidate at that setting. Comparing models at full float32 and deploying at 512-dimensional int8 tests a configuration you will never run. Finally, put a reranker behind whichever embedder you choose. A good reranker narrows the gap between embedders more than most leaderboard deltas.

Checklist before you commit:

  • Licence read on the model card at the exact version you will deploy.
  • Golden set of real queries, evaluated at production dimensions and precision.
  • Storage cost computed for your vector count, dims and quantisation.
  • Re-embedding cost and time estimated for the next migration.
  • Query instruction format copied exactly from the card.
  • Reranker in the evaluation loop, not added afterwards.
  • Benchmark version and date recorded next to every score you cite internally.

Frequently Asked Questions

What is the best embedding model in November 2026?

There is no single best embedding model in November 2026, because each leaderboard measures something different. By vendor-reported figures, Harrier-OSS-v1-27B leads multilingual MTEB v2, Nemotron 3 Embed 8B leads RTEB retrieval and Cohere Embed 5 Pro leads Cohere’s visual-document suite. For managed text RAG, the voyage-4 family is a strong value pick. For self-hosted commercial use, test Nemotron 3 Embed 8B against Qwen3-Embedding-8B. Choose by licence, modality and cost, then confirm with your own query set.

Is the MTEB leaderboard still reliable?

The MTEB leaderboard is still the best embedding model leaderboard for shortlisting, but it is no longer a single ranking. You must choose a benchmark first, such as English v2, multilingual v2, code or RTEB. Scores on public tasks can be inflated by training-data overlap, which is why RTEB added private datasets in October 2025. Treat any rank as a dated snapshot. Use it to pick three candidates, then run your own retrieval evaluation before you decide anything.

How much do embedding models cost per million tokens?

On list prices fetched on 17 November 2026, text input costs $0.02 per million tokens for OpenAI text-embedding-3-small and voyage-4-lite. It costs $0.06 for voyage-4, $0.08 for Cohere Embed 5 Fast, and $0.12 for Embed 5 Pro and voyage-4-large. OpenAI’s text-embedding-3-large costs $0.13. Google charges $0.20 for Gemini Embedding 2, or $0.10 in batch, and $0.15 for gemini-embedding-001. Open-weight models have no token fee, but you pay for GPU time and operations instead.

What are the best open source embedding models right now?

The strongest open-weight embedding models with commercial-friendly licences are Nemotron 3 Embed 8B under OpenMDW-1.1, and Qwen3-Embedding-8B, Harrier-OSS-v1, pplx-embed-v1 and EmbeddingGemma 2 under Apache 2.0 or MIT. BGE-M3 remains the practical choice for hybrid dense and sparse search. Jina v5 models score well but use the non-commercial CC BY-NC 4.0 licence. Our open-weight benchmark post covers these models in more depth, including licence caveats and self-hosting notes.

How many dimensions should my embeddings have?

For most RAG systems, 1024 dimensions is a sensible default, and many 2026 models support it through Matryoshka truncation. Higher dimensions such as 3072 or 4096 cost three to four times the storage for a typically small quality gain. Cohere recommends 1024-dimensional int8 for Embed 5. Test your chosen model at 512, 1024 and full size on your golden set. Then pick the smallest setting whose recall loss you can accept, and evaluate every other candidate at that same setting.

Do I need to re-embed my data if I switch models?

Yes, in almost every case. Each model family produces its own vector space, so vectors from different models cannot be compared. That applies within vendors too: gemini-embedding-001 and Gemini Embedding 2 are not compatible. The exception is a shared-space family. Voyage 4 models are interoperable with each other, and so are Cohere Embed 5 Pro and Fast. That lets you change the query model without re-indexing the corpus, as long as you stay within the family.

Further Reading

References

  1. OpenAI, “Vector embeddings” guide and text-embedding-3-large and -small model pages, developers.openai.com, fetched 17 Nov 2026.
  2. Cohere, “Embed 5” announcement, cohere.com/blog/embed-5, 30 Sep 2026; Cohere Embed model docs, docs.cohere.com, fetched 17 Nov 2026.
  3. Voyage AI, “The Voyage 4 model family: shared embedding space with MoE architecture,” 15 Jan 2026; Voyage embeddings and pricing docs, docs.voyageai.com, fetched 17 Nov 2026.
  4. Google, “Gemini Embedding 2: Our first natively multimodal embedding model,” blog.google, 10 Mar 2026; Gemini API model and pricing pages, ai.google.dev, fetched 17 Nov 2026.
  5. Google Developers Blog, “Gemini Embedding now generally available in the Gemini API,” 14 Jul 2025.
  6. Qwen team, Qwen3-Embedding-8B and -0.6B model cards, Hugging Face.
  7. NVIDIA, Nemotron-3-Embed-8B-BF16 and Nemotron-3.5-Embed-8B-BF16 model cards, Hugging Face.
  8. Microsoft Bing, “Microsoft Open Sources Industry Leading Embedding Model,” 7 Apr 2026; harrier-oss-v1-27b model card, Hugging Face.
  9. Perplexity, “pplx-embed: State-of-the-Art Embedding Models for Web-Scale Retrieval,” 26 Feb 2026.
  10. Google DeepMind, embeddinggemma-2 model card, Hugging Face.
  11. Jina AI, jina-embeddings-v5-text-small model card, Hugging Face.
  12. BAAI, bge-m3 model card; Snowflake, snowflake-arctic-embed-l-v2.0 model card; Nomic, nomic-embed-text-v2-moe model card, Hugging Face.
  13. Hugging Face and MTEB maintainers, “Introducing RTEB: A New Standard for Retrieval Evaluation,” 1 Oct 2025.
  14. Enevoldsen et al., “MMTEB: Massive Multilingual Text Embedding Benchmark,” arXiv 2502.13595.

By Riju — about

Comments

No comments yet. Why don’t you start the discussion?

Leave a Reply

Your email address will not be published. Required fields are marked *