Voyage-3 API Pricing, MTEB Benchmarks & Vector Cost Calculator (2026)
Priced from $0.02 to $0.06 per million tokens with a 32,000-token context window. Analyze why top enterprise AI teams choose Voyage for Claude RAG and code retrieval.
Voyage AI Ingestion & Model Simulator
Calculate embedding generation costs across the Voyage AI model catalog and compare against OpenAI text-embedding-3-large ($0.13/M).
1. Full Voyage AI Model Catalog & Specifications
Unlike generalized models, Voyage trains custom encoders for specific enterprise data domains:
| Model ID | Domain | Context Window | Dimensions | Cost per 1M Tokens |
|---|---|---|---|---|
| voyage-3 | General enterprise & web search | 32,000 tokens | 1,024 dims | $0.06 |
| voyage-3-lite | Low-latency, lightweight retrieval | 32,000 tokens | 512 dims | $0.02 |
| voyage-code-3 | Codebases, GitHub repos & ASTs | 32,000 tokens | 1,024 dims | $0.06 |
| voyage-finance-2 | Financial reports, tables & 10-Ks | 32,000 tokens | 1,024 dims | $0.12 |
| voyage-law-2 | Legal contracts, statutes & case law | 16,000 tokens | 1,024 dims | $0.12 |
2. Why the 32,000-Token Context Window Transforms RAG
Standard embedding models force developers to chop documents into tiny 300 to 500-token chunks. This shatters semantic cohesion:
- No more severed function definitions: A 500-line TypeScript class or Python module can be embedded as a single coherent vector.
- Multi-page financial tables: Voyage-3 preserves complete tabular structures without splitting headers from rows.
- Anthropic Claude integration: Pairs directly with Claude 3.5 Sonnet's 200k context without missing context boundary references.
Frequently Asked Questions
Voyage-3 General Embedding Architecture: 1024-Dim Geometry & Matryoshka TCO
Voyage AI's voyage-3 is a premier general-purpose text embedding model that delivers top-tier retrieval performance on the MTEB leaderboard. Operating natively at 1,024 dimensions with flexible Matryoshka representation learning (allowing vector truncation to 512 or 256 dimensions with negligible loss in accuracy), voyage-3 costs $0.12 per 1M tokens. It features a 32,000-token context window, eliminating chunk boundary clipping in technical manuals, legal agreements, and corporate documentation.
| Embedding Model | Price / 1M Tokens | Vector Dimensions | Context Window | MTEB Retrieval Score |
|---|---|---|---|---|
| Voyage-3 | $0.12 / 1M | 1,024 dims (Matryoshka flexible) | 32,000 tokens | 58.4 (Top Tier) |
| OpenAI text-embedding-3-large | $0.13 / 1M | 3,072 dims (3× RAM) | 8,191 tokens | 55.4 |
| Cohere embed-english-v3.0 | $0.10 / 1M | 1,024 dims | 512 tokens | 54.8 |
Production Pipeline: Python Batch Embedding with Truncated Dimensions
Leveraging Matryoshka dimension truncation to reduce Pinecone vector storage costs by 50%:
import voyageai
vo = voyageai.Client(api_key="pa-your-voyage-key")
documents = [
"Enterprise cloud database architecture with replication.",
"Serverless vector database indexing economics."
]
# Truncate to 512 dimensions: cuts index storage footprint in half with <1% accuracy loss
result = vo.embed(
texts=documents,
model="voyage-3",
input_type="document",
output_dimension=512
)
print(f"Generated {len(result.embeddings)} vectors of dimension {len(result.embeddings[0])}")Production Best Practices & Storage Optimization
- Specify output_dimension=512: If your vector database bill is scaling rapidly, truncating voyage-3 to 512 dimensions slashes RAM requirements by 50% while preserving 99.1% of baseline MTEB retrieval accuracy.
- Separate Document and Query Embeddings: Always pass `input_type="document"` when indexing articles and `input_type="query"` when embedding search user queries. Voyage uses asymmetric projection matrices to optimize cosine similarity.
- Prompt Caching Pass-Through: When embedding repetitive documentation prefixes, Voyage AI automatically applies prompt caching discounts across consecutive requests.
Matryoshka Representation Learning (MRL) & Storage Optimization
Voyage 3 delivers state-of-the-art general-purpose retrieval performance across 32,000 token context windows. A critical architectural capability is its support for Matryoshka Representation Learning (MRL), allowing engineers to truncate its native 1024-dimensional vectors down to 512 or 256 dimensions with negligible loss in Mean Reciprocal Rank (MRR). By reducing vector dimensions from 1024 to 256, cloud vector database memory footprints (Pinecone, Qdrant, Milvus) decrease by 75%, slashing monthly infrastructure hosting bills while maintaining superior retrieval accuracy.
Voyage 3 MRL Dimension Truncation vs Accuracy Benchmark
| Vector Dimension | Storage / 1M Docs | Cosine Search Latency | MTEB Retrieval Score | Database TCO Savings |
|---|---|---|---|---|
| 1024-dim (Native) | 4.1 GB | 12.4 ms | 68.4% | Baseline (0%) |
| 512-dim (MRL Truncated) | 2.05 GB | 6.8 ms | 67.9% (-0.5%) | 50% Savings |
| 256-dim (Aggressive MRL) | 1.02 GB | 3.9 ms | 66.8% (-1.6%) | 75% Savings |
MRL Truncation & L2 Normalization in Python
When truncating Matryoshka vectors client-side, always re-normalize the truncated slice to unit L2 norm to preserve cosine distance validity:
import numpy as np
import voyageai
vo = voyageai.Client()
res = vo.embed(["Enterprise knowledge graph architecture"], model="voyage-3")
full_vec = np.array(res.embeddings[0])
# Truncate to 256 dimensions and re-normalize
truncated_vec = full_vec[:256]
normalized_vec = truncated_vec / np.linalg.norm(truncated_vec)
print(f"Compact vector generated with L2 norm: {np.linalg.norm(normalized_vec):.4f}")Voyage 3 Production Concurrency & Batch Embedding Guardrails
Voyage 3 supports batch sizes up to 128 documents per API call with automatic rate limit backoff. For enterprise retrieval systems servicing high real-time query volumes, implement an asynchronous token bucket limiter to maintain steady throughput below organization quotas while sustaining sub-35ms query vector generation.