Vector Database Pricing in 2026: Pinecone vs Weaviate vs Qdrant vs pgvector, Computed at Three Scales

Some links in this article are affiliate links. Automated Wealth Lab may earn a commission at no extra cost to you. See our Affiliate Disclosure.

Disclosure: This article mentions two affiliate partners — DigitalOcean and Hostinger — in the self-hosting section, linked with affiliate links. Pinecone, Weaviate, Qdrant, and Supabase are covered editorially; we earn nothing if you sign up with them. Every price was checked against published pricing pages in October 2026, and every computed bill shows its assumptions so you can re-run the math yourself.

Every RAG tutorial tells you to pick a vector database. Almost none tell you what it will cost in month six, when the corpus has grown and users are actually querying it. That silence is expensive, because the four main options for a solo founder — Pinecone, Weaviate, Qdrant, and pgvector — do not bill for the same thing. One meters the size of the room each query searches. One meters the dimensions sitting on disk and ignores your queries entirely. One refuses to publish its paid rates at all. And one is a free extension whose price is whatever server you already pay for.

So we did the arithmetic nobody puts on the pricing pages. Below, we compute the monthly bill for three concrete workloads — 100K, 1M, and 10M vectors, at stated dimensions and query volumes — under identical assumptions for each option. Where a vendor’s pricing cannot be computed from public data, we say so plainly instead of inventing a number.

One warning before the tables: the vector count is the least interesting variable in your bill. Query volume, namespace layout, and your embedding model’s dimension count move the total far more. Founders surprised by a vector database invoice are almost never surprised by storage. They are surprised by reads.

The short answer: At 1M vectors and 1M queries a month, Pinecone Standard computes to $116.79/month, Weaviate Flex sits at its $45/month minimum, Qdrant Cloud’s paid price cannot be computed from public data (it publishes no per-unit rates), and self-hosting Qdrant or pgvector on a VPS starts at $12.99/month in server cost. At 10M vectors and 5M queries, Pinecone jumps to $5,745.20 — unless you split tenants into separate namespaces, which drops the same workload to $80.82. Weaviate at that scale is $80.03. The cheapest option depends less on your corpus than on how your queries are shaped.

Four pricing models that share almost nothing

Option	What is actually metered	Free tier	Paid floor
Pinecone	Storage ($0.33/GB/mo) + read units (per GB of namespace searched, per query) + write units (per KB upserted)	Starter: free, 2 GB storage, 2M write units, 1M read units/mo, AWS us-east-1 only	Builder $20/mo flat; Standard $50/mo minimum, then usage
Weaviate Cloud	Vector dimensions stored (from $0.00465 per 1M/month) + storage (from $0.12/GiB) + backups; queries are not metered	Free forever: 100,000 objects, 1 GB memory, 10 GB disk	Flex from $45/mo (minimum includes dimension + storage charges; backups on top)
Qdrant Cloud	Hourly usage on vCPU, RAM, disk, backup storage, and inference — but no published per-unit rates	Free forever: single node, 0.5 vCPU, 1 GB RAM, 4 GB disk	Not published; calculator or sales only
pgvector / self-hosted Qdrant	Nothing — free open-source software; you pay for the server	Software is free (pgvector extension; Qdrant is Apache-2.0)	The VPS bill: from $6.49/mo promo at Hostinger, $6/mo at DigitalOcean

That table explains every surprise later in this article. Pinecone is the only option whose bill scales with queries multiplied by corpus size. Weaviate’s bill is a storage bill wearing a database costume. Qdrant Cloud is a blank cell. And the self-hosted row converts a pricing problem into a sizing problem: pick the right RAM and the bill stays flat.

The three test scenarios

Every number below uses the same workload definitions, so the options stay comparable:

• Embedding size: 1,536 dimensions, float32 — the output size of OpenAI’s text-embedding-3-small / ada-002 class of models. One vector is 6,144 bytes.
• Scenario 1 — Prototype: 100,000 vectors, 50,000 queries/month.
• Scenario 2 — Production RAG: 1,000,000 vectors, 1,000,000 queries/month.
• Scenario 3 — Scaled product: 10,000,000 vectors, 5,000,000 queries/month.
• For Pinecone’s record math, each record carries 1,000 bytes of metadata and an 8-byte ID, giving 7,152 bytes per record (dimensions × 4 bytes + metadata + ID, per Pinecone’s metering formula).
• All data sits in one namespace / one collection, and every query searches the whole corpus, unless a section explicitly models the split alternative.
• Excluded everywhere: embedding generation (a separate API bill), initial loading (priced separately below), taxes, and negotiated discounts.

Pinecone: your bill is namespace size × query count

Pinecone’s metering is the most interesting of the four. A query does not cost a flat fee. It costs 1 read unit (RU) per GB of the namespace it searches, with a 0.25 RU minimum. Writes cost 1 write unit (WU) per KB upserted. On the Standard plan those units cost $16–$18 per million RUs and $4–$4.50 per million WUs, storage is $0.33/GB/month, and a $50 monthly minimum applies to usage.

Scenario 1 (100K vectors, 50K queries). The corpus is 0.7152 GB. Each query costs 0.7152 RU, so 50,000 queries consume 35,760 RUs — about $0.57 of reads, plus $0.24 of storage. This workload fits entirely inside the free Starter plan (2 GB storage, 1M RUs, 2M WUs per month; the one-time load of 100K records is roughly 715,200 WUs, also inside the cap). Monthly cost: $0. On Standard, the same usage bills at the $50 minimum — at small scale, the minimum is the price.

Scenario 2 (1M vectors, 1M queries). The corpus is 7.152 GB, so each query costs 7.152 RUs and the month consumes 7.152M RUs. Reads: 7.152 × $16 = $114.43. Storage: 7.152 × $0.33 = $2.36. Total: $116.79/month at the lowest published read rate, or $131.10 at the top of the range ($18/M RU). Note that the $20 Builder plan cannot serve this workload: the corpus fits its 10 GB storage cap, but 7.152M RUs blows through its 2M RU allowance. Storage fits; reads do not.

Scenario 3 (10M vectors, 5M queries). The corpus is 71.52 GB. Each query now costs 71.52 RUs, and 5M queries consume 357.6M RUs. Reads: $5,721.60. Storage: $23.60. Total: $5,745.20/month ($6,460.40 at $18/M RU). Storage is a rounding error; reads are 99.6% of the bill.

The namespace lever is worth more than any discount

Scenario 3 has a completely different price if the data model allows it. Split the same 10M vectors across 100 tenant namespaces of 100K vectors each (0.7152 GB per namespace), queries spread evenly, each query searching only its own tenant’s namespace. Each query now costs 0.7152 RU instead of 71.52. Monthly reads fall to 3.576M RUs = $57.22, storage is unchanged at $23.60, and the total is $80.82/month — a 71× reduction on identical data and query volume. The catch is real: this only works if a query genuinely never needs to search across tenants. A metadata filter inside one giant shared namespace does not get this treatment; Pinecone meters the full namespace searched, filter or not.

Loading and the other meters

Initial ingestion carries a trap of its own. Loading Scenario 2’s 1M records by upsert costs roughly 7.152M WUs ≈ $28.61–$32.18; Scenario 3’s 10M records cost $286.08–$321.84. Pinecone’s bulk import path is priced at $0.25/GB instead — $1.79 and $17.88 respectively. For a static corpus, import first and upsert only the changes. Backups ($0.10/GB/month), egress beyond the included 100 GB ($0.10/GB), and the Enterprise tier (a $500 minimum with higher unit rates — $24–$27/M RU — buying compliance features, not volume discounts) sit outside the scenario math but belong in a real budget.

Weaviate: the bill that ignores your traffic

Weaviate Cloud prices the corpus, not the conversation. Flex, its pay-as-you-go tier, charges from $0.00465 per million vector dimensions per month, plus storage from $0.12/GiB and backups from $0.03036/GiB, with a $45/month minimum that already includes the dimension and storage charges (backups are billed on top). Queries are simply not a billing dimension. Here are the same three scenarios, with storage modeled on vector bytes only:

Scenario	Dimensions charge	Storage charge	Backup	Monthly total
1 — 100K vectors	153.6M dims × $0.00465 = $0.71	0.57 GiB × $0.12 = $0.07	$0.02	$45.02 (minimum governs)
2 — 1M vectors	1,536M dims × $0.00465 = $7.14	5.72 GiB × $0.12 = $0.69	$0.17	$45.17 (minimum governs)
3 — 10M vectors	15,360M dims × $0.00465 = $71.42	57.2 GiB × $0.12 = $6.87	$1.74	$80.03

Three honest caveats. First, these are Weaviate’s “from” rates — the lowest published; the actual per-dimension rate varies by cloud, region, index type, and compression (aggressive quantization earns discounted dimension rates, which can pull a compressed 10M-vector corpus below our Scenario 3 figure). Second, our storage line counts vector bytes only; real objects carry payloads that add GiBs. Third, the free tier caps at exactly 100,000 objects with 1 GB of memory, and Scenario 1’s raw vectors alone occupy 0.57 GiB before the index takes its share — our prototype sits precisely on the free tier’s ceiling, which is why we model Flex as the realistic paid answer. Above Flex, Premium starts at $400/month prepaid and buys SSO, higher SLAs, and dedicated options — features, not a cheaper meter.

Qdrant: the honest blank in the table

Qdrant Cloud is where this comparison runs into a wall — and the wall itself is the finding. The free tier is genuinely good: a single-node cluster with 0.5 vCPU, 1 GB RAM, and 4 GB disk, free forever, no card required. But the paid Standard tier publishes no per-unit prices at all: its pricing page describes hourly metering on vCPU, memory, storage, backup storage, and inference tokens, then points you to a calculator inside the console or to sales. Premium adds SSO, private VPC links, and a 99.9% SLA behind an undisclosed minimum spend.

So: Qdrant Cloud’s paid cost at our three scenarios is not computable from public data, and we will not guess it. Third-party pages occasionally quote per-GB-hour estimates; none of those numbers appears on Qdrant’s own pricing page, so none appears here. Budgeting Qdrant Cloud honestly means running their calculator with your real dimensions and cluster size — and screenshotting the result, because there is no public rate card to check it against later.

The free tier, at least, can be sized with arithmetic. At 1,536 dimensions, one float32 vector is 6,144 bytes, so 1 GB of RAM holds roughly 175,000 vectors’ worth of raw vector bytes — before the HNSW index, payload data, and the engine itself take their share. Read that as a planning ceiling, not a guarantee: the free cluster is a prototype budget, comfortable in the tens of thousands of vectors at this dimension count, and RAM — not its 4 GB of disk — binds first.

pgvector and self-hosting: the VPS is the price tag

Both remaining options are free software: pgvector is an open-source PostgreSQL extension, and Qdrant’s engine is Apache-2.0, self-hostable with the same client code as its cloud. The database costs $0; the server is the entire bill, and sizing one is a RAM question — an in-memory HNSW index wants the vectors (plus index overhead and the OS) to fit in memory. Here is a planning model from current published VPS prices, using our scenarios’ raw vector sizes (0.61 GB, 6.14 GB, and 61.4 GB at float32). These are sizing estimates, not benchmarks; your latency target may demand more machine.

Scenario	Float32 RAM need	Sensible VPS	Monthly server cost
1 — 100K vectors	~0.6 GB vectors	Any 4 GB VPS	Hostinger KVM 1 (4 GB): $6.49 promo / $11.99 renewal; DigitalOcean 4 GB: $24
2 — 1M vectors	~6.1 GB vectors	16 GB for comfort; 8 GB is tight	Hostinger KVM 4 (16 GB): $12.99 / $28.99; DigitalOcean 16 GB: $96
3 — 10M vectors	~61 GB vectors (float32)	Quantize first: int8 shrinks vectors ~4× to ~15.4 GB, fitting 32 GB	Hostinger KVM 8 (32 GB): $25.99 / $49.99; DigitalOcean’s 16 GB at $96 is tight even quantized

Two levers change this table. Scalar quantization (float32 → int8) cuts vector memory roughly 4× in both Qdrant and pgvector-class setups, dropping Scenario 2 onto a 4 GB VPS and making Scenario 3 feasible on one mid-size box; on-disk index modes trade latency for the same effect. And pgvector’s special case: if your application already runs PostgreSQL with spare RAM and disk, the incremental cost of adding vector search can be a genuine $0 — no new service, no new server. No managed vendor can beat that. The managed-Postgres version is Supabase Pro from $25/month (8 GB disk included, then $0.125/GB) — but Scenario 2’s ~7.2 GB of records, plus an HNSW index, will outgrow the included disk, so budget the overage and a likely compute upgrade rather than anchoring on $25.

What the VPS prices exclude is you: patching, backups (DigitalOcean charges +20% for automated backups; Hostinger includes weekly backups, but its promo prices renew at roughly 1.7–2.2×), monitoring, and the 2 a.m. incident. A single-node self-hosted database has no SLA because you are the SLA. Price that honestly before declaring self-hosting the winner.

The master table

Monthly cost at the three scenarios (Pinecone at its lowest published read rate; Weaviate at its lowest “from” rates; self-host = Hostinger promo server cost only):

Scenario	Pinecone	Weaviate Flex	Qdrant Cloud	Self-hosted (Qdrant or pgvector)
1 — 100K vectors, 50K queries	$0 (free Starter)	$45.02	$0 free tier (RAM-tight); paid: not published	$6.49
2 — 1M vectors, 1M queries	$116.79	$45.17	Not published	$12.99
3 — 10M vectors, 5M queries	$5,745.20 (or $80.82 tenant-split)	$80.03	Not published	$25.99 (quantized)

What this model leaves out — deliberately

Embedding generation is excluded everywhere: turning text into vectors is a separate API bill, identical whichever database stores the result. Egress, restores, support tiers, HIPAA add-ons (Pinecone charges $190/month for one on Standard), and committed-use discounts are real money but workload-specific, so they are flagged in the text rather than baked into the tables. Every managed price here is a list price at the lowest published rate; region and cloud move Pinecone’s RU price between $16 and $18 per million and Weaviate’s dimension rate upward from its “from” figure.

FAQ

Which vector database is cheapest at 1M vectors?
At 1M queries a month: Weaviate Flex at $45.17 (its minimum), Pinecone Standard at $116.79, or a $12.99 VPS plus your time. At low query volumes Pinecone’s free Starter covers the corpus only while reads stay under 1M RUs — a 7.152 GB namespace exhausts that in about 140,000 whole-corpus queries.

Why is a Pinecone bill mostly reads instead of storage?
Because of the metering formula: each query costs 1 RU per GB of the namespace searched. Storage at $0.33/GB is nearly free by comparison — in Scenario 3, storage is $23.60 of a $5,745.20 bill. Corpus size hurts twice on Pinecone: once on disk, and again on every query.

Can I get a Qdrant Cloud price without talking to sales?
Not a firm one. Qdrant publishes no per-unit rates for its paid tiers; the only routes are the in-console calculator with your own cluster configuration, or sales. Anyone quoting you an exact Qdrant Cloud price from a blog post would be guessing.

Does the embedding model’s dimension count really change the bill?
Yes, roughly linearly. Drop from 1,536 to 768 dimensions and Pinecone’s Scenario 2 record shrinks to 4,080 bytes: the namespace becomes 4.08 GB, reads compute to $65.28, storage to $1.35 — $66.63 instead of $116.79. Weaviate’s dimension meter halves the same way. Model choice is a pricing decision, not just a quality one.

Can pgvector handle 10M vectors?
It can store and index them; the real question is what server you give it and what latency you demand. pgvector’s cost doesn’t change with scale — your VPS bill does (61.4 GB of float32 vectors is a RAM problem before it is a Postgres problem). We benchmarked no option here, so treat fit as a sizing estimate to validate with your own data.

When does self-hosting stop being the cheap option?
When you price your own operations time, when you need high availability (a second node doubles the server line), or when one incident costs more than a year of managed fees. Below roughly $50/month of managed spend, the VPS almost always wins on cash. Above that, you are buying back your weekends — which may be the correct trade.

Methodology

What we did: Read the official Pinecone and Weaviate pricing pages in full (October 2026) and computed every scenario bill from their published rates and metering formulas — Pinecone’s 1 RU per GB of namespace searched; Weaviate’s per-dimension rate under its $45 Flex minimum. Cross-checked the Pinecone model against an independent published analysis using the same formulas. Took Qdrant’s free-tier specs and its lack of published paid rates from current reviews of Qdrant’s pricing page, and VPS prices from current published DigitalOcean and Hostinger plan tables.

What we did NOT do: We created no accounts, ran no load tests, and measured no latency or recall — this is a pricing analysis, not a benchmark. We did not estimate Qdrant Cloud’s paid prices, because Qdrant does not publish the rates an estimate would require. Self-hosted sizing is a RAM-based planning model with assumptions printed, not a capacity guarantee.

Conflict disclosure: DigitalOcean and Hostinger are affiliate partners of this site and are linked as such where they appear. Pinecone, Weaviate, Qdrant, and Supabase are not partners.

AWL verdict

Choose by query shape, not by logo. If your data is naturally tenant-shaped and you want zero operations, Pinecone is fairly priced — if you split namespaces; search one giant namespace at volume and it becomes the most expensive option here by two orders of magnitude. If your corpus is stable and your traffic heavy, Weaviate’s query-blind pricing is the best deal in managed vector search, and its $45 floor is the price of admission. If cash is the priority and you can run a server, self-hosted Qdrant or pgvector on a $13–$26 VPS beats every managed bill in this article — paid in ops time instead of dollars. And Qdrant Cloud? A product we cannot price from its own website does not belong in a budget until its calculator gives you a number in writing.

Sources

• Pinecone official pricing page — plans, unit rates, minimums (verified October 2026): https://www.pinecone.io/pricing/
• Independent worked analysis of Pinecone’s metering formulas, cross-checked against Pinecone’s live pricing page (verified October 2026): https://omidsaffari.com/blog/pinecone-pricing
• Weaviate official pricing page — Flex rates, minimums, free tier limits (verified October 2026): https://weaviate.io/pricing
• Qdrant review documenting its tiers and the absence of published per-unit rates (verified October 2026): https://panoply.io/tools/qdrant/
• DigitalOcean Droplet plan prices by RAM tier (verified October 2026): https://betterstack.com/community/guides/web-servers/digitalocean-review/
• Hostinger KVM VPS plan prices, promo and renewal (verified October 2026): https://www.cloudpicked.com/hostinger-vps-review-en.html