How to Configure Make Supabase Connect

Published
Length
3 min read

Luis Felipe Dias

All posts

To set up a make supabase connect workflow, link your Make scenario to your database. You can use a dedicated Postgres user or the REST API with a project key. Many teams rush this step and paste the default admin password into Make. That choice gives an outside tool full admin power over every table and record. When an automation tool holds broad database rights, one bad scenario can drop data. It can also pull sensitive customer fields into third-party logs without your team knowing. Building

Your coding agents run with your access.

Claude Code reaches prod with a developer's credentials, and approval prompts get clicked through. hoop.dev checks every query, masks sensitive data, and holds risky changes for a human.

To set up a make supabase connect workflow, link your Make scenario to your database. You can use a dedicated Postgres user or the REST API with a project key. Many teams rush this step and paste the default admin password into Make. That choice gives an outside tool full admin power over every table and record.

When an automation tool holds broad database rights, one bad scenario can drop data. It can also pull sensitive customer fields into third-party logs without your team knowing. Building a safer link starts with understanding how your database handles roles and keys.

How a make supabase connect setup works

Every new Supabase project comes with a default postgres role. This role has admin rights, though it is not a full superuser. Supabase blocks superuser access to stop destructive actions on the database. Still, the password you set at project creation belongs to this admin role.

Supabase warns that you should not share this password with outside services. Instead, you should create a new Postgres user just for your Make workflows. You then grant that user only the table rights your automation needs.

Each project also includes built-in roles like anon, authenticated, service_role, and authenticator. When Make talks to your project through the API, it uses these built-in roles. If you use a direct database module in Make, it logs in with a Postgres user. Separating these accounts keeps your dashboard queries distinct from your background tasks. Queries run in the Supabase dashboard run as the postgres role with a source comment.

What native roles solve and what they miss

Creating a dedicated Postgres user for Make is a strong first step. It stops a scenario from touching tables outside its assigned scope. If someone leaks that password, you can revoke one user without breaking other apps. Role limits also help you follow basic access rules across your team.

Still, database roles only check who logs in at the start of a session. Once Make logs in, the database trusts every valid query that user sends. Native permissions cannot inspect individual queries in flight to block risky bulk reads. They also cannot rewrite sensitive fields like emails or phone numbers in query results.

End-to-End Encryption: architecture patterns and best practices

Continue reading? Get the full guide.

Free. No spam. Unsubscribe anytime.

If a Make scenario fetches a customer row, it pulls every allowed column. Raw card numbers or national IDs can then flow straight into Make execution logs. To stop data leaks, teams need controls that work on each query at runtime.

Steps to tighten your automation access

Start by auditing every Make scenario that reads or writes to your database. Replace any shared postgres admin credentials with a single-purpose database role right away. Give that role read or write access only to the specific tables it needs.

Next, review which columns your workflows actually need to finish their jobs. If a workflow only sends an order update, it does not need card numbers. Limit exposure by keeping raw personal data out of broad select queries. Finally, check your logs often to see what queries your external tools run.

Run guardrails and masking on the Postgres connection

Role grants and firewall rules are needed setup. Setup alone cannot check single SQL statements or mask sensitive rows in a response. By design, hoop.dev is an open-source proxy that sits beside Postgres, RDS, or Aurora as a sidecar for your Postgres. Clients and agent tools keep their credentials and point their connection string at the listener.

On each query, hoop.dev guardrails refuse disallowed drops, deletes, or table reads before they run. Next, hoop.dev data masking rewrites sensitive fields in returned rows that match your rules. Furthermore, hoop.dev holds SOC 2 Type II and logs every statement and verdict per resource. Check out the project on GitHub.

Frequently asked questions

Should I use the default postgres password in Make?

No, you should never give the default postgres password to an outside service. That role has admin rights, so create a separate database user for Make instead.

Does the Supabase postgres role have full superuser rights?

No, Supabase does not give superuser access because it allows destructive database actions. The default postgres role is an admin role with extra rights for specific tasks.

How can I protect sensitive fields when Make queries my database?

Create a restricted user for Make and limit which tables it can read. For deeper protection, use data masking to rewrite emails or card numbers in results.

The query runs. The emails stay hidden.