Vector Database Cost Calculator

Set how many vectors you store, pick the dimensions of your embedding model, and add the metadata that rides along with each vector. The calculator works out the raw data size, applies a 1.5× index overhead factor, and prices the resulting footprint against Pinecone serverless, Qdrant Cloud and Weaviate Cloud. Read the table as three separate estimates rather than a ranking — the providers bill different resources, so no row is marked cheapest. The two size outputs above the table are the numbers to reuse if you want to price any other engine.

How embeddings turn into gigabytes

Every dimension of a float32 embedding takes four bytes, and that one fact drives most of a vector database bill.

raw bytes = vectors × (dimensions × 4 + metadata bytes)

At the defaults — 5 million vectors, 1,536 dimensions, 200 bytes of metadata — each vector occupies 1,536 × 4 + 200 = 6,344 bytes. Multiply by 5 million and you get 31.72 GB of raw data. The index is not free: HNSW graph links, ID mappings and payload indexes inflate what actually sits on the provider's hardware. This calculator applies a flat 1.5× factor, turning 31.72 GB into 47.58 GB of billable footprint. Real overhead runs from about 1.3× to 2× depending on the HNSW M parameter and how much metadata gets indexed for filtering, so treat the factor as a sizing convention, not a measurement.

A short history of vector search

Finding the nearest point to a query is an old problem, and the hard part has always been dimensionality. Jon Bentley's k-d tree, published in 1975, organizes low-dimensional points into a binary tree for fast lookup, but in the hundreds or thousands of dimensions that embeddings occupy it decays to a full linear scan — the curse of dimensionality. The first practical escape arrived in 1998, when Piotr Indyk and Rajeev Motwani introduced locality-sensitive hashing, which buckets similar points together with random hash functions and trades exactness for speed. In 2011 Hervé Jégou, Matthijs Douze and Cordelia Schmid described product quantization, compressing each vector into a short code whose distance to a query can be estimated directly from the code — the ancestor of the quantization tricks that still cut bills today.

What turned this into an everyday concern was the arrival of vectors worth searching. In 2013 Tomáš Mikolov and colleagues at Google released word2vec, which produced dense representations of words where geometric closeness tracked meaning. Spotify open-sourced Annoy the same year — a forest of random projection trees that Erik Bernhardsson built during a company hack week and that Spotify used for music recommendations — and Facebook AI Research followed with FAISS in 2017, bundling product quantization, inverted files and GPU acceleration into a library that handled billions of vectors. The indexing method most managed services now reach for by default, the Hierarchical Navigable Small World graph, was described by Yury Malkov and Dmitry Yashunin in a 2016 preprint and published in the journal IEEE TPAMI in 2020.

None of those tools was a database — you embedded them in your own service and kept them running yourself. Pinecone, founded by Edo Liberty in 2019 and launched publicly in 2021, packaged approximate nearest neighbor search as a managed service and effectively created the vector database product category. The open-source challengers arrived on their own schedules. Weaviate predates the category: Bob van Luijt's first public code landed in 2016, and by the end of 2018 he had entered the project into a Dutch startup accelerator, with the company around it later taking the Weaviate name. Qdrant's engine appeared on GitHub in 2020, and André Zayarni and Andrey Vasnetsov founded the Berlin company behind it in 2021. Demand climbed after Patrick Lewis and co-authors named retrieval-augmented generation in a 2020 paper, then surged once ChatGPT arrived in late 2022 and retrieval over private documents became a mainstream requirement. The pricing pages this calculator reads are only a few years old.

Current provider rates

The rates below come from each provider's published pricing pages — Pinecone's serverless tier, Qdrant Cloud's capacity pricing and Weaviate Cloud's published plan rates — verified in July 2026. The table is generated from the same data file the calculator reads, so the two cannot drift apart.

These three bases measure different things. A storage-month is not a RAM-month, and neither is an activity unit, which is why the results table refuses to crown a winner: the provider that is cheapest at rest is often not cheapest once query volume enters the picture. Weaviate is the awkward one to normalise: its meter counts stored vector dimensions rather than whole vectors, so the per-million-vector band here is a convenience conversion pinned to 1,536 dimensions and scaled linearly.

Three deployments, three bills

A side project first. Semantic search over 250,000 documentation chunks, embedded with a 384-dimension MiniLM model and 100 bytes of metadata per chunk: each vector is 384 × 4 + 100 = 1,636 bytes, so the collection is 0.41 GB raw and 0.61 GB indexed. Qdrant prices the unrounded 0.6135 GB at $57 a gigabyte, or $34.97 a month, and Weaviate charges $2.81 to $5. Pinecone's storage charge would be about twenty cents, but the $50 serverless minimum sets the floor — at toy scale the storage-billed option is the expensive one.

The startup case is the calculator's defaults. Five million OpenAI text-embedding-3-small vectors: 31.72 GB raw, 47.58 GB indexed. Pinecone storage comes to 47.58 × $0.33 = $15.70, so the $50 minimum still applies. Qdrant needs the whole index in memory: 47.58 × $57 = $2,712.06. Weaviate lands between $225 and $400 depending on plan tier and region.

At scale-up size the picture inverts. Two hundred million vectors at 768 dimensions with 500 bytes of metadata each: 200,000,000 × 3,572 bytes = 714.4 GB raw, 1,071.6 GB indexed. Pinecone storage is 1,071.6 × $0.33 = $353.63 a month. Qdrant at list RAM rates would be $61,081.20 — a number nobody actually pays, because at this size you quantize, spill to disk or negotiate a committed-use deal. Weaviate scales to $4,500 – $8,000.

Why RAM billing costs 50 times more at rest

At the default inputs the Qdrant estimate is roughly 54 times Pinecone's, and the gap is architectural rather than a pricing blunder. An HNSW index answers in single-digit milliseconds because the whole graph lives in memory, and a gigabyte of RAM on a cloud VM costs orders of magnitude more per month than a gigabyte of object storage. Qdrant Cloud bills for that RAM around the clock whether you query once a day or a thousand times a second. Pinecone's serverless design, introduced in early 2024, pushes vectors down to blob storage, caches working sets on demand, and meters usage instead. Its Standard plan currently publishes $16 to $18 per million read units and $4 to $4.50 per million write units, varying by cloud and region, on top of the storage line. The Pinecone figure in this calculator deliberately excludes those request charges, so a heavily queried workload will land well above the number shown, while a rarely touched archive will land right on it.

Escape hatches and what the estimate ignores

Quantization is the biggest lever, and it descends directly from the 2011 product quantization work. Scalar int8 stores each dimension in one byte instead of four, cutting vector memory to a quarter with a small recall penalty. Binary quantization goes to one bit per dimension — a 32× reduction — and claws accuracy back by rescoring candidates against full-precision vectors on disk. Disk-based indexes attack the same cost from the other side: Qdrant can memory-map vectors and hold only the graph in RAM, and DiskANN-style indexes serve billion-vector collections from NVMe. Either route can cut the RAM-billed estimate by 4× or more.

The estimate also skips several things that show up on real invoices: replication doubles the RAM line for each extra replica, backups and staging environments bill separately, and Weaviate applies per-collection overheads. Vectors are assumed to be float32 — if your model emits float16 or int8 embeddings natively, halve or quarter the raw size before reading the table. All three providers reprice regularly, which is what the verified date on this page is for.

Prices change without notice and figures here are estimates, not quotes; this site is not affiliated with any provider named above. See the site disclaimer.

Frequently asked questions

How much does it cost to store 10 million OpenAI embeddings in Pinecone?

Ten million text-embedding-3-small vectors at 1,536 dimensions with 200 bytes of metadata each come to 63.44 GB raw and about 95.2 GB once index overhead is counted. At $0.33 per GB-month that is $31.40 of storage, so the $50 serverless minimum is what you actually pay. Read and write units for query traffic bill separately on top.

Why does Qdrant Cloud show 50 times the Pinecone price for the same data?

They bill different resources. Qdrant Cloud provisions nodes and charges for RAM at roughly $57 per GB-month, because HNSW indexes are served from memory. Pinecone serverless keeps vectors in object storage at $0.33 per GB-month and meters reads and writes separately. At the calculator defaults that works out to $2,712 against $50 at rest, before Pinecone request units are added.

Do embedding dimensions change vector database cost much?

Linearly, and across every provider. A 3,072-dimension vector occupies 12,288 bytes of floats against 1,536 bytes at 384 dimensions, which means eight times the storage, eight times the RAM and, under per-vector billing, roughly eight times the price. Switching from a large embedding model to a small one, or truncating Matryoshka embeddings to 768 dimensions, halves or quarters most bills for a modest recall cost.

What does the 1.5 index overhead factor cover?

The graph links, ID mappings and payload indexes a vector database builds on top of the raw floats. HNSW typically adds 30 to 100 percent depending on the M parameter and how much metadata is indexed for filtering, so 1.5 is a middle-of-the-road sizing convention rather than a guarantee. Measure a sample collection if you need the exact figure.

Can quantization make a vector database cheaper?

Yes, it is the main lever. Scalar int8 quantization stores each dimension in one byte instead of four, cutting vector memory to about a quarter. Binary quantization goes to one bit per dimension and rescoring recovers most recall. On a Qdrant cluster sized for the calculator defaults — around $2,712 a month at published RAM rates — int8 pulls the memory requirement down toward $700.

Is self-hosting pgvector cheaper than a managed vector database?

At small and medium scale, usually. A couple of million 768-dimension vectors fit comfortably in an 8 GB Postgres instance costing under $50 a month, and the operational surface is familiar. You give up managed scaling, replication and the specialist index tuning, and past a few tens of millions of vectors the comparison stops being about price and starts being about engineering time.