Embedding Models & Vector Dimensions Pricing Matrix: Voyage vs OpenAI vs Cohere (2026)
Vector embeddings convert unstructured text into dense numerical floating-point vectors for semantic search, clustering, and retrieval-augmented generation (RAG). While API costs are billed per million tokens processed, your downstream vector database RAM costs scale directly with vector dimensionality (512 vs 1,536 vs 3,072 dims).
RAG Ingestion & Vector DB Storage Simulator
Model monthly token generation bills alongside downstream Pinecone/Qdrant vector RAM hosting costs.
Frontier Text Embedding Models Benchmark & Pricing
Evaluating token price, dimensions, MTEB accuracy, and context capacity across industry standard providers.
| Model Identifier | Provider | Price / 1M Tokens | Dimensions | MTEB Score | Max Context | Matryoshka |
|---|---|---|---|---|---|---|
| text-embedding-3-small | OpenAI | $0.020 / 1M | 1,536 dims (to 512) | 62.3 Avg | 8,191 tokens | Native |
| text-embedding-3-large | OpenAI | $0.130 / 1M | 3,072 dims (to 1024) | 64.6 Avg | 8,191 tokens | Native |
| voyage-3 | Voyage AI | $0.120 / 1M | 1,024 dims | 67.8 (Leader) | 32,000 tokens | Static |
| voyage-code-3 | Voyage AI | $0.120 / 1M | 1,024 dims | 68.2 (Code SOTA) | 32,000 tokens | Static |
| text-embedding-004 | Google Gemini | $0.025 / 1M | 768 dims (to 256) | 66.3 High-Value | 2,048 tokens | Native |
| embed-english-v3.0 | Cohere | $0.100 / 1M | 1,024 dims | 64.5 High-Recall | 512 tokens | int8 / binary |
| mistral-embed | Mistral AI | $0.100 / 1M | 1,024 dims | 63.8 Multilingual | 8,192 tokens | Static |
| bge-large-en-v1.5 | Open Weights / HuggingFace | $0.000 (Self-Host) | 1,024 dims | 64.1 Open Leader | 512 tokens | Static |
Matryoshka Representation Learning & Downstream RAM Math
Why vector database hosting bills dwarf embedding API generation fees by an order of magnitude.
The Hidden Vector Database RAM Tax
Many developers mistakenly calculate RAG costs solely from the embedding API invoice ($0.02 to $0.12 per million tokens). However, in production, generated vectors must reside inside a vector index (such as HNSW graphs in Pinecone, Qdrant, Milvus, or pgvector).
Each vector float32 dimension consumes 4 bytes of raw memory. Adding HNSW graph edges and metadata adds an additional 30% to 50% indexing overhead. For an enterprise repository with 5,000,000 document chunks:
- At 3,072 dimensions (OpenAI Large): 5,000,000 × 3,072 × 4 bytes = 61.4 GB raw + 25 GB HNSW index = 86.4 GB RAM required (~$500/month in cloud memory pods).
- At 1,536 dimensions (OpenAI Small): 5,000,000 × 1,536 × 4 bytes = 30.7 GB raw + 12.5 GB index = 43.2 GB RAM required (~$260/month).
- At 512 dimensions (Matryoshka Truncated): 5,000,000 × 512 × 4 bytes = 10.2 GB raw + 4.1 GB index = 14.3 GB RAM required (~$85/month).
Real-World RAG Production Scenarios
Financial models across enterprise knowledge bases, e-commerce catalogs, and semantic code search.
5M Confluence & PDF Chunks
Ingesting 1.25 billion document tokens using text-embedding-3-small truncated to 512 dims. Total one-time generation: $25.00. Monthly Qdrant cloud hosting: $85.00/mo.
1,000 GitHub Monorepos
Semantic code retrieval across 200M code tokens using Voyage Code 3 (32,000 context window). Generation cost: $24.00. Sub-30ms AST function retrieval.
2,000,000 SKU Search
Daily re-indexing of product titles and attributes with Google text-embedding-004 (768 dimensions). 80M tokens monthly: $2.00/mo API + $40/mo vector storage.
from openai import OpenAI
import numpy as np
client = OpenAI()
def generate_compact_embedding(text: str) -> list[float]:
# Request text-embedding-3 with explicit Matryoshka dimension reduction
response = client.embeddings.create(
model="text-embedding-3-small",
input=text,
dimensions=512 # Automatically truncated & L2-normalized by API
)
vector = response.data[0].embedding
# Verify unit length (required for fast cosine dot product in vector DBs)
norm = np.linalg.norm(vector)
assert abs(norm - 1.0) < 1e-4, "Vector must be unit normalized"
return vector
# Process batch of chunks
chunks = ["Authentication handler for OAuth2 refresh tokens...", "Database connection pool timeout config..."]
embeddings = [generate_compact_embedding(c) for c in chunks]
print(f"Generated {len(embeddings)} vectors with {len(embeddings[0])} dimensions.")Production Gotchas & Operational Traps
Critical architectural issues to avoid when scaling RAG pipelines.
dimensions parameter, the resulting vector loses its L2 unit norm, breaking cosine similarity calculations. Always re-normalize before indexing!Related Vector Databases & Cost Calculators
Explore downstream indexing tools and provider pricing breakdowns.
🧮 Vector DB & RAG Sizing Calculator
Model RAM, disk, and cloud pricing across Pinecone, Qdrant, Weaviate, and Milvus.
⚔️ Pinecone vs Qdrant Showdown
Managed serverless vector DB vs open-source Rust-based vector search engine.
🧠 Voyage AI API Pricing Hub
Examine specialized code, legal, and finance embedding rates and MTEB scores.
📖 Cheapest Embedding APIs Guide
Comprehensive cost ranking and price-to-performance ratio analysis for 2026.
Frequently Asked Developer Questions
How does embedding dimensionality impact vector database storage bills?
A 3,072-dimension vector requires 4x the RAM and storage of a 768-dimension vector. In memory-indexed vector databases like Pinecone or Qdrant, RAM costs often exceed model embedding generation costs by 10x. Using Matryoshka representation learning to shorten vectors down to 512 or 768 dimensions cuts cloud RAM infrastructure bills by 60% to 75% with under 2% retrieval accuracy loss.
Why is Voyage AI ranked higher than OpenAI on the MTEB benchmark?
Voyage AI specializes exclusively in retrieval embeddings with custom tokenizers and domain-adapted models (voyage-3, voyage-code-3, voyage-law-2). On MTEB and Long-Context retrieval benchmarks, Voyage achieves 67.8% average recall versus OpenAI's 64.6%, with superior dense paragraph discrimination.
What is Matryoshka Representation Learning (MRL)?
MRL trains embedding models so that the highest-priority semantic features are packed into the earliest vector dimensions. This allows developers to truncate a 3,072-dimension vector (like text-embedding-3-large) down to 512 or 256 dimensions simply by slicing the array, saving massive storage without retraining.
When should an enterprise self-host embedding models like BGE or Nomic?
Self-hosting BGE-large or Nomic-embed-text on a dedicated GPU instance (e.g. NVIDIA L4 or RTX 4090 at $120-$200/mo) becomes financially superior when ingesting over 500 million tokens per month or when strict HIPAA/GDPR data residency forbids transmitting raw text to third-party APIs.
Does chunk size affect embedding API costs?
Yes. Smaller chunks (e.g. 128 tokens with 32-token overlap) require 3x more embedding API calls and generate 3x more vector rows than 512-token chunks. However, smaller chunks provide sharper retrieval specificity for LLM prompts. A 256 to 512 token chunk with 10% overlap offers the optimal balance between token expenditure and retrieval recall.
How does Gemini text-embedding-004 compare to OpenAI text-embedding-3-small?
Google's text-embedding-004 ($0.025/M tokens, 768 dims) offers an outstanding 66.3 MTEB score at half the dimension size of OpenAI text-embedding-3-small (1,536 dims, 62.3 MTEB, $0.020/M). This halves your downstream vector database RAM memory requirements while delivering slightly superior retrieval precision.