Will this pick up emails that were already in the inbox before I set up the scenario?

No. Make's Watch Emails trigger sets its cursor to the current moment when you first save the module. Emails that existed before that point are ignored. If you need to process historical emails, use Gmail's 'Search Emails' module in a separate one-time scenario run.

What happens if the same email gets posted to Slack twice?

This usually means the 'Modify an Email Labels' module at the end of the chain failed in a previous run, so the email never got the 'routed-to-slack' label and was picked up again. Check your scenario execution history for errors on that module. Also add 'routed-to-slack' to the Watch Emails 'Exclude labels' field as a second layer of protection.

Can I route emails from a shared Google Workspace inbox (support@company.com) instead of a personal Gmail?

Yes, but the Google account you connect in Make's OAuth must have direct access to that inbox — either it owns the inbox or has delegated access granted in Gmail Settings > Accounts > Grant access to your account. Service accounts are not supported through Make's standard Gmail connection.

How many Make operations does this use per month?

Each email processed runs through 4 modules (Gmail trigger, Text Parser, Slack, Gmail label modifier), costing 4 operations. At 200 support emails/month that's 800 operations — well within Make's free tier of 1,000 operations/month. At 500 emails/month you hit 2,000 operations and need the Core plan ($9/month for 10,000 ops).

Can I thread all messages about the same email into one Slack thread instead of posting separate messages?

Yes, but it requires extra steps. On the first Slack post, capture the returned 'ts' timestamp from Slack's API response. Store it in a Make data store keyed by Gmail Thread ID. On subsequent emails in the same thread, look up the stored ts and use Slack's 'Reply to a Thread' action instead of Create a Message.

Beginner~12 min setupCommunication & EmailVerified April 2026

How to Route Gmail Support Emails to Slack with Make

Make watches a Gmail support inbox, extracts key email details, and posts a formatted summary to a designated Slack channel so your team can coordinate a response before replying.

Steps and UI details are based on platform versions at time of writing — check each platform for the latest interface.

Make

Also on:Zapier N8n Power-automate Pipedream

Best for

Small support teams (2–15 people) who receive support email in Gmail and need a shared Slack space to triage and discuss tickets before responding.

Not ideal for

Teams handling 500+ support emails per day — at that volume, a dedicated helpdesk like Zendesk with native Slack integration costs less per ticket and avoids Make's operation count.

Sync type

real-time

Use case type

routing

Real-World Example

💡

A 10-person SaaS company routes all email to [email protected] into a private #support-tickets Slack channel. Before this automation, whoever happened to check Gmail first would claim the email — others had no visibility, and tickets got missed over weekends. Now every new email posts to Slack within 2 minutes with sender, subject, and a truncated preview, and teammates thread their discussion before anyone hits Reply.

What Will This Cost?

Drag the slider to your expected monthly volume.

Monthly workflow runs

/mo

505005K50K

Each platform counts differently — Zapier: 1 task per trigger. Make: 1 operation per module per record. n8n: 1 execution per run.

Prices shown for annual billing. Based on published pricing as of April 2026.

Estimated ROI

1000

min saved/mo

$583

labor value/mo

Free

no platform cost

Based on ~2 min manual effort per operation at $35/hr fully loaded labor cost.

Implementation

Skip the setup

Import this workflow directly into Make

Copy the pre-built Make blueprint and paste it straight into Make. All modules, filters, and field mappings are already configured — you just need to connect your accounts.

Before You Start

Make sure you have everything ready.

Gmail account with full read and label-modify permissions (OAuth scope: gmail.readonly + gmail.labels)

Slack workspace where you are an admin or can install apps, plus the ability to invite bots to channels

Make account on any plan — free plan works but limits polling to 15-minute intervals

A dedicated Gmail label named 'routed-to-slack' already created in Gmail before running the scenario

Target Slack channels (#support-tickets or branch-specific channels) already created and the Make bot invited to each

Field Mapping

Map these fields between your apps.

Field	API Name	Description
Required
Sender Name		Displayed in the Slack message header so teammates immediately know who sent the ticket without opening Gmail.
Sender Email		The reply-to address for the ticket. Include this so teammates can reply directly without switching to Gmail to find the address.
Subject		The email subject line — used as the ticket title in the Slack message and as the Router filter condition for keyword-based routing.
Date		Timestamp of when the email was received. Use Make's formatDate() to convert from Unix timestamp to a readable format before posting.
Body (HTML)		The raw email body passed into the Text Parser module to strip HTML before the plain-text output is truncated for the Slack preview.
Body Preview (truncated)		The Text Parser output, limited to 300 characters via substring(). This is what actually appears in Slack — not the full email body.
Message ID		Gmail's unique identifier for the email. Used in the 'Modify an Email Labels' module to label the exact email that was just routed, preventing duplicate Slack posts.

2 optional fields▸ show

Thread ID		Gmail's thread identifier. Include this in the Slack message as a reference if your team later needs to find the full conversation thread in Gmail.
Attachments		Indicates whether the email has attachments. Post a paperclip emoji or 'Has attachments: Yes' in the Slack message so teammates know to check Gmail for files.

Step-by-Step Setup

make.com > Scenarios > + Create a new scenario

Create a new Make scenario

Log into Make at make.com and click 'Create a new scenario' from your dashboard. You'll land on the visual scenario canvas — a dark grid with a single empty circle in the center. This is where your first module goes. Do not click the clock icon yet; that controls scheduling and you'll set it last.

1Log in at make.com
2Click the blue 'Create a new scenario' button in the top right
3Wait for the canvas to load — you'll see an empty circle labeled 'Add a module'

✓ What you should see: You should see the scenario canvas with one empty module circle and no modules connected yet.

⚠

Common mistake — If you see a 'Select a template' prompt, close it. Templates will pre-fill modules you don't want here.

Canvas > Empty module circle > Search 'Gmail' > Watch Emails

Add Gmail as the trigger module

Click the empty circle on the canvas to open the module picker. Search for 'Gmail' and select it. From the list of Gmail triggers, choose 'Watch Emails' — this is a polling trigger that checks your inbox on a schedule you define. Do not choose 'Watch Email Labels' unless you are routing by label; for this workflow you'll filter by sender address in the next step.

1Click the empty circle on the canvas
2Type 'Gmail' in the search bar
3Click 'Gmail' in the results list
4Select 'Watch Emails' from the trigger options

✓ What you should see: A Gmail module configuration panel opens on the right side of the screen with fields for Connection, Folder, and Criteria.

⚠

Common mistake — Make's Gmail trigger polls every 15 minutes on the free plan. If you need sub-5-minute delivery, you need a Core plan or higher, which allows scheduling down to 1-minute intervals.

Make

click +

search apps

Slack

Add Gmail as the trigger mod…

Slack

module added

Gmail module panel > Connection > Add > Google OAuth

Connect your Gmail account

In the Gmail module panel, click 'Add' next to the Connection field. A Google OAuth popup opens — sign in with the Google account that owns the support inbox. Grant Make permission to read your email. After authorizing, the connection name appears in the dropdown. If the support inbox belongs to a Google Workspace account, sign in with those credentials, not a personal Gmail account.

1Click 'Add' next to the Connection field
2Select the correct Google account in the OAuth popup
3Click 'Allow' on the permissions screen
4Confirm the connection name appears in the Connection dropdown

✓ What you should see: You should see the connection name (usually your email address) selected in the Connection field with no error banners.

⚠

Common mistake — Google Workspace accounts with restricted OAuth may block Make. If you see 'Access blocked,' your Workspace admin needs to whitelist Make's app ID in the Google Admin Console before you continue.

Make settings

Connection

Choose a connection…Add

click Add

Slack

Authorize Make

popup window

✓

Connected

green checkmark

Gmail module panel > Folder > Criteria > Sender Email Address

Configure Gmail filter and folder

Set the Folder field to 'INBOX'. In the 'Criteria' field, choose 'From a specific sender' if you want to route only emails from certain addresses, or leave it on 'All emails' to route everything in the inbox. In the 'Sender Email Address' field (visible when you choose the sender filter), type the domain or specific address — for example, enter '@enterprise-client.com' to catch all email from that domain. Set 'Maximum number of results' to 1 so each run processes one email at a time and you don't create duplicate Slack posts.

1Set Folder to 'INBOX'
2Set Criteria to 'From a specific sender' or 'All emails'
3If filtering by sender, type the address or domain in 'Sender Email Address'
4Set Maximum number of results to 1

✓ What you should see: The module panel shows your folder, criteria, and result limit filled in. No red validation errors visible.

⚠

Common mistake — Filters are the most common place setups break. Double-check the field name and value exactly match what your app sends — a single capital letter difference will block everything.

Slack

trigger

filter

Condition

matches criteria?

yes — passes through

no — skipped

Gmail

notified

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

Add a Text Parser to format the email body

Click the small '+' icon on the right edge of the Gmail module to chain a new module. Search for 'Text Parser' and select the 'HTML to Text' action. Map the Body field from the Gmail module into the HTML input. This strips HTML tags from the email body so your Slack message doesn't contain raw angle brackets and inline styles. Without this step, Slack messages from HTML-formatted emails look broken.

1Click the '+' icon to the right of the Gmail module
2Search 'Text Parser' in the module picker
3Select 'HTML to Text'
4In the HTML field, click the Body variable from the Gmail module output

✓ What you should see: A Text Parser module appears connected to Gmail. The HTML field shows the Gmail Body variable token (displayed as a blue pill).

⚠

Common mistake — Some support emails arrive as plain text with no HTML. The Text Parser still passes them through cleanly, so you don't need a separate branch for plain-text emails.

Message template

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

Canvas > + after Text Parser > Router > Right-click branch > Set filter

Add a Router to separate ticket types (optional but recommended)

Click '+' after the Text Parser module and search for 'Router'. Add it. A Router splits your scenario into multiple branches based on conditions — for example, one branch for billing emails, another for technical support. Right-click each router branch arrow to set a filter condition. Use Gmail's Subject variable and the 'contains' operator to match keywords like 'billing', 'bug', or 'refund'. Route each branch to a different Slack channel in the next steps.

1Click '+' after the Text Parser module
2Search and select 'Router'
3Right-click the first branch arrow and select 'Set up a filter'
4Set Condition: Subject > Contains (case insensitive) > 'billing'
5Repeat for each additional branch with different keywords

✓ What you should see: The Router appears with 2 or more branch arrows extending from it. Each branch shows a filter label (e.g., 'billing') below the arrow.

⚠

Common mistake — If no filter matches an incoming email, Make drops that run silently. Add a final 'catch-all' branch with no filter condition to route unmatched emails to a general #support channel so nothing disappears.

Canvas > + after Router branch > Slack > Create a Message

Add Slack module to post formatted message

On each Router branch (or directly after Text Parser if skipping the Router), click '+' and search for 'Slack'. Select the 'Create a Message' action. Connect your Slack workspace via OAuth when prompted. In the Channel field, type the exact Slack channel name starting with '#' (e.g., '#support-billing'). Build the message text using Make's text editor — combine Gmail variables and plain text to create a readable summary.

1Click '+' on a Router branch
2Search 'Slack' and select it
3Choose 'Create a Message'
4Click 'Add' next to Connection and authorize with your Slack workspace
5Set Channel to '#support-tickets' (or branch-specific channel)
6Build the message body using the field mapping in the next step

✓ What you should see: The Slack module shows your workspace connection, a channel name, and a message body field with at least one Gmail variable mapped in.

⚠

Common mistake — Slack's Create a Message action requires the bot to be invited to the channel first. If the message fails to send with a 'channel_not_found' error, type '/invite @Make' in the target Slack channel before running the scenario.

Message template

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

message template

🔔 New Record: {{text}} {{user}}
channel: {{channel}}
ts: {{ts}}

#sales

🔔 New Record: Jane Smith

Email: [email protected]

Company: Acme Corp

Slack module > Text field > Variable picker + formula editor

Build the Slack message body

In the Slack module's Text field, construct the formatted summary. Use Make's variable picker to insert Gmail fields between plain text. A well-formatted message includes the sender name, sender email, subject line, timestamp, and a truncated body preview. Use Make's substring() formula to limit the body preview to 300 characters — paste it directly in the Text field. The message should be scannable in under 5 seconds.

1Click inside the Text field of the Slack module
2Type '*New Support Ticket* :envelope:' as the header line
3Press Enter and add '*From:* ' then click the 'From Name' variable
4Add ' <' then the 'From Email' variable, then '>'
5Add '*Subject:* ' then the Subject variable
6Add '*Preview:* ' then open the formula editor and type: substring(Text Parser output; 0; 300)

✓ What you should see: The Text field shows a mix of plain text labels and blue variable tokens. The preview formula appears as a function token, not raw text.

⚠

Common mistake — Map fields using the variable picker — don't type field names manually. Hand-typed variable names often have invisible spacing errors that produce blank output.

Message template

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

Canvas > + after Slack module > Gmail > Modify an Email Labels

Add email label to mark routed messages

After the Slack module, add another Gmail module: 'Modify an Email Labels' action. Connect the same Gmail account. Set Message ID to the ID variable from the Watch Emails trigger. In the 'Add Labels' field, select or create a label called 'routed-to-slack'. This prevents Make from picking up the same email on the next poll cycle. Without this step, the same email fires every 15 minutes until Make's internal cursor advances.

1Click '+' after the Slack module
2Search 'Gmail' and select 'Modify an Email Labels'
3Set Connection to the same Gmail connection from step 3
4Set Message ID to the Message ID variable from the Watch Emails trigger
5In 'Add Labels,' type 'routed-to-slack' and press Enter to create it

✓ What you should see: A second Gmail module appears at the end of the chain. The Message ID field shows the blue variable token from the trigger.

⚠

Common mistake — Create the 'routed-to-slack' label in Gmail manually first (Gmail > Settings > Labels > Create new label), otherwise Make can't find it and will throw a 'Label not found' error at runtime.

Message template

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

Scenario canvas > Clock icon (bottom left) > Scheduling settings

Set the polling schedule

Click the clock icon at the bottom left of the scenario canvas. Set the interval based on your plan: free plan minimum is 15 minutes, Core plan allows 1 minute. For most support teams, 5 minutes is the right balance — fast enough to feel timely, slow enough that 30 emails/hour won't consume your operation count quickly. Each scenario run = 1 operation per module per email, so a 4-module chain costs 4 operations per email processed.

1Click the clock icon at the bottom left of the canvas
2Select 'At regular intervals'
3Set the interval to 5 minutes (or 1 minute on Core+)
4Click 'OK'

✓ What you should see: The clock icon shows a checkmark. The scenario status bar at the bottom displays the next scheduled run time.

⚠

Common mistake — The default polling interval is often 15 minutes. If you need faster delivery, check whether your plan supports shorter intervals before assuming it's a bug.

Scenario canvas > Run once button (bottom) > Activate scenario toggle (top right)

Test and activate the scenario

Click 'Run once' at the bottom of the canvas to manually trigger one poll cycle. Send a test email to your support inbox from an external address and wait 60 seconds. Watch the scenario execute — each module shows a speech bubble with a number indicating how many records it processed. Verify the Slack message appears in your channel with correct formatting. Once confirmed, click 'Activate scenario' (the toggle in the top right) to put it on the schedule you set.

1Send a test email to your support inbox from a different email account
2Click 'Run once' at the bottom of the canvas
3Watch each module bubble for a green checkmark or red error indicator
4Check your Slack channel for the test message
5Click the toggle in the top right to activate the scenario

✓ What you should see: Each module shows a green bubble with '1' indicating one record processed. The Slack channel contains a formatted message with the test email's subject, sender, and body preview.

⚠

Common mistake — If Run once picks up 0 emails, Make's internal cursor is set to 'from now' — it only picks up emails newer than when you first saved the trigger. Send a fresh test email after saving the scenario, not before.

Make

▶ Run once

executed

✓

Slack

✓

Gmail

🔔 notification

received

Going live

Production Checklist

Before you turn this on for real, confirm each item.

Confirm 'routed-to-slack' label exists in Gmail and is added to the Watch Emails 'Exclude labels' field to prevent duplicate posts

Set Maximum results to 1 in the Gmail Watch Emails module — higher values cause multiple Slack posts per run and inflate your operation count

Invite the Make Slack bot to every target channel before activating — test each channel with a Run once to confirm delivery

Add an error handler route (wrench icon > Add error handler) on the Slack module so Gmail label-marking still runs even if Slack fails

Set polling interval to 5 minutes minimum on Core plan — 15-minute free plan polling means tickets can sit for 15 minutes before the team sees them

Applies when: polling

Add a catch-all Router branch with no filter condition routing to #support-general so no email silently drops if subject keywords don't match

Monitor your Make operation usage for the first week — a 4-module chain costs 4 operations per email, and a busy inbox at 200 emails/month uses 800 operations

Troubleshooting

Common errors and how to fix them.

Frequently Asked Questions

Common questions about this workflow.

Analysis

VerdictWhy Make for this workflow

Use Make for this if your team is non-technical but needs more flexibility than Zapier provides. Make's visual Router module is the specific reason — you can split incoming emails into 3 or 4 Slack channels based on subject keywords in about 10 minutes, something that costs an extra Zap (and an extra $) in Zapier for each branch. Make also handles the HTML-to-text conversion natively through the Text Parser module, which saves you from building a separate data cleaning step. The one case where you'd skip Make: if your support volume is over 300 emails/day, you're better off connecting Zendesk or Freshdesk directly to Slack — both have native integrations that don't consume per-operation credits.

Cost

Real cost math: this scenario runs 4 modules per email. At 200 emails/month that's 800 operations — covered by Make's free tier (1,000 ops/month). At 500 emails/month you need 2,000 operations, which requires the Core plan at $9/month for 10,000 ops. Compare that to Zapier: their free tier gives you 100 tasks/month total, and each email-to-Slack action is 1 task. At 500 emails/month you're on Zapier's Professional plan at $49/month. Make is $40/month cheaper at that volume for this specific workflow.

Tradeoffs

Zapier's Gmail trigger fires within 1–2 minutes on paid plans versus Make's minimum 5-minute polling on Core — so Zapier wins on speed for high-urgency tickets. n8n handles this with more code flexibility: you can write JavaScript to parse the email body, score urgency, and route conditionally in a single Function node, which Make requires multiple modules to replicate. Power Automate has a native Office 365 / Teams version of this workflow that's better if your org is Microsoft-first — Outlook and Teams connect without OAuth friction in enterprise environments. Pipedream gives you real-time webhook-based Gmail triggering via Gmail push notifications, eliminating polling lag entirely. Make is still the right call for teams that want a visual no-code setup they can hand off to a non-developer to maintain, and where 5-minute latency is acceptable.

Three things you'll hit after launch. First, Gmail's OAuth token expires every 7 days if your Google Workspace has token refresh restrictions set — Make will start throwing 'Invalid credentials' errors and you'll need to reconnect the Gmail module. Check your Workspace admin settings for 'Token duration' under OAuth configurations. Second, Slack's rate limit for bot messages is 1 message per second per channel. If a batch of 10 emails arrives simultaneously at poll time, Make queues the Slack posts and they all go through, but you may see 10–15 second delays on messages 8–10. Third, forwarded emails and auto-replies often match your Watch Emails filter — set up a Gmail filter in your actual inbox to skip messages with 'Auto-Reply' or 'Out of Office' in the subject and apply a separate label, then add that label to Make's Exclude Labels field so auto-replies never hit Slack.

Ideas for what to build next

→
Add a Slack reaction to mark tickets as claimed — Extend the scenario to watch for a specific emoji reaction (e.g., :eyes:) on the Slack message and automatically apply a 'claimed' label in Gmail. This closes the loop so the team knows who is handling each ticket without leaving Slack.
→
Log tickets to a Google Sheet for volume tracking — Add a Google Sheets 'Add a Row' module after the Slack module to write each ticket — sender, subject, timestamp, channel routed to — into a tracking spreadsheet. After 30 days you'll have real data on ticket volume by category, which tells you whether your routing rules are working.
→
Send a daily digest instead of per-email posts — Build a separate scenario with a scheduled trigger (once per day at 9am) that searches Gmail for all emails labeled 'routed-to-slack' in the last 24 hours and posts a single digest message to Slack. This reduces Slack noise for lower-urgency support queues.