# How to Integrate Supabase with Make (Integromat)

- Tool: Supabase
- Difficulty: Beginner
- Time required: 15-20 min
- Compatibility: Supabase (all plans), Make (all plans), @supabase/supabase-js v2+
- Last updated: March 2026

## 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.

## Before you start

- 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).

```
URL: https://yourproject.supabase.co/rest/v1/todos
Method: GET

Headers:
  apikey: your-supabase-anon-key
  Authorization: Bearer your-supabase-anon-key
  Content-Type: application/json

Query String:
  select: id,task,is_complete,created_at
  order: created_at.desc
  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).

```
URL: https://yourproject.supabase.co/rest/v1/todos
Method: POST

Headers:
  apikey: your-supabase-anon-key
  Authorization: Bearer your-supabase-anon-key
  Content-Type: application/json
  Prefer: return=representation

Body (JSON):
{
  "task": "Task from Make automation",
  "is_complete": false
}
```

**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.

```
-- UPDATE example
URL: https://yourproject.supabase.co/rest/v1/todos?id=eq.5
Method: PATCH

Headers:
  apikey: your-supabase-anon-key
  Authorization: Bearer your-supabase-anon-key
  Content-Type: application/json
  Prefer: return=representation

Body (JSON):
{
  "is_complete": true
}

-- DELETE example
URL: https://yourproject.supabase.co/rest/v1/todos?id=eq.5
Method: DELETE

Headers:
  apikey: your-supabase-anon-key
  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.

```
-- In Make: Add a Webhooks > Custom Webhook trigger module
-- Copy the webhook URL (e.g., https://hook.make.com/abc123...)

-- In Supabase Dashboard: Database > Webhooks > Create
-- Table: todos
-- Events: INSERT, UPDATE
-- Type: HTTP Request
-- Method: POST
-- URL: https://hook.make.com/abc123...
-- Headers: Content-Type: application/json

-- The webhook payload includes:
-- { "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.

```
-- Admin read: bypass RLS to get all rows
URL: https://yourproject.supabase.co/rest/v1/todos
Method: GET

Headers:
  apikey: your-supabase-anon-key
  Authorization: Bearer your-supabase-service-role-key
  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 code example

File: `make-supabase-integration.ts`

```typescript
// Edge Function: webhook receiver for Make-to-Supabase integration
// Deploy: supabase functions deploy make-webhook

import { corsHeaders } from '../_shared/cors.ts'
import { createClient } from 'npm:@supabase/supabase-js@2'

Deno.serve(async (req) => {
  if (req.method === 'OPTIONS') {
    return new Response('ok', { headers: corsHeaders })
  }

  try {
    const supabase = createClient(
      Deno.env.get('SUPABASE_URL')!,
      Deno.env.get('SUPABASE_SERVICE_ROLE_KEY')!
    )

    const payload = await req.json()
    const { action, table, data } = payload

    let result

    switch (action) {
      case 'insert':
        result = await supabase.from(table).insert(data).select()
        break
      case 'update':
        result = await supabase.from(table).update(data.values).eq('id', data.id).select()
        break
      case 'delete':
        result = await supabase.from(table).delete().eq('id', data.id)
        break
      case 'select':
        result = await supabase.from(table).select(data.columns || '*').limit(data.limit || 100)
        break
      default:
        return new Response(
          JSON.stringify({ error: `Unknown action: ${action}` }),
          { headers: { ...corsHeaders, 'Content-Type': 'application/json' }, status: 400 }
        )
    }

    if (result.error) {
      return new Response(
        JSON.stringify({ error: result.error.message }),
        { headers: { ...corsHeaders, 'Content-Type': 'application/json' }, status: 400 }
      )
    }

    return new Response(
      JSON.stringify({ data: result.data }),
      { headers: { ...corsHeaders, 'Content-Type': 'application/json' }, status: 200 }
    )
  } catch (error) {
    return new Response(
      JSON.stringify({ error: 'Internal server error' }),
      { headers: { ...corsHeaders, 'Content-Type': 'application/json' }, status: 500 }
    )
  }
})
```

## Common mistakes

- **Forgetting the apikey header in Make HTTP requests, causing a 401 Unauthorized error** — undefined Fix: 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).
- **Using PATCH or DELETE without query string filters, accidentally modifying or deleting all rows in the table** — undefined Fix: Always add a filter like ?id=eq.5 to target specific rows. Test with GET first to verify the filter returns the correct rows.
- **Not setting the Prefer: return=representation header, getting empty responses from POST and PATCH requests** — undefined Fix: 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

## 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.

---

Source: https://www.rapidevelopers.com/supabase-tutorial/how-to-integrate-supabase-with-make-integromat
© RapidDev — https://www.rapidevelopers.com/supabase-tutorial/how-to-integrate-supabase-with-make-integromat