Best Embedding Models in 2026: Gemini, OpenAI, Voyage, Cohere, Qwen and BGE Compared

The best embedding models are the ones that retrieve your answer reliably: start with OpenAI text-embedding-3-small as the low-cost text baseline, compare Voyage 4 for retrieval, and choose Google Gemini Embedding 2 when the source includes audio or video. OpenAI's small model starts at $0.02 per million input tokens, but the larger commitment is the vector index you must rebuild if you change to an incompatible model.

An embedding model turns content into a vector, a list of numbers that lets search find related meaning even when the words differ. For a support bot, that means connecting “I can't get into my account” with the right sign-in troubleshooting article. Retrieval-augmented generation, or RAG, passes that retrieved source to the model writing the answer.

Specifications, prices and licences verified against the makers' live pages on 15 October 2026. This is a documentation-based comparison, not a hands-on accuracy or latency benchmark. The recommendations below are starting points for your own evaluation. OpenAI's pricing supplies the introductory rate.

Best embedding models at a glance

Use the cheapest model that meets your retrieval requirements, then change the shortlist when your languages, source formats or deployment constraints demand it. The seven families below cover managed APIs, private deployment and downloadable weights.

Prices are standard paid rates in USD per million text input tokens, unless the row says self-host. They exclude the vector database, answer generation and reranking, which means rescoring retrieved candidates with another model. Each provider tokenizes text differently, so the same document can produce different billable token counts.

“Open weights” means the model files are available to run yourself. It does not mean compute, deployment or maintenance is free. “Multilingual” also does not mean equally accurate in every language: test the actual query-to-document language pairs your customers use.

The model shortlist

1. OpenAI text-embedding-3: the practical text baseline

OpenAI text-embedding-3-small and text-embedding-3-large are hosted text embedding models, and small is my starting recommendation for a founder shipping a conventional help-centre search or support bot. It gives you a low-cost baseline without operating model servers. Large is the candidate to compare when small repeatedly misses relevant passages; paying for it before you have those examples skips the most useful part of the decision.

Dimensions: small defaults to 1,536; large defaults to 3,072. Both support shorter vectors through the dimensions parameter.
Maximum input: 8,192 tokens per input for either model.
Languages and modalities: multilingual text; neither accepts images, audio or video. The cited docs do not provide an exhaustive supported-language count.
Where to run: OpenAI's hosted embeddings API. Specifications, modalities.
Best for: a text-first application whose developer wants a measurable baseline quickly.
Standout: the same API gives you a small/large comparison and configurable output size.
Pricing: $0.02 per million input tokens for small; $0.13 for large, standard rates verified 15 October 2026. Pricing.
Free trial: no introductory API credit assumed; budget from paid usage.

The wall is the input format. A troubleshooting PDF reduced to extracted text may lose the screenshot that explains which button to press. Neither OpenAI embedding model restores that visual information. Use text embeddings when the answer survives extraction; compare a multimodal model when page appearance carries the answer.

Also separate model size from vector size. Large at a reduced output dimension may fit an existing storage constraint, but that does not make it interchangeable with small. A matching vector length is a schema match, not proof that two models organize meaning the same way.

Start the baseline without hiding retrieval failures

Keep the initial setup simple enough that you can explain why a result appeared.

1. 1

   Prepare answerable source chunks

   Split the help centre by topic or section. Keep the document title, source URL, customer permissions and stable chunk ID alongside each passage. Avoid combining unrelated instructions merely to fill the model's context window.

2. 2

   Fix the embedding configuration

   Choose text-embedding-3-small and record the output dimension. Embed every stored passage with that configuration, then create the vector index with the matching dimension. Preserve the original text separately.

3. 3

   Search before adding answer generation

   Embed each test question with the same configuration, retrieve the closest passages and inspect them. A plausible generated answer can conceal that retrieval selected the wrong source.

4. 4

   Compare a challenger on the same questions

   Create a separate candidate index for large or Voyage. Keep the source chunks and relevance labels fixed. Adopt the challenger only when the improvement matters to your application.

2. Voyage AI 4: the retrieval-focused API challenger

Voyage AI's Voyage 4 family is a hosted text embedding option worth putting beside your baseline when retrieval quality is central to the product. Start the comparison with voyage-4, then evaluate lite for latency and cost or large for the maker's highest-quality general-purpose option. A technical documentation search, where customers describe the same failure in different terms, is a more useful test than a collection of easy keyword matches.

Dimensions: 1,024 by default; 256, 512 and 2,048 also supported across voyage-4-lite, voyage-4 and voyage-4-large.
Maximum input: 32,000 tokens for each of those models.
Languages and modalities: multilingual text; the model table does not give an exhaustive language count. These are not the separate Voyage multimodal models.
Where to run: Voyage AI's hosted embeddings API. Model specifications.
Best for: a developer willing to run a retrieval comparison before choosing the API.
Standout: compatible embeddings across the general-purpose Voyage 4 family.
Pricing: per million input tokens, $0.02 for 4-lite, $0.06 for 4 and $0.12 for 4-large, verified 15 October 2026. Pricing.
Free trial: the pricing page lists an initial 200 million free tokens for the current general-purpose models; check the allocation against the model you use.

The compatibility claim is useful operationally. Voyage documents a shared embedding space across this family, so you can evaluate a different query-side variant without automatically rebuilding every document vector. Keep the output dimensions consistent and measure that exact document/query pairing. Do not extend this promise to every model carrying the Voyage name.

The wall is silent truncation: the API's truncation setting defaults to true. A long document can produce a valid vector even though its ending was discarded. Set truncation=false during ingestion development so oversize inputs fail visibly, then fix the chunking. A large context limit is room for coherent passages, not a reason to turn an entire manual into one search result. API behaviour.

For a code-only corpus, the maker also offers voyage-code-4; compare the specialist against the general-purpose candidate on repository questions. Do not add a specialist merely because some support articles contain code snippets.

3. Google Gemini Embedding 2: the broad multimodal choice

Google Gemini Embedding 2 is the managed option to shortlist when search must connect text with images, audio, video or PDF pages. A support system spanning written guides and recorded product demonstrations can keep those source types in one embedding space. Choose it because those modalities carry useful evidence, then compare its retrieval on your sources; a text-only help centre does not automatically benefit from a broader input menu.

Dimensions: 128 to 3,072; Google recommends 768, 1,536 or 3,072.
Maximum input: 8,192 tokens.
Languages and modalities: over 100 languages; text, images, audio, video and PDF.
Where to run: Gemini API, using the stable model ID gemini-embedding-2. Model card, capabilities.
Best for: managed search over sources that cannot be adequately represented as extracted text.
Standout: audio and video join text and images in the same vector space.
Pricing: standard rates per million input tokens are $0.20 text, $0.45 image, $6.50 audio and $12.00 video, verified 15 October 2026. Pricing.
Free trial: a free API tier is available, subject to its usage limits.

The wall is modality-specific ingestion. Google allows up to 6 images, 180 seconds of audio, 120 seconds of video, or one PDF of up to 6 pages per request, within the overall input constraints. Video processing uses at most 32 frames and does not process the video's audio track. A narrated demonstration therefore needs an explicit plan for its spoken explanation as well as its visuals. Input limits.

Store the timestamp or page reference with each embedded item. Finding the right video is less useful than opening the relevant moment; retrieving the right PDF is less useful than identifying the page that contains the answer. Your chunking and metadata determine that navigation experience.

A migration detail matters for existing Google users: gemini-embedding-001 and gemini-embedding-2 have incompatible embedding spaces. Keeping the same number of dimensions does not preserve compatibility. Google explicitly requires re-embedding the existing corpus when moving between them. Migration guidance.

4. Cohere Embed 5: enterprise documents and deployment flexibility

Cohere Embed 5 is the candidate for teams whose search problem lives in long documents, tables, charts and mixed text/image pages. The current family is embed-v5.0-pro and embed-v5.0-fast. For an internal support assistant searching visually structured manuals, compare page-aware retrieval with the text extraction you already use; the relevant question is whether the correct instruction survives your ingestion process.

Dimensions: 2,048 by default; 256, 512, 768, 1,024 and 1,536 also supported.
Maximum input: 128K tokens for Pro and Fast.
Languages and modalities: over 100 languages; text, images and mixed text/image inputs, including document-page representations.
Where to run: Cohere API, Model Vault, Microsoft Foundry and Amazon SageMaker; commercial private deployment in your VPC or on premises is also supported. Specifications, deployment and language coverage.
Best for: enterprise document search with a deployment requirement beyond a shared public API.
Standout: Pro and Fast share an embedding space, allowing a Pro-indexed corpus to be queried with Fast.
Pricing: $0.08 per million text tokens for Fast or $0.12 for Pro; both list $0.40 per million image tokens, verified 15 October 2026. Text pricing, image pricing.
Free trial: rate-limited trial API keys are free and cannot be used for production or commercial purposes.

The long context window is useful when a passage needs surrounding context, but it does not remove the retrieval-design problem. If a returned chunk contains an entire handbook, your answer model must still find the relevant passage. Compare a long-context representation with section-level chunks before choosing the larger input just because it fits.

Cohere also supports float, int8 and binary output representations. Those describe how the vector's numbers are stored; smaller representations can change memory and retrieval behaviour. Check what your chosen database and retrieval implementation accept, then measure the compressed configuration itself. A result obtained with full-size float vectors does not automatically validate a smaller binary index.

The maker still documents embed-v4.0, with a 128K context and 1,536 default dimensions. That is an existing model to evaluate on its own terms, not the current family's specification. Nor does private deployment make Embed 5 an Apache-licensed download: commercial deployment terms remain part of the purchase.

5. Qwen3-Embedding: the configurable open text family

Qwen3-Embedding gives developers downloadable text embedding models in different sizes, making it a strong self-hosted shortlist when data location or runtime control determines the architecture. For a company searching private engineering documents, start with the smallest variant that meets its relevance target. Moving straight to the largest checkpoint can turn an embedding choice into an infrastructure project before you know whether it improves answers.

Dimensions: maximum output sizes are 1,024 for 0.6B, 2,560 for 4B and 4,096 for 8B; the family supports adjustable dimensions.
Maximum input: 32K tokens across those variants.
Languages and modalities: over 100 languages, including support for code retrieval; text input. This is Qwen3-Embedding, not the separate Qwen3-VL family.
Where to run: your own infrastructure with the maker's Sentence Transformers, Transformers, vLLM or Text Embeddings Inference examples. Model card.
Licence: Apache 2.0. Licence file.
Best for: self-hosted multilingual text retrieval with control over model and output size.
Standout: task instructions let you specify the retrieval job.
Pricing: open weights, self-host; there is no universal per-million-token infrastructure price.
Free trial: downloadable weights; you supply the runtime and compute.

The wall is serving cost and behaviour under load. Measure indexing throughput and interactive query latency separately. Backfilling a corpus can tolerate a queue; a customer waiting for a support answer experiences every extra inference delay. Your batch size, input lengths, hardware and concurrency determine whether the larger model fits the product.

Follow the model card's retrieval instructions. Query formatting is part of the configuration you are evaluating, so record it with the checkpoint and output dimensions. A benchmark of one instruction format does not validate a different production prompt. Keep the document-side and query-side conventions stable while comparing candidates.

Self-hosting is most compelling when control itself has value or your measured workload justifies the operations. It is not automatically the cheaper way to embed a small help centre. The tiny hosted token bill can be lower than the time spent maintaining a model service, even before hardware is counted.

6. BAAI BGE-M3: open retrieval beyond one dense vector

BAAI BGE-M3 is the open model to shortlist when you want dense, sparse and multi-vector retrieval from the same model. Dense vectors capture semantic similarity; sparse representations attach weights to lexical features; multi-vector retrieval retains more than one vector for richer matching. A support corpus containing product identifiers and error codes is a useful setting for comparing those approaches, because near-meaning alone may return the wrong exact identifier.

Dimensions: 1,024 for the dense embedding; the sparse and multi-vector outputs have different structures.
Maximum input: 8,192 tokens.
Languages and modalities: more than 100 languages; text.
Where to run: self-host using the maker's FlagEmbedding implementation. Model card.
Licence: MIT, as recorded in the maker's model-card metadata.
Best for: developers prepared to evaluate hybrid retrieval, which combines lexical and semantic signals.
Standout: several retrieval representations from one model family.
Pricing: open weights, self-host; compute and storage are your costs.
Free trial: downloadable weights; no hosted service allowance implied.

The wall is that generating several representations does not make your database use them. If you save only the dense vector and run a dense search, you have built a dense retrieval system. Using sparse or multi-vector output requires compatible indexing and scoring, followed by a decision about how to combine results.

Start with dense retrieval, then add the lexical signal on the questions it should help: exact part names, error strings and identifiers. Examine whether those improvements damage broader paraphrase matching. Add a reranker only after you can see the candidate results it is being asked to repair.

BGE-M3 earns its place for this flexibility, not because an older launch benchmark proves it beats every current API. If you only need straightforward dense embeddings, compare it with Qwen and the hosted baseline before accepting extra retrieval complexity.

7. Google EmbeddingGemma: local search, with two distinct generations

Google EmbeddingGemma 2 is the local candidate when the application must search text and media on the user's device. A desktop knowledge tool could index notes alongside screenshots or recordings without sending every item to a hosted embedding API. The current model and the original embeddinggemma-300m differ in input support, context length and licence, so pin the exact repository in your build.

Dimensions: EmbeddingGemma 2 outputs 768 dimensions, with 512, 256 and 128 options.
Maximum input: 8,192 tokens.
Languages and modalities: over 100 languages; text including code, images, video and audio.
Where to run: locally or on your own infrastructure; the maker provides Sentence Transformers examples. Its 740M total parameters include selectively loadable vision and audio encoders. Model card.
Licence: Apache 2.0 for EmbeddingGemma 2, stated on that model card.
Best for: local or offline applications needing multimodal embeddings.
Standout: load the modality encoders your application needs.
Pricing: open weights, self-host; device resources and any hosted infrastructure remain your costs.
Free trial: downloadable weights.

The original EmbeddingGemma-300m remains a distinct text-only option: 300M parameters, a 2,048-token input limit, 768 dimensions with 512/256/128 alternatives, and training across over 100 spoken languages. It runs through Sentence Transformers, but its repository requires acceptance of Google's Gemma Terms of Use. Do not apply EmbeddingGemma 2's Apache licence to that older checkpoint. Original model and terms.

The wall is the device budget. Available memory, thermal behaviour and simultaneous application work matter more than whether a model file technically loads. Test a background indexing job while the user performs a normal foreground task. A compact model can still create an unpleasant application if ingestion monopolizes the device.

For shortened vectors, follow Google's normalization instructions and keep query and document dimensions aligned. Preserve the task prefixes as well. Those settings are part of the model deployment, not optional bookkeeping to reconstruct after retrieval quality changes.

How to choose for your search or support bot

Let a concrete requirement eliminate candidates before you compare quality. The decisive question is what failure would make the application unusable: missing the answer, losing visual evidence, sending data to an unacceptable location, or responding too slowly.

Best text embedding models

Start with OpenAI small and Voyage 4 for a hosted text application. Add OpenAI large when you want a comparison within the existing API; add Cohere when document structure and private deployment matter. Choose the challenger only if it improves the failures your users experience at acceptable latency and total cost.

For multilingual support, include cross-language examples: a Spanish question answered by an English article, local product names, mixed-language messages and transliterated terms. “Supports over 100 languages” does not establish that your most valuable language pair works well.

Best open source embedding models

Compare Qwen3-Embedding for configurable text retrieval, BGE-M3 when lexical and semantic retrieval both matter, and EmbeddingGemma 2 for local multimodal inputs. The licence applies to the exact checkpoint. Treat self-hosting as a deployment decision with a measurable operating cost, not a synonym for free API usage.

If the corpus contains photographed instructions, diagrams or recorded demonstrations, choose between extracting text and preserving the source modality deliberately. The text extraction route may be sufficient and easier to debug. Use multimodal retrieval when the missing visual or audio information changes the answer.

Best local embedding models

EmbeddingGemma 2 is the first local multimodal candidate here; Qwen's smaller variant and BGE-M3 belong on a text-only comparison. Measure on the hardware that will serve users. A result from a development workstation says little about the laptop or small server that must handle indexing and queries together.

The decision rule: keep the simplest candidate that clears your relevance, latency, deployment and language requirements. Switch when an evaluated alternative fixes an important failure, with enough benefit to justify the migration.

Read MTEB, then test your own data

Use the MTEB leaderboard to identify candidates, not to select a universal winner. MTEB, the Massive Text Embedding Benchmark, spans tasks such as retrieval, classification, clustering and similarity. Its leaderboard also provides language, domain and modality views. A score from one task collection is not automatically comparable with a score from another.

For RAG, inspect retrieval results relevant to your languages and domain. For visual sources, inspect a suitable multimodal or document-retrieval benchmark. Record the benchmark version and settings before using any result to support a decision. No numerical leaderboard scores are quoted here.

A useful first evaluation is a labelled set of 100 actual questions, with the source passages that should answer each. That is a proposed starting sample, not a claim of statistical certainty. Include questions with no valid answer, ambiguous wording, exact identifiers and the language combinations you serve.

Hold the source chunks, permissions, retrieval count and any reranker fixed while comparing models. Otherwise, you cannot tell whether the model or the surrounding pipeline caused the improvement. For a retrieval cutoff of ten, recall@10 measures how much of the relevant material appears in those results; nDCG@10 rewards putting more relevant results nearer the top.

Then inspect failures manually. Was the right passage missing, ranked too low, filtered out by permissions, or damaged during extraction? A model upgrade cannot repair a source passage that never entered the index. Measure query latency and ingestion throughput separately, and rerun the difficult cases after changing dimensions or compression.

Where to store and serve the vectors

Pinecone is a managed vector database that can store vectors you generate elsewhere and also hosts selected embedding models through its inference API. Its model catalog lists llama-text-embed-v2, multilingual-e5-large and pinecone-sparse-english-v0 as inference embedding options. That is a separate choice from calling Gemini, OpenAI or Voyage yourself and uploading their vectors.

Use integrated embedding when the supported model fits your evaluation and you want the service to handle text-to-vector conversion. Bring your own vectors when you want control over the model, media preprocessing or a self-hosted encoder. Pinecone's indexing documentation distinguishes these routes.

For a support bot, retain source text, stable IDs, access-control metadata and citations alongside the retrieval architecture. Embedding similarity is not authorization. Your application must restrict retrieval to material the user is allowed to see, whatever database you select.

The best vector database comparison covers the storage decision; Pinecone pricing covers its separate bill. If the assistant decides when to search, reformulates questions or performs follow-up retrieval, the agentic RAG explainer covers that workflow. An embedding model supplies the representation, while the retrieval system decides how to use it.

Dimensions change the storage commitment

Choose vector dimensions with the database in mind. At float32 precision, each number occupies four bytes. For one million vectors, 1,536 dimensions therefore require 6.144 GB of raw vector values; 3,072 dimensions require 12.288 GB. These are calculated decimal gigabytes, excluding metadata, index structures, replicas and other database overhead.

That is why a smaller output can matter even when embedding tokens are inexpensive. It also explains why model parameter count and vector dimensions should not be confused: one affects the encoder you run; the other affects every representation you store and search.

Test dimension reduction using the maker's supported method. Do not arbitrarily truncate a model that does not document support for it. Where normalization is required, apply it consistently. Then evaluate the reduced vectors themselves, because storage savings are useful only while the application still retrieves the required evidence.

Switching models means migrating an index

Budget for a corpus rebuild when the new model uses an incompatible embedding space. Replacing the query-side API name while keeping old document vectors usually breaks the match, even if both models return the same number of dimensions. Google's documented embedding-001-to-embedding-2 migration is an explicit example.

There are exceptions with stated boundaries: Voyage's general-purpose 4 family and Cohere's Embed 5 Pro/Fast pair document shared spaces. Those claims permit particular cross-model pairings, not arbitrary mixing across providers. Test the pairing and match the dimension and representation settings.

Estimate re-embedding with the actual number of input tokens. As an illustration, one million chunks averaging 500 tokens contain 500 million tokens. At Gemini Embedding 2's published standard text rate, the embedding pass calculates to $100. That excludes database writes, overlapping storage, preprocessing, queries, engineering and any discount. Rate source.

The token charge may be the easy part. You also need the source documents, the ingestion settings and enough capacity to keep the live system available while its replacement is built. Persist the model ID, dimensions, normalization, chunking version and query/document instructions with each index version.

1. 1

   Build a separate candidate index

   Re-embed retained source chunks with the new configuration. Keep the existing index serving requests. Use stable document IDs so you can compare corresponding records.

2. 2

   Replay the evaluation and inspect regressions

   Compare the candidate on the same labelled queries. Check permissions, citation targets, missing documents and query latency, as well as relevance. Account for documents changed during the backfill.

3. 3

   Switch the model and index together

   Route queries through the matching new encoder and index as one configuration change. Retain the old pair long enough to roll back if production behaviour differs from the evaluation.

How these were picked

These are seven model families with a clear role in the requested search, RAG and support-bot decision. Selection considered published input limits, dimensions, modalities, language coverage, deployment options, licences and current pricing. Maker pages were checked on the verification date; the storage and cost illustrations were calculated from the stated assumptions.

No models were benchmarked or load-tested for this article. The ordering is a recommended evaluation path for a typical text-first developer, not a measured accuracy ranking. Specialist code, domain-specific and other multimodal families were not given separate ranked cards; include them in your own shortlist when that specialty determines the application.

The ones to avoid

Avoid OpenAI text-embedding-3 for direct image or audio retrieval. It is a text family. Extracting words is a valid architecture, but it loses any information that exists only in the source's visuals or sound.

Avoid older Voyage 3 models as the automatic starting point for a new build. Voyage's current docs recommend the newer family. Keep an existing, evaluated deployment until there is a reason to pay the migration cost.

Avoid Qwen3-Embedding-8B as an unmeasured laptop default. Start by establishing the device's latency and resource limits, then evaluate whether the larger checkpoint earns its operational cost.

Avoid BGE-M3 for “hybrid search” if you will only store its dense output. You need a retrieval design that consumes the additional representation to gain that capability.

Avoid treating all EmbeddingGemma checkpoints as Apache 2.0. The current EmbeddingGemma 2 card states Apache 2.0; the original 300M repository uses Gemma terms. Exact versions matter in deployment as well as retrieval.

Frequently asked questions

Best embedding models for RAG

Start with OpenAI text-embedding-3-small as a low-cost hosted text baseline and compare Voyage 4 on your own questions. Gemini Embedding 2 or Cohere Embed 5 belong in the comparison when source modality changes the answer. Qwen3-Embedding, BGE-M3 and EmbeddingGemma are the self-hosted candidates here. The model that retrieves your labelled evidence reliably is the useful winner.

Best embedding models free

For hosted evaluation, Gemini offers a free API tier, Voyage lists initial token allowances, and Cohere provides rate-limited trial keys that exclude production and commercial use. Check the exact model's allowance and production terms before relying on free access for a customer-facing application.

Free embedding models for RAG

For self-hosted text RAG, compare Qwen3-Embedding and BGE-M3; for local multimodal RAG, include EmbeddingGemma 2. Their downloadable weights let you operate the encoder yourself, but inference, storage and maintenance still consume resources. Keep the licence attached to the exact checkpoint and include those operating costs when comparing with a hosted API.

Your next move: collect the support questions your current search misses and label the passages that should answer them. Use the AI business workflow audit checklist to define the workflow and success criteria before committing the full corpus.