How to Broadcast Gmail Project Updates to Slack with Make

Gmail > Settings > See all settings > Labels > Create new label

Create a Gmail label for project emails

Before touching Make, set up a Gmail label that will act as the trigger condition. Open Gmail, go to Settings > See all settings > Labels, and click 'Create new label'. Name it something like 'Project Updates' or per-project labels like 'Vendor-Acme'. You can also set up Gmail filters (Settings > Filters and Blocked Addresses) to auto-apply this label to emails from specific senders or containing specific subject keywords. Make will watch this label, so everything you want broadcast must carry it.

1. 1Open Gmail and click the gear icon in the top right
2. 2Click 'See all settings'
3. 3Navigate to the 'Labels' tab
4. 4Scroll to the bottom and click 'Create new label'
5. 5Type 'Project Updates' and click 'Create'

make.com > Scenarios > Create a new scenario

Create a new Make scenario

Log into Make at make.com and click the green 'Create a new scenario' button in the top right of the Scenarios page. You'll land on the visual canvas with a single empty circle in the center — this is where your trigger module goes. Don't click anything else yet. Make autosaves as you build, so there's no need to manually save after each module.

1. 1Log into make.com
2. 2Click 'Scenarios' in the left sidebar
3. 3Click the green '+ Create a new scenario' button
4. 4Wait for the blank canvas to load

Canvas > Click circle > Search 'Gmail' > Watch Emails

Add the Gmail trigger module

Click the large circle on the canvas. In the search box that appears, type 'Gmail' and select the Gmail app. From the list of triggers, choose 'Watch Emails'. This trigger polls Gmail on a schedule you set — every 1, 5, 15, or 30 minutes. You'll be prompted to connect your Google account; click 'Add' and authorize Make to read your Gmail. Make requests only the scopes it needs: gmail.readonly and gmail.labels.

1. 1Click the empty circle on the canvas
2. 2Type 'Gmail' in the module search bar
3. 3Click the Gmail app icon
4. 4Select 'Watch Emails' from the trigger list
5. 5Click 'Add' next to the Connection field and sign in with Google

Gmail module > Label dropdown > Max results > Schedule settings

Configure the Gmail trigger settings

Inside the Watch Emails module, set the Label field to the label you created in Step 1 — click the dropdown and select 'Project Updates'. Set 'Maximum number of results' to 10 (this controls how many emails Make processes per run). Leave 'Mark as read' unchecked unless you specifically want Make to mark emails as read after processing — leaving it unchecked means Gmail's read/unread state stays untouched. Set the polling interval by clicking the clock icon next to the scenario name at the bottom — 5 minutes is a good starting point.

1. 1Click the Label field and select 'Project Updates' from the dropdown
2. 2Set 'Maximum number of results' to 10
3. 3Leave 'Mark as read' unchecked
4. 4Click the clock icon at the bottom of the canvas
5. 5Set the interval to 'Every 5 minutes' and save

Canvas > Gmail module > + > Text Parser > HTML to Text

Add a text parser to extract a body snippet

Gmail's API returns the full HTML or plain-text body, which is too long and messy to dump directly into Slack. Add a 'Text Parser' module after Gmail by clicking the '+' button on the right edge of the Gmail module. Search for 'Text Parser' and select 'HTML to Text'. Connect it and map the Gmail module's 'Body' field (or 'Snippet' if you prefer the first 200 characters Gmail surfaces by default) to the HTML source field. This strips tags and gives you clean readable text for the Slack message.

1. 1Click the small '+' circle on the right edge of the Gmail module
2. 2Search for 'Text Parser' in the module search
3. 3Select 'HTML to Text'
4. 4In the HTML field, click and select '1. Body' from the Gmail output panel on the right

Canvas > Text Parser > + > Router > Filter settings per route

Add a Router for multi-channel broadcasting (optional but recommended)

If you're sending all emails to one Slack channel, skip this step and go to Step 7. If you want emails from different Gmail labels to go to different Slack channels, add a Router module. Click '+' after the Text Parser and search 'Router'. The Router creates parallel paths — one per Slack channel. Click each route's filter icon (the wrench) and set the filter condition: 'Gmail label name' contains 'Project-Acme' routes to #project-acme, and so on. Each route gets its own Slack module.

1. 1Click '+' after the Text Parser module
2. 2Search 'Router' and select it
3. 3Click the wrench icon on Route 1
4. 4Set filter: Field = '1. Labels > Name', Operator = 'Contains', Value = 'Project-Acme'
5. 5Repeat for each additional project label

Canvas > + > Slack > Create a Message > Add Connection

Add the Slack module and connect your workspace

Click '+' after the Text Parser (or after each Router route if using Step 6). Search 'Slack' and select 'Create a Message'. Click 'Add' next to the Connection field and authorize Make with your Slack workspace — you'll be redirected to Slack's OAuth page. Make needs the channels:write and chat:write scopes. Select the workspace and click Allow. You'll return to Make with the connection established.

1. 1Click '+' after the Text Parser or Router route
2. 2Search 'Slack' and click the app icon
3. 3Select 'Create a Message'
4. 4Click 'Add' next to Connection
5. 5Authorize Make in the Slack OAuth window and click 'Allow'

Slack module > Channel > Text field > variable picker

Map Gmail fields to the Slack message

Inside the Slack module, set the Channel field to the target channel (e.g., #project-updates). In the Text field, build your message using Make's variable picker. Click inside the Text field and use the panel on the right to insert Gmail outputs. Construct a message like: '*New Project Email* \n*From:* {{1.from}} \n*Subject:* {{1.subject}} \n*Received:* {{1.date}} \n\n{{2.text}}' where {{1}} is Gmail and {{2}} is Text Parser. This gives Slack a formatted, readable post.

1. 1Click the Channel dropdown and select your target Slack channel
2. 2Click inside the Text field
3. 3Type '*New Project Email*' then press Enter
4. 4Use the right-side panel to insert '1. From', '1. Subject', '1. Date', and '2. Text' variables
5. 5Format with Slack markdown: *bold* labels before each variable

📬 New entry: {{1.name}}
Email: {{1.email}}
Details: {{1.description}}

Canvas > dotted line between Gmail and Text Parser > Set up a filter

Add a subject line filter to exclude noise

Not every email in your 'Project Updates' label will be worth broadcasting — automated receipts, bounce notifications, and reply chains create noise. Add a Filter between the Gmail module and the Text Parser. Click the dotted line between the two modules and select 'Set up a filter'. Add a condition: Subject 'Does not contain' 'Undelivered' AND Subject 'Does not contain' 'Auto-Reply'. Add additional exclusion conditions matching your team's common noise patterns. This keeps Slack clean.

1. 1Click the small dotted segment of the line between the Gmail and Text Parser modules
2. 2Click 'Set up a filter'
3. 3Set Condition 1: Label = '1. Subject', Operator = 'Does not contain', Value = 'Undelivered'
4. 4Click 'Add AND rule'
5. 5Set Condition 2: Label = '1. Subject', Operator = 'Does not contain', Value = 'Auto-Reply'

Canvas > Run once button (bottom left)

Run a test with a real email

Send a test email to your Gmail address with the 'Project Updates' label applied (either manually apply it or trigger your Gmail filter). Back in Make, click 'Run once' at the bottom left of the canvas. Make will poll Gmail immediately, process the email through each module, and show bubble indicators above each module — green means success, red means error. Click any bubble to see the exact data that flowed through that module. Check your Slack channel for the posted message.

1. 1Send a test email to yourself and apply the 'Project Updates' label in Gmail
2. 2Return to Make and click 'Run once' at the bottom left
3. 3Watch the bubbles appear above each module
4. 4Click the bubble above the Slack module to verify the message payload
5. 5Check your Slack channel to confirm the message appeared

Canvas > Toggle switch (bottom left) > Scenarios > History

Activate the scenario

Once your test confirms everything works, click the toggle switch at the bottom left of the canvas — it should change from grey (off) to blue (on). Make will now poll Gmail automatically on the 5-minute schedule you set. You'll see the scenario status change to 'Active' in the Scenarios list. Check the scenario's execution history after 30 minutes to confirm it's running cleanly — go to Scenarios > click your scenario name > History tab.

1. 1Click the grey toggle switch at the bottom left of the canvas
2. 2Confirm it turns blue and reads 'Active'
3. 3Navigate to Scenarios in the left sidebar
4. 4Find your scenario and confirm its status shows 'Active'
5. 5Return after 30 minutes and click the scenario to check the History tab for successful runs

Paste this formula into the Slack module's Text field (replacing the plain variable references) to truncate long email bodies at 500 characters and add a clean ellipsis. In Make, click inside the Text field, delete the current body variable reference, and type this formula directly using the formula toggle (fx icon) for the body portion only.

{{if(
  length(trim(2.text)) > 500,
  concat(

{{if(
  length(trim(2.text)) > 500,
  concat(
    substring(
      trim(2.text),
      1,
      500
    ),
    '...'
  ),
  trim(2.text)
)}}

// Full Slack Text field value:
// *New Project Email*
// *From:* {{1.from}}
// *Subject:* {{1.subject}}
// *Received:* {{formatDate(1.date; 'MMMM D, YYYY h:mm A')}}
//
// {{if(length(trim(2.text)) > 500; concat(substring(trim(2.text); 1; 500); '...'); trim(2.text))}}

// Note: Make formula syntax uses semicolons (;) as argument separators,
// not commas. formatDate wraps the Gmail date in a human-readable format.
// length() and substring() are zero-indexed in Make — index 1 here means
// start at character 1 (Make uses 1-based indexing in substring).