turbopuffer

Pricing Changelog Changes to turbopuffer's pricing

more details in the pricing changelog: tpuf.link/pricing-feb-26

we’ve reduced query prices by up to 94%, thanks to infrastructure improvements we've made under the hood

puff harder, for much less

A series of three grouped bar charts displays the latency in milliseconds for filtered BM25 queries over 5 million documents before and after optimization, showing up to 20% speedups depending on query when a 1% matching filter is applied.

78% of tpuf text searches include a filter. they are now up to 20% faster

before → always score first, then filter
now → filter first (when cheaper), then score

How to build a distributed queue in a single JSON file on object storage How to build a single global queue for distributed systems on object storage: Start with a single file on object storage, then add write batching, a stateless broker, and high-availability.

queue.json on object storage is all you need to build a reliable distributed job queue

→ FIFO execution
→ at-least-once delivery
→ 10x lower tail latencies

tpuf.link/queue

Vercel indexes its entire GTM memory on turbopuffer Vercel's GTM engineering team built an AI lead agent that can access Gong transcripts, Slack channels, and Salesforce data. It's already saved over $2M.

Vercel's GTM engineers built an AI agent that searches across Gong, Slack, and Salesforce - helping sales work deals with better context

"I realized I could index Vercel's entire GTM corpus on turbopuffer with just my credit card." - Drew Bredvick

tpuf.link/vercel

January 2026 changelog list on dark background detailing FTS v2 speedups, turbopuffer MCP beta, token matching, permissions guide, stopword change, and group_by increase

january changelog

tpuf.link/chlog

Python code snippet demonstrating a ContainsAnyToken filter with aggregate and filters fields for counting matching documents on an arbitrary BM25 query

new: ContainsAnyToken filter

return documents that match any token in the query string

faster than BM25 when you just need a binary match (e.g. "showing 36 of 131,072" in your search UI) as it skips score computation entirely

docs: tpuf.link/containsany

Rust code snippet showing before/after. HashMap lookup replaced by precomputed nested array access for faster range retrieval. before: HashMap lookup at each step in binary search self.sstables.get(table_id).unwrap().range after: precomputed in parallel vec self.level_ranges[i][j][k]

8.3% of query CPU in our largest (~4 TiB) tpuf namespaces was being spent on hash-map lookups to figure out which files might contain a key range

fix: precompute it in a flat array

trade memory for cache-friendly access → 8% faster puffin'

ANN v3: 200ms p99 query latency over 100 billion vectors Our latest ANN release supports scales of 100+ billion vectors in a single search index, with 200ms p99 query latency at 1k QPS and 92% recall.

tpuf ANN v3, for when you need to index the entire web

100B+ vectors @ 50ms p50 / 200ms p99 latency

blog: tpuf.link/ann-v3

BM25 queries use an inverted index: each search term maps to a posting list of matching document ids

tpuf now dynamically adjusts the encoding of postings lists based on density, like roaring bitmaps

result → up to 26% faster search for queries whose terms match many documents

turbopuffer December 2025 changelog 🧱 Redesigned inverted index structure for faster FTS queries 📤 New object storage-native indexing queue for up to 10x faster queue time 🔦 kNN exact search for 100% recall on filtered vector search queries 🪣 Return a max number of search results per attribute value using limit.per 🇨🇦 AWS ca-central-1 (Montreal) region 🌏 Cross-region backups guide 🤝 Link multiple orgs to a single account for unified billing, SSO, and roles [opt-in, beta]

december changelog

tpuf.link/chlog

Designing inverted indexes in a KV-store on object storage How we redesigned our inverted index structure using fixed-sized posting blocks to achieve 10x smaller indexes and dramatically better throughput.

for FTS v2, we redesigned our inverted index structure

• tighter compression
• less KV overhead
• better MAXSCORE interaction

up to 10x smaller indexes → up to 20x faster text search!

tpuf.link/fts-index

Why BM25 queries with more terms can be faster (and other scaling surprises) I analyzed how BM25 query latencies scale with document count and top_k. Longer queries scale less efficiently, and essential terms impact performance in some surprising ways.

we modeled BM25 query latency across varying term counts, document counts, and top_k values.

takeaways:
- sometimes longer queries are *faster*
- the longer the query, the less efficiently it scales
- fitted curves on raw data are immensely gratifying

tpuf.link/bm25-latency

Line chart showing max indexing queue wait times peaking near 30 minutes before dropping to steady ~1 minutes, with a max latency marker at 57.55s around 15:04:30

we rolled out a new indexing queue on all tpuf shared regions

~10x lower index queue time → new documents get indexed sooner → faster queries on new data with less WAL scanning

built entirely on object storage, no kafka

(chart: max create_index time in queue, gcp us-east4)

TELUS indexes 25,000+ AI copilots on turbopuffer serverless vector and full-text search built from first principles on object storage: fast, 10x cheaper, and extremely scalable

TELUS indexes 25,000+ AI copilots on turbopuffer

"This doesn't exist without turbopuffer. If we used a traditional search provider, our bill would be in the millions each year." - Justin Watts, Distinguished Engineer

tpuf.link/telus

new: phrase matching

use the ContainsTokenSequence in your tpuf FTS queries to match documents on an exact phrase

docs: tpuf.link/phrase-match

Query documents serverless vector and full-text search built from first principles on object storage: fast, 10x cheaper, and extremely scalable

docs: tpuf.link/aggregations

Python- code snippet showing a turbopuffer query building a filtered aggregation: sum of total_lines_of_code grouped by programming_language, then printing results.

new: Sum aggregate function

combine it with group_by and filters for olap-style puffin'

Vectorized MAXSCORE over WAND: building faster text search for humans and agents turbopuffer has improved text search performance up to 20x by adopting the same text search algorithm as Apache Lucene, a vectorized variant of block-max MAXSCORE

yesterday: short human queries, scalar CPUs
today: long LLM queries, wide SIMD lanes

for FTS v2, we use a vectorized MAXSCORE algorithm instead of WAND, because dumb & serial beat smart & random algorithms on modern CPUs

tpuf.link/maxscore

turbopuffer logo alongside playerzero logo, stats below: "18x faster", "1B+ documents", "25k+ namespaces" on a dark background.

PlayerZero's AI retrieves and reasons over code and logs to debug large codebases.

"We went from 3 minutes to <10 seconds, with much better recall, which means fewer agent loops." - Maria Vinokurskaya, Founding Engineer

tpuf.link/playerzero

Dark-themed code snippet showing two Rust functions: a slow merge using BTreeSet::extend and a fast merge converting to iterator and merging into Vec.

instead of merging via BTreeSet, we exploit that both result sets (WAL and indexed) are already sorted, for an efficient iterator merge

turbopuffer queries are strongly consistent, which requires scanning new writes in the WAL while indexing happens async

tpuf's WAL scan is now up to 2x faster

November 2025 changelog list highlighting full-text search speedups, new tokenizers, copy_from_namespace encryption and cross-region copying, and increased top_k limit.

november changelog

tpuf.link/chlog

FTS v2: up to 20x faster full-text search turbopuffer's full-text search engine is getting a major upgrade for 20x better full-text search performance

blog: tpuf.link/fts-v2

Horizontal bar chart comparing turbopuffer FTS v1 vs v2 latencies for five queries on English Wikipedia, v2 much faster (3–20ms) vs v1 (8–174ms).

FTS v2: up to 20x faster full-text search

turbopuffer is now on par with Tantivy and Lucene for many queries, more to come

v2 now in beta. 2 PRs away from all query plans being implemented. will be enabled in prod for all, shortly.

Write Documents serverless vector and full-text search built from first principles on object storage: fast, 10x cheaper, and extremely scalable

docs: tpuf.link/cfn

new: cross-region and cross-org copy_from_namespace

copy your documents wherever you need to puff with a 50% discount - no more restrictions

good for manual backups, testing, and branching

october changelog

turbopuffer.com/docs/roadmap

tuning a query planner is an evergreen task. this month we improved p99.99 latency by >90% for this order-by query workload.

Guarantees serverless vector and full-text search built from first principles on object storage: fast, 10x cheaper, and extremely scalable

a database is nothing without its guarantees

as part of our recent patch_by_filter launch, we clarified the ACID properties users can expect from turbopuffer

read more here: turbopuffer.com/docs/guaran...