Supabase Vector

Editor’s note: This Supabase Vector review is based on my hands-on test of Supabase Vector, pgvector 0.8 on Supabase’s managed Postgres, on the Free and Pro plans in November 2026. I weighed compute sizing, the supabase-js workflow, embeddings, hybrid search, Vector Buckets, security and seven rivals from Pinecone to turbopuffer.

Quick verdict: I recommend Supabase Vector for teams already on Supabase or Postgres that want semantic search, RAG or agent memory beside relational data, under the same row-level security policies. The catch is RAM-driven compute pricing: Supabase’s benchmark puts 1 million 1536-dimension vectors on a 2XL, about $410 a month on top of the $25 Pro plan.

Supabase Vector is pgvector inside each project’s Postgres, with halfvec and sparsevec types, HNSW indexes and S3-backed Vector Buckets in alpha. In this review, I’ll take a closer look at Supabase Vector’s pricing, features, and scaling limits, so you can see exactly whether Postgres is enough for your embeddings or whether a dedicated vector database like Pinecone or Qdrant is the better buy.

Key Takeaways

• No separate vector fees: pgvector runs on every plan; compute, disk and egress set the cost.
• SQL-native retrieval: one query joins, filters and applies row-level security.
• Dimensions drive RAM: in Supabase’s benchmark, 1 million 384-dimension vectors fit Large ($110 a month); 1536 dimensions need 2XL ($410).
• Pausing and spend cap: Free pauses after one inactive week; Pro’s spend cap excludes compute and replicas.
• Compliance costs more: SOC 2 reports, Dashboard SSO and HIPAA need the $599 Team plan; the SLA is Enterprise-only.

Pros and Cons

Supabase Vector Pricing: How Much Does It Cost?

Supabase Vector has no separate price: pgvector is included on every plan, and a vector workload bills as Postgres (plan fee, compute size, disk and egress).

• Free ($0): for prototypes: a 500 MB database, shared CPU with 500 MB RAM, 5 GB egress, 500,000 Edge Function invocations and two active projects. Projects pause after one inactive week.
• Pro (from $25/month): for production apps: $10 a month in compute credits (one Micro instance), 8 GB disk per project then $0.125 per GB, 250 GB egress then $0.09 per GB, 2 million Edge Function invocations, seven-day daily backups and a spend cap that is on by default.
• Team (from $599/month): for companies that need SOC 2 and ISO 27001 reports, Dashboard SSO, project-scoped and read-only access, 14-day backups or the paid HIPAA add-on.
• Enterprise (custom): for a 99.9% uptime SLA, 24×7 support and a private Slack channel.

Plan	Monthly base price	Egress included	Backup retention	Main production gate
Free	$0	5 GB	Not included	Inactivity pausing
Pro	From $25	250 GB	7 days	No compliance reports
Team	From $599	250 GB	14 days	HIPAA costs extra
Enterprise	Custom	Custom	Custom	Contracted uptime SLA

Compute size	Approximate monthly price	RAM	CPU
Micro	$10	1 GB	Shared
Small	$15	2 GB	Shared
Medium	$60	4 GB	Shared
Large	$110	8 GB	2 dedicated vCPUs
XL	$210	16 GB	4 dedicated vCPUs
2XL	$410	32 GB	8 dedicated vCPUs
4XL	$960	64 GB	16 dedicated vCPUs
8XL	$1,870	128 GB	32 dedicated vCPUs
12XL	$2,800	192 GB	48 dedicated vCPUs
16XL	$3,730	256 GB	64 dedicated vCPUs

Compute is billed hourly per project, and each project runs on its own VM.

The spend cap excludes compute hours and read replicas, so a resize shows up on the bill even with the cap on. Read replicas run on the primary’s compute size and are billed separately.

Point in Time Recovery costs $100 a month per seven days of retention. Vector Buckets are free under fair use during the public alpha, with egress still charged.

Is Supabase Vector Good Value for Money?

• 384-dimension example: 1 million gte-small vectors fit Large in Supabase’s benchmark, so Pro plus Large comes to about $125 a month ($25 + $110 – $10 credit).
• 1536-dimension example: 1 million OpenAI vectors need 2XL, about $425 a month.
• Pinecone: Builder is $20 a month flat with 10 GB storage, and Starter is free with 2 GB, so a pure vector workload can cost less there.
• Qdrant Cloud: its free-forever cluster (1 GB RAM, 4 GB disk) never pauses, unlike a Supabase Free project.
• Neon: the closest like-for-like rival, pgvector at $0.106 per CU-hour on Launch.
• Included app infrastructure: the same bill covers Auth, Storage, Realtime and Edge Functions.

Supabase is good value beside an app you already run on it, especially when 384-dimension models or halfvec keep the index small. It is poor value for a vector-only workload of tens of millions of 1536-dimension vectors.

Reviewer’s Notes: I recommend prototyping on Free (wake the project before demos), launching on Pro with the Micro credit, then sizing compute from Supabase’s benchmark for your dimension count. Try halfvec before paying for the next size up: in Supabase’s 900,000-vector test it halved table and index size at the same recall.

My Experience With Supabase Vector

Supabase Vector needs a Postgres table and a SQL function, not just an index endpoint. I built my test on gte-small, whose 384 dimensions match the cheaper sizing example above.

Enabling pgvector in a New Project

I created a project on the Free plan, picked a region, and enabled the vector extension under Database > Extensions. The extension lives in the project’s Postgres, so there was no separate vector service to provision.

Pinecone’s serverless index skips database setup, but it has no relational rows to join.

Creating a Table, a Vector Column and an HNSW Index

I created a documents table with a vector(384) column for gte-small and an HNSW index using vector_ip_ops, because inner product is the fastest operator for normalized vectors.

create extension if not exists vector with schema extensions;

create table documents (
  id bigint generated always as identity primary key,
  body text,
  embedding extensions.vector(384)
);

create index documents_embedding_idx
on documents using hnsw (embedding extensions.vector_ip_ops);

HNSW can be built right after the table exists. IVFFlat should wait until the table holds representative data and needs a rebuild when the distribution changes.

The distance operator must match the index:

• Euclidean distance: <->, paired with vector_l2_ops.
• Negative inner product: <#>, paired with vector_ip_ops.
• Cosine distance: <=>, paired with vector_cosine_ops.

Generating Embeddings With an Edge Function

I set up a database webhook so each insert called an Edge Function, which ran Supabase.ai.Session('gte-small') and wrote the 384-dimension embedding back to the row. That path needed no external embedding API. OpenAI’s 1536-dimension models instead require the function to call the provider.

Edge Function limits that matter for batching:

• Memory: 256 MB.
• CPU time: two seconds per request, excluding asynchronous I/O.
• Wall-clock duration: 150 seconds on Free and 400 seconds on paid plans.

Bulk ingestion therefore belongs in the queued automatic-embeddings pattern below.

Querying From supabase-js

PostgREST cannot use pgvector’s operators directly, so I wrapped the similarity search in a SQL function, match_documents, taking the query embedding, a similarity threshold and a match count, and called it with supabase.rpc().

Because the function is plain SQL, I added a WHERE clause on metadata and let row-level security policies filter rows per user.

A selective WHERE filter can return fewer rows than the LIMIT, because the planner still uses the HNSW index and filters the candidates it returns. I sized match_count with that in mind.

Building a Large Index

For the large build I switched to psql through the session pooler on port 5432 (a direct connection also works), because the dashboard SQL editor stops queries after about two minutes.

I raised maintenance_work_mem within the instance’s RAM first.

Reviewer’s Notes: I recommend loading a representative sample and checking dashboard RAM use against the compute size before picking the production instance. Run app queries alongside, since the index shares the database.

HNSW Indexes, Dimension Limits and How Far One Instance Scales

Supabase’s benchmark at 0.99 accuracy fits 1 million 384-dimension vectors on Large’s 8 GB RAM at 270 queries per second. At 1536 dimensions, the same instance tops out at about 224,000 vectors.

Compute size	Approximate monthly price	1536-dimension vectors (QPS)	384-dimension vectors (QPS)
Micro	$10	15,000 (480)	100,000 (580)
Small	$15	50,000 (175)	250,000 (440)
Medium	$60	100,000 (240)	500,000 (350)
Large	$110	224,482 (280)	1,000,000 (270)
XL	$210	500,000 (360)	1,000,000 (525)
2XL	$410	1,000,000 (560)	1,000,000 (790)
4XL	$960	1,000,000 (950)	1,000,000 (1,650)

Micro and Small ran into swap in Supabase’s benchmark, so their indexes did not fully fit in memory. That makes 15,000 to 100,000 vectors the realistic ceiling for the cheapest sizes, depending on dimensions.

Indexed dimension limits constrain model choice:

• HNSW with vector: up to 2,000 dimensions.
• HNSW with halfvec: up to 4,000 dimensions.
• HNSW with bit: up to 64,000 dimensions.
• IVFFlat with vector: up to 2,000 dimensions.

OpenAI’s 3072-dimension text-embedding-3-large therefore needs shortening or a halfvec representation for HNSW. A half-precision expression index keeps the original vector(3072) column, as long as queries use the same cast.

In Supabase’s pgvector 0.7.0 benchmark on 900,000 OpenAI vectors, halfvec cut the table from 7 GB to 3.5 GB and the index from 7,734 MB to 3,867 MB with the same 0.945 recall. The index build took 90 seconds instead of 264.

Supabase’s benchmark also found m=32 and ef_construction=80 delivered 35% more QPS than 24/56 on 1 million OpenAI vectors; on 4XL, the higher settings lifted throughput from 950 to 1,280 QPS.

Supabase’s production checklist runs in four steps:

1. Load on oversized compute: at least 8XL while preparing.
2. Record RAM use under representative queries.
3. Scale down to the compute size with that much RAM.
4. Pre-warm with pg_prewarm and 10,000 to 50,000 warm-up queries.

Pinecone is serverless and turbopuffer runs on object storage, so neither asks you to pick a RAM tier before loading vectors.

Best for: hundreds of thousands to a few million vectors per project, depending on dimensions. Skip if: you plan for tens of millions of 1536-dimension vectors on one instance.

Embeddings, Automatic Embeddings and Hybrid Search

Edge Functions run gte-small natively at 384 dimensions, so Supabase Vector generates embeddings without an external API key. Keeping those embeddings in sync with changing rows takes more code.

Automatic embeddings, launched April 1, 2025, is a pattern, not a toggle:

1. Queue changes: database triggers add jobs to pgmq.
2. Schedule processing: pg_cron runs the processor every 10 seconds.
3. Send batches: pg_net calls an Edge Function.
4. Generate embeddings: the function calls an embedding API, OpenAI by default.
5. Write results: embeddings return to the vector column; failed jobs stay queued and retry.

Setup also requires:

• Extensions: vector, pgmq, pg_net, pg_cron and hstore.
• Vault: the project URL stored as a secret.
• Triggers: one embedding trigger per table.

I like the retryable queue, which keeps embedding work off the write path, but you own the pipeline. Changing models means editing the function and re-embedding content yourself.

Hybrid search is another SQL recipe. A tsvector column handles keyword matching through websearch_to_tsquery, ranked by ts_rank_cd and fused with vector rankings using Reciprocal Rank Fusion in one function.

The recipe defaults both weights to 1, uses rrf_k=50 and caps results at 30. Weaviate and Qdrant ship hybrid search built in, which beats maintaining the fusion function yourself when you do not need Postgres joins.

Integrations cover LangChain, LlamaIndex, OpenAI, Hugging Face and Amazon Bedrock. The Python vecs client has had no release since December 2024, so I used plain SQL and supabase-js instead.

My verdict: the toolkit covers RAG plumbing for small and mid-size corpora, but every piece is SQL and Edge Function code your team maintains.

Vector Buckets: Cold Storage for Large Vector Sets

Vector Buckets launched December 1, 2025, as a Supabase Storage bucket type built on Amazon S3 Vectors. They are in public alpha for Pro projects and above, free under fair use with egress charged.

• Organization: 10 buckets per project and 10 indexes per bucket.
• Dimensions: up to 4,096.
• Distance metrics: cosine and Euclidean only.
• Writes: up to 1,000 vectors per request.
• Retrieval: topK up to 10,000, with 100 results per response and pagination.
• Launch regions: us-east-1, us-east-2, us-west-2, eu-central-1 and ap-southeast-2.
• SQL access: queries through a Postgres foreign data wrapper.

Supabase’s suggested split keeps recent, latency-sensitive content in pgvector and falls back to Vector Buckets for the long tail: archives, media similarity and de-duplication.

Vector Buckets filter by metadata rather than row-level security, so tenant isolation works differently than in Postgres tables. turbopuffer already sells object-storage vector search from a $16 monthly minimum.

pgvector has lower latency, while Vector Buckets are cheaper. Treat buckets as an alpha: keep production retrieval in pgvector and wait for post-alpha pricing before budgeting around them.

Security, Compliance and Reliability

Supabase Vector stores embeddings in Postgres tables, so row-level security governs similarity queries and each tenant searches only its own rows. Pinecone instead isolates tenants through namespaces.

• Compliance reports: Supabase holds SOC 2 Type 2 and ISO 27001; report access starts on Team.
• HIPAA: a paid add-on with a signed BAA on Team or Enterprise, price on request. Free and Pro are ineligible, and self-hosted Supabase does not support it out of the box.
• SSO: Dashboard SSO starts on Team. End-user SAML SSO includes 50 MAU, then costs $0.015 per MAU.
• Uptime SLA: 99.9% monthly per product, Enterprise only. Alpha and beta features such as Vector Buckets are excluded, as are outdated extension versions and under-provisioned compute.
• Backups: daily, kept seven days on Pro and 14 on Team; Point in Time Recovery is extra.
• Regions and replicas: 17 AWS regions plus general Americas, Europe and APAC options. Read replicas get their own endpoints and replicate asynchronously.

Asynchronous replication means a replica can miss freshly written embeddings, so retrieval that follows a write belongs on the primary.

Budget Team at $599 a month from day one if a security review, Dashboard SSO or a BAA is on the roadmap, then add compute and the HIPAA charge.

How Does Supabase Vector Compare to Competitors?

Supabase Vector’s rivals split into dedicated vector databases (Pinecone, Qdrant, Weaviate, turbopuffer) and other managed databases that hold vectors (Neon, Tiger Data, MongoDB Atlas Vector Search).

Product	Free entry	Paid entry	Distinguishing model
Supabase Vector	500 MB database	Pro from $25/month plus compute	pgvector inside Supabase Postgres
Pinecone	Starter, 2 GB	Builder $20/month	Serverless vector service
Qdrant Cloud	1 GB RAM, 4 GB disk	Usage-based Standard	Open-source vector database
Weaviate Cloud	Sandbox	Flex from $45/month	Built-in hybrid search
Neon	100 CU-hours, 1 GB per project	$0.106/CU-hour plus storage	Postgres that scales to zero
Tiger Data	30-day trial	Compute from $30/month	Postgres with pgvectorscale
MongoDB Atlas Vector Search	M0, 512 MB	Flex capped at $30/month	Vectors inside MongoDB Atlas
turbopuffer	None	Launch $16/month minimum	Object-storage-based search

• Pinecone: Starter includes 2 GB in AWS us-east-1; Builder costs $20 a month with 10 GB, and Standard has a $50 monthly minimum. It fits vector-only applications that would rather run serverless than size database RAM.
• Qdrant: the free-forever single-node cluster includes 1 GB RAM and 4 GB disk, and usage-based Standard carries a 99.5% uptime SLA. It fits teams that want open source with built-in hybrid search.
• Weaviate: a free sandbox, Flex from $45 a month and Premium from $400. It fits teams that want built-in hybrid search instead of Supabase’s SQL recipe.
• Neon: Postgres with pgvector and scale-to-zero compute; Free includes 100 CU-hours per project, and Launch costs $0.106 per CU-hour and $0.35 per GB-month. It fits intermittent workloads where idle compute spending matters.
• Tiger Data: Postgres with pgvectorscale, compute from $30 a month and a 30-day trial instead of a permanent free tier. It fits teams that want pgvectorscale on managed Postgres.
• MongoDB Atlas Vector Search: vector search inside Atlas, with a free 512 MB M0 cluster and Flex capped at $30 a month. It fits applications whose data already lives in MongoDB.
• turbopuffer: object-storage-based vector search with a $16 monthly Launch minimum and a $256 Scale minimum. It fits very large, cost-sensitive vector sets with no relational data attached.

Supabase wins when vectors must sit next to app data under row-level security; a dedicated store wins once the vector set alone outgrows a 2XL.

How I Reviewed Supabase Vector

I set up Supabase Vector on the Free and Pro plans, enabled pgvector, built a vector(384) column with an HNSW index, generated gte-small embeddings in an Edge Function and called a match function from supabase-js. I also tried the hybrid search and automatic-embedding recipes, looked at Vector Buckets and worked through the compute sizing math.

I weighted these areas:

• Pricing and value: plan fees, compute credits and overages.
• Setup: extension configuration and large-index builds.
• Query workflow: RPC functions, filtering and row-level security.
• Scaling and performance: dimensions, RAM requirements and half-precision storage.
• Search features: automatic embeddings, hybrid search and Vector Buckets.
• Security and compliance: plan gating, backups and SLA exclusions.
• Alternatives: Pinecone, Qdrant, Weaviate, Neon, Tiger Data, MongoDB Atlas Vector Search and turbopuffer.

Prices current as of November 2026.

Supabase Vector Review: Should You Store Your Embeddings in Supabase?

Yes, if your app already runs on Supabase or Postgres, your corpus sits in the hundreds of thousands to low millions of vectors, and similarity search needs relational joins and row-level security. Start at Pro’s $25 a month plus a compute size matched to your RAM use.

No, if you need:

• Vector-only serverless operation: Pinecone.
• A free cluster that never pauses: Qdrant Cloud.
• Built-in hybrid search: Weaviate.
• Postgres that scales to zero: Neon, which also runs pgvector.
• Tens of millions of vectors at low cost: turbopuffer, on object storage.

Settle these before committing:

• Embedding dimensions: Supabase’s million-vector benchmark moves from Large at 384 dimensions to 2XL at 1536.
• Precision: whether halfvec meets your retrieval needs, since it halves index size at the same recall in Supabase’s test.
• Compliance: whether you need Team for SOC 2 reports, Dashboard SSO or HIPAA.

Size from RAM use, measured with your real filters and application traffic, not from vector count alone. Compute bills hourly, so a temporary upsize for the initial load costs hours, not months.

Start a free project at Supabase Vector and build the vector(384) workflow above before committing to paid compute.

FAQ

Is Supabase Vector free?

Yes, pgvector is included on Supabase’s Free plan: a 500 MB database, shared CPU with 500 MB RAM and two active projects. Projects pause after one week of inactivity, so Free suits prototypes rather than always-on production retrieval. Pro starts at $25 a month with a $10 compute credit.

How many vectors can Supabase handle?

Capacity depends on RAM and embedding dimensions. Supabase’s benchmark fits 1 million 384-dimension vectors on Large with 8 GB RAM, and 1 million 1536-dimension vectors on 2XL with 32 GB. These are benchmark results, not hard limits. Vector Buckets go further on Amazon S3 Vectors but remain in public alpha.

Is Supabase Vector the same as pgvector?

Supabase Vector is pgvector plus Supabase’s managed platform and AI toolkit: gte-small in Edge Functions, automatic embeddings, hybrid search and Vector Buckets. pgvector supplies the vector types and indexes inside Postgres. Standard pgvector tables and SQL move to any Postgres with pgvector; Edge Functions and the embedding pipeline need their own migration.

Does Supabase support hybrid search?

Yes, through a SQL function you add, not a built-in setting. The recipe fuses Postgres full-text rankings and vector rankings with Reciprocal Rank Fusion, using a rank constant of 50 and equal keyword and semantic weights. See Embeddings, Automatic Embeddings and Hybrid Search above for the trade-offs.

Is Supabase Vector better than Pinecone?

Supabase Vector is better when embeddings need joins and row-level security alongside existing app data. Pinecone is better for a vector-only serverless service with no compute sizing; Builder costs $20 a month with 10 GB storage. See How Does Supabase Vector Compare to Competitors? above for the full breakdown.