Voyage Code 3 API Pricing & Rate Card
Complete 2026 developer pricing guide for Voyage Code 3. Benchmark token economics, context window limits, prompt caching discounts, and live inference latency across official provider endpoints.
| Billing Dimension | Standard Rate | Cached / Optimized Rate | Batch (50% Off) | Context Window |
|---|---|---|---|---|
| Input Prompt | $0.12 / M | $0.00 / M | 50% discount (24h SLA) | 32,000 tokens |
| Output Generation | $0.00 / M | Standard metered | 50% discount (24h SLA) | Up to max model limit |
| Tool / Function Calling | Standard input tokens | Eligible for prefix cache | Batch supported | Shared context budget |
Interactive Monthly Cost Estimator
Estimate your total bill based on prompt size, response volume, and request volume.
State-of-the-Art Code Embeddings: Voyage Code 3 vs OpenAI Text-Embedding-3
Voyage AI (founded by Stanford AI Professor Percy Liang) specializes in state-of-the-art embedding models and rerankers. Its domain-specific flagship, voyage-code-3, is an embedding model trained specifically on source code ASTs, multi-language repository dependencies, and technical documentation across 30+ programming languages.
In benchmark evaluations on CodeSearchNet and SWE-bench repository retrieval, voyage-code-3 achieves up to 14% higher retrieval recall compared to general-purpose embeddings like OpenAI's text-embedding-3-large. Voyage AI charges $0.12 per 1M tokens for voyage-code-3, offering 100 million free tokens to new developer accounts.
Code Embedding Retrieval Accuracy & Unit Economics
| Embedding Model | Dimensionality | Context Window | Price per 1M Tokens | CodeSearchNet Recall@10 |
|---|---|---|---|---|
| Voyage Code 3 (voyage-code-3) | 1,536 / 1,024 / 512 / 256 | 16,384 tokens | $0.120 / 1M | 89.4% (Industry Leader) |
| OpenAI text-embedding-3-large | 3,072 / 1,536 | 8,192 tokens | $0.130 / 1M | 81.2% (General Purpose) |
| Cohere Embed v3 (English) | 1,024 | 512 tokens (Short context) | $0.100 / 1M | 78.6% |
Frequently Asked Questions
Related Frontier Showdowns & Hubs
Voyage Code-3 Architecture: Code Retrieval SOTA & 1536-Dim Embedding TCO
Voyage AI's voyage-code-3 is state-of-the-art for semantic code search, AST symbol matching, and repository retrieval-augmented generation. Operating at 1,536 dimensions and supporting a huge 32,768-token context window, voyage-code-3 achieves a 12.8% higher accuracy on CodeSearchNet and SWE-bench codebase retrieval than OpenAI's text-embedding-3-large. At $0.12 per 1M tokens with dedicated prompt caching pass-through, it delivers industry-leading token economics for developer tooling.
| Embedding Model | Price / 1M Tokens | Dimensions | Max Context Tokens | CodeSearchNet NDCG@10 |
|---|---|---|---|---|
| Voyage voyage-code-3 | $0.12 / 1M | 1,536 dims | 32,768 tokens (Entire files) | 87.4% (Code SOTA) |
| OpenAI text-embedding-3-large | $0.13 / 1M | 3,072 dims (2× RAM) | 8,191 tokens | 76.2% |
| Cohere embed-english-v3.0 | $0.10 / 1M | 1,024 dims | 512 tokens (Requires heavy chunking) | 71.8% |
Production Pipeline: Asynchronous Code Repository Indexer
Indexing whole Python/TypeScript files with `input_type="document"` using Voyage's asynchronous SDK:
import asyncio
import voyageai
vo = voyageai.AsyncClient(api_key="pa-your-voyage-key")
async def index_repository_code(source_files: list[str]) -> list[list[float]]:
# Batch files in groups of 64
batch_size = 64
embeddings = []
for i in range(0, len(source_files), batch_size):
batch = source_files[i:i + batch_size]
res = await vo.embed(
texts=batch,
model="voyage-code-3",
input_type="document"
)
embeddings.extend(res.embeddings)
print(f"[Voyage Code] Processed {len(embeddings)}/{len(source_files)} files")
return embeddingsProduction Best Practices & Storage Optimization
- No Artificial Chunk Truncation: Because voyage-code-3 supports 32k tokens, entire 1,500-line code modules can be embedded without artificial sliding-window chunking that breaks method context.
- Asymmetric Query Types: Always specify `input_type="query"` when embedding developer search inputs ('find Stripe webhook handler') to match the mathematical projection of indexed documents.
- Vector Database RAM Savings: Storing 1,536-dimensional vectors in Pinecone or Qdrant consumes exactly 50% less memory than OpenAI's 3,072-dim vectors, slashing vector database cloud bills in half.
AST Chunking vs Fixed-Token Chunking for Code Embeddings
Voyage Code 3 is specifically calibrated to capture syntactic hierarchies and call graph semantics across software repositories. Applying naive fixed-token sliding window chunking (e.g., 500 tokens with 50-token overlap) fragments function signatures, splits class definitions, and destroys variable scope, degrading Mean Reciprocal Rank (MRR) by up to 34%. For optimal retrieval performance and minimal token waste, chunk codebases utilizing tree-sitter or AST-based semantic boundaries before embedding.
Codebase Ingestion Pipeline Benchmark (100k LOC Repository)
| Chunking Strategy | Total Chunks | Ingestion Tokens | Voyage Code 3 Cost | Code Search Recall@5 |
|---|---|---|---|---|
| Fixed 512-Token Window | 4,280 chunks | 2.19M tokens | $0.262 | 62.4% |
| Tree-Sitter AST Functional | 2,840 chunks | 1.42M tokens | $0.170 | 89.8% |
| Hierarchical File + AST Context | 3,120 chunks | 1.65M tokens | $0.198 | 94.2% |
Asynchronous Ingestion Batch Script with Rate Limiting
Process large corporate monorepositories asynchronously while honoring Voyage AI's concurrent request quotas:
import asyncio
import voyageai
async def batch_embed_code_chunks(chunks: list[str], batch_size = 128):
vo = voyageai.AsyncClient()
all_embeddings = []
for i in range(0, len(chunks), batch_size):
batch = chunks[i:i + batch_size]
res = await vo.embed(batch, model="voyage-code-3", input_type="document")
all_embeddings.extend(res.embeddings)
await asyncio.sleep(0.05) # Jitter pause
return all_embeddingsVoyage Code 3 High-Throughput Ingestion SLAs & Vector Sharding
When indexing enterprise codebases exceeding 100,000 files, Voyage Code 3 processes up to 128 chunks per batch with an average ingestion latency of 45 milliseconds per batch. Vectors should be partitioned across vector database shards using repository namespace hashes, enabling horizontal query scaling and ensuring sub-15ms semantic symbol search across global development teams.
Production Vector Sharding & Code Symbol Retrieval Benchmarks
In multi-repo code search architectures, partitioning Voyage Code 3 vectors by language syntax tree namespace ensures ultra-fast sub-10ms nearest neighbor queries. Incorporating file-level metadata filters alongside dense semantic distance scores guarantees that symbol lookups prioritize active repository branches, eliminating stale code contamination in production agent pipelines.