Pinecone vs Weaviate vs pgvector: what a million vectors costs to keep

The unit each vendor sells is the whole argument

A million 768-dimension vectors is a small dataset. The three shortlisted products do not price it in the same unit, which is why two teams with identical workloads can land on bills that do not reconcile. Pinecone sells operations, Weaviate sells stored dimensions, and pgvector sells nothing at all because it is an extension inside Postgres.

Pinecone's serverless model meters storage, writes and reads. Its documentation puts read cost at 1 read unit per 1 GB of namespace size per query, with a minimum of 0.25 RU. That single sentence moves the bill more than the vector count does, because namespace size is a design choice the buyer controls.

Weaviate Cloud meters the total number of vector dimensions stored, from $0.00465 per million dimensions on the Flex plan, with storage from $0.12 per GiB and backups from $0.03036 per GiB. The vendor's own FAQ says the dimension count is used because it is a number you can calculate rather than abstract read or write units.

pgvector has no meter. The README documents HNSW and IVFFlat indexes inside Postgres, and the cost is whatever Postgres instance holds the graph. The arithmetic that settles most comparisons is that a 1,536-dimension embedding occupies 6,152 bytes, so a million of them is 6.2 GB, which fits in the memory of a database server many teams already pay for.

What a million vectors costs before and after the namespace decision

The published numbers support a comparison at one million vectors, but only if the query volume and the namespace layout are stated. Pinecone's read charge scales with the size of the namespace being queried, not with the number of results returned, so splitting data across namespaces is a pricing lever as much as a data-modelling one.

The worked example in the published analysis is stark. Ten million vectors held in a single namespace model at about $984 a month of reads, while the same data spread across 100 namespaces models at about $10. The vectors did not change. The read units did.

Weaviate's floor is published and its ceiling is not. Flex starts at $45 a month and Premium from $400 a month, and the vendor states that list prices for vector-dimension rates vary by cloud provider and region. A buyer cannot compute a regional bill from the pricing page alone and should ask for a running-cost estimate from the console module before signing.

Pinecone's plan minimums are published at $50 a month and $500 a month depending on the plan, applied to usage, with anything above billed pay-as-you-go. Storage is quoted at $0.33 per GB per month in the published analysis, and ingestion at $0.0005 per unit, or $0.001 for multi-modal. Those are the lines to model, not the headline minimum.

Where each option breaks at this scale

pgvector's ceiling is memory, not vector count. The README warns that HNSW builds fall back to on-disk graph construction once the graph outgrows maintenance_work_mem, and the extension prints a notice that building will take significantly more time. A team that sizes the instance for steady-state queries and not for index builds will meet that notice on the first reindex.

Pinecone's break is the opposite shape. On-demand indexes use shared multi-tenant capacity for reads with best-effort caching, so cold queries fetch from object storage. The vendor sells dedicated read nodes for sustained high query volumes, priced as a fixed hourly rate for read capacity based on node type, shards and replicas, with storage, write and egress costs unchanged.

That dedicated tier is the answer to a latency problem, and it removes the per-query meter. A buyer moving to it should ask what the hourly rate is for the node type and replica count they need, because the documentation describes the pricing dimension without publishing a rate on the page.

Weaviate's break is the backup line and the compression choice. The vendor's price-book note says backups are on by default for every cluster, that rates changed for usage from 1 September 2026, and that the effect depends on cloud and region. Compression does not reduce stored dimensions but does earn discounted list prices, so the index type chosen at creation sets the rate.

The managed tiers buy different things

Pinecone's Bring Your Own Cloud deployment runs the data plane in the customer's AWS, GCP or Azure account inside a dedicated VPC, with vectors, metadata and queries staying in that environment and no inbound network access required. An agent in the cluster pulls operations from Pinecone's control plane and executes them locally, stored as Kubernetes CRDs.

That matters to a buyer whose blocker is data residency rather than price, because the control plane still handles index lifecycle, authentication and billing while never storing or processing vectors. Only operational metrics and traces are transmitted, filtered of customer data. The pricing page does not publish a BYOC rate, so the number is quote-only and the question to ask is what the minimum commitment is.

Weaviate's managed tiers separate on support and assurance rather than deployment model. Flex carries a 99.5% availability SLA and a one business day severity 1 response, Premium carries 99.9% and four hours, and the dedicated contract tier carries 99.95% and one hour. HIPAA compliance and PrivateLink appear only at the dedicated tier.

pgvector's managed equivalent is whatever Postgres service the team already runs. The README notes the extension comes preinstalled with Postgres.app and many hosted providers, which means the operational question is backup, failover and point-in-time recovery on that instance, not a vector vendor's SLA.

The query-volume line where the managed service stops being cheap

The crossover is not a vector count. It is the point where read units, multiplied by queries per month, exceed the cost of the compute that would hold the graph. At one million 768-dimension vectors the dataset is small enough that a single Postgres instance can hold it, and the published analysis puts pgvector's incremental cost at roughly $100 a month of extra managed compute against roughly $100 a month for a new Pinecone dependency.

Above that, the namespace arithmetic dominates. A team querying a single large namespace at high volume pays per GB of that namespace on every query, while a team that partitioned its data pays a fraction. The published example of $984 against $10 for the same ten million vectors is the clearest evidence that schema design, not vendor selection, is the first cost decision.

Weaviate's dimension meter behaves differently because it does not move with query volume. A high-QPS application on a fixed dimension count pays the same whether it serves a thousand queries or a million, which favours steady, heavy read traffic and penalises a large corpus that is rarely queried.

The lever that beats all three is quantization. The published analysis puts the storage and RAM reduction at 4 to 32 times, and Weaviate confirms that more aggressive compression yields discounted list prices for vector dimensions. A buyer comparing vendors before comparing index types is comparing the wrong line.

The decision rule for a million vectors

Choose pgvector if the team already runs Postgres, the corpus is around a million vectors, and the instance has memory to hold the HNSW graph with headroom for index builds. The condition is that someone owns the maintenance_work_mem setting and the reindex window, because that is where this option fails rather than at the query.

Choose Pinecone if query latency has to be predictable under sustained load and the team will do the namespace design work before import. The condition is that the read-unit arithmetic is modelled against the actual namespace layout, and that dedicated read nodes are priced with the vendor, since the hourly rate is not published.

Choose Weaviate Cloud if the workload is read-heavy at a fixed corpus size and the team wants hybrid search and compression in the same product. The condition is that the regional dimension rate and the backup line are confirmed in the console before commitment, because both vary by cloud and region and the backup rate changed for usage from 1 September 2026.