Supabase pgvector Free Tier 2026: Limits, Cost, and When It Breaks

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 shared CPU, 1 GB of file storage, 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 near 50,000 to 80,000 vectors.

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

Supabase Pro is $25 per month per project.^[1] For a pgvector workload the three things it changes are: the inactivity pause is removed so the project stays online 24/7, the included database disk rises to 8 GB, and included egress rises to 250 GB per month before a $0.09 per GB overage applies.^[1]

The 8 GB disk is the headline number for vectors. 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. 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 dollar columns are current-rate figures for four other vendors (Postgres+pgvector at a $35 generic managed baseline, Pinecone $50 and Turbopuffer $64 plan minimums, LanceDB on R2), used for cross-vendor comparison, not the Supabase price; Supabase's own free-vs-Pro economics are the $0 and $25 figures above.^[4]

The engine reports a storage footprint near 0.36 GB at this volume. That comfortably fits the free tier's 500 MB database with room left for application tables, which is why a 50,000-vector prototype is squarely a free-tier workload on raw storage. Triple the vector count toward the free-tier ceiling and you are at roughly 1 GB stored, which is where the free tier runs out of database room and the decision becomes Pro.

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.21), because metered storage and reads are tiny at this scale. The fully managed plans with floors are not: Pinecone Standard bills its $50/mo minimum and Turbopuffer Launch its $64/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.21/mo) prices the same small workload under a dollar a month and avoids paying a $25 database tier just to hold embeddings. Note the floored managed plans (Pinecone $50, Turbopuffer $64) cost more than Supabase Pro at this scale, so pick the no-minimum route if cost is the deciding factor.

The broader trade-off across the stack is covered in the pgvector vs Pinecone cost analysis 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.^[1]
3. Vector search only, no other Postgres need: consider a no-minimum or object-storage vector store (LanceDB on R2 is about $0.21/mo) rather than paying a database tier for embeddings alone; avoid the floored managed plans (Pinecone $50, Turbopuffer $64) 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 and retention window 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 50,000 to 80,000 vectors at 1,536 dimensions once index and metadata overhead are counted. 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 May 2026).

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

Supabase Pro is $25 per month per project. It raises the included database disk to 8 GB, removes the inactivity pause entirely, and bumps included egress to 250 GB before overage. For a pgvector workload that means the project stays online 24/7 and has headroom for several hundred thousand vectors before disk overage applies (verified May 2026).

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 on the order of 50,000 to 80,000 vectors. 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, a serverless vector store such as Turbopuffer or Pinecone prices the same small workload under one dollar a month and avoids paying a database tier for vectors alone.