Embedding model comparison: dimensions, storage and cost in one table
text-embedding-3-large outputs 3,072 dimensions; text-embedding-3-small outputs 1,536; OpenAI's older ada-002 also uses 1,536. For 2 million chunks of 400 tokens each, that is 24.6 GB, 12.3 GB and 12.3 GB of float32 vectors before index overhead, or a quarter of that at int8.
Your corpus
Advanced: storage rate, replicas and re-embeds
Storage GB is per replica. The cost line multiplies by replicas. The database's index overhead, payloads and backups are not included.
Self-hosted presets use a $0 per-token price. GPU and operations costs are not included.
Result 3-small
List prices, 19 Nov 2026. Decimal GB. Index overhead, replication, payloads, backups, GPU cost for self-hosting and egress are excluded.
Embedding models, side by side
| Model | Provider | Dimensions | Max input | $/1M tokens | Notes |
|---|---|---|---|---|---|
| Plugsky Embed | Plugsky | 2,048 | 8,192 | Flat plan | Included in plans; 8K context |
| text-embedding-3-small | OpenAI | 1,536 | 8,191 | $0.02 | Supports dimensions shortening |
| text-embedding-3-large | OpenAI | 3,072 | 8,191 | $0.13 | Supports dimensions shortening |
| text-embedding-ada-002 | OpenAI | 1,536 | 8,192 | $0.10 | Legacy model |
| Gemini Embedding 001 | 3,072 | 2,048 | $0.15 | Output dimensionality configurable | |
| Embed v3 English | Cohere | 1,024 | 512 | $0.10 | Short input limit; chunk accordingly |
| Mistral Embed | Mistral | 1,024 | 8,000 | $0.10 | General-purpose |
| nomic-embed-text-v1.5 | Nomic | 768 | 8,192 | Self-host | Matryoshka 64–768 |
| BGE-M3 | BAAI | 1,024 | 8,192 | Self-host | Multilingual |
Rows with an uncertain dimension or input limit were left out rather than guessed. If a model is missing, use its published model card and enter the dimensions and price manually in the calculator. Plugsky Embed is included in plans rather than priced per token.
The three numbers that decide an embedding model
Embedding models are easier to choose than chat models because the decision rests on three measurable properties, not on vibes.
Dimensions. The length of the output vector. More dimensions can carry more information, but they cost proportionally more to store, index and compare. The relationship between dimension count and retrieval quality is not linear, and past a point the extra dimensions buy very little.
Maximum input. The number of tokens the model will embed in one call. Text beyond the limit is truncated, not rejected, which is the quietest failure mode in retrieval: the tail of a long chunk disappears and the vector silently represents only the first part of the text.
Price per million tokens. Embedding is usually cheap relative to generation, but at corpus scale it stops being rounding error. A 500-million-token backfill costs $10 on text-embedding-3-small and $65 on text-embedding-3-large at list prices, before any re-embedding.
Everything else — benchmark scores, language coverage, quantization support — narrows the choice after those three have eliminated the obviously wrong options.
Dimensions: what they buy, and what they cost
A vector is an array of floating-point numbers. In the default float32 representation, each dimension is 4 bytes. The storage per vector is therefore dimensions × 4 bytes, before the index.
| Dimensions | Bytes / vector | 1M vectors | 10M vectors |
|---|---|---|---|
| 384 | 1,536 | 1.54 GB | 15.4 GB |
| 768 | 3,072 | 3.07 GB | 30.7 GB |
| 1,024 | 4,096 | 4.10 GB | 41.0 GB |
| 1,536 | 6,144 | 6.14 GB | 61.4 GB |
| 2,048 | 8,192 | 8.19 GB | 81.9 GB |
| 3,072 | 12,288 | 12.29 GB | 122.9 GB |
The jump from 1,536 to 3,072 doubles storage and doubles the memory bandwidth needed for a brute-force scan. If you are using an approximate index, it also changes the index's memory profile. Before choosing the larger model, test whether the extra dimensions improve recall on your own evaluation set. On many retrieval tasks the difference is small; on others it is real. The only way to know is to measure.
Maximum input is not chunk size
A model with an 8,191-token input limit can embed an 8,191-token document, but that does not mean it should. Embedding a whole document into one vector averages away the details that a retriever needs. Most RAG systems chunk at 300–800 tokens and embed each chunk separately, which keeps the vector specific and the input well below the model limit.
Two limits matter and they are different:
- Model input limit. The hard truncation point. Text above it is silently cut.
- Chunk size. The design choice. It should be set by the document structure and the retrieval task, not by the model maximum.
If you chunk at 1,000 tokens and the model limit is 512 — as Cohere Embed v3 English is — every chunk loses nearly half its text. The retriever then fails in a way that looks like a ranking problem but is really a truncation problem. Check the limit before you check the index. Use the RAG chunk size calculator for the chunk-size decision.
Worked example: 2 million chunks
Take 2 million chunks at 400 tokens each — 800 million tokens. At list prices:
| Model | Dimensions | Cost to embed once | float32 storage | int8 storage |
|---|---|---|---|---|
| text-embedding-3-small | 1,536 | $16.00 | 12.29 GB | 3.07 GB |
| text-embedding-3-large | 3,072 | $104.00 | 24.58 GB | 6.14 GB |
| text-embedding-ada-002 | 1,536 | $80.00 | 12.29 GB | 3.07 GB |
| Gemini Embedding 001 | 3,072 | $120.00 | 24.58 GB | 6.14 GB |
| Embed v3 English | 1,024 | $80.00 | 8.19 GB | 2.05 GB |
| Mistral Embed | 1,024 | $80.00 | 8.19 GB | 2.05 GB |
| nomic-embed-text-v1.5 | 768 | Self-host | 6.14 GB | 1.54 GB |
| BGE-M3 | 1,024 | Self-host | 8.19 GB | 2.05 GB |
The embedding bill is small. The storage bill is not. At 1,536 dimensions and float32, 2 million vectors occupy 12.29 GB. At 3,072 dimensions, 24.58 GB. Multiply by your vector database's per-GB rate, add replicas, and over a year the storage cost can exceed the one-time embedding cost. That asymmetry drives the decision: choose the smallest dimension that passes your retrieval evaluation, not the largest your budget allows. A model change later forces a full re-embed anyway, so the cost of starting small is a re-run, not a permanent handicap.
Vector storage: float32, int8 and binary
The same 2 million vectors at different precisions:
| Precision | Bytes / dimension | 1,536 dims | 3,072 dims | Quality impact |
|---|---|---|---|---|
| float32 | 4 | 12.29 GB | 24.58 GB | Baseline |
| float16 | 2 | 6.14 GB | 12.29 GB | Usually negligible; test on your evaluation set |
| int8 | 1 | 3.07 GB | 6.14 GB | Small recall loss, often acceptable |
| binary | 1 bit | 0.384 GB | 0.768 GB | Larger recall loss; needs reranking |
The formulas:
bytes_per_vector = dimensions × bytes_per_dimension
binary_bytes_per_vector = ceil(dimensions ÷ 8)
total_bytes = vectors × bytes_per_vector
GB = total_bytes ÷ 1,000,000,000
GiB = total_bytes ÷ 1,073,741,824
Quantization is not free. int8 and binary reduce storage and speed up distance computation, but they change the ranking. A common pattern is binary vectors for candidate generation followed by a reranker or a float32 rescoring pass on the top 100–1,000 results. That keeps most of the storage saving while recovering much of the recall. Measure the recall delta on your own dataset; published numbers vary by model and corpus. A reranker comparison is the next step if you go binary.
Matryoshka truncation
Matryoshka Representation Learning trains a model so that the first n dimensions of a vector are themselves a usable embedding. You can truncate a 1,536-dimension vector to 256, 512 or 768 and keep a useful, if slightly worse, representation. OpenAI's text-embedding-3 models expose this through the dimensions parameter; nomic-embed-text-v1.5 supports Matryoshka truncation from 64 to 768 dimensions.
The appeal is obvious: one embedding call, several storage tiers, no second model. The catch is that truncation is not free. Quality falls as dimensions fall, and the curve is model- and task-specific. The original Matryoshka paper (Kusupati et al., arXiv:2205.13147) shows graceful degradation, not zero degradation.
A practical protocol:
- Embed a representative sample at full dimensions.
- Evaluate retrieval at 100%, 50% and 25% of the dimensions on your own labelled queries.
- Pick the smallest size that stays within an acceptable recall loss — commonly 1–3 points.
- Re-embed the full corpus once at that size; do not store full vectors and truncate at query time unless you have a reason.
The last point matters for storage. Truncating at query time saves nothing; the full vector is already stored. Truncation only reduces storage if you write the shortened vector.
Which dimension should you pick?
| Dimensions | Good fit | Trade-off |
|---|---|---|
| 384 | Edge, mobile, very large corpora, latency-sensitive search | Lowest storage; weakest fine-grained recall |
| 768 | General-purpose RAG, multilingual models, balanced cost | Good quality per byte |
| 1,024 | Domain-specific retrieval, code search, multilingual | More storage, modest quality gain |
| 1,536 | Default for OpenAI small; general English retrieval | Twice the storage of 768 |
| 2,048 | Plugsky Embed; balanced hosted option | Included in plans; check the 8K input limit |
| 3,072 | Maximum-quality retrieval, small corpora, offline evaluation | 2× storage of 1,536; diminishing returns on many tasks |
The decision rule: start at 768 or 1,536, build an evaluation set of 100–300 real queries with known relevant chunks, and measure recall@10 and nDCG@10 at each dimension you are considering. If 768 is within 2 points of 3,072, take 768 and spend the savings on a reranker. A reranker usually buys more quality per dollar than another 1,536 dimensions.
Reading MTEB scores without being misled
MTEB is a useful benchmark and a poor selector. Three cautions:
- Version drift. Scores from different leaderboard versions are not directly comparable. A score in one release is not the same measurement as the same number in another.
- Task mismatch. MTEB averages over retrieval, classification, clustering, reranking and more. Your task is one of them. A model that wins the average can lose on your domain.
- Domain gap. Legal, medical, Arabic and code corpora are underrepresented in the average. A model that tops the general leaderboard can trail a smaller domain-specific model on your documents.
Use MTEB to build a shortlist of five, then run your own evaluation. This page deliberately omits a blended MTEB score column: without the leaderboard version and retrieval subset, a single number invites the wrong comparison.
Download the dataset
The model rows behind this page are available as CSV and JSON, with source and verification dates. CC BY 4.0.
Methodology
Dimensions, maximum input and prices are compiled from provider model cards and the models.dev catalogue, retrieved 19 Nov 2026. Every row is a value we could verify; uncertain rows were omitted rather than guessed. Storage arithmetic uses decimal GB and excludes index overhead, replication and payloads. Self-hosted models show a $0 per-token price because there is no API fee; GPU, memory and operations costs are not modelled. The dataset is published under CC BY 4.0.
Related: RAG chunk size calculator · RAG cost calculator · vector database comparison · reranker comparison · LLM API cost calculator · Plugsky Embed · plans.
FAQ
What dimension is text-embedding-3-large?
3,072 dimensions. text-embedding-3-small and the older ada-002 both output 1,536. The v3 models also accept a dimensions parameter that returns a shorter Matryoshka-truncated vector, so the stored dimension can be lower than the default.
Can I shorten an embedding without re-embedding the corpus?
Only if the model was trained with Matryoshka representation learning and you stored the full vector. You can truncate at query time, but that saves no storage because the full vector is already stored. To save storage, write the shortened vector at embed time.
How much storage do 1 million embeddings need?
At 1,536 dimensions in float32, about 6.14 GB before index overhead. At int8 it is about 1.54 GB, and as binary about 192 MB. Multiply by your database's replication factor and add index and payload overhead.
Does a bigger dimension always improve retrieval?
No. Quality improves with dimensions up to a point, then plateaus or improves only marginally, and the curve depends on the model and the task. Test recall@10 on your own queries at 768, 1,536 and 3,072 before paying for the larger vectors.
Want embeddings without a separate per-token bill?
Plugsky Embed is a 2,048-dimension, 8,192-token embedding model included in Plugsky plans. Use the same OpenAI-compatible API as generation, with flat-rate pricing and a 7-day money-back guarantee.
See Plugsky Embed → See plans and caps