For most companies under about 10 million vectors, a managed vector database costs $50 to $1,500 a month and is cheaper than self-hosting once engineering time is counted. Self-hosting starts to win at high query volume, at 50–100 million vectors and above, or when you can reuse an existing Postgres or platform team. Memory footprint: vector count multiplied by dimensions, plus index overhead. This sets the size of the machines you need when self-hosting, and the storage line when you buy managed.
Query and write volume: usage-priced services such as Pinecone Serverless charge per read and write, so busy applications pay more each month. Capacity-priced options, including self-hosting, charge the same whether you run one query or a million.
People: a self-hosted cluster needs someone to patch, scale, back up, tune and be on call for it. That cost exists even when the infrastructure is cheap.
The common mistake is comparing a managed price per gigabyte with the raw cost of a virtual machine. A fair comparison counts replicas, backups, index rebuilds and the engineer who keeps it all running.
All figures in this guide are planning estimates based on published list prices as of November 2026. Vendors changed pricing several times during 2026, so check current rates before you commit.
Before comparing prices, work out how much memory and storage your vectors need. Every cost model starts from bytes, not from vector counts.
Each dimension of a standard float32 vector takes 4 bytes. A 1,536-dimension embedding is about 6.1 KB.
An HNSW index, the most common search index, adds graph structure on top. A vector index sizing guide suggests roughly doubling raw vector size to account for it.
Add metadata (document IDs, text chunks, filters) and replicas for availability.
1 million vectors: about 6 GB of raw vectors, roughly 12–25 GB in memory with the index.
10 million vectors: about 61 GB raw. One analysis of pgvector in production budgets 20–25 KB per vector with the graph, or 200–250 GB, if nothing is compressed.
100 million vectors: over 600 GB raw before the index. At this scale, ClickHouse's engineering guidance suggests evaluating whether standard in-memory HNSW is still the right structure.
Quantization shrinks vectors with a small loss in recall:
Half precision (float16, or halfvec in pgvector) halves memory.
Scalar quantization to int8 cuts memory by about 75%.
Binary or product quantization can cut memory by up to 90% or more, usually paired with re-ranking to recover accuracy.
Smaller embedding models help too. A 768-dimension model needs half the memory of a 1,536-dimension one, and many newer models let you request shorter vectors directly.
Compression is the single biggest cost lever in vector search, and it applies whether you self-host or buy managed.
Managed vector databases use three main pricing models: usage-based, per-dimension and capacity-based. The same workload can cost very different amounts depending on which model you are on.
Pinecone's pricing page lists storage at $0.33 per GB per month, with Standard plan read units from $16 per million and write units from $4 per million, plus a $50 monthly minimum. Enterprise starts at $500 a month with higher unit rates.
The detail that drives cost: according to UsagePricing's breakdown, a query uses roughly 1 read unit per GB of namespace searched, with a minimum of 0.25, and a write uses 1 write unit per KB. In practice, large single namespaces make every query expensive, while splitting data into many smaller namespaces (for example, one per customer) keeps reads cheap.
Best fit: small to mid-size indexes, spiky or low query volume, multi-tenant apps that split data by namespace.
Weaviate Cloud bills mainly on vector dimensions stored. After a January 2026 restructure, UsagePricing reports a Flex plan at $45 a month with an entry rate of about $0.00465 per million dimensions, with Premium plans from $400 a month. Higher-dimension embeddings cost proportionally more, so compression and smaller models reduce the bill directly.
Best fit: teams that want hybrid keyword and vector search built in, with a predictable monthly bill.
Qdrant Cloud bills hourly for the vCPU, memory and storage you allocate, with no per-query fees. Zilliz Cloud (managed Milvus) uses compute units. Managed Postgres with pgvector, such as AWS RDS, Supabase or Neon, bills for the database instance.
Capacity pricing gets cheaper per query as traffic grows, until you need a bigger node.
Best fit: steady, high query volume, and teams that already run Postgres.
Published comparisons often assume light traffic. One 2026 comparison at 10 million 768-dimension vectors put Qdrant Cloud at about $65 a month, Pinecone at $70, pgvector on RDS at $120 and Weaviate Cloud at $135. Those numbers are useful for small workloads but say little about cost at production query volume, which is where the models diverge.
Self-hosting replaces a vendor bill with three costs: compute, operations and people. The software is free; running it reliably is not.
Compute and storage
You run Qdrant, Milvus, Weaviate or Postgres with pgvector on your own virtual machines or Kubernetes cluster. Memory-optimized instances are the main cost:
A 32 GB memory-optimized cloud instance costs roughly 150–250 a month on demand.
A 128 GB instance costs roughly 600–900 a month.
A 256 GB instance costs roughly 1,200–1,800 a month.
Plan for at least two replicas for availability, plus disk, snapshots and backups. Reserved instances or committed-use discounts typically cut compute by 30–50%.
Index builds and rebuilds: HNSW builds are memory-hungry. A guide to scaling pgvector estimates about 60 GB of working memory to build an index on 5 million 1,536-dimension vectors, so builds may need temporary larger machines.
Re-embedding: switching embedding models means re-embedding and re-indexing the whole corpus, which needs spare capacity.
Scaling and sharding: past a single node, you manage shards, replicas and rebalancing.
Security: network isolation, encryption, access control and patching.
Monitoring: latency, recall, memory pressure and disk usage.
Running a production vector database needs part of an engineer's time for upgrades, tuning, incidents and on-call. As a planning range:
Small single-node deployment: about 10% of one engineer.
Mid-size replicated cluster: about 25% of one engineer.
Large sharded cluster: about 50% of one engineer or more.
At a fully loaded cost of $200,000 a year, that is roughly $1,700 to $8,300 a month, often more than the infrastructure itself.
If your team already operates Postgres in production, adding pgvector for a few million vectors can cost almost nothing extra. Backups, monitoring, access control and on-call already exist. This is why pgvector is often the cheapest option for small and mid-size RAG workloads. At small scale, managed services win clearly. At mid scale, the answer depends on query volume and whether you can share engineering time. At very large scale, self-hosting usually wins on cost if you have the team.
The assumptions: 1,536-dimension embeddings, a RAG workload with 1 million queries a month at small scale and 5 million at mid and large scale, and monthly re-indexing of about 10% of vectors. Engineering time is costed at $200,000 a year fully loaded.
Pinecone Serverless: about 7 GB stored costs about $2; at roughly 7 read units per query, 1 million queries cost about $112; writes are minor. Total about $120 a month.
Weaviate Cloud Flex: about 1.5 billion dimensions at the entry rate is a few dollars, so the $45 plan minimum applies. Total about 45–100 a month.
Self-hosted on new infrastructure: two 32 GB instances plus storage cost about $400, plus about 10% of an engineer at about $1,700. Total about $2,100 a month.
pgvector on existing Postgres: often under $200 a month in extra capacity.
Verdict: managed, or pgvector on Postgres you already run.
Pinecone Serverless in one large namespace: about 70 GB stored costs about $23, but at roughly 70 read units per query, 5 million queries cost about $5,600. Total about $5,700 a month. Split into many smaller namespaces, reads drop sharply.
Weaviate Cloud: about 15 billion dimensions at the entry rate is about $71 a month in dimension charges, plus plan minimums and any compute or compression add-ons.
Self-hosted with int8 quantization: two 128 GB instances plus storage cost about $1,600, plus about 25% of an engineer at about $4,200. Total about $5,800 a month.
Qdrant Cloud or similar capacity-priced managed service: typically a few hundred to a few thousand dollars a month depending on the cluster, with no per-query fees.
Verdict: a capacity-priced managed service or a well-partitioned usage-based index is usually cheapest. Self-hosting only wins here if engineering time is shared with an existing platform team.
Pinecone Serverless in large namespaces: read costs become very large at millions of queries a month. Dedicated read capacity, aggressive namespace partitioning or an enterprise agreement becomes necessary.
Self-hosted with quantization and sharding: four 256 GB instances (two shards, two replicas) plus storage cost about $6,500, plus about 50% of an engineer at about $8,300. Total about $15,000 a month.
Managed capacity-priced services: one 2026 comparison estimated about $480 a month on Qdrant Cloud versus about $280 self-hosted at 100 million vectors and 10 million queries a month, but that assumes compact vectors and a lean configuration. Real costs scale with dimensions, replicas and recall targets.
Verdict: self-hosting or a negotiated enterprise contract usually wins, and compression, disk-based indexes such as DiskANN, and partitioning matter more than the vendor.
Usage-based pricing is cheapest at low volume and becomes expensive when large indexes meet high query volume.
Capacity-based pricing, managed or self-hosted, gets cheaper per query as traffic grows.
People cost dominates self-hosting below roughly 50 million vectors unless the engineers are already on payroll for other infrastructure.
Treat these as illustrative numbers; plug in your own vector count, dimensions, query volume and salaries.
Choose managed when speed and low operational load matter most, and self-host when scale, data control or existing infrastructure make it cheaper. Whichever you pick, a few levers cut cost on any platform.
Choose managed when
You have fewer than about 10 million vectors, or traffic that is spiky or unpredictable.
You do not have database or platform engineers with spare capacity.
Speed to production matters more than unit cost.
You need built-in features such as hybrid search, reranking or multi-tenancy without building them.
You already run Postgres, Kubernetes or search infrastructure with an experienced team.
You have 50–100 million vectors or more, or very high, steady query volume.
Data residency, air-gapped deployment or strict compliance rules out third-party hosting.
You need custom indexing, filtering or hardware choices that managed services do not offer.
Quantize: use half precision, int8 or binary quantization with re-ranking. It is the biggest saving available.
Use smaller embeddings: choose a 768-dimension or shorter output where retrieval quality holds up in your evaluations. Partition by tenant or topic: smaller namespaces or collections make each query cheaper on usage-based pricing and faster everywhere.
Index only what you search: keep raw text and rarely queried metadata in cheaper storage, linked by ID.
Delete stale vectors: remove outdated document versions and duplicates on a schedule.
Re-embed in batches: plan model upgrades as batch jobs on temporary capacity, not on your production cluster.
Cache frequent queries: many RAG workloads repeat the same questions.
Start on pgvector if you already run Postgres, and move to a dedicated vector database only when measured latency, scale or features require it.
A vector database typically costs $50 to $1,500 a month for up to 10 million vectors on a managed service, and several thousand dollars a month at larger scale. Self-hosting has lower infrastructure cost but adds engineering time that often exceeds the hardware.
It can be at high query volume or above roughly 50 million vectors, especially if your team already runs similar infrastructure. Below that, Pinecone or another managed service is usually cheaper once engineering time is included.
About 6 GB for 1 million 1,536-dimension float32 vectors, and roughly 12–25 GB once an HNSW index and metadata are added. Quantization can reduce this by 50–90%.
Yes, for many workloads up to several million vectors, especially if you already run Postgres. Past about 10 million high-dimension vectors, you will need quantization, memory tuning and possibly partitioning, or a dedicated vector database.
Read costs scale with the size of the namespace each query searches, not just the number of queries. Large single namespaces make every query expensive; splitting data into smaller namespaces and reducing vector size usually lowers the bill.
For small projects, free tiers from Pinecone, Qdrant and Weaviate, or pgvector on an existing Postgres database, cost little or nothing. At large scale, self-hosted open-source options such as Qdrant, Milvus or pgvector are cheapest if you have the team to run them. Plan for it. Keep embeddings and source documents in your own storage so you can re-index into another database. Switching usually costs a re-embedding or re-indexing run plus testing, not a rebuild of your application.
The cheapest option depends on your vector count, query patterns and team. CodingCops designs and runs retrieval infrastructure for RAG and AI agents, managed or self-hosted, and sizes it against real workloads before you commit. Talk to CodingCops for a cost model built on your data.