Vector Database Cost Calculator

How vector database pricing actually works

Vector database pricing breaks down into three core dimensions: storage, queries (reads), and writes (upserts/updates). Storage is what most people focus on — and it scales linearly with the product of vector count, dimensions, and bytes per element (4 for float32, 1 for int8, 0.125 for binary). Replication multiplies storage by your replica count, and metadata adds a per-vector overhead that is invisible in toy calculations but easily becomes 10–30% of total bytes at scale.

Queries and writes are where the pricing models diverge sharply. Pinecone Serverless meters individual operations as Read Units (RU) and Write Units (WU), where a typical similarity search costs ~2 RU and an upsert costs ~3 WU. Weaviate Cloud charges per million stored dimensions per month and bundles queries into the price. Qdrant Cloud and MongoDB Atlas charge for the cluster and let you query as much as the hardware can serve. Self-hosted databases charge for the instance hours regardless of utilisation. This means the "cheapest" provider depends entirely on whether your workload is storage-bound, query-bound, or write-bound — and the same workload can swing the answer by 10× across providers.

A fourth dimension that calculators often ignore: minimum spend. Pinecone Serverless has a $50/mo Standard plan minimum and a $500/mo Enterprise minimum. Weaviate Cloud Standard tier has a $25/mo minimum. Below those thresholds, computed usage-based pricing is irrelevant — the minimum is what you pay.

Pinecone vs Weaviate vs Qdrant vs Milvus — which is cheapest at each scale?

The answer changes with scale. At prototype scale (100K vectors, 10K queries/month), the free tiers and below-minimum economics make every managed provider look about the same — $25 to $60 per month is a typical band. Self-hosted starts to look attractive only when you already have idle infrastructure to run on; otherwise the EC2 baseline alone is $70+/month.

At small production scale (1M vectors, 100K queries/month), Pinecone Serverless is bound by its $50 minimum, Weaviate Cloud is around $30–60, Qdrant Cloud starts at ~$36 (the smallest cluster), and Zilliz starts at ~$110 (one Compute Unit). Self-hosted pgvector on the smallest r6g.large is ~$80 + EBS, which beats most managed options without DevOps overhead.

At medium scale (10M vectors, 1M queries/month), the differences become material. Pinecone Serverless is typically $200–400/mo dominated by reads; Pinecone Pod-based on s1.x2 is a flat ~$140/mo; Qdrant Cloud needs a 2 vCPU/8 GB tier at ~$70/mo plus replication; Zilliz needs ~7 CUs ≈ $760/mo. Self-hosted on r6g.2xlarge is ~$295 + EBS + DevOps.

At large scale (100M+ vectors), the picture flips. Self-hosted Milvus or Qdrant on r6g.4xlarge ($590 + EBS + DevOps ≈ $1,200/mo) typically beats every managed option, but only if you have engineers to run it. Pinecone Serverless can creep into the thousands due to Read Units; Pinecone Pod-based scales linearly via larger pods; Qdrant Cloud needs 16 vCPU+ tiers ($570+/mo). The right answer at this scale is often "managed for the first 12 months while you learn the workload, self-hosted after that."

Serverless vs pod-based vs self-hosted economics

Serverless pricing (Pinecone Serverless, Chroma Cloud) charges per operation. It wins for spiky, low-utilisation workloads — if you serve 10,000 queries during a daily 2-hour window and nothing the rest of the day, you pay only for what you used. It loses for steady high-QPS workloads because Read Units add up: 10M queries/month × 2 RU × $8.25/M RU = $165/mo just for reads.

Pod-based and cluster-based pricing (Pinecone Pod, Qdrant Cloud, Zilliz, MongoDB Atlas) charges for capacity, regardless of utilisation. The pod is always running and serving; you pay the same hourly rate whether you do 1 query or 1 million. This wins when QPS is high and steady — a 24/7 RAG service hitting 1,000 QPS on average is much cheaper on a single Pinecone p2.x4 pod than on Serverless.

Self-hosted is the same model as cluster-based but at raw cloud prices: an r6g.2xlarge runs ~$295/mo on-demand or ~$180/mo on a 1-year reserved instance. The savings are real but the operational cost is also real — backups, snapshots, version upgrades, security patches, monitoring, and the on-call burden of being the database team. For a typical 5-engineer startup, self-hosted is rarely worth it below ~$2,000/mo of managed equivalent. For a Series B+ company with a platform team, the break-even is closer to $500/mo.

Quantization tradeoffs: int8 4× cheaper, binary 32× cheaper

Quantization compresses each vector element from 4 bytes (float32) to 1 byte (int8) or 1 bit (binary). The storage savings are immediate and proportional: int8 cuts storage by 75%, binary by 96.875%. This matters most for storage-dominated workloads — large indices with infrequent queries.

The recall trade-off is real but smaller than most people expect. Modern int8 quantization (used internally by Qdrant, FAISS, and most recent vector DB versions) typically loses under 2% recall@10 on standard benchmarks. Binary quantization combined with re-ranking can preserve 95%+ of float32 recall while cutting both storage and query latency by 8–10×.

Two caveats: quantization is not free CPU-wise — query-time decompression adds a small overhead, and re-ranking requires keeping the original full-precision vectors somewhere (often on disk). Some managed providers (Pinecone, Zilliz) use quantization internally without exposing it to you, so toggling the quantization input here only affects providers where it's a user choice (Qdrant, Weaviate, self-hosted).

Replication, HA, and multi-region cost multipliers

Replication is the most-skipped input in cost estimation. A production deployment typically runs with replicationFactor 2 (active-passive) or 3 (active-active), which doubles or triples the storage and per-pod compute cost. MongoDB Atlas is the exception — its dedicated tiers always include a 3-node replica set, so the replication input does not multiply Atlas cost. Pinecone Serverless replicates internally and rolls the cost into Read/Write Unit pricing, so the input also does not multiply Serverless cost (this calculator ignores it for those two providers).

For Pinecone Pod, Qdrant Cloud, Zilliz, and self-hosted setups, replicationFactor multiplies the pod/cluster/VM cost directly. A self-hosted Qdrant deployment on r6g.2xlarge × 3 replicas is ~$885/mo for compute alone before storage and DevOps.

Multi-region (active-active across us-east + eu-west, for example) effectively means running independent clusters in each region — multiply by the number of regions for both compute and storage. Plus inter-region egress fees, which neither this calculator nor most vendor calculators include because they depend on your traffic patterns.

Hidden costs to watch for

The pricing displayed by every vendor is missing several real-world costs. The biggest is data egress: pulling query results out to your application server costs $0.05–$0.09/GB on most clouds. For a high-QPS application this is small but non-zero. Cross-region egress (your Pinecone is in us-east, your app is in eu-west) is significantly more expensive and worth co-locating to avoid.

Backup and snapshot storage is typically billed separately at ~$0.02/GB/month on managed providers and at S3 rates on self-hosted. For a 100 GB index with 30 days of daily snapshots, that's $60–80/mo of backup cost that doesn't appear in any "Vector DB Pricing" page.

Filtered search costs more than unfiltered search on most providers. Pinecone charges 5–10 RU per filtered query versus 1–2 RU for unfiltered. If your application heavily uses metadata filters (e.g., per-tenant search in a multi-tenant SaaS), your effective Read Unit consumption can be 3× the calculator estimate.

Finally, re-embedding when you change models is rarely budgeted for. Switching from text-embedding-3-small to text-embedding-3-large requires re-embedding every document — that's 100% Write Unit consumption against your entire corpus, plus the embedding model API cost. For a 10M document corpus, that's a one-time cost of $60K+ just on the embeddings.

When to switch from managed to self-hosted

The break-even between managed and self-hosted is not just about list price. A reasonable framework: total managed cost > 3× the raw infrastructure cost AND your team has bandwidth to operate a stateful service. The 3× multiplier accounts for the loaded cost of an on-call rotation, monitoring, backups, and incident response.

Concretely: at $500/mo of managed cost, raw infra equivalent is ~$170/mo and self-hosted is rarely worth the operational investment. At $2,000/mo of managed cost, infra equivalent is ~$670/mo, and self-hosted starts making sense for teams that already run other stateful services. At $10,000/mo of managed cost, the infra cost is ~$3,300/mo and the savings clearly justify a dedicated platform team.

The other consideration is feature drift. Managed providers ship new features (filtered search optimisations, hybrid search, sparse vector support, GPU acceleration) faster than you can keep up. The "save 60% by self-hosting" calculation looks worse if you also need to backport six months of upstream improvements every year.

Choosing dimensions: 1536 vs 768 vs 384

Dimensions are largely a function of the embedding model you pick. OpenAI text-embedding-3-small produces 1536-dim vectors; Cohere embed-english-v3 produces 1024-dim; BGE-base and the original Sentence-BERT models produce 768-dim; BGE-small and lightweight models produce 384-dim. The dimensionality directly multiplies storage cost.

The MTEB leaderboard suggests that lower-dim models from 2025–2026 (BGE-base v2, Voyage-3-lite, Cohere embed-v4) often match or beat older 1536-dim models on retrieval benchmarks. If you're storage-constrained or cost-constrained, evaluating a 768-dim alternative to your current 1536-dim setup is the single biggest lever — it cuts storage 50% and often improves latency.

A pragmatic approach: build your retrieval pipeline with 1536 dim during prototyping, then run a recall@10 evaluation on a 768-dim alternative before going to production. Most teams find the recall delta is under 2% but the cost delta is exactly 50%.

Real-world worked examples

Example 1 — RAG chatbot, 1M docs at 1536 dim, 100K queries/month, weekly re-embed: Storage is ~6 GB at float32 with 1 KB metadata × 2 replicas. Pinecone Serverless ≈ $50/mo (minimum applies, computed usage ~$15). Pinecone Pod s1.x1 ≈ $140 with 2 replicas. Weaviate Cloud ≈ $25/mo (minimum). Qdrant Cloud 1 vCPU tier × 2 ≈ $72. pgvector self-hosted r6g.large × 2 ≈ $147 + $1 EBS + ($500 DevOps if enabled). Verdict at this scale: Weaviate Cloud or Pinecone Serverless, both at the minimum.

Example 2 — Ecommerce semantic search, 50M products at 768 dim, 10M queries/month: Storage ≈ 154 GB at float32 with 1 KB metadata × 2 replicas. Pinecone Serverless ≈ $300+ (reads dominate at ~$165). Qdrant Cloud 4 vCPU tier × 2 ≈ $285. Zilliz ≈ 33 CUs × $0.15/hr × 730 × 2 ≈ $7,200. pgvector self-hosted r6g.4xlarge × 2 ≈ $1,180 + $15 EBS + DevOps. Verdict at this scale: Qdrant Cloud or self-hosted depending on team capability.

Example 3 — High-write AI agent, 5M vectors, 100K queries/mo, 500K writes/mo: Storage ≈ 31 GB at float32 × 2 replicas. Pinecone Serverless ≈ $20 (under minimum, pays $50). Pinecone Pod s1.x1 × 2 ≈ $140. Qdrant Cloud 1 vCPU × 2 ≈ $72. self-hosted Qdrant r6g.large × 2 ≈ $147 + $4 EBS + DevOps. Verdict: Qdrant Cloud beats both Pinecone tiers and the self-hosted route at this scale, especially given the write-heavy pattern.

2026 vector database pricing trends

Three trends are reshaping vector DB economics in 2026. First, quantization is becoming default in managed offerings: Pinecone, Zilliz, and Weaviate now apply scalar quantization automatically for index storage, which has compressed listed prices ~40% since 2024 even though headline numbers haven't moved much. The "$/million dimensions" Weaviate charges is meaningfully lower than the 2024 number because they're storing fewer bytes per dimension.

Second, Postgres extensions (pgvector and pgvector-rs) have closed most of the recall gap with purpose-built vector DBs, especially after pgvector 0.5 added HNSW indexing. For workloads under ~50M vectors, self-hosted Postgres on a single beefy instance is now a credible alternative to a dedicated vector DB — and it brings the cost savings of running your existing application database.

Third, hybrid pricing models are emerging. Pinecone introduced "Reserved" billing in late 2025 (commit to monthly spend, get 25–40% discount). Qdrant offers BYOC deployments where you bring your own cloud infrastructure and pay only for the control plane. Zilliz has tiered "Cloud Lite" and "Cloud Standard" SKUs. The list-price comparisons in this calculator should be treated as upper bounds; negotiate with vendors at scale and the real numbers come down 25–50%.