n8n + Supabase Workflow: Build Powerful Backend Automations
Supabase has become my go-to backend for every project I build. A Postgres database, authentication, real-time subscriptions, storage, and edge functions — all in one platform with a generous free tier. I use it daily for client projects, internal tools, and my own SaaS experiments.
But Supabase alone handles storage and queries. It does not handle the workflows that connect your data with the rest of your stack — sending emails when users sign up, syncing records with your CRM, processing data from external APIs, or generating reports on a schedule.
That is where n8n comes in. The combination of Supabase as your data layer and n8n as your automation layer creates a backend that can do almost anything, without writing traditional server code.
I am Javier, a startup consultant in Chile, and I have been running this Supabase plus n8n stack in production for over a year. In this tutorial, I will share everything I have learned — from basic CRUD operations to complex, real-time workflows that power actual businesses.
Why n8n and Supabase Together?
Both tools share a philosophy that appeals to me: open source, self-hostable, and designed for developers who want control without vendor lock-in.
Here is what each brings to the table:
Supabase provides:
– PostgreSQL database with a REST API
– Real-time subscriptions via websockets
– Authentication and user management
– File storage with CDN
– Edge functions for custom logic
– Row Level Security for data protection
n8n provides:
– Visual workflow builder with 400+ integrations
– Conditional logic, loops, and data transformation
– Scheduled triggers and webhooks
– Error handling and retry mechanisms
– Complete control over data flow
Together, they let you build backend systems that would normally require a custom Node.js or Python server — but with a visual interface and without maintaining server code.
If you are evaluating automation tools, my n8n vs Zapier comparison explains why n8n is the better choice for developer-oriented workflows like Supabase integrations.
Getting Started: Connecting n8n to Supabase
Setting up the connection is straightforward. You will need your Supabase project URL and API keys.
If you do not have n8n yet, the quickest path is n8n cloud — you will have a working instance in minutes. For self-hosting instructions, see my n8n beginner guide.
Step 1: Get Your Supabase Credentials
1. Log into your Supabase dashboard at supabase.com
2. Select your project
3. Go to Settings > API
4. Copy the Project URL (e.g., https://abcdefghij.supabase.co)
5. Copy the anon/public key for read operations
6. Copy the service_role key for write operations (keep this secret)
[SCREENSHOT: Supabase Settings API page showing the Project URL and API keys]
Important: The anon key respects Row Level Security (RLS) policies. The service_role key bypasses RLS entirely. For n8n workflows that need full database access, use the service_role key, but treat it like a database password.
Step 2: Configure Supabase Credentials in n8n
n8n has a built-in Supabase node, which makes setup simple:
1. Add a Supabase node to a new workflow
2. Click Credentials > Create New
3. Select Supabase API
4. Enter your Host (Project URL without the protocol, e.g., abcdefghij.supabase.co)
5. Enter your Service Role Secret (the service_role key)
6. Test the connection
[SCREENSHOT: n8n Supabase credential configuration with host and service role key fields]
Alternatively, you can use the HTTP Request node with Supabase’s REST API directly. I use this approach for operations the built-in node does not cover:
URL: https://abcdefghij.supabase.co/rest/v1/your_table
Headers:
apikey: your-service-role-key
Authorization: Bearer your-service-role-key
Content-Type: application/json
Prefer: return=representation
Core Operations: CRUD with Supabase
Creating Records (Insert)
1. Add a Supabase node
2. Set Operation to "Create"
3. Select the Table
4. Map your data fields to column names
Example -- inserting a new contact:
{
"name": "Maria Garcia",
"email": "[email protected]",
"company": "TechStartup",
"source": "website_form",
"created_at": "{{ $now.toISO() }}"
}
[SCREENSHOT: Supabase Create node configured with field mappings for a contacts table]
Reading Records (Select)
1. Set Operation to "Get All" or "Get"
2. For "Get All", you can add filters:
- Column: status
- Operator: equals
- Value: active
For complex queries, I use the HTTP Request node with Supabase's PostgREST query syntax:
GET https://your-project.supabase.co/rest/v1/contacts?status=eq.active&order=created_at.desc&limit=10
This query language is powerful. You can do joins, full-text search, and aggregations directly in the URL parameters.
Updating Records
1. Set Operation to "Update"
2. Specify the row ID or filter condition
3. Provide the fields to update
I frequently use this to update status fields:
{
"id": "{{ $json.id }}",
"status": "processed",
"processed_at": "{{ $now.toISO() }}"
}
Deleting Records
1. Set Operation to "Delete"
2. Specify the row ID or filter condition
Be careful with deletes. I recommend adding a deleted_at timestamp column and using soft deletes (updating the column) instead of hard deletes. This gives you a safety net if something goes wrong.
The Main Workflow: Webhook to Supabase Pipeline
Let us build a complete workflow that receives data from a webhook, processes it, inserts it into Supabase, and triggers downstream actions.
Use Case: Lead Capture and Processing
This workflow handles incoming leads from a website form:
Webhook --> Validate Data --> Supabase (Insert) --> Check for Duplicates --> Enrich Data --> Supabase (Update) --> Send Welcome Email --> Notify Sales on Slack
Step 1: Webhook Trigger
1. Add a Webhook node
2. Set the method to POST
3. Copy the webhook URL for your form
The webhook receives data like:
{
"name": "Carlos Mendoza",
"email": "[email protected]",
"company": "InnovateCL",
"interest": "automation consulting",
"source": "blog_cta"
}
[SCREENSHOT: Webhook node showing a received test payload with lead data]
Step 2: Validate the Data
Add an IF node to validate required fields:
- Email is not empty AND matches email pattern
- Name is not empty
- Company is not empty
If validation fails, send a response back to the form indicating the error. If it passes, continue to the next step.
Step 3: Check for Duplicates
Before inserting, check if this email already exists in your database:
1. Add a Supabase node
2. Set Operation to "Get All"
3. Filter: email equals {{ $json.email }}
Then an IF node:
- If rows returned > 0, this is a duplicate -- update the existing record instead of creating a new one
- If rows returned = 0, proceed with insert
[SCREENSHOT: Duplicate check flow showing Supabase read node followed by IF node branching to Update or Create]
Step 4: Insert into Supabase
1. Add a Supabase node
2. Set Operation to "Create"
3. Map the fields:
name: {{ $json.name }}
email: {{ $json.email }}
company: {{ $json.company }}
interest: {{ $json.interest }}
source: {{ $json.source }}
status: new
created_at: {{ $now.toISO() }}
The response includes the newly created record with its auto-generated id, which we use in subsequent steps.
Step 5: Enrich the Data
I use an HTTP Request node to call a data enrichment API (like Clearbit or a custom service) to add company information:
GET https://api.enrichment-service.com/company?domain={{ $json.email.split('@')[1] }}
Then update the Supabase record with the enriched data:
{
"id": "{{ $json.id }}",
"company_size": "{{ $json.enrichment.employees }}",
"industry": "{{ $json.enrichment.industry }}",
"linkedin_url": "{{ $json.enrichment.linkedin }}"
}
Step 6: Send Welcome Email
Add an Email Send node:
To: {{ $json.email }}
Subject: Thanks for your interest, {{ $json.name.split(' ')[0] }}
Body:
Hi {{ $json.name }},
Thanks for reaching out about {{ $json.interest }}. I will review your request and get back to you within 24 hours.
In the meantime, you might find these resources helpful:
- Our automation guide
- Case studies from similar companies
Best,
Javier
Step 7: Notify Sales on Slack
Final step -- let the sales team know:
:bell: New lead captured!
*{{ $json.name }}* from {{ $json.company }}
:email: {{ $json.email }}
:dart: Interest: {{ $json.interest }}
:mag: Source: {{ $json.source }}
:office: Company size: {{ $json.company_size || 'Unknown' }}
[SCREENSHOT: Complete workflow showing all nodes connected from Webhook through validation, Supabase insert, enrichment, email, and Slack]
Real-Time Workflows with Supabase
One of Supabase's killer features is real-time subscriptions. While n8n does not natively subscribe to Supabase real-time events, there are two effective approaches to build reactive workflows.
Approach 1: Database Webhooks (Supabase Triggers)
Supabase lets you create database triggers that call webhooks when data changes:
1. In Supabase, go to Database > Triggers
2. Create a new trigger on your table
3. Set it to fire on INSERT, UPDATE, or DELETE
4. Use a database function that calls net.http_post to your n8n webhook URL
CREATE OR REPLACE FUNCTION notify_n8n()
RETURNS TRIGGER AS $$
BEGIN
PERFORM net.http_post(
url := 'https://your-n8n.com/webhook/supabase-trigger',
body := json_build_object(
'type', TG_OP,
'table', TG_TABLE_NAME,
'record', row_to_json(NEW),
'old_record', row_to_json(OLD)
)::jsonb
);
RETURN NEW;
END;
$$ LANGUAGE plpgsql;
This gives you near-real-time reactions to database changes.
Approach 2: Polling with Schedule Trigger
For simpler setups, poll for changes:
1. Schedule Trigger runs every minute
2. Supabase node reads records with updated_at greater than the last check time
3. Process only the changed records
I store the last check timestamp in a separate Supabase table or in n8n's static data:
// In a Code node
const lastCheck = $getWorkflowStaticData('global').lastCheck || new Date(0).toISOString();
$getWorkflowStaticData('global').lastCheck = new Date().toISOString();
return [{ json: { lastCheck } }];
[SCREENSHOT: Polling workflow showing Schedule Trigger, Code node for timestamp management, and Supabase read with filter]
User Management Workflows
Supabase Auth provides user management out of the box. Here are workflows I build around it.
New User Onboarding
When a user signs up through Supabase Auth:
1. Supabase Database Webhook fires on insert to the auth.users table
2. n8n creates a profile record in a profiles table with default settings
3. Sends a welcome email sequence (day 0, day 3, day 7)
4. Adds the user to your email marketing tool
5. Notifies the team on Slack
User Activity Monitoring
Track user engagement:
1. Schedule Trigger runs daily
2. Supabase node queries for users who have not logged in for 7 days
3. Email node sends a re-engagement message
4. Supabase node updates the user's engagement status
Account Cleanup
For users who signed up but never verified their email:
1. Schedule Trigger runs weekly
2. Supabase query: users where email_confirmed_at is null AND created_at is older than 30 days
3. Supabase node deletes or archives these abandoned accounts
4. Slack node reports the cleanup stats
Advanced Patterns
Batch Processing with Supabase
For processing large datasets, combine Supabase pagination with n8n's SplitInBatches node:
1. Supabase node reads 100 records at a time using limit and offset
2. SplitInBatches node processes them in groups of 10
3. Each batch goes through your processing pipeline
4. Wait node adds a small delay between batches to avoid overloading APIs
Multi-Table Workflows
Real applications involve multiple related tables. Here is a pattern I use for order processing:
1. Read the order from the orders table
2. Read related items from the order_items table using the order ID
3. Read customer details from the customers table
4. Process the complete order with all related data
5. Update all tables with the processing result
Using the HTTP Request node with Supabase's PostgREST, you can even do this in a single request with embedded resources:
GET /rest/v1/orders?select=*,order_items(*),customers(*)&id=eq.123
Edge Functions Integration
Supabase Edge Functions let you run custom server-side code. I use them with n8n for operations that need to happen close to the database:
1. n8n sends a request to a Supabase Edge Function
2. The function performs complex database operations (transactions, aggregations)
3. Returns the result to n8n for further processing
This is useful when you need database transactions that guarantee consistency -- something you cannot achieve with multiple individual API calls.
Error Handling and Resilience
Retry Logic
Supabase API calls can fail due to network issues or rate limits. I add retry logic:
1. Enable Retry on Fail in the Supabase node settings
2. Set max retries to 3
3. Set wait between retries to 5 seconds
Data Consistency
When a workflow updates multiple tables, a failure midway can leave data in an inconsistent state. My approach:
1. Write all changes to a pending_operations table first
2. Process the operations in order
3. Mark each as "completed" when done
4. A separate cleanup workflow handles any "pending" operations that are older than expected
Monitoring
I run a daily health check workflow:
1. Schedule Trigger at 8 AM
2. Supabase node counts records in key tables
3. IF node checks for anomalies (sudden drops or spikes)
4. Slack node sends a daily health report
:chart_with_upwards_trend: Daily Database Health Report
Users: 1,247 (+12 today)
Orders: 89 (+5 today)
Active leads: 34
Failed operations: 0
All systems normal.
Performance Tips
Use RPC for Complex Queries
For complex aggregations or joins, create a Supabase RPC function:
CREATE FUNCTION get_monthly_stats(target_month DATE)
RETURNS JSON AS $$
SELECT json_build_object(
'total_orders', COUNT(*),
'revenue', SUM(total),
'avg_order_value', AVG(total)
)
FROM orders
WHERE created_at >= target_month
AND created_at < target_month + INTERVAL '1 month';
$$ LANGUAGE sql;
Call it from n8n:
POST /rest/v1/rpc/get_monthly_stats
Body: { "target_month": "2026-04-01" }
This is much more efficient than reading all orders and aggregating in n8n.
Index Your Filter Columns
If your n8n workflows frequently filter by specific columns (like status, created_at, or email), make sure those columns are indexed in Supabase:
CREATE INDEX idx_leads_status ON leads(status);
CREATE INDEX idx_leads_created_at ON leads(created_at);
This dramatically speeds up queries, especially as your tables grow.
FAQ
Can I use Supabase's free tier with n8n for production workflows?
Yes, Supabase's free tier includes 500MB of database storage, 1GB of file storage, 50,000 monthly active users for auth, and 500,000 edge function invocations. For many small to medium applications, this is more than enough. I ran my first production workflow on the free tier for six months before upgrading. Pair it with n8n Community Edition (self-hosted and free) or n8n Cloud's free tier, and you have a complete automation backend at zero cost. Just monitor your usage and upgrade when you approach the limits.
How do I handle Supabase Row Level Security with n8n?
When you use the service_role key in n8n, it bypasses Row Level Security entirely. This is by design because n8n is acting as a backend service, not as an end user. If you need to respect RLS policies in your workflows (for example, to process data as a specific user), you can use the Supabase Auth API to generate a JWT for that user, then use that JWT in the Authorization header of your HTTP Request node instead of the service_role key. However, for most automation scenarios, the service_role key with proper workflow logic is simpler and more practical.
What happens if my n8n workflow fails mid-way through a multi-step Supabase operation?
This is a real concern because unlike direct database transactions, API calls through n8n are not atomic. If your workflow inserts a record in table A but fails before inserting the related record in table B, you end up with orphaned data. My recommended approach is to implement an idempotent design: use unique constraints to prevent duplicate inserts, check for existing records before creating new ones, and add a cleanup workflow that runs periodically to fix any inconsistencies. For critical operations, consider using a Supabase Edge Function that wraps multiple database operations in a single transaction, called from n8n as one atomic step.
Wrapping Up
The n8n plus Supabase combination is the most productive backend stack I have worked with. Supabase handles data storage, authentication, and real-time updates, while n8n handles the workflow logic that connects everything together. Between them, they cover 90% of what you would traditionally need a custom backend server for.
The webhook-to-Supabase pipeline we built in this tutorial is a pattern I use in almost every project. Whether it is lead capture, order processing, or user onboarding, the structure is the same: receive data, validate it, store it, enrich it, and trigger downstream actions.
I have been running this stack in production for my consulting business and several client projects, and it has been remarkably reliable. The combination of Supabase's PostgreSQL foundation with n8n's workflow engine gives you a solid, scalable backend without the overhead of maintaining custom server code.
Ready to try it yourself? Get started with n8n and connect it to a Supabase project. Start with a simple insert workflow and build from there. You will be surprised how quickly you can build production-ready backend automations.
For more on n8n, check out my comprehensive review and my beginner guide for getting started.
Happy automating.