Posted on Jun 25, 2026 · Updated Jun 25, 2026 · 9 min read
Vector Database Pricing 2026: Pinecone vs pgvector vs Weaviate
Vector database pricing is confusing on purpose: every vendor meters a different thing. One charges for storage and queries, another for nodes, a third for "vector dimensions," and the cheapest option is the database you already run. The result is that two teams with the same workload can pay $65 or $500 a month for what is functionally the same index — entirely down to which product they picked and how it's metered.
This guide cuts through it with real 2026 numbers. We compare the four databases most teams actually evaluate — Pinecone, pgvector, Weaviate, and Qdrant — on how each is priced, then put a concrete monthly cost on the same workload at 1M, 10M, and 100M vectors. It pairs with our monthly cost of a production RAG system guide, since the vector DB is one line in that bill.
TL;DR — vector database pricing (2026)
- pgvector is effectively free — you pay only for the Postgres instance you already run ($50–$180/mo on RDS)
- Qdrant Cloud is cheapest among managed dedicated DBs at scale: ~$65/mo for 10M vectors, billed per node, no per-query fee
- Pinecone Serverless ~$70/mo at 10M vectors but a $50/mo plan minimum; metered on storage ($0.33/GB), reads, and writes
- Weaviate Cloud is the priciest per million without quantization (~$135/mo at 10M) but Binary Quantization cuts it ~5x
- The biggest lever isn't the vendor — it's quantization, which can cut storage and RAM 4–32x on any of them
- Below ~5M vectors, pgvector on your existing database is almost always the cheapest production-grade choice
Table of contents
How is a vector database priced?
There are three pricing models in the market, and knowing which one a vendor uses tells you where your bill will come from:
- Consumption (storage + reads + writes). Pinecone Serverless is the archetype: you pay for data stored, queries served, and vectors written, with no server to size. Cheap when idle, but query-heavy apps can surprise you because reads are metered.
- Capacity (per node / per cluster). Qdrant Cloud and self-hosted Weaviate or Milvus bill for the RAM, CPU, and disk you reserve. There is no per-query charge, so a high-QPS app on a fixed cluster gets cheaper per query as it scales.
- Dimension-based. Weaviate Cloud meters "vector dimensions stored per month" (~$0.095 per million dimensions on the Shared tier). Higher-dimension embeddings cost proportionally more — a 1,536-dim OpenAI vector costs twice a 768-dim one.
And then there is pgvector, which has no pricing model at all because it is a free Postgres extension. Your only cost is the database instance, which most teams running a RAG or search feature already pay for. That single fact reshapes the whole comparison below.
Pinecone vs pgvector vs Weaviate vs Qdrant
Entry pricing and the metered units for each, at 2026 list prices. "Entry" is the smallest realistic production footprint, not the free tier.
| Database | Pricing model | What you pay | Entry cost |
|---|---|---|---|
| pgvector | Instance only | Your Postgres server (RAM-bound) | $0 license + ~$50/mo DB |
| Qdrant Cloud | Per node | RAM/CPU/disk, no per-query fee | ~$0.014/hr (~$10/mo) |
| Pinecone Serverless | Consumption | $0.33/GB storage + reads + writes | $50/mo plan minimum |
| Weaviate Cloud | Per dimension | ~$0.095 / 1M vector-dimensions/mo | ~$25/mo entry |
Two things stand out. First, Pinecone's $50/mo plan minimum means it is rarely the cheapest option for a small index — you pay $50 whether you store 100K vectors or 5M. Second, Qdrant and pgvector both decouple cost from query volume, which matters enormously for a high-traffic app: on a consumption model, doubling traffic roughly doubles your read bill; on a per-node model, you often serve the extra queries for free until you outgrow the cluster.
Cost at 1M, 10M, and 100M vectors
The same workload — 768-dimension embeddings, moderate query volume, single replica — priced across all four. Treat these as planning estimates at 2026 list prices, not quotes; real bills move with dimensions, replication, and query rate.
| Database | 1M vectors | 10M vectors | 100M vectors |
|---|---|---|---|
| pgvector (RDS) | ~$50/mo | ~$120/mo | ~$700/mo+ |
| Qdrant Cloud | ~$25/mo | ~$65/mo | ~$550/mo |
| Pinecone Serverless | $50/mo (min) | ~$70/mo | ~$500/mo |
| Weaviate Cloud | ~$25/mo | ~$135/mo | ~$1,000/mo |
The pattern: at small scale (1M vectors), pgvector and the per-node clouds win and Pinecone's floor hurts. At 100M vectors, the gaps compress into a band and pgvector's memory requirements start pushing it up — you need a large, RAM-heavy instance to hold a 100M-row HNSW index, so the "free database you already run" quietly becomes a $700+/mo machine.
Quantization: the lever that beats vendor choice
The single biggest cost driver in a vector database is not the vendor — it's how many bytes each vector occupies in RAM. A raw 768-dimension float32 vector is ~3 KB; 10M of them need ~30 GB of memory before index overhead, and RAM is what you actually pay for. Quantization shrinks that dramatically:
- Scalar quantization (int8): ~4x smaller, minimal recall loss. The safe default.
- Binary quantization: up to 32x smaller and far faster, with a small recall hit you recover via re-ranking. Weaviate, Qdrant, and Milvus all support it.
- Product quantization: aggressive compression for very large indexes where RAM is the binding constraint.
This is why Weaviate's headline price looks high but its real-world bill is competitive: with Binary Quantization, that ~$135/mo 10M-vector index drops toward ~$30. Before you switch databases to save money, turn on quantization on the one you have — it's a bigger lever than the vendor logo.
Which one should you pick?
A short decision guide, by situation:
- You already run Postgres and have < 5M vectors → pgvector. No new vendor, no new bill, transactional consistency with your app data. The default for most SMBs.
- High query volume, cost-sensitive → Qdrant Cloud. Per-node billing means QPS doesn't inflate the invoice, and quantization is first-class.
- You want zero ops and bursty/idle traffic → Pinecone Serverless. You pay for what you use and never size a server — just watch the read meter and the $50 floor.
- You need hybrid search, modules, and managed convenience → Weaviate Cloud, with quantization on from day one.
- 100M+ vectors, dedicated infra team → self-hosted Qdrant or Milvus on your own nodes; you pay only for the VMs.
For where this sits in the bigger picture, see how the vector DB line fits into a full RAG system's monthly cost (spoiler: it's usually the small line), and how AI infrastructure spend is trending in our State of AI Infrastructure Costs 2026.
See your real AI infrastructure spend in one place
spendark pulls your AWS, Azure, and GCP bills together and flags the database and GPU line items that are quietly growing — so the vector DB, embeddings, and inference don't surprise you at month end.
Frequently asked questions
What is the cheapest vector database?
For most teams it's pgvector, because it runs inside the Postgres instance you already pay for — no separate vendor or bill. Among dedicated managed databases, Qdrant Cloud is typically cheapest at scale (~$65/mo for 10M vectors) because it bills per node with no per-query fee. The real cost-cutter on any of them is quantization, which shrinks RAM 4–32x.
Is pgvector good enough for production?
Yes, for the common case. With an HNSW index, pgvector handles millions of vectors with good latency, and you get transactional consistency with your application data for free. It starts to strain past ~10–50M vectors or very high QPS, where a memory-bound dedicated database (Qdrant, Weaviate, Milvus) becomes worth the extra vendor.
How is Pinecone priced in 2026?
Pinecone Serverless is consumption-based: roughly $0.33/GB-month for storage plus metered read and write units, with a $50/month minimum on the Standard plan. A ~10M-vector index lands around $70/month, but query-heavy workloads pay more because reads are metered separately from storage.
How many vectors can pgvector handle?
Comfortably into the low tens of millions on a reasonably sized instance, provided the HNSW index fits in RAM. The binding constraint is memory, not row count: ~10M 768-dim vectors need ~30 GB before quantization, so you size the database around RAM. Beyond that, consider a dedicated vector DB or quantization.
Does query volume change my vector database bill?
It depends on the pricing model. On consumption-based pricing (Pinecone), more queries mean more read units and a higher bill. On per-node pricing (Qdrant, self-hosted Weaviate/Milvus, pgvector) you pay for the cluster regardless of query count, so a high-QPS app gets cheaper per query as it grows — until you need a bigger node.
Estimate your cloud costs — for free
Compare AWS, Azure, and GCP pricing side by side with our free calculator, and dig into the guides to learn how to cut cloud waste. No sign-up required.