Resources · Make integration

MySQL Make integrationAutomate MySQL with Make.

Your database can do the work while you do something else. The MySQL Make integration gives you 8 modules, bricks you drop into a scenario, the automation Make runs for you. Nothing inside MySQL sets it off, so Make checks your tables at the interval you set. Here is what each one does.

Try the MySQL integration on MakeSee the 8 modules

Verified Trustpilot reviews · AI, automation & growth agency

What you can automate

What can the MySQL Make integration actually do?

It links your MySQL server to Make once, and that connection, your database account tied to Make, is reused by every MySQL module you add later. From there Make reads rows, writes them, changes them, removes them, and passes them to the other apps in the same scenario. The 8 modules split into 6 actions, 1 search and 1 iterator.

The easiest win is a report nobody has to export by hand. Select row(s) from a table pulls the rows that match your filter, one by one, and the next module drops them into a sheet or a message. Nobody outside the team needs a database login.

Then there is the intake side, the form answer that lands straight in your table. Insert row into a table writes the record where it belongs, and Update row(s) in a table marks it as handled once the rest of the scenario has run.

Teams with SQL already written keep it that way: the procedure runs, Make just calls it. Execute a stored procedure hands back what the procedure returns, and Iterate recordset of a stored procedure splits that result into single rows the scenario can work through.

What Make will not do here is watch your database. MySQL has no trigger, the module that starts a scenario when something happens, so a schedule or another app has to kick things off. Your server also has to answer from the internet. When a scenario fails and the reason is not obvious, Make troubleshooting lists what usually breaks.

The same database has a node on the other tool as well: the MySQL n8n integration page covers it, and n8n vs Make is there if the choice is still open.

Connect

How do you connect MySQL to Make?

  1. 01

    Add a MySQL module and create the connection

    You need a MySQL server that is already running and reachable before anything else. In Make, drop any MySQL module into a scenario and click Create a connection. That connection is your database account linked to Make once, and every MySQL module you add later reuses it.

  2. 02

    Fill in the server fields

    Give the connection a name, then complete Host with the public address of your server, Port, User and Password. Add Database too: most modules do without it, Execute a query (advanced) does not.

  3. 03

    Save it and confirm the access

    Click Save. Make then asks you to authenticate and confirm access if the server expects it. An old server may need Allow insecure authentication switched on. For TLS, the optional fields take a P12, PFX or PEM file that Make uses without keeping it.

First scenario

Your first scenario with MySQL

GoalOn each scheduled run, Make asks MySQL for the rows a stored procedure returns and takes them one at a time.

  1. 01

    Create the scenario

    From the Scenarios page, open a new scenario and click the + to place the first module. Search MySQL by name and pick Execute a stored procedure.

  2. 02

    Point it at your procedure

    Click Create a connection if this is your first MySQL module, then choose the procedure you want called. Make can only list what the connection lets it read.

  3. 03

    Split the result row by row

    Click the + on the right of the module and add Iterate recordset of a stored procedure. It turns the recordset into one bundle per row, a bundle being one item handed from a module to the next.

  4. 04

    Test with Run once

    Click Run once, the button that runs the scenario a single time. Every module shows the bundles it received, so you read the real rows before the scenario touches anything else.

  5. 05

    Schedule it, then switch it on

    Open Scheduling on the first module, the little clock. A new scenario is set to every 15 minutes by default. Choose your interval, then flip the scenario on.

Modules

What MySQL can do inside a scenario

MySQL gives you 8 modules in 3 groups. For each one: what it does for you, when to reach for it, and what to watch out for.

Actions

6 modules
MySQL1

Delete row(s) from a table

Action

This one removes the rows that match the conditions you set and gives back a confirmation, nothing else. The rows are gone.

When to use it
clearing a staging table once another module has copied its content somewhere safe.
Watch out
Make has no undo button on a delete. Try your conditions on Select row(s) from a table first and read what comes back.
MySQL2

Execute a query (advanced)

Action

Here you write the SQL and Make runs it against your database as it is. It is the way out when none of the 6 ready-made actions covers what you need.

When to use it
a join across two tables for a summary that a single Select cannot produce.
Watch out
this module needs the Database field filled in your connection, or it has nothing to run against.
MySQL3

Execute a stored procedure

Action

Calls a procedure that already lives in your database and collects what it returns. The logic stays in MySQL, Make only fires it at the right moment.

When to use it
a closing routine your developer wrote, that you want running without anyone opening a SQL client.
Watch out
the recordset arrives in one block. To handle it row by row, chain it with Iterate recordset of a stored procedure.
MySQL4

Insert row into a table

Action

One record in, one row written. You map the values coming from the module before it, and the module hands back the row it created.

When to use it
a form answer or a paid invoice that has to live in your own database, not only in the tool that received it.
Watch out
one bundle makes one row. A list has to be split into bundles before it can be written.
MySQL5

Update row(s) in a table

Action

Changes the columns you name on the rows that match your condition, and leaves the rest of the table alone.

When to use it
flagging a record as processed at the end of a scenario, so the next run skips it.
Watch out
a loose condition touches more rows than you had in mind. Check with Run once what happened before you switch the scenario on.
MySQL6

Pass NULL values into a table

ActionIn the docs only

Writes a real NULL into a column instead of an empty string. The difference shows up the moment you filter or count rows.

When to use it
an optional field comes back empty and your reports must not treat it as a value.
Watch out
the Make app directory does not show this one, only the documentation lists it. Look it up by name in the module search.

Searches

1 module

You may also use the existing basic text operators for comparing dates and datetimes. Just use text formatted date/datetime as the second operand: YYYY-MM-DD for date typeYYYY-MM-DD HH:mm:ss for datetime type Literal static datetime value example: Formatted dynamic datetime value example:

MySQL7

Select row(s) from a table

Search

Reads a table and sends every matching row forward, one bundle per row. Zero, one or several: the modules after it run as many times as there are results.

When to use it
pulling the rows of a given day to push them into a sheet the whole team can read.
Watch out
dates compare as text here. Pass the value as YYYY-MM-DD, or YYYY-MM-DD HH:mm:ss when the column holds a time.

Iterators

1 module
MySQL8

Iterate recordset of a stored procedure

Iterator

In Make“Iterates through recordset received from a stored procedure.”

Takes the recordset a stored procedure returned and breaks it into one bundle per row, so each row travels through the rest of the scenario on its own.

When to use it
the procedure returns a list of unpaid invoices and each one has to become its own reminder.
Watch out
it only makes sense right after Execute a stored procedure. Anywhere else it finds no recordset to open.
Need help

Need help automating MySQL with Make?

A person reads every message.

FAQ

Questions that come up next

01Is the MySQL Make integration free?
Yes, from the Free plan. MySQL is a standard app, so it is available on every plan. The Free plan gives you 2 active scenarios, a minimum of 15 minutes between two scheduled runs, 5 minutes of execution at most, files up to 5 MB and 512 MB of transfer. What you spend is counted in operations: one operation is one module handling one item. Reading a table and writing row by row therefore costs one operation per row. Paid plans drop the interval to 1 minute, lift the cap on active scenarios and allow 40 minutes per run.
02What do you need before you connect MySQL to Make?
A MySQL server that is already configured and reachable from the internet, plus a user with rights on the database. Make asks for the server address, the port, the user and the password, and for the database name as soon as you use Execute a query (advanced). If the database sits on your own machine, comment out the bind-address line in the MySQL server configuration, restart the daemon, then create a user and grant it privileges from the command line. The values localhost and 127.0.0.1 are refused in the Host field.
03Can a change in MySQL start a scenario by itself?
No. MySQL has no trigger module in Make, so nothing happening in your tables wakes a scenario up. Two ways around it. Either the scenario runs on a schedule, the clock on its first module, set to every 15 minutes by default, 15 minutes minimum on the Free plan and down to 1 minute on a paid plan. Or it starts on another app's trigger, a form sent or a payment received, and MySQL comes in afterwards as an action. The second option avoids runs that find nothing.
04What if a module is missing or a limit gets in the way?
MySQL has no Make an API Call module, so that usual escape hatch is not available. In practice Execute a query (advanced) replaces it: you write the query, Make runs it, and joins or bulk updates stop being a problem. Execute a stored procedure does the same job for logic already written in the database. When the blocker is the connection rather than the module, it is almost always the server that fails to answer. The team can look at it with you.
05Make or n8n for MySQL?
It depends on what your other tools already run on. Make gives you a visual editor and counts operations module by module, which suits a small team that wants to reread its scenarios months later. MySQL also has a node in n8n, so both can read and write your tables. Decide on what you can verify: where your other apps are already connected, who will maintain the scenarios, and whether anyone on your side writes SQL. The comparison page on the site sets out those criteria.
Hack'celeration Lab

Get our weekly automation tips.

No spam. Unsubscribe anytime.

Same platform

Other docs you might need on this stack.

Browse all integrations