7 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. We checked every spec and price below against the vendor docs and Hugging Face model cards on 19 September 2026. 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 7 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).
• A top score claimed on an MTEB variant, either on the model card or in the vendor's launch post (Qwen, Microsoft Harrier, Jina).
• 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).

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. 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. All benchmark figures are vendor or model-card claims, not our own measurements.

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 7 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 is the cheapest API option we verified, 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. 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.

5. 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.

6. 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.

7. 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.

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 and Gemini stop at 8,192. 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 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 is MTEB English v2. Voyage reports RTEB retrieval gains, not MTEB at all. 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

Teams often swap embedding models three times before finding the real problem was chunking, missing metadata filters, no reranker or a stale index. 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.

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. 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.