Which Embedding Model Should You Use in 2026? Specs Compared

An embedding model turns text (and, for some models, images, audio, video or PDFs) into vectors you search by similarity, and the choice locks you in: switching models means re-embedding your whole corpus. For a cheap text default, pick text-embedding-3-small or voyage-4-lite at $0.02 per 1M tokens; for long documents, Cohere Embed 5 (128k tokens) or the Voyage 4 series (32k); for one vector space across text, images, audio and video, Gemini Embedding 2 on the API or EmbeddingGemma 2 as open weights; and for self-hosting, Qwen3-Embedding if you want flexible dimensions or BGE-M3 if you want sparse and dense vectors from one model.

Last updated: October 18, 2026

There are no quality rankings in this post. Every number is a documented spec from the site's verified embedding models table, which tracks 59 models with values read from official docs, pricing pages and Hugging Face cards on October 18, 2026. The few benchmark figures that appear are labelled vendor-reported, with the vendor named.

Official Sources#

The four numbers that decide it#

Price per 1M tokens. API embedding prices in the dataset run from $0.02 (text-embedding-3-small, voyage-4-lite, Titan Text V2) to $0.20 (Gemini Embedding 2 text input, $0.10 on Batch). That is a 10x spread, but as the worked example below shows, the absolute numbers are small next to storage for most corpora. Open-weight models have no per-token price; you pay for the GPU or CPU that runs them.

Dimensions. The length of each vector. Bigger vectors cost more to store and compare. What matters more than the default is whether the model is flexible: most current models are trained with Matryoshka Representation Learning (MRL), which Google's docs describe as training the model so that the first dimensions of a vector are a useful smaller version of the whole thing. You can keep the first 768 of 3072 numbers and still have a working embedding. OpenAI's v3 models, Gemini Embedding 2, Cohere Embed 5, the Voyage 4 series, Codestral Embed, Titan V2, Nova, the Alibaba models and most open-weight models here support this. Mistral Embed (1024), BGE-M3 (1024) and legacy text-embedding-ada-002 (1536) are fixed.

Max input tokens. How much text one embedding can cover. Most API models stop at 8,192 tokens (OpenAI, Gemini Embedding 2, Titan V2, Mistral at 8k). Voyage 4 takes 32,000, and Cohere Embed 5 and Qwen3.7 Text Embedding take 128,000. Long context does not remove the need to chunk for retrieval, but it means a whole contract section or source file can be one vector when that is what you want. Watch the failure mode: Google's docs say Gemini Embedding 2 silently truncates input over its limit.

Modalities. Text-only, text plus code, or genuinely multimodal (images, audio, video, PDF pages in the same space as text). Multimodal matters when the query is text and the answer is a screenshot, a diagram or a clip.

For open weights, add a fifth: license. Everything in the open-weight table below allows commercial use, but the licenses differ (Apache-2.0, MIT, OpenMDW-1.1), so read the one you ship.

The full 59-model table with filters and per-model pages lives at /models/embeddings.

%% title: Which embedding model should I pick
flowchart TD
  A[Start] --> B{Self-host required?}
  B -- Yes --> C{Need image, audio or video?}
  C -- Yes --> D[EmbeddingGemma 2]
  C -- No --> E{Hybrid sparse plus dense?}
  E -- Yes --> F[BGE-M3]
  E -- No --> G[Qwen3-Embedding or Granite R2]
  B -- No --> H{Docs over 8k tokens?}
  H -- Yes --> I[Cohere Embed 5 or Voyage 4]
  H -- No --> J{Multimodal?}
  J -- Yes --> K[Gemini Embedding 2 or Nova]
  J -- No --> L[text-embedding-3-small or voyage-4-lite]

API models at a glance#

Notes on the table:

• Voyage: the first 200 million tokens are free per account, and the Batch API is 33% cheaper (with no free tokens), per Voyage pricing.
• Gemini Embedding 2: text is $0.20 per 1M; image input is $0.45, audio $6.50 and video $12.00 per 1M tokens, and there is a free tier for interactive use, per Gemini API pricing.
• Alibaba prices are the Singapore region. Both models accept an OpenAI-compatible endpoint.
• OpenAI's pricing page lists only the standard embeddings rate; check the model page or Batch docs for any batch discount before budgeting.
• Nova: AWS documents the four supported sizes; the sources we read do not name a default.

What each does well, on documented capability alone. OpenAI ties for the lowest price and pairs it with fully flexible dimensions and a simple API. Gemini Embedding 2 has the widest modality set of any API here: text, images (up to 6 per request), audio (180 s), video (120 s) and a PDF of up to 6 pages, all in one space. Cohere Embed 5 has the longest context among the multimodal options and handles PDFs and mixed text-image inputs. Voyage gives you three general-purpose price points that share one embedding space, plus an open-weight sibling. Codestral Embed and Voyage Code 4 are documented as optimized for code retrieval. Codestral Embed, along with voyage-4-large, voyage-4 and voyage-4-lite, offers int8, uint8, binary and ubinary output types; Voyage's docs do not list those output types for voyage-code-4. Titan V2 and Nova keep everything inside Bedrock, and Qwen3.7 Text Embedding returns dense and sparse vectors from one call with 128k context.

One gotcha worth knowing before you embed news or changelogs: OpenAI's guide notes the v3 embedding models lack knowledge of events after September 2021.

Open-weight models at a glance#

A few specifics from the cards that change how you deploy:

• Qwen3-Embedding (released June 3, 2025) wants an instruction on the query side only. Qwen's card says leaving it off typically drops retrieval by about 1% to 5%, and advises writing instructions in English.
• EmbeddingGemma 2 loads in modular configurations: about 744M parameters in total (Google rounds it to 740M), of which the text-and-code backbone is 270M (the vision and audio encoders are the rest). The card warns that float16 returns NaN or degraded embeddings, so run it in bfloat16 or float32. Our EmbeddingGemma 2 guide covers local setup and the storage math on a real repository.
• BGE-M3 is the one model here that emits dense, sparse (lexical weight) and multi-vector ColBERT outputs from a single pass, which makes it a natural fit for hybrid retrieval.
• Nemotron 3.5 Embed 8B runs with vLLM, Transformers or Sentence Transformers per its card. Its card lists a 10/20/2026 Hugging Face release date although the repo was created October 7, 2026, so treat it as brand new.
• Granite 311M R2 ships ONNX and OpenVINO weights for CPU inference, covers 200+ languages, and its card says Ollama does not support it.
• Nomic Embed Text v2 MoE has a 512-token input limit, the shortest here, and needs trust_remote_code=True.
• Voyage 4 Nano produces embeddings compatible with the hosted Voyage 4 series, so you can embed locally and query through the API, or the reverse.

Hosting cost is your hardware, not a per-token rate. The open-weight embeddings page lists sizes, licenses and a usage snippet for each.

What 1B tokens costs#

A worked task: embed a 1B-token corpus once, at list prices.

For most teams that is a one-time bill, paid again only when you re-chunk or switch models. The recurring costs are query embeddings (small: a million 20-token queries is 20M tokens, or $0.40 on text-embedding-3-small) and vector storage, which runs every month and scales with the dimension count you pick.

Dimensions are a storage decision#

Raw vector storage is vectors x dimensions x 4 bytes for float32. For 10 million vectors:

Those are raw vectors only. HNSW graphs, metadata and replicas sit on top, and many vector stores keep the index in memory, so the dimension you choose shows up directly on the RAM line of your bill. The helper we used to compute the table, plus the normalization function you need when you truncate vectors yourself:

// Raw vector bytes only: float32 = 4 bytes per dimension.
// Index overhead (HNSW graphs, metadata) comes on top of this.
export function rawVectorBytes(vectors: number, dims: number, bytesPerDim = 4): number {
  return vectors * dims * bytesPerDim;
}

const gib = (b: number) => (b / 1024 ** 3).toFixed(2);

for (const dims of [3072, 1536, 1024, 768, 512, 256]) {
  console.log(`${dims} dims x 10M vectors = ${gib(rawVectorBytes(10_000_000, dims))} GiB`);
}

// L2-normalize a vector you truncated yourself (needed for gemini-embedding-001
// below 3072 dims, or when you slice a Matryoshka vector client-side).
export function l2normalize(v: number[]): number[] {
  const mag = Math.hypot(...v);
  return mag === 0 ? v : v.map((x) => x / mag);
}

Quantized output types cut storage further. voyage-4, voyage-4-large and voyage-4-lite (not listed for voyage-code-4) and Codestral Embed return int8 or uint8 (1 byte per dimension) and binary or ubinary (one bit per dimension, so a 1024-dim vector is 128 bytes instead of 4,096). Titan V2 offers binary output. Mistral Embed outputs vectors with norm 1, so cosine, dot product and Euclidean distance rank results identically.

How much do you lose by shrinking? Two vendor-reported data points, not independent measurements:

• Google publishes an MTEB table for gemini-embedding-001 across MRL sizes: 2048 dims scores 68.16, 1536 scores 68.17, 768 scores 67.99, 512 scores 67.55, 256 scores 66.19 and 128 scores 63.31 (Gemini embeddings docs). On Google's numbers, going from 1536 to 768 halves storage for a fraction of a point; going below 256 costs noticeably more.
• OpenAI says a text-embedding-3-large embedding shortened to 256 dimensions still outperforms an unshortened 1536-dimension text-embedding-ada-002 embedding on MTEB (OpenAI embeddings guide).

The practical rule: start at a size the vendor recommends (Google names 768, 1536 and 3072 for Gemini), evaluate recall on your own queries at two sizes, and pick the smaller one if the gap is within your tolerance. Decide early, because changing dimensions later still means rewriting every stored vector.

%% title: Matryoshka truncation and normalization
flowchart LR
  A[Full vector 3072] --> B[Keep first 768]
  B --> C{API truncated it?}
  C -- Yes --> D[Already normalized]
  C -- No --> E[L2 normalize yourself]
  D --> F[Store 768 floats]
  E --> F

The normalization step is where people get burned. Google's docs say gemini-embedding-2 normalizes truncated outputs for you, while gemini-embedding-001 needs manual normalization below 3072. OpenAI recommends the dimensions parameter over slicing, and says that if you shorten vectors by hand you must L2-normalize them. Skip that and cosine similarity on unnormalized truncated vectors quietly ranks results differently.

Code: request smaller vectors from the API#

Ask the API for the size you want rather than slicing client-side. OpenAI, with text-embedding-3-small at 512 dimensions:

import OpenAI from "openai";

const client = new OpenAI(); // reads OPENAI_API_KEY

// Ask the API for 512 dimensions instead of the 1536 default.
// OpenAI's guide recommends the dimensions parameter over truncating by hand.
export async function embedDocs(texts: string[]): Promise<number[][]> {
  const res = await client.embeddings.create({
    model: "text-embedding-3-small",
    input: texts,
    dimensions: 512,
  });
  return res.data.map((d) => d.embedding);
}

const vectors = await embedDocs(["How do I rotate an API key?"]);
console.log(vectors[0].length); // 512

Gemini Embedding 2 at 768 dimensions, with the task written into the text:

import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({}); // reads GEMINI_API_KEY

// gemini-embedding-2 has no task_type parameter: the task goes in the text.
const asQuery = (q: string) => `task: search result | query: ${q}`;
// Google's docs: if a document has no title, use "title: none".
const asDocument = (text: string, title = "none") =>
  `title: ${title} | text: ${text}`;

export async function embed(texts: string[]): Promise<number[][]> {
  const res = await ai.models.embedContent({
    model: "gemini-embedding-2",
    // One Content object per text returns one embedding per text.
    contents: texts.map((t) => ({ parts: [{ text: t }] })),
    config: { outputDimensionality: 768 },
  });
  return (res.embeddings ?? []).map((e) => e.values ?? []);
}

const [doc] = await embed([asDocument("Rotate keys from the dashboard.", "Key rotation")]);
const [query] = await embed([asQuery("how do I rotate an api key")]);
console.log(doc.length, query.length); // 768 768

Why one Content object per text: Google's docs say gemini-embedding-2 returns a single aggregated embedding when you pass multiple parts inside one Content. That is useful for embedding an image and its caption together, and a silent bug when you meant to batch ten separate chunks and got one vector back.

Both examples type-check (strict, moduleResolution: bundler) against openai@7.38.0 and @google/genai@2.30.0 with TypeScript 7.0.2; we did not run live calls. If you are wiring this into a retrieval pipeline, What is RAG walks through where the embedding step sits.

Query and document are not the same input#

Many models embed queries and documents differently, either through a parameter or a text prefix. Get this wrong and retrieval degrades without any error.

The rule that saves you: whatever prefix or type you index documents with, query with its documented counterpart, and keep both strings identical forever. Version the prefix alongside your vectors, because changing it later is a re-embed too.

%% title: Asymmetric query and document embedding
sequenceDiagram
  participant App
  participant Model
  participant DB as Vector DB
  App->>Model: title: X | text: doc
  Model-->>App: doc vector
  App->>DB: upsert
  App->>Model: task: search result | query: q
  Model-->>App: query vector
  App->>DB: nearest neighbors
  DB-->>App: top k chunks

Why switching models means re-embedding#

Vectors from different models live in different spaces. A query vector from model B compared against document vectors from model A returns numbers, not meaningful neighbors. Google states this plainly for its own models: the embedding spaces of gemini-embedding-001 and gemini-embedding-2 are incompatible, and upgrading requires re-embedding all existing data. That matters on a schedule, because the Gemini deprecations page lists a May 14, 2028 shutdown for gemini-embedding-001 with gemini-embedding-2 as the replacement. Other providers retire older embedding models on their own schedules, so check the deprecation page of whichever API you use before you build on it.

There are two documented exceptions, both within a single family:

• Voyage 4 series: Voyage's docs say all embeddings created with the 4 series are compatible with each other, including the open-weight voyage-4-nano. You can index with voyage-4-large and query with voyage-4-lite.
• Cohere Embed 5: Pro and Fast share an embedding space, and Cohere recommends indexing with Pro and querying with Fast.

Everything else needs a migration. The recipe:

1. Store the model id, dimension count and prefix version next to every vector, so you always know what produced it.
2. Re-embed the corpus with the new model into a separate index while the old one keeps serving.
3. Run a fixed set of real queries against both and compare recall on the results you know are correct.
4. Cut over when the new index matches or beats the old one, then drop the old index.

%% title: Re-embedding migration
flowchart TD
  A[Old index, model A] --> B[Re-embed corpus with model B]
  B --> C[New index, model B]
  A --> D[Shadow queries]
  C --> D
  D --> E{Recall OK?}
  E -- Yes --> F[Cut over and drop A]
  E -- No --> G[Adjust chunks or dims]
  G --> B

The re-embed bill is the 1B-token table above. The engineering time to run two indexes side by side is usually the larger cost, which is the real argument for choosing carefully the first time.

Pick by task#

Once you have picked a model and a dimension count, the vector database comparison covers where to store the vectors.

FAQ#

Which embedding model should I use in 2026?#

For text-only RAG on a budget, text-embedding-3-small or voyage-4-lite at $0.02 per 1M tokens. For documents longer than 8k tokens, Cohere Embed 5 (128k) or the Voyage 4 series (32k). For mixed media, Gemini Embedding 2 ($0.20 per 1M text tokens). To self-host, Qwen3-Embedding for flexible dimensions or BGE-M3 for hybrid sparse and dense retrieval. Then test recall on your own queries before committing.

Does reducing embedding dimensions hurt retrieval quality?#

Somewhat, and less than you might expect for MRL-trained models. Google's vendor-reported MTEB table for gemini-embedding-001 shows 67.99 at 768 dims versus 68.17 at 1536, falling to 63.31 at 128. OpenAI reports that text-embedding-3-large at 256 dims beats text-embedding-ada-002 at 1536 on MTEB. Neither is a measurement on your data, so evaluate two sizes on your own query set.

Can I switch embedding models without re-embedding?#

No, with two documented exceptions: models within the Voyage 4 series (including voyage-4-nano) share one space, and Cohere Embed 5 Pro and Fast share one space. Even Google's two Gemini embedding models are incompatible with each other.

Do I need task prefixes like "query:" and "passage:"?#

It depends on the model. Nemotron uses query: and passage:, Nomic requires search_query: and search_document: , Cohere requires input_type, Voyage takes an optional input_type, Gemini Embedding 2 wants task strings in the text (with title: none for documents that have no title), and Qwen3-Embedding wants a query-side instruction. BGE-M3 needs no query prefix, and OpenAI and Mistral document none. Use exactly what the docs say, on both sides, every time.

Are open-weight embedding models free for commercial use?#

The ones covered here allow it, under different licenses: Apache-2.0 for Qwen3-Embedding, EmbeddingGemma 2, Granite Embedding R2, Nomic Embed Text v2 MoE and voyage-4-nano; MIT for BGE-M3; and OpenMDW-1.1 for Nemotron 3.5 Embed 8B. Read the license text for the model you ship.

Sources#

• OpenAI embeddings guide
• OpenAI API pricing
• OpenAI text-embedding-3-small model page
• OpenAI text-embedding-3-large model page
• Gemini API embeddings
• Gemini API pricing
• Gemini API deprecations
• Cohere Embed models
• Cohere pricing
• Voyage text embeddings
• Voyage pricing
• Mistral text embeddings
• Mistral Embed model page
• Codestral Embed model page
• Mistral code embeddings
• Amazon Titan Text Embeddings V2 model card
• Amazon Nova 2 embeddings guide
• Amazon Bedrock pricing
• Alibaba Cloud Model Studio embedding
• Alibaba Cloud Model Studio pricing
• Qwen3-Embedding-8B model card
• Qwen3-Embedding-0.6B model card
• EmbeddingGemma 2 model card
• EmbeddingGemma 2 announcement
• BGE-M3 model card
• Nemotron 3.5 Embed 8B model card
• OpenMDW 1.1 license
• Granite Embedding 311M Multilingual R2 model card
• Nomic Embed Text v2 MoE model card
• Voyage 4 Nano model card

Continue Reading#

• Vector Database Comparison for RAG and AI Agents
• EmbeddingGemma 2 Guide: Local Multimodal Embeddings for Code
• What is RAG