Vector Database Pricing Explained: Storage, Writes, and Queries

Vector database pricing is easier to understand when it is treated as a workload equation rather than a plan comparison. The database may bill for stored bytes, dimensions, provisioned memory, writes, queries, data transfer, or some combination of them. A low storage rate can therefore coexist with a high query bill, while a usage-based service can still have a monthly minimum.

For a useful estimate, keep three ledgers separate:

1. Storage: the vectors, IDs, metadata, indexes, replicas, and backups retained over time.
2. Writes: the initial import plus every upsert, update, delete, and re-indexing cycle.
3. Queries: interactive searches, retrieval calls from agents, fetches, lists, and retries.

This guide shows how to construct those ledgers for a retrieval-augmented generation (RAG) workload. Prices and billing rules were checked against official vendor pages on 2026-07-23. A [VERIFY] marker identifies a rate or charge that could not be confirmed from a current official page and must be checked before a purchasing decision.

Why vector database list prices can mislead

Two services that both advertise usage-based pricing may measure completely different things. Pinecone On-Demand meters serverless indexes with read units, write units, storage, and egress. Turbopuffer describes storage, writes, and queries in terms of logical bytes and data queried, while also applying plan minimums. Qdrant Cloud takes a provisioned-resource approach: its official billing documentation says managed clusters are charged for CPU, memory, disk, backup storage, and paid inference tokens.

That difference changes what “one million vectors” costs. The vector count alone omits at least five variables:

• embedding dimensions;
• bytes used per dimension;
• metadata and identifier size;
• number of replicas or copies;
• query and update frequency.

A million 384-dimensional vectors and a million 3,072-dimensional vectors are not equivalent storage workloads. Nor is an archive queried 1,000 times per month equivalent to a support assistant making several retrieval calls for every user message.

Minimum commitments also matter. On 2026-07-23, Pinecone listed Starter at $0, Builder at a flat $20 per month, Standard with a $50 monthly minimum, and Enterprise with a $500 monthly minimum. Its cost documentation explains that a Standard customer whose measured usage is $20 still pays $50. Turbopuffer listed a $16 monthly minimum for Launch and $256 for Scale; Enterprise was shown as at least $4,096 per month with a 35% usage premium. These are minimums, not estimates of the database resources a specific application needs.

The practical rule is to calculate raw usage first and apply the plan floor afterward:

Estimated invoice = max(plan minimum, storage + writes + queries + other charges)

That expression is only a planning model. Taxes, contracted discounts, support, inference, network transfer, backups, and vendor-specific rounding may sit outside it.

Billing-model comparison

The following table summarizes the inputs that matter before applying any plan minimum. It is a comparison of billing models, not a claim that the products provide identical features or performance.

Service	Primary database meters	Verified minimum or free entry point	Cost driver to test first
Pinecone serverless	GB-month storage, WUs, RUs, egress	Starter $0; Builder $20 flat; Standard $50 minimum; Enterprise $500 minimum	Targeted namespace size and write batching
turbopuffer	Logical storage and writes; queried data or pinned GB-hours	Launch $16; Scale $256; Enterprise at least $4,096 plus 35% usage premium	Namespace size, query frequency, and whether pinning is economical
Qdrant Cloud	Provisioned CPU, memory, disk, backup storage, and paid inference tokens	Free single node: 0.5 vCPU, 1 GB RAM, 4 GB disk	Required RAM/disk, node count, and replication

All entries were checked on 2026-07-24 against the official sources listed below. Region, cloud, contract, and selected features can change the invoice, so this table should be used to choose a calculation method rather than to select a vendor by one number.

Official sources checked 2026-07-23: Pinecone pricing, Pinecone cost documentation, turbopuffer pricing, the turbopuffer pricing changelog, Qdrant Cloud pricing, and Qdrant Cloud billing.

Storage units: vectors are only part of the footprint

Begin with a provider-neutral estimate of logical record size:

record bytes = ID bytes + metadata bytes + vector dimensions × bytes per dimension

For dense vectors stored as 32-bit floating-point values, use four bytes per dimension unless the vendor documents another representation. Pinecone publishes the same four-byte formula for estimating dense-vector index size. It also notes that each non-zero sparse-vector value uses eight bytes. Physical indexes, compression, replicas, and implementation overhead can make a provider’s billable size differ from this logical estimate.

Suppose a RAG system contains 1,000,000 chunks. Each record has:

• a 1,536-dimensional dense vector;
• 600 bytes of metadata;
• a 24-byte identifier.

The estimated logical size is:

1,000,000 × (24 + 600 + 1,536 × 4) = 6,768,000,000 bytes

That is 6.768 decimal GB, or about 6.30 GiB. Keep the GB/GiB distinction visible because providers may define billing units differently.

Chunking is therefore a pricing decision. More overlap creates more chunks; more chunks create more vectors, IDs, and repeated metadata. Before selecting a database, estimate the chunk count from total document content, target chunk size, and overlap. The planned Context Wire RAG chunk estimator is intended to produce that provider-neutral input, but this article does not link to it because the tool route has not yet been confirmed.

Metadata is often the hidden storage multiplier. Copying a long source excerpt into every record can cost more than the vector itself. Store only the fields required for filtering, authorization, attribution, or retrieval. Do not remove fields that are necessary for security or correct citations merely to reduce a small storage charge.

The RAG chunk size calculator guide explains how chunk length and overlap affect the record count used in this storage equation.

At Pinecone’s verified Standard rate of $0.33 per GB per month on 2026-07-23, 6.768 GB would produce about $2.23 per month in base index storage before backups, replicas, egress, inference, or a plan minimum. This is an arithmetic illustration, not a quote. Pinecone’s official page lists the same $0.33 rate for Enterprise, but other Enterprise usage units are priced differently.

The marked storage illustration recalculates from its four workload inputs; the later full cost worksheet retains its stated workload.

For turbopuffer, the current exact storage rate displayed by its interactive calculator was not available in the static official page response: [VERIFY: current logical-storage rate, unit definition, and regional variation as of 2026-07-23 at https://turbopuffer.com/pricing]. Qdrant does not reduce managed-cluster pricing to a per-vector rate; its official pricing page says billing is based on provisioned resource usage and offers a free single-node cluster with 0.5 vCPU, 1 GB RAM, and 4 GB disk as of the verification date.

Write and indexing cost: count bytes and change cycles

Write cost is not just the first upload. A realistic write ledger includes:

• initial ingestion;
• new documents added during the month;
• changed chunks upserted after source edits;
• deletions for expired or revoked content;
• full re-embedding after an embedding-model migration;
• dual writes during a database migration;
• failed jobs that a vendor still treats as billable.

Pinecone’s official cost documentation states that an upsert uses one write unit (WU) per 1 KB of request data, with a minimum of five WUs per request. Updating an existing record counts the new and existing record sizes; deletes use one WU per 1 KB of deleted records, also with a five-WU request minimum. Batching small records is important because sending one record per request can repeatedly trigger that minimum.

For the 6.768 GB example, a rough first-pass import through ordinary upserts represents at least about 6.768 million KB of payload before serialization overhead and request rounding. At Pinecone Standard’s verified rate of $4.00–$4.50 per million WUs, varying by cloud and region on 2026-07-23, that suggests roughly $27.07–$30.46 for the payload component of the initial write. The actual charge can be higher because JSON or protocol overhead, request minimums, record updates, and the vendor’s billable-unit rules are not captured in that multiplication. Pinecone also offers an object-storage import path with separate pricing, so a large migration should compare import and upsert estimates rather than assume they are interchangeable.

Write cost can recur unexpectedly. If 10% of the corpus changes every month, budget for about 10% of the applicable initial-write workload, plus any delete and replacement operations. A complete re-embedding can approach another full write cycle even when the source documents have not changed.

Turbopuffer’s official pricing changelog confirms that filterable attributes are billed once per vector column for writes and storage when a namespace contains multiple vector columns. It also says copy_from_namespace receives a 50% discount on write costs. The current base write rate still needs confirmation: [VERIFY: current per-GB written rate and how deletes, rewrites, and failed writes are billed as of 2026-07-23 at https://turbopuffer.com/pricing].

If you are comparing retrieval architecture as well as database cost, the existing Pinecone and turbopuffer RAG comparison provides the surrounding trade-offs. Use the billing model here to test the workload rather than choosing from a headline rate.

Read and query cost: model the retrieval path

Query cost should start with application behavior, not monthly active users. One user action may trigger query rewriting, multiple namespace searches, hybrid retrieval, a retry, and a final fetch. Measure database operations per accepted answer.

A basic monthly query estimate is:

monthly searches = user actions × retrieval calls per action × retry factor

If 80,000 user questions cause an average of 1.15 searches and 8% of attempts are retried, the planning volume is:

80,000 × 1.15 × 1.08 = 99,360 searches

Round that to 100,000 for a capacity estimate, then test peak traffic separately.

Pinecone’s verified rule on 2026-07-23 is that a query consumes one read unit (RU) per 1 GB in the targeted namespace, with a 0.25-RU minimum per query. Fetching uses one RU per ten records with a one-RU minimum, while listing up to 100 records costs one RU per call. For a 6.768 GB namespace and 100,000 queries, the simplified estimate is 676,800 RUs. At the verified Standard rate of $16–$18 per million RUs, varying by cloud and region, that is approximately $10.83–$12.18 in query usage before fetches, lists, egress, retries not already counted, and the Standard plan minimum.

Namespace design can change that result. Pinecone calculates query RUs from the size of the targeted namespace, so separating tenants or datasets may reduce the data searched per query when the access pattern permits it. Do not merge or split namespaces solely for cost without testing recall, authorization boundaries, operational complexity, and latency.

Turbopuffer uses a different query model. Its official pricing changelog states that, beginning in February 2026, the base queried-data rate became $1 per PB, the minimum billable data per query became 1.28 GB, and marginal discounts apply above 32 GB and 128 GB. Those facts were verified on 2026-07-23. However, namespace pinning uses GB-hours rather than per-query TB-queried pricing, with documented minimums of 64 GB and ten minutes. A workload with sustained traffic therefore needs two scenarios: unpinned query usage and pinned capacity. [VERIFY: the current pinning GB-hour rate, replica multiplier, and any regional adjustments before quoting a total.]

Embedding and generation are separate from database reads. A cheap retrieval layer cannot compensate for uncontrolled context sent to an LLM. The guide to cutting LLM token spend covers that adjacent cost ledger.

Serverless minimums and charges outside the headline rate

After calculating storage, writes, and queries, audit the charges that do not fit neatly into those columns.

Cost area	What to ask
Plan floor	Is the amount a fee, a usage credit, a hard cap, or a minimum commitment?
Egress	Are query results, exports, cross-region traffic, or private endpoints billed?
Backups	Are backup storage and restore operations charged separately?
Availability	Do replicas or multi-zone deployments multiply storage or compute?
Indexing	Is index construction included in writes, compute, or a separate import unit?
Inference	Are embedding and reranking bundled with the database or separately metered?
Operations	Are monitoring, support, SSO, audit logs, or private networking plan-gated?

Pinecone explicitly lists egress as a serverless metric and documents backup storage and restore as size-based charges. Exact current backup, restore, import, and egress rates should be taken from the selected cloud and region at purchase time: [VERIFY: those rates as of 2026-07-23 before publication].

Qdrant illustrates why a serverless-unit calculator cannot be applied to every product. Its official pricing and billing pages say paid managed clusters are billed hourly for compute, memory, disk, backup storage, and paid inference tokens. In that model, idle provisioned capacity can dominate the bill even when query volume is low. Conversely, a stable high-traffic service may value predictable provisioned resources more than a request-metered design.

The minimum can dominate a small RAG deployment. In the worked Pinecone scenario, base storage plus 100,000 queries plus the one-time initial write is roughly $40–$45 before omitted charges. On Standard, the verified $50 monthly minimum would set the invoice floor for a month in which total metered services remain below $50. In later months, when there is no full import, measured database usage could fall substantially while the same minimum remains.

Worked RAG cost estimate

Use a worksheet that keeps recurring and one-time costs separate.

Workload assumptions

• 1,000,000 chunks;
• 1,536 dense dimensions;
• 624 combined bytes for ID and metadata;
• 100,000 vector queries per month;
• one initial load, then 10% of records rewritten monthly;
• no sparse vectors in this simplified example.

Step 1: storage

The logical estimate is 6.768 GB. At Pinecone Standard’s verified $0.33 per GB-month, base storage is about $2.23 per month.

Step 2: initial write

Treating the logical payload as approximately 6.768 million billable KB gives a rough range of $27.07–$30.46 at $4.00–$4.50 per million WUs. Add a safety margin for request encoding, minimums, and operational retries, or replace the estimate with observed WUs from a pilot.

Step 3: steady-state writes

If 10% of the records are rewritten each month, a simple proportional placeholder is $2.71–$3.05. An update can count old and new record sizes under Pinecone’s documented rules, so this placeholder may understate an update-heavy workload. Measure a real change batch.

Step 4: reads

At 6.768 RUs per query, 100,000 queries consume approximately 676,800 RUs. The verified Standard range produces about $10.83–$12.18.

Step 5: apply the floor and omitted charges

The recurring subtotal after the initial import is roughly $15.77–$17.46 for storage, proportional rewrites, and queries. The Standard monthly minimum makes that at least $50 before any backup, egress, inference, support, or other charges. The import month also remains at least $50 if all metered usage stays below the floor.

This example is useful because it exposes the dominant variable: at this size and traffic level, the plan minimum matters more than base storage. At higher query volume, reads may dominate. With large metadata or frequent corpus replacement, writes may dominate. Run at least three cases—quiet, expected, and peak—and include a re-indexing month.

For applications that can route among several model providers, database cost should be evaluated alongside availability and model spend. The production OpenRouter alternatives guide covers that broader decision without treating the vector store as the whole RAG bill.

Questions to ask vendors before committing

A pricing calculator is only as accurate as its definitions. Send vendors the same workload description and ask for the billable result, not merely the recommended plan.

1. What exactly is a billable GB, dimension, read unit, write unit, or queried byte?
2. Does metadata count once, once per vector column, or again in indexes and replicas?
3. How are small requests rounded, and what minimum applies per operation?
4. Are updates billed for both the old and new record?
5. Are failed writes, imports, or queries billable?
6. How do namespaces, shards, tenants, and replicas affect query units?
7. What are the monthly plan minimum and included credits, and do unused credits expire?
8. What do backups, restores, exports, and network egress cost?
9. Does multi-zone availability multiply storage or compute?
10. Are embedding, hybrid search, full-text search, and reranking separate services?
11. Can usage be exported by namespace or tenant for chargeback?
12. What hard budget controls, alerts, and automatic shutdown protections exist?
13. Which rates vary by cloud, region, marketplace, or contract?
14. What pricing changes have occurred in the last year, and how are customers notified?

Then run a pilot using representative documents and production-like metadata. Record the provider’s reported storage, units per batch write, units per query, p95 latency, and retrieval quality. A cost estimate without a quality gate can reward a configuration that is cheap because it returns poor results.

Frequently asked questions

How much does a vector database cost for one million vectors?

There is no reliable per-million-vector answer without dimensions, metadata size, write frequency, query volume, and the plan minimum. In this article’s 1,536-dimension example, one million logical records occupy about 6.768 GB before provider-specific overhead; storage is only one part of the invoice.

Are vector database queries charged per search?

Sometimes, but vendors define a search differently. Pinecone converts each query into RUs based on the targeted namespace size, while turbopuffer meters queried data or pinned GB-hours. Qdrant Cloud primarily charges for provisioned resources, so the cluster can incur cost even during a quiet hour.

Why can the monthly bill exceed the storage estimate?

Writes, reads, egress, backups, replicas, inference, support features, and monthly minimums may be billed separately. Apply the plan floor only after estimating these components, and distinguish a one-time import month from steady-state months.

Is self-hosting with pgvector or another open-source database always cheaper?

No. Self-hosting can remove a managed-service minimum but adds compute, storage, backups, monitoring, upgrades, and engineering time. The pgvector versus Pinecone comparison outlines the operational trade-offs that should be added to a total-cost estimate.

How can I reduce vector database cost without hurting retrieval quality?

Start with representative measurement: remove unnecessary duplicated metadata, batch small writes, target only the required namespace, and avoid retries that do not improve results. Test every change against retrieval quality; the RAG retrieval evaluation guide provides a separate quality check.

Primary sources and verification notes

The following official pages were rechecked on 2026-07-24:

• Pinecone pricing: plan minimums and current list rates for storage, WUs, RUs, egress, imports, backups, and restores.
• Pinecone understanding cost: RU and WU definitions, per-request minimums, namespace-based query billing, and how minimum usage is applied.
• turbopuffer pricing: Launch, Scale, and Enterprise minimum commitments.
• turbopuffer pricing changelog: the February 2026 queried-data changes, April 2026 namespace pinning, and June 2026 Launch minimum reduction.
• Qdrant Cloud pricing: free-cluster resources and the CPU, memory, disk, backup, and inference-token billing dimensions.
• Qdrant Cloud billing and payments: resource-based cluster billing and payment timing.

Interactive calculators, region selectors, and contracted prices may expose details that static public pages do not. The existing [VERIFY] markers therefore remain intentionally unresolved until a specific cloud, region, and plan are selected.

The final decision should compare cost per accepted retrieval or cost per successfully answered user task—not cost per vector in isolation. Keep the storage, write, and query ledgers separate, apply minimums last, and preserve [VERIFY] markers until every selected-region rate has been confirmed on the vendor’s current official page.