Skip to main content
RapidDev - Software Development Agency
supabase-tutorial

How to Integrate Supabase with Make (Integromat)

Connect Supabase to Make (formerly Integromat) using the HTTP module with your Supabase REST API URL and anon key. Make does not have a native Supabase module, so you use the HTTP Make a Request module to call Supabase's auto-generated REST API. Pass the apikey and Authorization headers for authentication. You can read, insert, update, and delete rows, plus trigger Make scenarios from Supabase database changes using webhooks.

What you'll learn

  • How to configure the Make HTTP module to call Supabase REST API
  • How to perform CRUD operations on Supabase tables from Make
  • How to trigger Make scenarios from Supabase database changes using webhooks
  • How to handle authentication and RLS with Make requests
Book a free consultation
4.9Clutch rating
600+Happy partners
17+Countries served
190+Team members
Beginner7 min read15-20 minSupabase (all plans), Make (all plans), @supabase/supabase-js v2+March 2026RapidDev Engineering Team
TL;DR

Connect Supabase to Make (formerly Integromat) using the HTTP module with your Supabase REST API URL and anon key. Make does not have a native Supabase module, so you use the HTTP Make a Request module to call Supabase's auto-generated REST API. Pass the apikey and Authorization headers for authentication. You can read, insert, update, and delete rows, plus trigger Make scenarios from Supabase database changes using webhooks.

Connecting Supabase to Make (Integromat) for Automated Workflows

Make is a visual automation platform that connects hundreds of services. While Make does not have a native Supabase module, you can use the HTTP module to call Supabase's REST API directly. This tutorial shows you how to set up the HTTP module with proper authentication, perform CRUD operations on your Supabase tables, and trigger Make scenarios automatically when data changes in your database using webhooks.

Prerequisites

  • A Supabase project with at least one table and RLS policies configured
  • A Make account (free tier works for testing)
  • Your Supabase project URL and anon key from Dashboard > Settings > API
  • Basic understanding of REST APIs and HTTP methods

Step-by-step guide

1

Set up the HTTP module in Make to call Supabase

In Make, create a new scenario and add an HTTP > Make a Request module. Configure the URL to point to your Supabase REST API endpoint for the table you want to access. The URL format is https://<project-ref>.supabase.co/rest/v1/<table_name>. Add two required headers: apikey with your anon key, and Authorization with Bearer followed by your anon key (for unauthenticated access) or a user JWT (for authenticated access).

typescript
1URL: https://yourproject.supabase.co/rest/v1/todos
2Method: GET
3
4Headers:
5 apikey: your-supabase-anon-key
6 Authorization: Bearer your-supabase-anon-key
7 Content-Type: application/json
8
9Query String:
10 select: id,task,is_complete,created_at
11 order: created_at.desc
12 limit: 50

Expected result: The HTTP module returns an array of JSON objects representing the rows from your Supabase table, filtered by your RLS policies.

2

Insert data into Supabase from a Make scenario

To insert data, change the HTTP method to POST and include the row data as a JSON body. The Supabase REST API uses PostgREST conventions: set the Prefer header to return=representation to get the inserted row back in the response. The RLS INSERT policy must allow the insert for the role you are using (anon or authenticated).

typescript
1URL: https://yourproject.supabase.co/rest/v1/todos
2Method: POST
3
4Headers:
5 apikey: your-supabase-anon-key
6 Authorization: Bearer your-supabase-anon-key
7 Content-Type: application/json
8 Prefer: return=representation
9
10Body (JSON):
11{
12 "task": "Task from Make automation",
13 "is_complete": false
14}

Expected result: A new row is created in the todos table. The response contains the full inserted row including the auto-generated id and created_at.

3

Update and delete records with filters

Use PATCH for updates and DELETE for deletions. Add filters as query parameters using PostgREST syntax to target specific rows. For example, id=eq.5 matches rows where id equals 5. Always include a filter when updating or deleting to avoid modifying all rows. The RLS UPDATE and DELETE policies must allow the operation.

typescript
1-- UPDATE example
2URL: https://yourproject.supabase.co/rest/v1/todos?id=eq.5
3Method: PATCH
4
5Headers:
6 apikey: your-supabase-anon-key
7 Authorization: Bearer your-supabase-anon-key
8 Content-Type: application/json
9 Prefer: return=representation
10
11Body (JSON):
12{
13 "is_complete": true
14}
15
16-- DELETE example
17URL: https://yourproject.supabase.co/rest/v1/todos?id=eq.5
18Method: DELETE
19
20Headers:
21 apikey: your-supabase-anon-key
22 Authorization: Bearer your-supabase-anon-key

Expected result: The targeted row is updated or deleted. PATCH returns the updated row when Prefer: return=representation is set. DELETE returns a 204 No Content.

4

Trigger Make scenarios from Supabase database changes

To trigger a Make scenario when data changes in Supabase, use Make's Webhook trigger module. Create a custom webhook in Make to get a unique URL, then create a Supabase database webhook that sends the changed row data to that URL on INSERT, UPDATE, or DELETE events. This creates an event-driven automation that reacts to database changes in real time.

typescript
1-- In Make: Add a Webhooks > Custom Webhook trigger module
2-- Copy the webhook URL (e.g., https://hook.make.com/abc123...)
3
4-- In Supabase Dashboard: Database > Webhooks > Create
5-- Table: todos
6-- Events: INSERT, UPDATE
7-- Type: HTTP Request
8-- Method: POST
9-- URL: https://hook.make.com/abc123...
10-- Headers: Content-Type: application/json
11
12-- The webhook payload includes:
13-- { "type": "INSERT", "table": "todos", "record": { ... }, "old_record": null }

Expected result: Every INSERT or UPDATE on the todos table sends the row data to the Make webhook, triggering the scenario automatically.

5

Use the service role key for admin operations

When your Make automation needs to perform operations that bypass RLS (for example, reading all users' data or performing admin updates), use the SUPABASE_SERVICE_ROLE_KEY in the Authorization header instead of the anon key. This key bypasses all RLS policies and has full access to the database. Store it securely in Make's scenario variables and never expose it in client-side code.

typescript
1-- Admin read: bypass RLS to get all rows
2URL: https://yourproject.supabase.co/rest/v1/todos
3Method: GET
4
5Headers:
6 apikey: your-supabase-anon-key
7 Authorization: Bearer your-supabase-service-role-key
8 Content-Type: application/json

Expected result: The request bypasses all RLS policies and returns all rows from the table, regardless of which user owns them.

Complete working example

make-supabase-integration.ts
1// Edge Function: webhook receiver for Make-to-Supabase integration
2// Deploy: supabase functions deploy make-webhook
3
4import { corsHeaders } from '../_shared/cors.ts'
5import { createClient } from 'npm:@supabase/supabase-js@2'
6
7Deno.serve(async (req) => {
8 if (req.method === 'OPTIONS') {
9 return new Response('ok', { headers: corsHeaders })
10 }
11
12 try {
13 const supabase = createClient(
14 Deno.env.get('SUPABASE_URL')!,
15 Deno.env.get('SUPABASE_SERVICE_ROLE_KEY')!
16 )
17
18 const payload = await req.json()
19 const { action, table, data } = payload
20
21 let result
22
23 switch (action) {
24 case 'insert':
25 result = await supabase.from(table).insert(data).select()
26 break
27 case 'update':
28 result = await supabase.from(table).update(data.values).eq('id', data.id).select()
29 break
30 case 'delete':
31 result = await supabase.from(table).delete().eq('id', data.id)
32 break
33 case 'select':
34 result = await supabase.from(table).select(data.columns || '*').limit(data.limit || 100)
35 break
36 default:
37 return new Response(
38 JSON.stringify({ error: `Unknown action: ${action}` }),
39 { headers: { ...corsHeaders, 'Content-Type': 'application/json' }, status: 400 }
40 )
41 }
42
43 if (result.error) {
44 return new Response(
45 JSON.stringify({ error: result.error.message }),
46 { headers: { ...corsHeaders, 'Content-Type': 'application/json' }, status: 400 }
47 )
48 }
49
50 return new Response(
51 JSON.stringify({ data: result.data }),
52 { headers: { ...corsHeaders, 'Content-Type': 'application/json' }, status: 200 }
53 )
54 } catch (error) {
55 return new Response(
56 JSON.stringify({ error: 'Internal server error' }),
57 { headers: { ...corsHeaders, 'Content-Type': 'application/json' }, status: 500 }
58 )
59 }
60})

Common mistakes when integrating Supabase with Make (Integromat)

Why it's a problem: Forgetting the apikey header in Make HTTP requests, causing a 401 Unauthorized error

How to avoid: Always include both headers: apikey (identifies the project, always uses the anon key) and Authorization (determines access level, uses anon key or service role key).

Why it's a problem: Using PATCH or DELETE without query string filters, accidentally modifying or deleting all rows in the table

How to avoid: Always add a filter like ?id=eq.5 to target specific rows. Test with GET first to verify the filter returns the correct rows.

Why it's a problem: Not setting the Prefer: return=representation header, getting empty responses from POST and PATCH requests

How to avoid: Add the header Prefer: return=representation to get the full row data back in the response after inserts and updates.

Best practices

  • Store your Supabase URL and keys in Make's scenario variables for easy reuse across modules
  • Use the anon key for operations that should respect RLS, and the service role key only for admin operations
  • Always include query string filters on PATCH and DELETE requests to avoid modifying all rows
  • Test webhook payloads by inserting a test row and capturing the structure in Make before building the full scenario
  • Add error handling modules in Make to catch and log failed Supabase API calls
  • Use the Prefer: return=representation header for POST and PATCH to get the affected rows in the response
  • Create dedicated RLS policies for the anon role if your Make automation uses the anon key

Still stuck?

Copy one of these prompts to get a personalized, step-by-step explanation.

ChatGPT Prompt

I want to connect Make (Integromat) to my Supabase database. Show me how to configure the HTTP module in Make to read, insert, update, and delete rows using the Supabase REST API with proper authentication headers. Also show how to trigger Make scenarios from Supabase database changes using webhooks.

Supabase Prompt

Set up a Make-to-Supabase integration using the HTTP module for CRUD operations on the REST API. Include the URL format, required headers (apikey, Authorization, Prefer), query string filter syntax, and a database webhook configuration that triggers Make scenarios on INSERT and UPDATE events.

Frequently asked questions

Does Make have a native Supabase module?

No. As of March 2026, Make does not have a dedicated Supabase module. Use the HTTP > Make a Request module to call Supabase's REST API directly with the proper headers.

Which Supabase key should I use in Make?

Use the anon key for operations that should respect RLS policies (the safe default). Use the service role key only for admin operations that need to bypass RLS. The apikey header always uses the anon key.

How do I filter rows in the Supabase REST API from Make?

Add query parameters using PostgREST syntax: ?column=eq.value for equals, ?column=gt.10 for greater than, ?column=like.*search* for pattern matching. Chain multiple filters with & between them.

Can I trigger a Make scenario when a Supabase row changes?

Yes. Create a Webhooks > Custom Webhook trigger in Make, copy the URL, then create a database webhook in Supabase Dashboard > Database > Webhooks that sends the row data to that URL on INSERT, UPDATE, or DELETE events.

Why does my Make HTTP request return an empty array?

An empty array usually means RLS is blocking the query. Check that you have a SELECT policy for the role you are using. If using the anon key, you need a policy that grants SELECT to the anon role.

Can I use Make to call Supabase Edge Functions?

Yes. Use the HTTP module to POST to https://<project-ref>.supabase.co/functions/v1/<function-name> with the same apikey and Authorization headers. Pass the function payload as the JSON body.

Can RapidDev help build Make automations that integrate with Supabase?

Yes. RapidDev can design and implement Make scenarios that read, write, and react to Supabase database changes, including webhook configuration, error handling, and complex multi-step workflows.

RapidDev

Talk to an Expert

Our team has built 600+ apps. Get personalized help with your project.

Book a free consultation

Need help with your project?

Our experts have built 600+ apps and can accelerate your development. Book a free consultation — no strings attached.

Book a free consultation

We put the rapid in RapidDev

Need a dedicated strategic tech and growth partner? Discover what RapidDev can do for your business! Book a call with our team to schedule a free, no-obligation consultation. We'll discuss your project and provide a custom quote at no cost.