Free tool · no sign-up

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.

Plugsky Embed

Self-hosted presets use a $0 per-token price. GPU and operations costs are not included.

Result 3-small

800 million tokens cost $16.00 to embed once on text-embedding-3-small. At 1,536 dimensions in float32, 2 million vectors occupy 12.29 GB (11.44 GiB). Monthly query cost is $0.40; storage cost depends on your database rate.
Embed once$16.00
Query cost / mo$0.40
Bytes / vector6,144
Storage12.29 GB

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

Dimensions, maximum input and list price per 1M tokens, retrieved 19 Nov 2026. “Flat plan” means no per-token embedding price; the plan fee is separate.
ModelProviderDimensionsMax input$/1M tokensNotes
Plugsky EmbedPlugsky2,0488,192Flat planIncluded in plans; 8K context
text-embedding-3-smallOpenAI1,5368,191$0.02Supports dimensions shortening
text-embedding-3-largeOpenAI3,0728,191$0.13Supports dimensions shortening
text-embedding-ada-002OpenAI1,5368,192$0.10Legacy model
Gemini Embedding 001Google3,0722,048$0.15Output dimensionality configurable
Embed v3 EnglishCohere1,024512$0.10Short input limit; chunk accordingly
Mistral EmbedMistral1,0248,000$0.10General-purpose
nomic-embed-text-v1.5Nomic7688,192Self-hostMatryoshka 64–768
BGE-M3BAAI1,0248,192Self-hostMultilingual

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.

Float32 storage by dimension count. Decimal GB; index overhead and replicas are additive.
DimensionsBytes / vector1M vectors10M vectors
3841,5361.54 GB15.4 GB
7683,0723.07 GB30.7 GB
1,0244,0964.10 GB41.0 GB
1,5366,1446.14 GB61.4 GB
2,0488,1928.19 GB81.9 GB
3,07212,28812.29 GB122.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:

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:

One-time embedding cost for 800 million tokens, and the storage at the model's default dimension in float32.
ModelDimensionsCost to embed oncefloat32 storageint8 storage
text-embedding-3-small1,536$16.0012.29 GB3.07 GB
text-embedding-3-large3,072$104.0024.58 GB6.14 GB
text-embedding-ada-0021,536$80.0012.29 GB3.07 GB
Gemini Embedding 0013,072$120.0024.58 GB6.14 GB
Embed v3 English1,024$80.008.19 GB2.05 GB
Mistral Embed1,024$80.008.19 GB2.05 GB
nomic-embed-text-v1.5768Self-host6.14 GB1.54 GB
BGE-M31,024Self-host8.19 GB2.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:

Storage for 2 million vectors at 1,536 and 3,072 dimensions by precision. Decimal GB; binary uses ceil(dimensions ÷ 8) bytes.
PrecisionBytes / dimension1,536 dims3,072 dimsQuality impact
float32412.29 GB24.58 GBBaseline
float1626.14 GB12.29 GBUsually negligible; test on your evaluation set
int813.07 GB6.14 GBSmall recall loss, often acceptable
binary1 bit0.384 GB0.768 GBLarger 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:

  1. Embed a representative sample at full dimensions.
  2. Evaluate retrieval at 100%, 50% and 25% of the dimensions on your own labelled queries.
  3. Pick the smallest size that stays within an acceptable recall loss — commonly 1–3 points.
  4. 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?

Dimension guidance by workload. Test on your own queries before committing.
DimensionsGood fitTrade-off
384Edge, mobile, very large corpora, latency-sensitive searchLowest storage; weakest fine-grained recall
768General-purpose RAG, multilingual models, balanced costGood quality per byte
1,024Domain-specific retrieval, code search, multilingualMore storage, modest quality gain
1,536Default for OpenAI small; general English retrievalTwice the storage of 768
2,048Plugsky Embed; balanced hosted optionIncluded in plans; check the 8K input limit
3,072Maximum-quality retrieval, small corpora, offline evaluation2× 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:

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.

Download CSV · Download JSON

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