How to Forward Gmail Meeting Notes to Slack with Pipedream

pipedream.com > Workflows > New Workflow

Create a new Pipedream workflow

Go to pipedream.com and sign in. Click 'New Workflow' in the top-left of the Workflows dashboard. You'll land on the workflow builder canvas with a single empty trigger block at the top. Give the workflow a name — something like 'Gmail Meeting Notes → Slack' — by clicking the untitled field at the top of the canvas. This name shows up in your workflow list and in Pipedream's error notification emails, so make it descriptive.

1. 1Sign in at pipedream.com
2. 2Click 'New Workflow' in the top-left sidebar
3. 3Click the untitled workflow name field at the top and type 'Gmail Meeting Notes → Slack'
4. 4Click the trigger block labeled 'Add a trigger'

Trigger Block > Search Apps > Gmail > New Email

Add the Gmail trigger

In the trigger block, search for 'Gmail' and select it from the app list. Choose the trigger event 'New Email' — this fires every time a new email lands in the inbox. Pipedream uses Gmail's push notification API here, not polling, so events fire within seconds of email delivery. You'll see a configuration panel on the right side of the screen where you'll connect your account and set filters.

1. 1Click the trigger block on the canvas
2. 2Type 'Gmail' in the search field
3. 3Select 'Gmail' from the app list
4. 4Choose 'New Email' as the trigger event

Trigger Config Panel > Connect Account > Google OAuth

Connect your Gmail account

In the trigger configuration panel, click 'Connect Account' under the Gmail section. Pipedream opens a Google OAuth popup. Sign in with the Gmail account that receives meeting follow-ups — this must be the actual inbox where those emails land. Grant the requested scopes, which include reading mail and managing push notifications. After approving, the account appears in the dropdown labeled with your email address.

1. 1Click 'Connect Account' in the right-side config panel
2. 2Sign in with the Gmail account that receives meeting emails
3. 3Click 'Allow' on the Google permissions screen
4. 4Confirm your email address appears in the account dropdown

Trigger Config Panel > Label > Search > Test Trigger

Configure the Gmail label or search filter

In the trigger config panel, set the 'Label' field to the Gmail label where meeting follow-ups land — for example, 'meeting-notes' or 'INBOX'. If you don't use labels, leave it as 'INBOX' and you'll filter by subject line content in the next code step. Optionally, set the 'Search' field to a Gmail search string like 'subject:(meeting OR follow-up OR action items)' to pre-filter at the trigger level. Click 'Test Trigger' at the bottom of the panel to pull a real email as sample data.

1. 1Set the 'Label' dropdown to 'INBOX' or your specific meeting label
2. 2In the 'Search' field, type: subject:(meeting OR "follow-up" OR "action items")
3. 3Click 'Test Trigger' at the bottom of the config panel
4. 4Select a real meeting email from the results to use as sample data

Canvas > + > Run Node.js Code

Add a Node.js code step to parse and classify the email

Click the '+' button below the trigger block to add a new step. Choose 'Run Node.js code' (not an app). This code step reads the raw email data and does two things: checks whether the email body actually contains meeting-related content, and determines which Slack channel to route it to based on keywords or sender domain. Paste the code provided in the pro tip section below into the code editor. The output of this step — channelId and formattedMessage — gets used by the Slack step next.

1. 1Click the '+' button below the Gmail trigger block
2. 2Click 'Run Node.js code' in the step type list
3. 3Clear the default code in the editor
4. 4Paste the classification and formatting code from the pro tip below
5. 5Click 'Test' to run the step against your sample email

Paste this into the Node.js code step added in Step 5. It decodes the Gmail base64 body, classifies the email as meeting-related using keyword matching, routes it to the correct Slack channel based on sender domain, and builds a formatted mrkdwn message with extracted action items. The function returns 'isMeetingEmail: false' to halt non-meeting emails at the filter step.

import { Buffer } from 'buffer';
export default defineComponent({
  async run({ steps, $ }) {

import { Buffer } from 'buffer';

export default defineComponent({
  async run({ steps, $ }) {
    const email = steps.trigger.event;

    // Decode base64url email body (handles multipart MIME)
    let bodyText = '';
    try {
      const parts = email.payload?.parts;
      if (parts && parts.length > 0) {
        const textPart = parts.find(p => p.mimeType === 'text/plain');
        bodyText = textPart
          ? Buffer.from(textPart.body.data, 'base64url').toString('utf-8')
          : Buffer.from(email.payload.body.data || '', 'base64url').toString('utf-8');
      } else {
        bodyText = Buffer.from(email.payload?.body?.data || '', 'base64url').toString('utf-8');
      }
    } catch (err) {
      $.flow.exit('Could not decode email body: ' + err.message);
    }

    // Meeting classification keywords
    const subject = email.payload.headers.find(h => h.name === 'Subject')?.value || '';
    const meetingKeywords = ['meeting', 'follow-up', 'followup', 'action items', 'recap',
      'minutes', 'call summary', 'discussion summary', 'confirmed', 'kickoff'];
    const isMeetingEmail = meetingKeywords.some(k =>
      subject.toLowerCase().includes(k) || bodyText.toLowerCase().includes(k)
    );

    if (!isMeetingEmail) {
      return { isMeetingEmail: false };
    }

    // Extract sender details
    const fromHeader = email.payload.headers.find(h => h.name === 'From')?.value || '';
    const dateHeader = email.payload.headers.find(h => h.name === 'Date')?.value || '';
    const receivedDate = new Date(dateHeader).toLocaleString('en-US', {
      month: 'short', day: 'numeric', year: 'numeric',
      hour: 'numeric', minute: '2-digit', timeZoneName: 'short'
    });

    // Extract sender domain for channel routing
    const emailMatch = fromHeader.match(/<([^>]+)>/) || [null, fromHeader];
    const senderEmail = emailMatch[1];
    const senderDomain = senderEmail.split('@')[1]?.replace('.com', '').replace('.', '-') || 'general';

    // Channel routing map — update these to match your real Slack channel IDs
    const channelMap = {
      'acmecorp': 'C0123456789',   // #client-acme
      'globexsolutions': 'C9876543210', // #client-globex
      'default': 'C1111111111'    // #meetings-general
    };
    const channelId = channelMap[senderDomain] || channelMap['default'];

    // Extract action items (lines starting with numbered lists or bullet indicators)
    const actionItemRegex = /(?:\d+[.)\s]|[-•*]\s)(.+)/g;
    const actionItems = [...bodyText.matchAll(actionItemRegex)].map(m => m[1].trim());
    const actionBlock = actionItems.length > 0
      ? '*Action Items:*\n' + actionItems.map(a => `• ${a}`).join('\n')
      : bodyText.slice(0, 300).trim() + (bodyText.length > 300 ? '...' : '');

    // Build Slack mrkdwn message
    const isConfirmation = subject.toLowerCase().includes('confirm');
    const emoji = isConfirmation ? '📅' : '📋';
    const label = isConfirmation ? 'Meeting Confirmed' : 'Meeting Follow-up';

    const formattedMessage =
      `*${emoji} ${label}:* ${subject}\n` +
      `*From:* ${fromHeader}\n` +
      `*Received:* ${receivedDate}\n\n` +
      actionBlock;

    return {
      isMeetingEmail: true,
      channelId,
      formattedMessage,
      subject,
      senderEmail,
      receivedDate
    };
  }
});

Canvas > + > Filter

Add a filter step to stop non-meeting emails

Click '+' below the code step and choose 'Filter' from the built-in Pipedream helpers. Set the condition to: steps.classify_email.isMeetingEmail === true. This prevents every email in the inbox from reaching Slack — only emails the code step flagged as meeting-related will continue. Without this filter, your Slack channel fills up with unrelated emails the moment someone's inbox gets a newsletter or receipt.

1. 1Click '+' below the Node.js code step
2. 2Select 'Filter' from the helpers section
3. 3Set the left-hand field to: {{steps.classify_email.$return_value.isMeetingEmail}}
4. 4Set the operator to 'is true'
5. 5Click 'Continue' to save the filter condition

Canvas > + > Slack > Send a Message

Add the Slack step to post the message

Click '+' below the filter step and search for 'Slack'. Select the 'Send a Message' action. In the config panel, connect your Slack workspace via OAuth — click 'Connect Account' and authorize Pipedream's Slack app in your workspace. For the 'Channel' field, reference the output from the code step: {{steps.classify_email.$return_value.channelId}}. For the 'Message Text' field, reference: {{steps.classify_email.$return_value.formattedMessage}}.

1. 1Click '+' below the filter step
2. 2Search for 'Slack' and select it
3. 3Choose 'Send a Message' as the action
4. 4Click 'Connect Account' and authorize Pipedream in your Slack workspace
5. 5Set 'Channel' to {{steps.classify_email.$return_value.channelId}}
6. 6Set 'Message Text' to {{steps.classify_email.$return_value.formattedMessage}}

Slack Step > Advanced Options > Blocks / Username / Unfurl Links

Configure Slack message formatting

In the Slack step config panel, expand 'Advanced Options'. Enable 'Use Blocks' if you want a structured Slack Block Kit message — this looks significantly better than plain text for meeting summaries. Alternatively, the code step can output pre-formatted mrkdwn text with bold sender names and bullet-point action items. Set 'Username' to something like 'Meeting Bot' and upload a bot icon URL if desired. Check 'Unfurl Links' to off — meeting notes often contain calendar links that generate noisy previews.

1. 1Click 'Advanced Options' inside the Slack step config panel
2. 2Set 'Username' to 'Meeting Bot'
3. 3Set 'Unfurl Links' to false
4. 4Set 'Unfurl Media' to false
5. 5If using Block Kit, set 'Blocks' to {{steps.classify_email.$return_value.blocks}}

Workflow Canvas > ••• Menu > Add Error Handler > Slack > Send a Message

Add error handling with a catch step

Click the three-dot menu on the workflow canvas and select 'Add Error Handler'. This creates a parallel branch that runs if any step throws an error. In the error handler, add a Slack step that posts to a private #alerts or #automation-errors channel with the error message and which workflow failed. This is essential for production — without it, a Gmail API hiccup or malformed email silently drops the message with no notification.

1. 1Click the three-dot '•••' menu in the top-right of the workflow canvas
2. 2Select 'Add Error Handler'
3. 3In the error handler branch, click '+' and add a Slack step
4. 4Set the channel to your internal #alerts or #automation-errors channel
5. 5Set the message to: 'Gmail→Slack meeting workflow failed: {{error.message}}'

Canvas > Deploy Button > Events Log

Deploy and verify the live workflow

Click 'Deploy' in the top-right corner of the workflow canvas. The workflow status changes from 'Draft' to 'Active'. Send a real test email to the Gmail account with a subject containing 'meeting notes' or 'action items'. Watch the Pipedream event log (left sidebar > Events) — you should see a new event appear within 30 seconds of sending the email. Click the event to inspect each step's input and output in the execution detail view.

1. 1Click the blue 'Deploy' button in the top-right corner
2. 2Confirm the workflow status shows 'Active'
3. 3Send a real test email to the connected Gmail account
4. 4Click 'Events' in the left sidebar to watch incoming events
5. 5Click the new event entry to open the execution detail view