turbopuffer pricing

About

turbopuffer is a serverless vector and full-text search database built directly on object storage (e.g. S3) with SSD caching, designed to make large-scale retrieval an order of magnitude cheaper than memory-resident vector databases. It serves AI and search teams running retrieval-augmented generation, semantic search, and hybrid (vector + full-text) workloads, with a multi-tenant architecture purpose-built for namespaces-per-customer patterns at billion-document scale.

The company positions itself against in-memory vector databases (Pinecone, Qdrant, Weaviate) by trading a small amount of cold-start latency for a storage cost structure anchored to cheap object storage rather than RAM. Its benchmarks advertise p50 warm-query latency around 14ms at 10M documents, and it markets a path “to billion-scale” handled directly with the customer’s engineering team.

turbopuffer monetizes purely on usage — writes, queries, and stored data — rather than on nodes, pods, or provisioned memory. The plan tier a customer selects (Launch, Scale, Enterprise) changes the monthly minimum spend and the security/support envelope, but the underlying per-unit usage rates are the same on Launch and Scale; only Enterprise adds a 35% usage premium in exchange for single-tenancy, BYOC, and SLAs.

Pricing summary : serverless vector search billed per write, query, and GB-month

turbopuffer uses pure usage-based pricing: there are no seats and no platform fee — you pay for metered writes, queries, and stored data, subject to a tier-scaled monthly minimum. The three published tiers differ in their minimum spend and their compliance/support entitlements, not in their base usage rates (Launch and Scale share rates; Enterprise adds a 35% premium).

• Storage — billed per GB-month of logical stored data. (Base per-GB rate is shown only inside the interactive cost calculator and was not exposed in the static capture — recorded as unknown rather than guessed.)
• Writes — billed per GB written. copy_from_namespace copies bill at a 50% discount on write costs.
• Queries — billed per unit of data queried. The base queried-data rate is $1/PB (reduced from $5/PB in February 2026), with marginal volume discounts: 80% off bytes between 32–128 GB queried and 96% off above 128 GB per query. Minimum billable data per query is 1.28 GB.
• Namespaces — multi-tenant by design; the calculator includes an allotment (e.g. 10 namespaces) before per-namespace charges apply.
• Pinning — pinned namespaces (introduced April 2026) bill in GB-hours instead of per-query, scaling with namespace size, replica count, and time pinned (minimums of 64 GB and 10 minutes).

What makes this different: the monthly tier price is a floor on usage, not an add-on fee — customers pay the greater of their metered usage or the tier minimum, so the model behaves like consumption usage-based billing with a commitment floor rather than a classic seat-plus-overage SaaS plan.

Pricing by product

turbopuffer ships a single product (the search database) sold across three tiers. Tiers gate compliance and support; the metered usage dimensions are common to all.

turbopuffer database (plan tiers)

Usage rates (metered across all tiers)

Sales motions across products: PLG / self-serve sign-up for Launch and Scale; sales-led, quoted for Enterprise (single-tenancy, BYOC, SLAs).

Hidden costs : the monthly minimum floor and the per-query 1.28 GB scan minimum

turbopuffer’s pure-usage model is honest, but two mechanics quietly shape the bill: the tier minimum (you pay it even when usage is lower) and the 1.28 GB minimum billable data per query (small namespaces still scan a minimum chunk). Because the base storage and write rates live only inside the interactive calculator, the two archetypes below isolate the parts that are publicly stated — the query rate and the minimum floor.

Early-production RAG app (low traffic, under the floor)

A small team runs a single-tenant RAG index of ~3M documents with light query traffic — well under what $64 of usage would buy. They pay the Launch minimum regardless.

The lesson: at low volume turbopuffer behaves like a $64/mo subscription — the usage-based billing only becomes the dominant cost once metered usage clears the floor.

High-QPS multi-tenant search (many small queries)

A consumer app issues a very high rate of queries against many small per-tenant namespaces. Each query bills a minimum of 1.28 GB scanned, so query cost is driven by query count, not data size.

The lesson: high-QPS workloads on tiny namespaces are billed on the 1.28 GB per-query minimum, not on actual bytes scanned — so the headline $1/PB rate understates cost for query-heavy, data-light patterns. Latency-sensitive teams can switch such namespaces to pinning (GB-hours), trading the per-query floor for a time-based rate. For the storage-versus-RAM economics that make turbopuffer cheaper at rest, see our note on storage-based billing.

Want to estimate your own turbopuffer bill? Use the turbopuffer pricing calculator to model your monthly cost based on document count, write rate, query rate, and namespace count.

Pricing evolution : a public changelog of query-rate cuts and new billing modes

turbopuffer maintains a dated public pricing changelog (last updated April 3, 2026), so its rate history is fully recoverable. The through-line is a series of price cuts on queries — the opposite of the typical SaaS price-creep — plus the introduction of new billing modes (copy_from_namespace, pinning) rather than new tiers.

Cadence

Tracked range: 2024 Q3–2026 Q2. Quarters not listed were verified stable (0 price changes, 0 SKU additions) against the public pricing changelog.

Notable changes

• 2024-09 — Introduced copy_from_namespace, copies billed at a 50% discount on write costs (turbopuffer.com/docs/pricing-log).
• 2025-07 — Query pricing for large namespaces cut up to 80%: 80% marginal discount on bytes queried over 32 GB per query (turbopuffer.com/docs/pricing-log).
• 2026-02 — Base queried-data rate cut from $5/PB to $1/PB; 80% marginal discount 32–128 GB, 96% above 128 GB; minimum billable data per query raised from 256 MB to 1.28 GB (turbopuffer.com/docs/pricing-log).
• 2026-03 — Multi-vector-column billing clarified: filterable attributes billed once per vector column for writes and storage; non-filterable attributes billed once total (turbopuffer.com/docs/pricing-log).
• 2026-04 — Namespace pinning introduced, billed in GB-hours (size × replicas × time) with minimums of 64 GB and 10 minutes (turbopuffer.com/docs/pricing-log).

The February 2026 query-rate cut in detail

The Feb 2026 change is the most consequential: the base scan rate fell 5× ($5/PB → $1/PB), and the marginal-discount curve (80% for 32–128 GB, 96% above 128 GB per query) means the biggest namespaces saw effective reductions up to 94%. This is corroborated by the same period in which turbopuffer was scaling to a reported $100M run-rate (Sacra, March 2026) on workloads like Cursor and Notion — i.e. the cut coincided with, rather than constrained, rapid revenue growth, consistent with object-storage unit economics improving as volume grows. The simultaneous increase of the per-query minimum from 256 MB to 1.28 GB partly offsets the cut for tiny, high-QPS namespaces (see Hidden costs).

What’s unique : object-storage economics, a usage-floor tier model, and price cuts over time

Object storage instead of RAM. turbopuffer’s core differentiator is architectural: vectors and indexes live on object storage (e.g. S3) with SSD caching, not in provisioned memory. This trades a small amount of cold-start latency for a cost structure anchored to cheap storage, and it’s why the company can keep cutting query prices rather than raising them. Pricing follows architecture — there are no pods, nodes, or provisioned-memory SKUs.

The tier price is a floor, not a fee. Launch ($64), Scale ($256), and Enterprise (≥$4,096) are monthly minimums on metered usage, not platform fees stacked on top of usage. Customers pay the greater of their usage or the minimum — a commitment floor wrapped around pure consumption, rather than the seat-plus-overage shape most SaaS uses.

Compliance gates the tier, rates stay flat. Launch and Scale charge identical usage rates; the higher Scale floor buys HIPAA-ready BAA, SSO, and audit logs — not cheaper or pricier units. Only Enterprise changes the unit economics, adding a 35% usage premium in exchange for single-tenancy, BYOC, CMEK, and a 99.95% uptime SLA. This cleanly separates “what compliance do you need” from “how much do you use.”

Prices go down, publicly and on the record. Across 2024–2026 every metered change in the changelog was a cut or a discount (50% copy discount, 80% then 94% query reductions). turbopuffer publishes these in a dated pricing changelog — unusually transparent for an infrastructure vendor and a deliberate trust signal.

New billing modes, not new tiers. Rather than adding plans, turbopuffer adds meters: copy_from_namespace (50% write discount), and namespace pinning (GB-hours). The pricing surface area grows by exposing real cost levers to customers, not by fragmenting the plan grid.

Strengths & weaknesses

Billing UX : an interactive cost calculator and a public pricing changelog

• Cost calculator — an interactive widget on the pricing page lets you set vector dimensions, attribute size, plan tier, and per-dimension volumes (storage GB, writes/WPM, queries/QPM, namespaces) to produce an estimated monthly cost (with the Launch $64/mo floor applied).
• Plan selector — Launch / Scale / Enterprise toggle inside the calculator recomputes the estimate, surfacing the Enterprise 35% usage premium.
• Pricing Changelog — a public, dated docs page (/docs/pricing-log, last updated April 3, 2026) records every rate change over time, including the Feb 2026 query-rate cut from $5/PB to $1/PB.
• copy_from_namespace — a first-class API operation billed at a 50% write discount, exposing migration/copy economics directly in the product.
• Namespace pinning — an explicit billing mode (GB-hours) customers can opt into for latency-sensitive namespaces, with documented 64 GB / 10-minute minimums.
• Contact-sales workflow — the Enterprise path routes to a sales form (“let’s get puffin’”) advertising response within a few hours.

Strategic wins : why object-storage economics and a floor-based model landed

1. Pricing follows architecture — and the architecture gets cheaper

By building on object storage instead of RAM, turbopuffer’s unit cost falls as object-storage and caching improve, which is why it can keep cutting query prices (5× in Feb 2026) while growing revenue. Most vector databases priced on provisioned memory cannot do this without margin pain. This is a textbook case of choosing a value metric aligned to a deflating cost base — a principle we cover in choosing the right usage metric.

2. The minimum-as-floor model captures small accounts without a free tier

By making the tier price a floor on usage rather than a platform fee, turbopuffer guarantees $64+ from every account while still letting heavy users pay pure usage. It is a commitment floor that funds support and compliance without the seat math, and it sidesteps the free-tier abuse that plagues consumption infra. See our take on usage minimums and commitments.

3. The public pricing changelog is a trust weapon

Publishing every rate change on a dated /docs/pricing-log page — all of them cuts — signals to buyers that prices will not creep up after lock-in. For infrastructure that sits in a critical path, that predictability is worth more than a marginal discount, and it pre-empts the pricing-change backlash that hits vendors who change quietly.

4. Compliance is decoupled from unit price

Launch and Scale share usage rates; the higher Scale floor buys HIPAA/SSO/audit, not pricier units. Customers never feel taxed on usage for needing compliance — they pay a higher minimum, not a higher rate — which keeps the metered story clean and defensible.

Areas to improve : surface the gated rates and the per-query floor up front

1. Publish the base storage and write rates as static numbers

Today the per-GB storage and write rates live only inside the interactive calculator, so they are invisible to AI search engines and hard to cite in a budget memo. Publishing them as plain text (even as “from $X/GB”) would improve price transparency and let finance teams model without the widget.

2. Make the 1.28 GB per-query minimum prominent

High-QPS, data-light workloads are billed on the per-query floor, not the $1/PB headline — a surprise for teams that size their bill off the marquee rate. A worked “query-heavy vs data-heavy” example on the pricing page would set expectations and reduce sticker shock, in the spirit of honest bill-shock prevention.

3. Quote the Enterprise 35% premium against a worked baseline

”≥$4,096/mo + 35% usage premium” is hard to internalize without numbers. Showing a single illustrative single-tenant workload at both Scale and Enterprise rates would make the premium concrete and shorten sales cycles.

4. Offer an annual commit discount for predictable spend

turbopuffer already has a commitment floor; layering a documented annual-commit discount on top would reward predictable large accounts and formalize the commitment economics buyers expect at the Enterprise tier.

Key takeaways

1. Align the value metric to a deflating cost base. turbopuffer prices on object-storage-backed usage, so it can cut prices as its costs fall — a structural advantage RAM-priced competitors lack.
2. A minimum-as-floor beats a platform fee for consumption infra. Charging the greater of usage or a tier minimum captures small accounts and funds support without a free tier or seat math.
3. Decouple compliance from unit price. Selling HIPAA/SSO/SLA as a higher minimum rather than a higher rate keeps the metered story clean and avoids penalizing regulated buyers on usage.
4. A public, dated pricing changelog is a moat, not a liability. When every logged change is a cut, transparency becomes a reason to trust the vendor through lock-in.
5. Watch the per-unit minimums. A 1.28 GB per-query floor means the headline $1/PB rate understates cost for query-heavy, data-light workloads — always model the minimums, not just the marquee rate.

UBP implications

1. Object storage reframes vector-DB economics. Pricing anchored to storage instead of memory lets a usage-based vendor lower prices over time, shifting the competitive axis from features to unit cost — a pattern other usage-based infra categories will follow.
2. The “floor, not fee” pattern is a clean substitute for free tiers. For high-cost consumption products, a tier-scaled monthly minimum monetizes small accounts and discourages abuse while preserving pure-usage economics for heavy users.
3. Per-request minimums are the hidden lever in metered pricing. turbopuffer’s 1.28 GB per-query floor shows how a single minimum can dominate the bill for a whole workload class — every usage-based vendor should model and disclose its smallest billable unit.

Sources

• turbopuffer pricing page — Launch/Scale/Enterprise tiers, minimums, and cost calculator (accessed 2026-06-04)
• turbopuffer pricing changelog — dated record of every rate change 2024–2026 (accessed 2026-06-04)
• turbopuffer Enterprise / contact sales — single-tenancy, BYOC, SLA enterprise path (accessed 2026-06-04)
• turbopuffer documentation — Pinning — GB-hour pinning billing mechanics (accessed 2026-06-04)
• See more usage-based pricing breakdowns in the UsagePricing blueprint corpus.

Bottom line

turbopuffer is one of the cleanest examples of pricing that follows architecture: by building search on object storage rather than RAM, it can charge pure usage, keep cutting query prices, and still hit a $100M run-rate. The tier price is a floor — not a fee — and the public pricing changelog turns transparency into a trust advantage. The catch is in the minimums: no free tier, a $64/mo entry floor, and a 1.28 GB per-query scan minimum that can dominate query-heavy bills. Model the floors, not just the $1/PB headline — and compare it against the rest of the blueprint corpus.

Pricing timeline : Major events on a vertical axis

Each milestone below corresponds to a public pricing change, product launch, or material adjustment. Major events use a filled marker; minor adjustments use a faded one.

Current snapshot — usage pricing with tier-scaled minimums

Jun 2026

Three tiers (Launch $64/mo, Scale $256/mo, Enterprise ≥$4,096/mo at a 35% usage premium) act as monthly minimums on metered usage. Queried-data base rate is $1/PB, min 1.28 GB billable per query; writes and storage metered per GB with copy_from_namespace at a 50% write discount. Storage and write base rates are exposed only inside the interactive calculator — recorded as unknown rather than guessed.

Namespace pinning billed in GB-hours

Apr 2026

Introduced namespace pinning, which bills pinned namespaces in GB-hours instead of per-query rates; cost scales with namespace size, replica count, and time pinned, with minimums of 64 GB and 10 minutes. Source: turbopuffer.com/docs/pricing-log (last updated April 3, 2026).

Multi-vector-column billing clarified

Mar 2026

Filterable attributes are billed once per vector column for writes and storage (reflecting per-column ANN index cost); non-filterable attributes are billed once regardless of vector-column count. Source: turbopuffer.com/docs/pricing-log.

Base query rate cut from $5/PB to $1/PB (up to 94% off largest namespaces)

Feb 2026

Base queried-data rate dropped from $5/PB to $1/PB; added an 80% marginal discount between 32–128 GB and 96% above 128 GB per query; minimum billable data per query rose from 256 MB to 1.28 GB. Source: turbopuffer.com/docs/pricing-log.

Query pricing for large namespaces cut by up to 80%

Jul 2025

Introduced an 80% marginal discount on bytes queried over 32 GB per query, reducing the cost of scanning large namespaces. Source: turbopuffer.com/docs/pricing-log.

copy_from_namespace introduced at a 50% write discount

Sep 2024

turbopuffer added the copy_from_namespace operation, allowing data to be copied between namespaces at a 50% discount on write costs — making bulk migration and branching cheaper than re-ingesting. Source: turbopuffer.com/docs/pricing-log.