Embedding Dimension Calculator
Enter your embedding count and dimensions to see exactly how much storage you need across every precision level.
- Free
- No account
- Runs in your browser
- Nothing uploaded
100,000 vectors × 1536 dimensions at float32 (4 bytes) with HNSW index. Index overhead: 40%.
| Precision | Raw | Indexed | Monthly cost |
|---|---|---|---|
| float32 (4 bytes)selected | 585.94 MB | 820.31 MB | $0.018 |
| float16 (2 bytes) | 292.97 MB | 410.16 MB | <$0.01 |
| int8 (1 byte) | 146.48 MB | 205.08 MB | <$0.01 |
| binary (1 bit) | 18.31 MB | 25.63 MB | <$0.01 |
Runs entirely in your browser — your input is never uploaded, logged, or stored.Privacy policy
What is Embedding Dimension Calculator?
Vector embeddings are arrays of numbers that represent text, images, or audio as points in a high-dimensional space. Each embedding has a fixed number of dimensions — 384, 768, 1024, 1536, or 3072 are the most common — and each dimension stores a floating-point number.
The raw storage is straightforward: number of vectors multiplied by dimensions multiplied by the bytes per value. But the real cost depends on two things most calculators ignore. First, precision: storing at float32 (4 bytes) is standard, but float16 (2 bytes) and int8 (1 byte) quantization can cut storage by 50–75% with minimal quality loss for many use cases. Second, vector databases add index overhead — HNSW indexes typically need 30–50% more space than the raw vectors, and IVF indexes around 20–30%.
This calculator shows you the full picture: raw storage at every precision, index overhead for common vector DB configurations, and an estimated monthly cost based on cloud storage pricing. It is for developers choosing between embedding models, sizing a vector database, or building a cost model for a RAG pipeline.
Raw storage (bytes) = num_vectors × dimensions × bytes_per_value
Precision levels: • float32: 4 bytes per dimension — standard, no quantization • float16: 2 bytes per dimension — 50% reduction, minimal quality loss for retrieval • int8: 1 byte per dimension — 75% reduction, slight quality trade-off • binary: ceil(dimensions / 8) bytes — extreme compression for similarity search
Index overhead multiplier: • HNSW (default): 1.4× raw vector size — graph-based index, best recall/speed trade-off • IVF: 1.25× raw vector size — inverted file index, good for large datasets • Flat (no index): 1.0× — raw vectors only, brute-force search
Monthly cost = total_storage_GB × price_per_GB_per_month Default: $0.023/GB/month (S3 Standard, us-east-1). Adjust to match your provider.
| Model | Provider | Dimensions | Notes | |
|---|---|---|---|---|
| text-embedding-3-small | OpenAI | 1,536 | Default model, good balance | |
| text-embedding-3-large | OpenAI | 3,072 | Higher quality, 2× storage | |
| embed-english-v3.0 | Cohere | 1,024 | English-optimized | |
| embed-multilingual-v3.0 | Cohere | 1,024 | 100+ languages | |
| all-MiniLM-L6-v2 | Sentence-Transformers | 384 | Fast, lightweight, local | |
| all-mpnet-base-v2 | Sentence-Transformers | 768 | Best quality open-source | |
| text-embedding-004 | 768 | Gemini-era embedding |
Worked examples
- 100,000 embeddings at 1536 dimensions (OpenAI text-embedding-3-small), float32, HNSW index → 585.9 MB raw, 820.3 MB with index, $0.02/month.
- 1,000,000 embeddings at 768 dimensions (all-mpnet-base-v2), float32, HNSW index → 2.86 GB raw, 4.01 GB with index, $0.09/month.
- 500,000 embeddings at 1024 dimensions (Cohere embed-english-v3), float16, IVF index → 976.6 MB raw, 1.22 GB with index, $0.03/month.
- 10,000,000 embeddings at 384 dimensions (all-MiniLM-L6-v2), int8, HNSW index → 3.58 GB raw, 5.01 GB with index, $0.12/month.
How to use Embedding Dimension Calculator
- Enter the number of vectors (embeddings) you plan to store.
- Select the embedding model or enter a custom dimension count.
- Pick the precision level — float32 is standard, float16 and int8 save space with minimal quality loss.
- Choose your vector database index type to include realistic overhead.
- Adjust the storage price if you are not using S3 Standard.
- Read the results: raw storage, index overhead, total size, and estimated monthly cost.
Common errors
- The number of vectors is 0 — enter how many embeddings you plan to store.
- The dimension count is 0 — enter the embedding dimension for your model.
- The price per GB is negative — storage costs cannot be negative.
- The result shows a very small cost — that is expected for small datasets. Cloud storage is cheap per GB; costs become significant at millions of vectors.
- The total size is much larger than expected — check if you selected float32 instead of a quantized precision. Float16 halves storage; int8 quarters it.
FAQ
What is an embedding dimension?
The dimension is the length of the vector — how many numbers represent each piece of text. OpenAI's text-embedding-3-small produces 1536-dimensional vectors; all-MiniLM-L6-v2 produces 384-dimensional ones. Higher dimensions capture more nuance but use more storage.
Should I use float32 or quantized precision?
Float32 is the safe default — no quality loss. Float16 halves storage with negligible impact on retrieval quality for most use cases. Int8 cuts storage to 25% with a slight quality trade-off that matters only for very similar documents. Binary is extreme compression — use it only when storage is the binding constraint.
How much overhead does a vector database add?
It depends on the index type. HNSW (the most common) typically adds 30–50% overhead because it builds a graph structure on top of the raw vectors. IVF adds around 20–30%. A flat index adds nothing — it stores raw vectors and uses brute-force search. The calculator uses the midpoint of each range.
Which embedding model should I choose?
It depends on your use case. OpenAI models (1536d, 3072d) are convenient if you already use their API. Open-source models like all-MiniLM-L6-v2 (384d) run locally and are free. Cohere models (1024d) balance quality and dimensions. The calculator helps you compare storage costs across all of them.
Why does the monthly cost seem so low?
Cloud storage is cheap — S3 Standard costs $0.023/GB/month. A million 768-dimensional float32 embeddings use about 2.86 GB, which costs $0.066/month. The real cost of embeddings is usually compute (generating them), not storage. Costs become significant only at tens of millions of vectors or with GPU-accelerated databases that charge per node.
Related tools
Prefer AllUtil on Google
One click adds AllUtil to your Google preferences. You'll see our tools highlighted with a Preferred badge in Search and AI answers.