12 Best Embedding Models for RAG and Semantic Search (2026 Benchmarks and Pricing)

The best embedding model in September 2026 depends on what you are building. For the highest accuracy through an API, Voyage 4 and Gemini Embedding 2 are the current picks. For the cheapest sane default, OpenAI's text-embedding-3-small costs $0.02 per 1M tokens. For open weights you can run yourself, Qwen3-Embedding-8B and Microsoft's Harrier models lead the model-card benchmark claims, and BGE-M3 remains the most downloaded multilingual option. For code search through an API, Mistral's Codestral Embed is a code-tuned alternative to voyage-code-4. For small self-hosted models, EmbeddingGemma, Snowflake Arctic Embed L v2.0, Nomic Embed Text v2 and multilingual-e5-large-instruct round out the 12. The list started with 7 models and now covers 12. We checked the first 7 against vendor docs and Hugging Face model cards on 19 September 2026, and the 5 added on 26 September 2026 against their model cards and vendor pages. Where a score is the vendor's own claim, we label it "vendor-reported."

One caveat before the list. The MTEB leaderboard on Hugging Face is a JavaScript app with no public API we could query, so we could not pull a single live ranking. The scores below come from model cards and vendor pages, and they use different MTEB variants (English v2, multilingual). Do not compare a 74.3 to a 71.7 as if they were one scale. The section "How to read the benchmarks" explains this.

How we chose these 12 models

We started from three live signals and kept models that showed up in at least one:

• Vendor docs listing the model as current (OpenAI, Google, Voyage AI, Mistral).
• A top score claimed on an MTEB variant or a retrieval benchmark, either on the model card or in the vendor's launch post (Qwen, Microsoft Harrier, Jina, Google EmbeddingGemma, Snowflake, Nomic).
• Adoption, measured by the Hugging Face download counter for the last 30 days (BGE-M3 at about 38M, Qwen3-Embedding-0.6B at about 8.6M on 19 Sept 2026, and EmbeddingGemma at about 2.9M, multilingual-e5-large-instruct at about 1.4M, Nomic Embed Text v2 at about 1.4M and Arctic Embed L v2.0 at about 940K on 26 Sept 2026).

We mixed API and open-weight models on purpose, since that is the first decision most teams face. We left out any model where we could not verify a price or a spec. Cohere Embed v4 is the notable case. Its docs list 1536 dimensions by default and a 128k context, but we found no per-token price on Cohere's public pricing page, so it sits in "also considered" instead of the list. The order below is grouped (API first, then open-weight), not a ranking. Within the open-weight group, the models with longer context and larger claimed scores come first, and the 512-token models come last. Nothing here is a star rating, because embedding models are not reviewed by buyers the way SaaS tools are.

Comparison table

Sources: vendor docs and Hugging Face model cards, pulled 19 September 2026 (Voyage 4, Gemini Embedding 2, OpenAI text-embedding-3, Qwen3-Embedding, Harrier, Jina v5 and BGE-M3) and 26 September 2026 (Codestral Embed, Arctic Embed, EmbeddingGemma, Nomic Embed, multilingual-e5). All benchmark figures are vendor or model-card claims, not our own measurements. BEIR and MIRACL are retrieval benchmarks, not MTEB averages, so they do not compare with the MTEB column values either.

Where the model sits in a RAG pipeline

Changing the embedding model later means re-embedding every document and rebuilding the index. That is the real switching cost, and it is why the choice deserves an afternoon of testing before you commit. Voyage 4 is the one family here that softens this. Its docs say all 4-series embeddings are compatible with each other, so you can embed documents with voyage-4-large and queries with a cheaper model.

The 12 best embedding models

1. Voyage 4 family (voyage-4-large, voyage-4, voyage-4-lite)

Best for: teams that want top retrieval accuracy from an API and care about the accuracy-to-cost dial.

• Specs. 32,000-token context, 1024 dimensions by default with 256, 512 and 2048 available. Multilingual, per the Voyage docs.
• Price. $0.12 (large), $0.06 (standard), $0.02 (lite) per 1M tokens. The first 200M tokens are free per account (Voyage pricing page, 19 Sept 2026). Domain models such as voyage-code-4 are $0.12.
• Benchmark (vendor-reported, Voyage blog, 15 Jan 2026). On Voyage's RTEB evaluation, voyage-4-large beat Gemini Embedding 001 by 3.87% on average, Cohere Embed v4 by 8.20% and OpenAI v3 Large by 14.05%. This is Voyage grading itself against older competitor models, and it predates Gemini Embedding 2.
• Pros. Shared embedding space across the 4 series, long context, domain variants for code, finance and law, and a free tier that covers a real prototype.
• Cons. No open weights except voyage-4-nano (Apache 2.0). You depend on one vendor's API.

Pick this if you want the best-documented accuracy tier and may want to mix a big document model with a cheap query model.

2. Gemini Embedding 2

Best for: multimodal search where text, images, audio, video and PDFs share one vector space.

• Specs. 3072 dimensions by default, adjustable from 128 to 3072 (Google recommends 768, 1536 or 3072). 8,192 input tokens. Over 100 languages. Stable since April 2026 per the model page.
• Price. $0.20 per 1M text tokens, $0.10 in batch. Images, audio and video are priced separately. The free tier is subject to Google using your data to improve its products (Gemini API pricing page, 19 Sept 2026).
• Benchmark. The docs page publishes no text-only MTEB figure for Gemini Embedding 2. For the older gemini-embedding-001, Google reports 68.17 at 1536 dimensions and 63.31 at 128, which shows how far you can truncate before quality drops (vendor-reported).
• Pros. One model for mixed media, automatic renormalization when you truncate, and a cheap batch rate.
• Cons. 8,192 tokens is short next to the 32K models here. It has the highest text price on this list. The free tier data terms rule it out for private content.

Pick this if your corpus mixes PDFs, images and text and you want one index.

3. OpenAI text-embedding-3-large and text-embedding-3-small

Best for: the low-friction default, especially if you already use OpenAI.

• Specs. 3072 dimensions (large) and 1536 (small), both reducible with the dimensions parameter. 8,192 input tokens.
• Price. $0.13 (large) and $0.02 (small) per 1M tokens (OpenAI model page, 19 Sept 2026). OpenAI's model page captions its embeddings price as the Batch API price, but the embeddings guide lists 62,500 (small) and 9,615 (large) pages per dollar at about 800 tokens per page. That works out to $0.02 and $0.13 per 1M tokens, so we treat both as the standard rates.
• Benchmark (vendor-reported, OpenAI embeddings guide). MTEB 64.6 for large and 62.3 for small.
• Pros. The small model ties voyage-4-lite as the cheapest API option we verified ($0.02 per 1M tokens), and tooling support is the widest.
• Cons. These are the oldest models in the list. Their vendor-reported MTEB scores sit below the newer figures from Qwen, Harrier and Jina, though those use different variants.

Pick this if you need a working RAG prototype today and cost per token matters more than the last few points of accuracy.

4. Mistral Codestral Embed

Best for: code search and coding assistants that need retrieval over a large codebase through an API.

• Specs. Model name codestral-embed (API name codestral-embed-2505). 1536 dimensions by default, up to 3072, with the first dimensions ordered by relevance so you can cut them. Output types include float, int8, uint8, binary and ubinary (Mistral docs). 8,192-token context per the launch post, which recommends 3,000-character chunks with 1,000 characters of overlap.
• Price. $0.15 per 1M input tokens (Mistral API pricing page, 26 Sept 2026). The launch post lists a 50% discount through the batch API. Mistral's general text model, mistral-embed, is $0.10 per 1M tokens and outputs 1024 dimensions.
• Benchmark (vendor-reported, Mistral launch post, 28 May 2025). Mistral says Codestral Embed outperforms Voyage Code 3, Cohere Embed v4.0 and OpenAI's large embedding model on code retrieval, and that even at 256 dimensions with int8 precision it beats those competitors. No MTEB average is published, and the comparison predates voyage-code-4.
• Pros. A code-tuned model with flexible dimensions and binary output, so storage can shrink a lot, and a batch discount for bulk indexing.
• Cons. Closed weights, API only. It is tuned for code, so a general text corpus is a better fit for mistral-embed or another model in this list.

Skip it if your corpus is mostly prose, or you need to run embeddings on your own hardware.

Pick this if you are building code search or a coding assistant and want a second code-tuned API to test against voyage-code-4.

5. Qwen3-Embedding-8B

Best for: self-hosted multilingual retrieval with a permissive license.

• Specs. 7.57B parameters, 32K context, dimensions up to 4096 with user-defined sizes from 32 to 4096, 100+ languages including programming languages. Instruction-aware, so you can steer it per task.
• License and cost. Apache 2.0. Weights alone take about 15 GB in bf16 (our arithmetic: 7.57B parameters times 2 bytes), so plan on a 24 GB-class GPU for real workloads. The 0.6B sibling is far lighter and had about 8.6M downloads in 30 days.
• Benchmark (model card). Ranked first on the multilingual MTEB leaderboard on 5 June 2025 with 70.58. That is more than 15 months old, and newer models have since claimed higher numbers.
• Pros. Apache 2.0, long context, flexible dimensions, and sizes from 0.6B to 8B.
• Cons. 4096 dimensions cost storage (see "How to choose"). You run the inference stack yourself.

Pick this if you need strong multilingual quality on your own hardware and your legal team wants Apache 2.0.

6. Microsoft Harrier-oss-v1 (0.6B and 27B)

Best for: the highest claimed open-weight score, or a small MIT-licensed model that punches above its size.

• Specs. Decoder-only models with 32,768 max tokens. The 0.6B outputs 1,024 dimensions, the 27B outputs 5,376. A 270M version also exists (640 dimensions).
• License and cost. MIT. The 27B needs about 54 GB for weights in bf16 (our arithmetic), so it is a multi-GPU or 80 GB-class job. The 0.6B fits in about 1.2 GB.
• Benchmark (model card, released 30 March 2026). The card lists a multilingual MTEB v2 score of 74.3 for the 27B and 69.0 for the 0.6B, and says the family reached state of the art on that benchmark at release. That is Microsoft's claim, not verified by us.
• Pros. The top self-reported number in this list, an MIT license, and a 0.6B that is cheap to serve.
• Cons. It is the newest family here, so it has less production history. The 27B had only about 5,500 downloads in 30 days against roughly 184,000 for the 0.6B. A 5,376-dimension vector is heavy to store.

Pick this if accuracy is the priority and you have the GPUs, or take the 0.6B when you want MIT-licensed quality on a modest server.

7. Jina embeddings v5-text-small

Best for: a small multilingual model with long context and task adapters.

• Specs. 677M parameters per the card, 1024 dimensions with Matryoshka truncation down to 32, 32,768 tokens, 119+ languages. Built on Qwen3-0.6B-Base.
• License. CC BY-NC 4.0 on the Hugging Face weights, which is non-commercial. For commercial use, Jina points to its API and cloud marketplaces. We could not verify Jina's per-token price, so we do not quote one. Check current terms before you build on it.
• Benchmark (vendor-reported, model card, released 18 Feb 2026). 71.7 on MTEB English v2 and 67.7 on MMTEB, described as the highest among multilingual models under 1B parameters.
• Pros. Strong small-model numbers, holds up under truncation and binary quantization, and GGUF and MLX builds for edge use.
• Cons. The non-commercial license blocks many teams, and pricing is opaque until you sign up.

Pick this if you want a sub-1B multilingual model and are fine paying Jina for a commercial license or API access.

8. BGE-M3

Best for: hybrid search where you want dense, sparse and multi-vector retrieval from one model.

• Specs. 1024 dimensions, 8,192 tokens, 100+ working languages (model card).
• License and adoption. MIT. It is the most downloaded model here, about 38M downloads in 30 days on 19 Sept 2026.
• Benchmark. The card states no MTEB average, so we give none. The repo was last updated in July 2024.
• Pros. Three retrieval modes in one model, a card that recommends hybrid retrieval plus reranking, and years of production use with plenty of tooling.
• Cons. It is the oldest model in this list. Newer 0.6B models with 32K context may beat it on long documents, so test on your data.

Pick this if you want a proven, MIT-licensed multilingual model with built-in sparse retrieval and you do not need 32K context.

9. Snowflake Arctic Embed L v2.0

Best for: multilingual retrieval with a permissive license and heavy vector compression.

• Specs. 568M parameters (303M non-embedding), 1024 dimensions with Matryoshka truncation to 256, and a context window of up to 8,192 tokens via RoPE. Built on BAAI/bge-m3-retromae, which the card says makes it a drop-in replacement in existing inference stacks.
• License and adoption. Apache 2.0, and the card says the models can be used commercially free of charge. About 940K downloads in 30 days on 26 Sept 2026.
• Benchmark (model card, released 4 Dec 2024). Average NDCG@10 of 55.6 on BEIR (15 datasets) and 55.8 on MIRACL (4 languages). On the same table, BGE-M3 scores 48.8 on BEIR and 56.8 on MIRACL, so Arctic trades a little multilingual score for a lot of English retrieval. At 256 dimensions, BEIR drops to 54.3.
• Pros. Strong English and multilingual retrieval in one model, 128-byte vectors possible with 256 dimensions plus 4-bit quantization, and an Apache 2.0 license.
• Cons. The Matryoshka step is 256 dimensions only, not a free range. 8,192 tokens is a quarter of the 32K models here, and the card is from late 2024.

Skip it if you need chunks longer than 8,192 tokens or dimension sizes between 256 and 1024.

Pick this if you want a BGE-M3 class model with better English retrieval numbers on its card and small compressed vectors.

10. EmbeddingGemma-300m

Best for: a 300M-parameter model with published MTEB English, multilingual and code scores.

• Specs. 300M parameters, 768 dimensions with 512, 256 and 128 available through Matryoshka learning, 2K maximum input context, trained on data in 100+ spoken languages (Google model card, checked 26 Sept 2026).
• License and adoption. Released under Google's Gemma terms. The Hugging Face card lists the license as "gemma" and gates the weights until you acknowledge it. Read the terms before commercial use. About 2.9M downloads in 30 days on 26 Sept 2026.
• Benchmark (Google model card, 768 dimensions, full precision). MTEB English v2 mean (task) 69.67, MTEB multilingual v2 mean (task) 61.15, MTEB Code v1 mean (task) 68.76. These are Google's own figures.
• Pros. Small, so it is cheap to serve, and its card publishes a code score next to the text scores.
• Cons. 2K tokens is short next to the 8K and 32K models here, and the Gemma terms are a separate license to review, not Apache or MIT.

Skip it if you embed long sections, or your legal team only accepts Apache 2.0 or MIT.

Pick this if you want a small model with published multilingual and code numbers for on-prem or edge use.

11. Nomic Embed Text v2 MoE

Best for: a small multilingual model where you can inspect the training code and data.

• Specs. Mixture of experts with 475M total parameters and 305M active during inference (8 experts, top-2 routing). 768 dimensions, truncatable to 256. Maximum input is 512 tokens. About 100 languages, trained on over 1.6B pairs (model card).
• License and adoption. Apache 2.0. Nomic released the weights, training code and training data. About 1.4M downloads in 30 days on 26 Sept 2026.
• Benchmark (model card, Feb 2025). BEIR 52.86 and MIRACL 65.80. Nomic describes it as state of the art among roughly 300M-parameter multilingual models. On the same table, Arctic Embed v2 Large scores 55.65 on BEIR, so the larger Arctic model leads on English retrieval.
• Pros. Fully reproducible, small active size, and Matryoshka truncation that the card says cuts storage by 3x with little loss.
• Cons. The 512-token limit forces small chunks. Every text needs a search_query: or search_document: prefix, and the Transformers path needs trust_remote_code.

Skip it if your chunks run past about 512 tokens.

Pick this if you need a small, auditable multilingual model and short chunks suit your content.

12. multilingual-e5-large-instruct

Best for: a proven MIT-licensed multilingual baseline to test newer models against.

• Specs. 24 layers, 1024 dimensions, initialized from xlm-roberta-large, 100 languages. Long texts are truncated at 512 tokens (model card).
• License and adoption. MIT. About 1.4M downloads in 30 days on 26 Sept 2026. The card cites a 2024 technical report and points to Microsoft's unilm repo for evaluation code.
• Benchmark. The card lists per-task MTEB results but no single average, so we give none.
• Pros. MIT license, wide tooling support and instruction-tuned queries, so a one-sentence task description can steer retrieval.
• Cons. The card says low-resource languages may see weaker quality. Queries need an Instruct: ... Query: ... prefix or quality drops, and 512 tokens is short.

Skip it if you need long context or strong results in low-resource languages without testing first.

Pick this if you want a well-known MIT baseline for your own eval set.

Also considered

• Cohere Embed v4. 1536 dimensions by default (256, 512 and 1024 also available), 128k context, text and images, per Cohere's docs. Left out of the list because we found no verified per-token price.
• voyage-4-nano. Apache 2.0 open weights, 32,000 context, about 340M parameters (180M non-embedding plus 160M embedding), with 2048, 1024, 512 and 256 dimensions. Worth a look for local development.
• Qwen3-Embedding-0.6B. Apache 2.0 at 1024 dimensions, and the lightest way into the Qwen family.

Use-case decision table

How to choose

API or self-hosted. An API means no GPU work and a per-token bill. Embedding a 1B-token corpus costs about $20 with text-embedding-3-small, $130 with text-embedding-3-large, $120 with voyage-4-large (less after the free 200M tokens) and $200 with Gemini Embedding 2 (our arithmetic from the listed prices). Self-hosting turns that into fixed GPU cost. It pays off at high volume, with strict data residency, or when query traffic is constant, because you also embed every query.

Dimensions and storage. Vector storage scales linearly with dimensions. One million float32 vectors take about 4.1 GB at 1024 dimensions, 6.1 GB at 1536, 12.3 GB at 3072, 16.4 GB at 4096 and 21.5 GB at 5376 (our arithmetic: vectors times dimensions times 4 bytes). Most models here support Matryoshka truncation, so you can cut dimensions and quantize. Google's own table shows gemini-embedding-001 scoring 68.17 at 1536 and 67.55 at 512, so test truncation before you pay for the full size.

Multilingual. Check that the languages you need are in the model card, not just the headline count. Qwen3-Embedding lists 100+ languages, Jina v5 119+, Gemini Embedding 2 over 100. Test on your own language pairs, including cross-language queries.

Long context and chunking. Max tokens caps the chunk size you can embed. Voyage 4, Qwen3, Harrier and Jina v5 accept 32K or more. OpenAI, Gemini, Codestral Embed, BGE-M3 and Arctic Embed stop at 8,192. EmbeddingGemma takes 2K, and Nomic Embed Text v2 and multilingual-e5 stop at 512. Long context does not mean you should embed whole documents. Chunks around a paragraph or a section usually retrieve better, though that depends on your content.

Domain. For code, legal and finance, look at domain-tuned models first (Voyage lists code, finance and law variants, and Mistral sells Codestral Embed for code) and compare them to a general model on your data.

Latency. Query embedding happens on every search. A 27B model is slower to serve than a 0.6B model, and API calls add network time. Voyage's shared embedding space lets you index with a large model and query with a small one.

How to read the benchmarks

MTEB averages dozens of tasks: retrieval, clustering, classification, reranking, semantic similarity. A model can top the average and still lose on retrieval in your domain, because the average includes tasks you do not care about. The numbers in this post also come from different variants. OpenAI's 64.6 is an older MTEB average. Harrier's 74.3 is multilingual MTEB v2. Jina's 71.7 and EmbeddingGemma's 69.67 are MTEB English v2. Voyage reports RTEB retrieval gains, not MTEB at all. Snowflake and Nomic report BEIR and MIRACL retrieval scores, which are different benchmarks again. None of these numbers are comparable across rows.

Our recommendation, not a claim from any source, is to build a small eval set from your own data. About 200 real queries, each with the chunks that should be retrieved, is enough to separate models that differ by more than a few points. Run your top 2 or 3 candidates and measure recall at 5 or 10. It takes an afternoon and tells you more than any leaderboard.

When the model is not the bottleneck

When retrieval is poor, the cause is often chunking, missing metadata filters, no reranker or a stale index rather than the model. If retrieval quality stays poor after you have tested a strong model on your own queries, the pipeline around it is the next place to look. Our list of RAG frameworks covers the chunking and retrieval layer, and if data cannot leave your network, private on-prem AI for regulated industries walks through the hosting side. To serve open-weight models locally, see local LLM tools.

AY Automate is a service, not an embedding vendor, so it is not in the list above. If you want help designing the whole pipeline, see our RAG pipeline architecture and development service. For the surrounding decisions, read vector databases for AI agents and GraphRAG implementation. For model shopping in another category, see free AI models for coding.

FAQ

What is the best embedding model in 2026?

There is no single winner. On vendor-reported numbers, Microsoft's Harrier-oss-v1-27b claims the top multilingual MTEB v2 score in our list (74.3), and Voyage says voyage-4-large has the best RTEB retrieval results among the API models it tested. The right choice depends on language, budget and hosting. Test two or three on your own queries.

What is the best open source embedding model?

For permissive licenses, Qwen3-Embedding-8B (Apache 2.0) and Microsoft Harrier-oss-v1 (MIT) lead the model-card claims we found. BGE-M3 (MIT) is the most downloaded. Arctic Embed L v2.0 and Nomic Embed Text v2 are Apache 2.0, and multilingual-e5-large-instruct is MIT. Jina v5 has strong scores, but its Hugging Face weights are CC BY-NC 4.0, which restricts commercial use.

What is the cheapest embedding model?

Among verified API prices, OpenAI text-embedding-3-small and voyage-4-lite are both $0.02 per 1M tokens, and Voyage gives 200M tokens free per account. Self-hosted open models have no per-token fee but cost GPU time.

How many dimensions should I use?

Start with 1024, or 768 to 1536 if the model supports truncation. Storage grows linearly, and Google's own numbers show little quality loss between 1536 and 768 dimensions for gemini-embedding-001. Confirm on your eval set.

Can I switch embedding models later?

Yes, but you must re-embed every document and rebuild the vector index, because vectors from different models are not compatible. The exception is Voyage's 4 series, which Voyage says shares one embedding space across its models.

Does a higher MTEB score mean better RAG results?

Not reliably. MTEB averages many task types and several variants exist, so scores from different sources are not directly comparable. Retrieval-specific scores and your own 200-query eval are better predictors.

What is the best embedding model for code search?

Test a code-tuned model first. Voyage sells voyage-code-4 at $0.12 per 1M tokens and Mistral sells Codestral Embed at $0.15. Qwen3-Embedding lists code retrieval among its tasks, and EmbeddingGemma publishes an MTEB Code v1 score of 68.76. Compare two of them on real queries from your own repository.

Which embedding models are free for commercial use?

Check the license, not the download page. Qwen3-Embedding, Snowflake Arctic Embed and Nomic Embed Text v2 are Apache 2.0. Harrier, BGE-M3 and multilingual-e5-large-instruct are MIT. EmbeddingGemma uses Google's separate Gemma terms, and Jina v5 weights are CC BY-NC 4.0, which rules out commercial use without a paid route.

Why do some embedding models need a query prefix?

Many open models learned to tell queries and documents apart through a text prefix. Nomic Embed Text v2 expects search_query and search_document prefixes, Arctic Embed wants a "query: " prefix on queries only, and multilingual-e5 wants a one-line task instruction. Skip the prefix and retrieval quality drops, per their model cards.

What is the smallest embedding model worth self-hosting?

In this list, EmbeddingGemma has 300M parameters, Harrier has a 270M version, Nomic Embed Text v2 uses 305M active parameters and Arctic Embed L v2.0 has 303M non-embedding parameters. Small models cut GPU cost, but EmbeddingGemma stops at 2K tokens, Nomic at 512 and Arctic at 8,192. Match that limit to your chunk size first.