Vector Database Costs: Pricing Models, Hidden Fees, and Total Cost of Ownership

The Four Cost Components

Every vector database deployment has four cost categories, and ignoring any one of them leads to budget surprises.

1. Storage costs cover the disk or cloud storage where vectors and metadata persist. Vector storage is predictable: a 1536-dimensional vector (OpenAI's text-embedding-3-small output) consumes approximately 6KB. One million vectors take roughly 6GB of raw vector storage. With HNSW index overhead, the total disk footprint is 8 to 12GB per million vectors. Metadata adds variable storage depending on what you store alongside each vector, typically 1 to 10KB per record.

2. Compute costs cover the servers or cloud instances that run the database and process queries. For managed services, this is baked into per-query pricing. For self-hosted deployments, it is the monthly cost of your VPS or cloud instance. The compute requirement is dominated by RAM, since the HNSW index must fit in memory for fast queries. CPU usage during queries is minimal.

3. Embedding costs are the fees for converting your text (or other data) into vector embeddings. Every document you store needs to be embedded once (ingestion cost), and every query needs to be embedded once (per-query cost). If you use a paid embedding API, these costs are ongoing and proportional to data volume and query volume. If you run open-source embedding models locally, the cost is the GPU hardware amortized over time.

4. Operational costs include engineering time for setup, maintenance, monitoring, troubleshooting, and upgrades. Managed services minimize this at a price premium. Self-hosted deployments trade monthly fees for engineering hours. The right balance depends on your team's skills and your total query volume.

Managed Service Pricing Breakdown

Pinecone Serverless charges per read unit, write unit, and GB stored. In practice, a typical query consumes 5 to 10 read units, making the effective cost approximately $0.04 to $0.08 per 1,000 queries. Storage costs $0.33 per GB per month. The free tier covers 100,000 vectors and several thousand queries per day.

Monthly costs at common scales: 500K vectors, 5K queries/day = $0 (free tier). 2M vectors, 20K queries/day = $30 to $60. 5M vectors, 50K queries/day = $100 to $200. 10M vectors, 100K queries/day = $300 to $600. 50M vectors, 500K queries/day = $1,500 to $3,000.

Qdrant Cloud charges based on cluster size with fixed monthly pricing per node. A starter node (1 vCPU, 4GB RAM) costs approximately $25 per month. A production node (4 vCPU, 16GB RAM) costs approximately $65 per month. A high-memory node (8 vCPU, 64GB RAM) costs approximately $200 per month. There are no per-query charges, which makes Qdrant Cloud increasingly cost-effective at higher query volumes.

Monthly costs: 500K vectors = $25 (starter). 2M vectors = $65 (production). 10M vectors = $200 (high-memory). 50M vectors = $400 to $800 (multi-node cluster).

Weaviate Cloud offers a free sandbox tier for development and paid tiers starting at approximately $25 per month. Production pricing scales with compute resources and storage. Weaviate does not charge per query, which aligns with Qdrant's model and favors high-volume workloads.

Self-Hosted Cost Analysis

Self-hosted infrastructure costs are predictable monthly server bills with no per-query charges. The cost depends entirely on your hosting provider and the hardware you select.

Budget option (Hetzner): A Hetzner CX32 (4 vCPU, 16GB RAM, 160GB NVMe) costs approximately 15 EUR per month and handles 1 to 2 million vectors with Qdrant. A CCX33 (8 vCPU, 32GB RAM, 240GB NVMe) costs approximately 40 EUR per month and handles 5 to 8 million vectors with quantization. Hetzner's dedicated servers start at 40 EUR per month with significantly more hardware.

Mid-range option (DigitalOcean): A regular droplet with 8GB RAM costs $48 per month. Memory-optimized droplets start at $84 per month for 16GB RAM. These handle 500K to 5M vectors depending on configuration.

Enterprise option (AWS): An r6g.large (2 vCPU, 16GB RAM) costs approximately $75 per month on-demand, $45 reserved. An r6g.xlarge (4 vCPU, 32GB RAM) costs approximately $150 on-demand, $90 reserved. Add EBS storage costs of $0.08 per GB per month.

The cost advantage of self-hosting scales linearly with query volume. At 10,000 queries per day, managed services may be cheaper (Pinecone's free tier covers this). At 100,000 queries per day, self-hosting saves 60 to 80%. At 1,000,000 queries per day, self-hosting saves 90%+ because there are no per-query fees.

Embedding Costs: The Hidden Multiplier

Embedding costs often exceed database costs, especially during initial data ingestion and for high-query-volume applications.

OpenAI text-embedding-3-small: $0.02 per million tokens. A typical 500-word document chunk is roughly 650 tokens, so embedding 1 million chunks costs approximately $13. Each query embedding costs roughly $0.00001 (negligible individually, but 100,000 queries per day adds $30 per month in embedding costs alone).

OpenAI text-embedding-3-large: $0.13 per million tokens. Same calculation, 1 million chunks costs approximately $85 to embed. Query costs scale proportionally.

Cohere embed-v4: $0.10 per million tokens for search documents, $0.10 per million tokens for search queries. Competitive with OpenAI's large model and optimized specifically for search workloads.

Open-source models (self-hosted): Running BGE-M3 or Nomic Embed on your own GPU eliminates per-token costs entirely. A consumer GPU like the NVIDIA RTX 4060 ($300) generates roughly 1,000 embeddings per second, handling 86 million embeddings per day. An A100 cloud GPU ($3 per hour) handles initial bulk embedding jobs at much higher throughput. For ongoing query embedding, even a CPU can generate 50 to 100 embeddings per second, sufficient for moderate workloads.

For a concrete example, an AI agent with a 2 million document knowledge base using OpenAI's small model: initial embedding cost is $26 (one-time). With 50,000 queries per day, the monthly query embedding cost is approximately $20. If documents are updated frequently and re-embedded weekly, add $104 per month. Total monthly embedding cost: $124. This is in the same range as many managed database costs and should not be ignored in budget planning.

Cost Comparison at Four Scales

Startup scale: 200K vectors, 5K queries per day. Pinecone serverless: $0 (free tier). Qdrant Cloud: $25/month. Self-hosted Qdrant: $10 to $15/month. pgvector on existing PostgreSQL: $0. Embedding costs (OpenAI small): $3/month for queries. Recommendation: Pinecone free tier or pgvector. Do not spend money on infrastructure at this scale.

Growth scale: 2M vectors, 50K queries per day. Pinecone serverless: $100 to $200/month. Qdrant Cloud: $65/month. Self-hosted Qdrant: $15 to $40/month. pgvector: $0 to $50 (if you need to upgrade your PostgreSQL instance). Embedding costs: $30/month. Total with Pinecone: $130 to $230. Total self-hosted with open-source embeddings: $15 to $40. Recommendation: Self-hosted Qdrant if you have infrastructure skills, Qdrant Cloud or Pinecone if you do not.

Production scale: 10M vectors, 200K queries per day. Pinecone serverless: $500 to $1,200/month. Qdrant Cloud: $200 to $300/month. Self-hosted Qdrant: $40 to $100/month. Embedding costs: $120/month (OpenAI) or $0 (self-hosted model). Total with Pinecone: $620 to $1,320. Total self-hosted with self-hosted embeddings: $80 to $200. Recommendation: Self-hosted Qdrant or Weaviate. The savings justify the operational investment.

Enterprise scale: 100M vectors, 1M queries per day. Pinecone: $3,000 to $8,000/month. Qdrant Cloud cluster: $800 to $1,500/month. Self-hosted Qdrant cluster: $200 to $600/month. Embedding costs: $600/month (OpenAI) or $100 to $200/month (GPU rental for self-hosted model). Total self-hosted: $300 to $800. Recommendation: Self-hosted with dedicated infrastructure engineering. At this scale, managed service premiums cost more than a full-time infrastructure engineer's salary.

Common Cost Mistakes

Storing full documents in metadata. If you store the complete source text alongside each vector for RAG retrieval, metadata can consume 2 to 10x more storage than the vectors themselves. A 2,000-character text chunk is roughly 2KB, while a 1536-dimensional vector is 6KB. But many teams also store titles, URLs, tags, and timestamps, pushing per-record metadata to 5 to 15KB. At 10 million records, this adds 50 to 150GB of metadata storage. Consider storing only a document ID in vector database metadata and retrieving the full text from a cheaper storage layer (PostgreSQL, S3) when needed.

Using larger embeddings than necessary. OpenAI's text-embedding-3-large (3072 dimensions) costs 6.5x more per embedding than text-embedding-3-small (1536 dimensions) and consumes 2x more storage. For most RAG and agent memory workloads, the small model provides comparable retrieval quality. Benchmark both on your specific data before committing to the larger model.

Not enabling quantization. Scalar quantization reduces vector storage and memory consumption by 4x with minimal recall impact (typically less than 1% drop). On a 10 million vector deployment, quantization can reduce your required RAM from 64GB to 16GB, which translates to a 60 to 70% reduction in server costs. Qdrant, Weaviate, and Milvus all support quantization. Enable it from the start.

Ignoring embedding model costs during prototyping. Teams that prototype with OpenAI embeddings on small datasets are surprised when the embedding costs at production scale exceed their database costs. Run cost projections at your target data volume and query volume before committing to an embedding provider. If projected embedding costs exceed $200 per month, evaluate self-hosted open-source models seriously.