Resources · Make integration

Gmail Make integrationAutomate Gmail with Make.

Gmail can keep working while you are somewhere else. The Gmail Make integration opens 16 modules, the bricks you chain inside Make: one trigger that starts the run when mail arrives, 12 actions that write, move or label a message, and 2 searches that look things up.

Try the Gmail integration on MakeSee the 16 modules

Verified Trustpilot reviews · AI, automation & growth agency

What you can automate

What does the Gmail Make integration actually cover?

Connecting Gmail to Make means letting a scenario, the automation you build as a chain of modules, read and write your mail for you. You link your Google account once, and that connection is reused by every Gmail module you add afterwards. Nothing runs on your machine, and no code is involved.

Three shapes come back constantly. A shared inbox that answers by itself: Watch Emails picks up what arrives and Send an Email acknowledges it, so nobody is left waiting. A mailbox that sorts itself: the same trigger, then Modify Email Labels and Mark an Email as Read to put away whatever the scenario has already handled. Attachments that end up where they belong: List email attachments and media checks what came with the message, Iterate Attachments hands the files over one at a time.

The documentation draws a few lines worth knowing before you build. The Gmail app is on version 4, which is what a new scenario gives you; the older version 2 modules still exist, in separate legacy documentation. A connection made with an address ending in @gmail or @googlemail expires after 6 months, and you reauthorize it yourself from the Connections section. Anything a scenario takes out of Gmail travels under the Google API Services User Data Policy, so treat message bodies and attachments the way you treat customer data.

Gmail also exists as a node in n8n, so the choice stays open: the n8n vs Make comparison lays out the criteria, and the Gmail n8n integration page covers the same mailbox from the other side. If you would rather learn the editor properly before building anything the team depends on, Make training starts from the same first scenario as this page.

Connect

How do you link your Google account to Make?

  1. 01

    Add a Gmail module and open the connection

    Log in to Make, drop any Gmail module into your scenario, then click Create a connection. Make asks for the account before anything else, because every list it offers you afterwards is read from your own mailbox.

  2. 02

    Fill in the optional parts, if you need them

    Nothing that follows is required. Connection name is there so you can tell two accounts apart later, Additional Scopes takes the Gmail API scopes you need, and Advanced settings is where your own Google client credentials go if you have them.

  3. 03

    Sign in with Google and confirm access

    Click Sign in with Google, pick the account, and confirm access when Google asks. A Google account is the only prerequisite. Once the window closes, the connection is stored in Make and every Gmail module you add later reuses it.

First scenario

Your first scenario with Gmail

GoalWhen a new email lands in the mailbox you watch, Make replies to the sender on its own.

  1. 01

    Create the scenario

    From the Scenarios page, create a new scenario and click the + to place the first module. The canvas is empty at that point, which is exactly what it should look like.

  2. 02

    Drop in Watch Emails

    Search for Gmail by name, pick Watch Emails, then click Create a connection to link your Google account to the scenario.

  3. 03

    Set what the trigger watches

    Fill in the module fields. Now that the connection exists, Make lists what it can read in your mailbox and you choose which messages should come through.

  4. 04

    Add the reply

    Click the + on the right of the trigger, add Send an Email, and map data from the previous module so the reply carries the right recipient and subject.

  5. 05

    Test it with Run once

    Click Run once and the scenario runs a single time. Read the bundles each module received, a bundle being the item that travels from one module to the next.

  6. 06

    Schedule it and switch it on

    Set the clock on the first module, every 15 minutes by default, then flip the scenario switch. From there Make checks the mailbox at that rhythm without you.

Triggers

What starts a Gmail scenario

1 module starts a scenario when something happens in Gmail. A scheduled trigger is checked by Make on the scenario's schedule; an instant one is called by Gmail as soon as it happens.

Gmail1Watch Emails

Watch Emails

Scheduled trigger

In Make“Triggers when a new email is received to be processed according to specified criteria.”

Watch Emails is the starting point of almost every Gmail scenario. It picks up new messages that match the criteria you set and passes each one to the modules that follow.

How it fires
it is a scheduled trigger, which means Make goes and checks the app on the scenario's schedule instead of being notified: every 15 minutes by default, and no faster than that on the Free plan.
When to use it
a shared contact address where every incoming message has to open a record somewhere else.
Watch out
nothing moves until the clock comes round, so test with Run once rather than sitting and waiting.
Modules

What Gmail can do inside a scenario

Gmail gives you 15 modules in 5 groups. For each one: what it does for you, when to reach for it, and what to watch out for.

Actions

10 modules
Gmail1

Send an Email

Action

In Make“Sends a new email.”

Send an Email writes a new message from the connected account and sends it while the scenario runs. The recipient sees ordinary mail coming from your address.

When to use it
a form is filled in outside office hours and the person gets the pricing sheet before anyone has read the notification.
Watch out
mail leaves for real on every run, so point your Run once tests at your own address first.
Gmail2

Reply to an email

ActionIn the docs only

Reply to an email answers a message that is already in the mailbox, so your answer stays inside the same thread instead of opening a new conversation.

When to use it
a request arrives on the contact address and gets a first word back while a human prepares the real answer.
Watch out
it needs a message to answer, so it belongs after Watch Emails or after a search that hands it one.
Gmail3

Search emails

SearchIn the docs only

Search emails goes through the mailbox and brings back what matches, as bundles the following modules work on one after another.

When to use it
a customer calls back about an order and the scenario has to gather every message that quotes the reference.
Watch out
a search returns zero, one or several results, so plan for all three: the rest of the scenario runs once per message it finds.
Gmail4

Get an email

ActionIn the docs only

Get an email pulls one specific message into the scenario so the modules after it have its content to work with.

When to use it
a message reference sits in a tracking tool and someone needs the full mail behind it.
Watch out
it starts from a message you can already point to; while you still do not know which one, Search emails goes first.
Gmail5

Copy an Email

Action

In Make“Copies an email or a draft into a selected folder.”

Copy an Email drops a copy of a message, or of a draft, into the folder you choose. The original stays where it was.

When to use it
keeping an archive folder per client without disturbing the thread the team reads.
Watch out
you end up with two copies, and a scenario that counts messages later will count both.
Gmail6

Move an Email

Action

In Make“Moves a chosen email or a draft to a selected folder.”

Move an Email takes a message or a draft out of its folder and puts it in the one you name. One copy, new place.

When to use it
clearing an invoice out of the main inbox as soon as the scenario has filed it elsewhere.
Watch out
anything further down the scenario that looks for the message in its old folder comes back empty, so move it last.
Gmail7

Modify Email Labels

Action

In Make“Modifies labels on the specified email message.”

Modify Email Labels acts on the message you point it at and changes the labels on it, one specified message at a time.

When to use it
reclassifying one mail after a decision taken further down the flow, rather than tagging everything that goes past.
Watch out
it works on a message that has already been identified, so it sits behind a trigger or a search, never alone at the start.
Gmail8

Mark an Email as Read

Action

In Make“Marks an email or a draft in a selected directory as read by setting the "Read" flag.”

Mark an Email as Read sets the read flag on a message or a draft in the folder you point at, exactly as if someone had opened it.

When to use it
the scenario has already handled the message and there is no reason to leave it bold in front of the team.
Watch out
it changes the mailbox for real, so a Run once test on the wrong message quietly marks something nobody has actually read.
Gmail9

Mark an Email as Unread

Action

In Make“Marks an email or draft in a selected directory as unread by setting the "Unread" flag.”

Mark an Email as Unread pushes a message or a draft back into the unread pile so a person notices it again.

When to use it
one branch of the scenario gives up on a case and wants to hand it back to a human.
Watch out
run the same scenario twice on the same message and it just lands back on unread, so add a check in front of it if that matters downstream.
Gmail10

Delete an Email

Action

In Make“Removes an email or a draft from a selected folder.”

Delete an Email removes a message or a draft from the folder you name. The scenario does not ask for confirmation.

When to use it
clearing out the drafts a test run generated, once the flow is validated.
Watch out
there is no way back from inside Make, so test with Run once on a folder you do not mind emptying before you switch anything on.

Draft

2 modules
Gmail11

Create a Draft

Action

In Make“Creates a new draft and adds it to a selected folder.”

Create a Draft writes a new draft and files it in the folder you select, right where the person who has to send it will look.

When to use it
a shared mailbox where drafts live in their own folder and the team picks from there.
Watch out
this only prepares the message, nothing goes out yet. Someone still has to send it, by hand from Gmail or with the Send a draft email module.
Gmail12

Send a draft email

ActionIn the docs only

Send a draft email takes a draft that already exists and puts it on its way. The writing happened earlier, this module only presses the button.

When to use it
an approval turns green in another tool and the draft that was waiting finally goes out.
Watch out
it needs the draft to exist, so a scenario that creates and sends keeps the two modules in that order.

Attachment

1 module
Gmail13

List email attachments and media

SearchIn the docs only

List email attachments and media reports what came attached to a message, so the scenario knows what it is dealing with before touching a single file.

When to use it
a supplier sends orders as attachments and you want to check something is actually there before filing.
Watch out
like any search it can come back with nothing, one item or several; and on the Free plan a file above 5 MB will not go through the scenario.

Other

1 module
Gmail14

Make an API call

ActionIn the docs only

Make an API call opens the door to the rest of the Gmail API. It sends your own request through the connection already in place, which covers whatever the listed modules leave out.

When to use it
a corner of Gmail no module exposes, when the only other option is leaving Make to write a script.
Watch out
the scopes that request needs have to sit in Additional Scopes on the connection, and that is the step people skip.

Other modules

1 module
Gmail15

Iterate Attachments

Iterator

In Make“Iterates through received attachments.”

Iterate Attachments takes the attachments that arrived together and hands them over one by one: the modules behind it run once per file instead of once per email.

When to use it
a message carrying several documents, each of which has to be filed on its own.
Watch out
every pass counts as an operation, the execution of one module on one item, so a loaded message runs the rest of the chain that many times.
Need help

Need help automating Gmail with Make?

A person reads every message.

FAQ

Questions that come up next

01Is the Gmail Make integration free?
Yes, from the Free plan. Gmail is a standard app, and standard apps are included on every Make plan. What the Free plan limits is the running, not the app: 2 active scenarios, 15 minutes minimum between two scheduled runs, 5 minutes of execution per pass, files up to 5 MB and 512 MB of transfer. A paid plan brings the interval down to 1 minute, lifts the cap on active scenarios and raises execution to 40 minutes. What your plan counts each month are operations, one execution of one module on one item.
02What do you need to connect Gmail to Make?
A Google account, and that is the whole list. Add a Gmail module, click Create a connection, sign in with Google and confirm access. The rest only matters in two cases: Additional Scopes if you plan to call the Gmail API yourself through Make an API call, and Advanced settings if you bring your own Google client credentials. That second path needs the serviceusage.services.enable permission on the Google Cloud project; if you do not have it, ask the project owner or the IAM admin to grant it.
03Does the Gmail trigger react in real time?
No. Watch Emails is a scheduled trigger: Make goes and checks the mailbox on the scenario's schedule, Gmail pushes nothing to Make. A brand new scenario looks every 15 minutes, which is also the Free plan minimum; paid plans go down to 1 minute. Gmail has no instant trigger in Make, the kind where the app notifies Make through a webhook, so there is no lightning badge to look for here. In practice the delay is rarely the problem: set the clock to match how long a person would have taken to open the mailbox.
04What if a module is missing or a limit gets in the way?
Gmail ships Make an API call, which is the way out: it reaches any endpoint of the Gmail API with the connection you already made, so whatever the 16 listed modules do not cover stays within reach. Two conditions. The scopes for that request have to be in Additional Scopes on the connection, since that is where the module draws its rights from. And the request itself is yours to write, the module passes it through as it stands. If the blocker is the version rather than the module, check whether you are on version 4 or still on the older version 2 modules.
05Make or n8n for Gmail?
Both cover Gmail, so the choice is about how you work rather than about the mailbox. Make suits you if you want to see the scenario as a chain of round modules, build it without code and hand it over to someone who is not technical. n8n rewards people who are happy writing a bit of JavaScript and want to host the whole thing themselves. The honest test: open both editors, build the same acknowledgement flow, and keep the one where you understood what you were doing faster.
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