How to Route Gmail Support Emails to Slack with n8n

n8n Canvas > + New workflow

Create a new workflow in n8n

Open your n8n instance (cloud at app.n8n.cloud or self-hosted). Click the orange '+ New workflow' button in the top-left of the canvas. Rename it immediately by clicking 'My workflow' at the top and typing 'Gmail → Slack Support Routing'. Saving the name now prevents confusion when you have multiple workflows running.

1. 1Click '+ New workflow' in the left sidebar
2. 2Click the workflow title 'My workflow' at the top center of the canvas
3. 3Type 'Gmail → Slack Support Routing' and press Enter
4. 4Click 'Save' in the top-right corner

Canvas > Add first step > Gmail > On Message Received

Add the Gmail trigger node

Click the gray 'Add first step' node on the canvas. In the node picker panel that opens on the right, type 'Gmail' in the search box. Select 'Gmail' and then choose 'On Message Received' as the trigger. This trigger polls Gmail on a schedule you define — it is not a push webhook, so there is an inherent delay between email arrival and trigger firing.

1. 1Click the gray 'Add first step' node
2. 2Type 'Gmail' in the search field of the node panel
3. 3Click 'Gmail' in the results list
4. 4Select 'On Message Received' under the Triggers section

Gmail Trigger Node > Parameters > Credential > Create new credential

Connect your Gmail account

In the Gmail Trigger configuration panel, click 'Create new credential' under the Credential field. A modal opens asking you to sign in with Google. Click 'Sign in with Google', choose the Google account that owns your support inbox, and grant n8n the requested Gmail read permissions. The credential is stored encrypted in n8n and reused across nodes.

1. 1Click the 'Credential' dropdown in the Gmail Trigger panel
2. 2Select 'Create new credential'
3. 3Click 'Sign in with Google' in the OAuth modal
4. 4Select your support Google account from the account picker
5. 5Click 'Allow' on the Google permissions screen

Gmail Trigger Node > Parameters > Filters

Filter to support emails only

In the Gmail Trigger parameters, set 'Filters' to narrow which emails fire the trigger. Set 'Label' to 'INBOX' to catch all incoming mail, then add a custom filter in the 'Search' field using Gmail query syntax. Type 'to:[email protected] is:unread' — this ensures only unread emails addressed to your support alias trigger the workflow, ignoring sent items, spam, and already-read threads.

1. 1Scroll to the 'Filters' section in the Gmail Trigger panel
2. 2Set 'Label' to 'INBOX'
3. 3Click '+ Add filter' and select 'Search'
4. 4Type: to:[email protected] is:unread
5. 5Set 'Poll Times' to 'Every Minute' under the trigger schedule

Canvas > + > Code > JavaScript

Add a Code node to format the message

Click the '+' connector below the Gmail Trigger node to add the next node. Search for 'Code' and select the Code node. This is where you parse the raw Gmail data and build the formatted Slack message. The Code node runs JavaScript and gives you full access to the email fields — sender, subject, date, and body snippet. Paste the transformation code from the Pro Tip section below into the JavaScript editor.

1. 1Click the '+' icon below the Gmail Trigger node
2. 2Search for 'Code' in the node picker
3. 3Select 'Code' and choose 'JavaScript' mode
4. 4Click inside the code editor and select all existing placeholder code
5. 5Paste the Pro Tip code from this guide

Paste this into the Code node (Step 5). It decodes the base64 Gmail body, extracts the sender name separately from the email address, formats a human-readable timestamp, truncates the body to 300 characters, and builds both a plain-text Slack message and a Block Kit JSON object so you can choose either format in the Slack node.

// n8n Code Node — Gmail to Slack Support Routing
// Runs in 'Run Once for Each Item' mode
const email = items[0].json;

// n8n Code Node — Gmail to Slack Support Routing
// Runs in 'Run Once for Each Item' mode

const email = items[0].json;

// --- 1. Decode base64 email body ---
let bodyText = '';
try {
  const rawBody = email?.payload?.body?.data || '';
  bodyText = rawBody
    ? Buffer.from(rawBody, 'base64').toString('utf-8').replace(/<[^>]+>/g, '').trim()
    : '[No body content]';
} catch (e) {
  bodyText = '[Body decode failed]';
}

// --- 2. Extract sender name and address separately ---
const fromHeader = (email?.payload?.headers || [])
  .find(h => h.name === 'From')?.value || 'Unknown Sender';
const senderMatch = fromHeader.match(/^(.+?)\s*<(.+)>$/);
const senderName = senderMatch ? senderMatch[1].trim() : fromHeader;
const senderEmail = senderMatch ? senderMatch[2].trim() : fromHeader;

// --- 3. Extract subject ---
const subject = (email?.payload?.headers || [])
  .find(h => h.name === 'Subject')?.value || '(No Subject)';

// --- 4. Format timestamp ---
const receivedMs = parseInt(email?.internalDate || Date.now(), 10);
const receivedDate = new Date(receivedMs).toLocaleString('en-US', {
  month: 'short', day: 'numeric', year: 'numeric',
  hour: '2-digit', minute: '2-digit', timeZoneName: 'short'
});

// --- 5. Truncate body to 300 chars ---
const bodyPreview = bodyText.length > 300
  ? bodyText.substring(0, 300) + '...'
  : bodyText;

// --- 6. Build Gmail deep link ---
const gmailLink = `https://mail.google.com/mail/u/0/#inbox/${email.id}`;

// --- 7. Plain text Slack message ---
const slackMessage =
  `🎫 *New Support Ticket*\n` +
  `*From:* ${senderName} <${senderEmail}>\n` +
  `*Subject:* ${subject}\n` +
  `*Received:* ${receivedDate}\n` +
  `*Preview:* ${bodyPreview}\n` +
  `<${gmailLink}|View in Gmail>`;

// --- 8. Block Kit JSON for rich formatting ---
const slackBlocks = JSON.stringify([
  {
    type: 'header',
    text: { type: 'plain_text', text: '🎫 New Support Ticket', emoji: true }
  },
  {
    type: 'section',
    fields: [
      { type: 'mrkdwn', text: `*From:*\n${senderName}` },
      { type: 'mrkdwn', text: `*Email:*\n${senderEmail}` },
      { type: 'mrkdwn', text: `*Subject:*\n${subject}` },
      { type: 'mrkdwn', text: `*Received:*\n${receivedDate}` }
    ]
  },
  {
    type: 'section',
    text: { type: 'mrkdwn', text: `*Preview:*\n${bodyPreview}` }
  },
  {
    type: 'actions',
    elements: [{
      type: 'button',
      text: { type: 'plain_text', text: 'View in Gmail' },
      url: gmailLink,
      action_id: 'view_gmail'
    }]
  }
]);

return [{
  json: {
    slackMessage,
    slackBlocks,
    senderName,
    senderEmail,
    subject,
    receivedDate,
    bodyPreview,
    gmailLink,
    messageId: email.id,
    threadId: email.threadId
  }
}];

Canvas > + > Gmail > Mark as Read

Mark the email as read to prevent duplicates

Add a Gmail node (not the trigger — a regular action node) after the Code node. Set the action to 'Mark as Read' and pass in the message ID from the trigger output using the expression '{{ $node["Gmail Trigger"].json.id }}'. This tells Gmail to flag the email as read so the trigger won't pick it up again on the next poll cycle. Connect this node between the Code node and the Slack node.

1. 1Click '+' below the Code node
2. 2Search for 'Gmail' and select it
3. 3Set the Action to 'Mark as Read'
4. 4In the 'Message ID' field, click the expression toggle (the pill icon)
5. 5Type: {{ $node["Gmail Trigger"].json.id }}

Canvas > + > Slack > Send a Message

Add the Slack node

Click '+' after the Mark as Read node and search for 'Slack'. Select the Slack node and set the action to 'Send a Message'. Connect your Slack workspace using 'Create new credential' — this opens a Slack OAuth flow where you authorize n8n to post messages. Choose the OAuth 2.0 option, not the Bot Token option, unless you have already created a Slack app with a bot token.

1. 1Click '+' after the Gmail 'Mark as Read' node
2. 2Search 'Slack' and select it
3. 3Set Action to 'Send a Message'
4. 4Click 'Create new credential' under the Credential field
5. 5Click 'Connect' and authorize n8n in the Slack OAuth window that opens

Slack Node > Parameters > Channel / Text

Configure the Slack message content and channel

In the Slack node, set 'Channel' to the exact Slack channel name where tickets should appear — for example '#support-tickets'. In the 'Text' field, click the expression toggle and reference the output from your Code node. Use '{{ $node["Code"].json.slackMessage }}' to pull in the pre-formatted message block. If you want rich block formatting, switch 'Message Type' from 'Text' to 'Block' and reference '{{ $node["Code"].json.slackBlocks }}'.

1. 1Set the 'Channel' field to '#support-tickets' (or your channel name)
2. 2Click the expression toggle next to the 'Text' field
3. 3Type: {{ $node["Code"].json.slackMessage }}
4. 4Optional: Switch 'Message Type' to 'Block' for richer formatting
5. 5If using Block: set Blocks field to {{ $node["Code"].json.slackBlocks }}

Slack Node > Right-click > Add node on error > Slack

Add an error notification node

Click the canvas background to deselect all nodes, then right-click the Slack node and select 'Add node on error'. Add another Slack node and point it to a private '#automation-errors' channel (or your personal DMs). Configure the text to include '{{ $json.message }}' so you see the actual error when something breaks. This ensures silent failures don't leave tickets unrouted.

1. 1Right-click the Slack 'Send a Message' node
2. 2Select 'Add node on error'
3. 3In the new Slack node, set Channel to '#automation-errors' or your Slack user ID
4. 4Set Text to: 'Support routing failed: {{ $json.message }} — check n8n workflow Gmail→Slack'
5. 5Click 'Save' on the canvas

Gmail Trigger Node > Fetch Test Event > Execute Workflow

Test with a real email

Click the Gmail Trigger node and press 'Fetch Test Event' at the bottom of the panel. n8n will poll Gmail immediately and return the most recent unread email matching your filter. If the inbox is empty, send yourself a test email to [email protected] from a different address and wait 30 seconds, then retry. Once you have a test event, click 'Execute Workflow' to run all nodes manually and verify each output.

1. 1Click the Gmail Trigger node to open its panel
2. 2Click 'Fetch Test Event' at the bottom of the panel
3. 3Wait for n8n to return an email sample — it appears as JSON in the 'Output' tab
4. 4Click 'Execute Workflow' in the top toolbar to run all nodes with that test data
5. 5Click each downstream node to verify its Output tab shows the expected data

Canvas > Top-right toggle > Active

Activate the workflow

Once the test run succeeds, click the toggle in the top-right corner of the canvas to switch the workflow from 'Inactive' to 'Active'. The toggle turns green and n8n begins polling Gmail on your configured schedule. You will see executions appear in the 'Executions' tab in the left sidebar as emails arrive. Set a reminder to check the error log after the first 24 hours in production.

1. 1Confirm all nodes show green checkmarks from the test run
2. 2Click 'Save' one final time before activating
3. 3Click the gray 'Inactive' toggle in the top-right corner
4. 4Confirm the toggle turns green and reads 'Active'
5. 5Navigate to 'Executions' in the left sidebar to monitor live runs