Supabase Free Tier Limits 2026: pgvector Cost and Pausing

The short answer: the Supabase free tier is a genuine $0 pgvector database for prototypes, and it breaks on the 7-day inactivity pause long before it breaks on the 500 MB storage cap.^[1] Most posts frame the free tier around storage. That is the wrong lens for a vector workload at solo scale, where 500 MB already holds tens of thousands of embeddings. The real question is whether your project can tolerate a database that goes to sleep. This article prices the free and Pro tiers against a real pgvector workload and gives a decision rule.

1. What the Supabase free tier gives a pgvector workload

The Supabase free tier includes a 500 MB Postgres database on a shared CPU with 500 MB of RAM, 1 GB of file storage, 5 GB of egress, 50,000 monthly active users for Auth, and the pgvector extension (registered in Postgres under the name vector).^[1][2] pgvector on Supabase supports both HNSW and IVFFlat indexes and the halfvec type that stores values in 16-bit half precision to cut storage roughly in half.^[2] You can run two active free projects at once.^[1]

For a retrieval-augmented-generation prototype, that is a working vector store at zero cost: store the embedding column, build an HNSW index, query by cosine distance, and filter by application columns in the same SQL statement. Nothing about vector search itself is gated behind a paid tier. The extension, the index types, and the distance operators are all on the free plan.^[2]

2. Where the free tier breaks for vectors

The free tier has one limit that ends production use before any storage cap matters: free projects are paused after 7 days of inactivity.^[1] A paused project does not serve queries until it is manually restored, which takes a moment but returns errors in the meantime. For a RAG endpoint that a user might call at any hour, that is a hard stop.

Three places the free tier gives out, in the order they usually bite:

• The 7-day pause. Any project with sporadic traffic risks waking to a paused database. This is the first wall for real usage, and it has nothing to do with vector count.^[1]
• Shared CPU under index build. Building an HNSW index over tens of thousands of vectors is CPU-heavy. On shared free-tier compute, large index builds are slow and can time out.
• The 500 MB ceiling. This is last, not first. At 1,536 dimensions a float32 vector plus its HNSW index entry is on the order of 12 KB stored, so 500 MB minus application tables lands somewhat under 40,000 vectors, or about twice that with halfvec.

3. The Pro tier: $25/mo and no pausing

Supabase Pro starts at $25 a month, which includes the first project and $10 a month of compute credits, enough for one Micro instance; additional projects start at $10 a month.^[1] For a pgvector workload the three things it changes are: the inactivity pause is removed so the project stays online around the clock, included disk rises to 8 GB per project (then $0.125 per GB), and included egress rises to 250 GB a month (then $0.09 per GB).^[1] For the full Supabase picture beyond vectors, see Supabase Auth pricing and Supabase vs Firebase vs Neon.

The 8 GB disk is the headline number for storage. At the same 12 KB-per-vector stored footprint, 8 GB holds several hundred thousand 1,536-dimension vectors before disk overage applies, and the halfvec type roughly doubles that. Memory runs out sooner. The $10 credit covers the 1 GB Micro instance, and Supabase's own pgvector benchmark served 15,000 1,536-dimension vectors from Micro, 50,000 from the 2 GB Small ($15 a month) and 224,482 from the 8 GB Large ($110).^[5][6] Past about 15,000 full-precision vectors, budget for a larger compute size if you want the HNSW index answered from memory. For most solo-founder RAG products, Pro is the tier where the vector store stops being a prototype and starts being something a user can hit without a wake-up delay.

4. Sizing the index: how many vectors fit

The storage footprint is the same arithmetic regardless of tier, so the engine below prices a representative small RAG workload (50,000 vectors at 1,536 dimensions, 90-day retention) and reports the stored GB it implies. The Postgres+pgvector column is Supabase itself: $30 a month, the $25 Pro plan plus Small compute at $15 less the $10 credit, because Small is the size Supabase benchmarks for 50,000 such vectors.^[5] The other columns price Pinecone and Turbopuffer at their plan minimums and LanceDB on R2, for cross-vendor comparison.^[4]

The engine reports a storage footprint near 0.36 GB at this volume. That counts the vectors with a storage allowance but not an HNSW index, which stores its own copy of each vector; with the index, 50,000 full-precision vectors come close to or past the free tier's 500 MB. On disk, a free-tier prototype therefore stays around 30,000 to 40,000 vectors, switches to halfvec, or moves to Pro; in memory, the free plan's Nano instance (up to 0.5 GB) is smaller than the 1 GB Micro that Supabase benchmarks at 15,000 vectors, so expect slower queries well before the disk fills.^[6] Triple the vector count and the vectors alone are about 1.1 GB, well past the free tier.

5. Supabase pgvector vs a managed vector DB

The engine also prices the same workload on dedicated vector stores. At 50,000 vectors the no-minimum and object-storage options are well under a dollar a month (LanceDB on R2 is about $0.08), because metered storage and reads are tiny at this scale. The hosted plans with minimums are not: Turbopuffer Launch bills its $16/mo minimum and Pinecone Standard its $50/mo minimum regardless of usage. So the honest comparison depends on which store you pick, a sub-dollar object-storage or free-tier route versus a floored managed plan, and on architecture more than on the metered rate.

Two clear cases:

• You already store app data in Supabase. pgvector wins on friction. Vectors live in the same database, the same transaction, and you can filter by application columns before the vector search runs. No second system to sync.
• You only need vector search and run no Postgres. A no-minimum or object-storage vector store (such as LanceDB on R2, around $0.08/mo) prices the same small workload under a dollar a month and avoids paying $30 for a database (Pro plus Small compute) just to hold embeddings. Of the hosted plans with minimums, Turbopuffer ($16) costs less than that Supabase setup at this scale and Pinecone ($50) more; the no-minimum route is cheapest if cost is the deciding factor.

The broader trade-off across the stack is priced in the Embeddings DB Cost calculator and the cheapest vector database ranking.

6. The free-vs-Pro decision rule

The decision rule, in three branches:

1. Prototype with no real users yet: free tier. It is a working pgvector database at $0, and tens of thousands of vectors fit the 500 MB cap.^[1] Accept the 7-day pause as the cost of free.
2. Anything a user can hit at an unpredictable time: Pro at $25/mo. The pause removal alone justifies it, and you get 8 GB of disk headroom for the vector index; add Small compute ($15/mo) once the index passes about 15,000 full-precision vectors.^[1][5]
3. Vector search only, no other Postgres need: consider a no-minimum or object-storage vector store (LanceDB on R2 is about $0.08/mo) rather than paying a database tier for embeddings alone; or Turbopuffer's $16 minimum if you want it hosted; Pinecone's $50 minimum is the costliest option at this scale.

The methodology behind the cost model is documented at the Embeddings DB Cost methodology page.^[4] Rerun the Embeddings DB Cost engine with your own vector count before committing to a tier.

Frequently asked questions

Is the Supabase free tier enough for a pgvector RAG project?

For prototypes and small side projects, yes. The Supabase free tier includes a 500 MB Postgres database with the pgvector extension available, which holds roughly 40,000 vectors at 1,536 dimensions once the HNSW index and metadata are counted, or about twice that with the halfvec type. The constraint that bites first is not storage but the 7-day inactivity pause: free projects pause after one week with no traffic, which makes them unsuitable for anything a user might hit unpredictably (verified on supabase.com/pricing, 2026-10-11).

What does the Supabase Pro tier cost and what does it add for vectors?

Supabase Pro starts at $25 a month with the first project included and $10 a month of compute credits; additional projects start at $10 a month. It raises included database disk to 8 GB per project (then $0.125 per GB), removes the inactivity pause and includes 250 GB of egress (then $0.09 per GB). For a pgvector workload the project stays online around the clock with disk for several hundred thousand vectors before overage, though the included Micro compute (1 GB) holds about 15,000 1,536-dimension vectors in memory on Supabase's benchmark; Small, at $15 a month, holds 50,000 (verified 2026-10-19).

How many vectors fit in the Supabase free tier 500 MB database?

A 1,536-dimension float32 vector is about 6 KB of raw payload, and the HNSW index roughly doubles the stored footprint. At 500 MB total, after leaving room for application tables, a realistic ceiling is somewhat under 40,000 vectors at full precision, or about twice that with halfvec. Dropping to the halfvec (16-bit) type or fewer dimensions roughly doubles that ceiling.

Should I use Supabase pgvector or a dedicated vector database?

If you already store application data in Supabase Postgres, pgvector is the lower-friction choice because vectors live in the same database and the same transaction. If you do not run Postgres and only need vector search, LanceDB on object storage prices the same small workload under a dollar a month and Pinecone's free Starter plan (up to 2 GB, 1M read units a month) covers it at $0, avoiding a database tier for vectors alone; Turbopuffer's hosted Launch plan starts at $16.