How to Send Gmail Digest Summaries to Slack with Pipedream

pipedream.com > Workflows > New Workflow

Create a new Pipedream Workflow

Go to pipedream.com and sign in. Click the blue 'New Workflow' button in the top-right corner of your dashboard. Give the workflow a name like 'Gmail Digest to Slack' in the name field at the top of the canvas. You'll land on the workflow editor with an empty trigger slot at the top and a '+' button below it for adding steps.

1. 1Click 'New Workflow' in the top-right of the dashboard
2. 2Type a workflow name such as 'Gmail Digest to Slack' in the name field
3. 3Click 'Save' to confirm the name before proceeding

Workflow Canvas > Trigger Slot > Schedule

Set a Schedule Trigger

Click the trigger placeholder at the top of the canvas. In the search box, type 'Schedule' and select the built-in 'Schedule' source — this does not require any connected account. Set the cron expression to '0 8 * * 1-5' for 8:00 AM Monday through Friday, or '0 8 * * 1' for a Monday-only weekly digest. Pipedream shows a human-readable preview of the next 5 scheduled run times so you can confirm the timing is correct before saving.

1. 1Click the trigger placeholder at the top of the canvas
2. 2Type 'Schedule' in the search field and select the 'Schedule' source
3. 3Click 'Custom (cron syntax)' and enter '0 8 * * 1-5' for weekday digests
4. 4Check the 'Next runs' preview to confirm timing
5. 5Click 'Save and continue'

Workflow Canvas > + Step > Gmail > Find Emails > Connect Account

Connect Your Gmail Account

Click the '+' button below the trigger to add a new step. Search for 'Gmail' and select it. Choose the action 'Find Emails' (also listed as 'Search Emails' depending on your Pipedream version). Click 'Connect Account' and authenticate with the Google account that owns the inbox you want to query. Pipedream uses OAuth 2.0 — you'll see a Google consent screen asking for Gmail read access.

1. 1Click '+' below the Schedule trigger
2. 2Search for 'Gmail' and select it from the app list
3. 3Choose the 'Find Emails' action
4. 4Click 'Connect Account' and select or add your Google account
5. 5Accept the Gmail read permissions on the Google consent screen

Workflow Canvas > Gmail Step > Query Field

Configure the Gmail Search Query

In the 'Find Emails' step, fill in the 'Query' field using standard Gmail search operators. To capture emails from the last 24 hours with a specific label, use: 'label:escalation newer_than:1d'. For unread emails from a domain, use: 'from:@enterprise-client.com is:unread newer_than:1d'. Set the 'Max Results' field to 20 — this prevents the Slack message from becoming unreadable if there's a spike in email volume. The results will include the full email metadata for each match.

1. 1Click inside the 'Query' field in the Gmail step
2. 2Type your Gmail search string, e.g. 'label:escalation newer_than:1d'
3. 3Set 'Max Results' to 20
4. 4Click 'Test' to run the step and verify real emails are returned

Workflow Canvas > + Step > Run Node.js Code

Add a Node.js Code Step to Format the Digest

Click '+' below the Gmail step and choose 'Run Node.js code'. This step will take the array of email objects from Gmail and build a formatted Slack Block Kit message. Paste the code provided in the Pro Tip section into the code editor. The step reads from the previous Gmail step's output using the 'steps' object — specifically 'steps.gmail.$return_value' — and maps each email to a Slack block with the sender, subject, timestamp, and a direct link to the thread in Gmail.

1. 1Click '+' below the Gmail Find Emails step
2. 2Select 'Run Node.js code' from the step options
3. 3Paste the formatting code into the code editor
4. 4Click 'Test' to verify the step outputs a valid Slack blocks array

Paste this into the Node.js code step (Step 5) in the Pipedream workflow canvas. It reads the Gmail results array from the previous step, deduplicates against previously-sent message IDs stored in Pipedream's built-in $.db key-value store, builds a Block Kit message, and exports both the blocks array and the email count for the downstream Slack step.

// Pipedream Node.js step — Gmail Digest Formatter with Deduplication
// Reads from Gmail 'Find Emails' step and builds Slack Block Kit blocks
export default defineComponent({

// Pipedream Node.js step — Gmail Digest Formatter with Deduplication
// Reads from Gmail 'Find Emails' step and builds Slack Block Kit blocks

export default defineComponent({
  async run({ steps, $ }) {
    const emails = steps.gmail.$return_value || [];

    if (emails.length === 0) {
      return { blocks: [], email_count: 0 };
    }

    // Load previously sent message IDs from Pipedream's key-value store
    const sentIds = (await $.db.get('sent_message_ids')) || [];

    // Filter out emails already included in a previous digest
    const newEmails = emails.filter(email => !sentIds.includes(email.id));

    if (newEmails.length === 0) {
      return { blocks: [], email_count: 0 };
    }

    // Build the digest date header
    const today = new Date().toLocaleDateString('en-US', {
      weekday: 'long', month: 'short', day: 'numeric'
    });

    const blocks = [
      {
        type: 'header',
        text: {
          type: 'plain_text',
          text: `📬 Gmail Digest — ${today} — ${newEmails.length} email${newEmails.length !== 1 ? 's' : ''}`,
          emoji: true
        }
      },
      { type: 'divider' }
    ];

    // Build one section block per email
    for (const email of newEmails) {
      // internalDate is in milliseconds — convert to seconds for Slack date tokens
      const timestampSeconds = Math.floor(Number(email.internalDate) / 1000);
      const gmailUrl = `https://mail.google.com/mail/u/0/#inbox/${email.threadId}`;

      // Truncate subject and snippet to keep blocks compact
      const subject = (email.subject || '(no subject)').slice(0, 80);
      const snippet = (email.snippet || '').slice(0, 120);
      const from = email.from || 'Unknown sender';

      blocks.push({
        type: 'section',
        text: {
          type: 'mrkdwn',
          text: [
            `*<${gmailUrl}|${subject}>*`,
            `From: ${from}`,
            snippet,
            `<!date^${timestampSeconds}^{date_short_pretty} at {time}|Received>`
          ].join('\n')
        }
      });

      blocks.push({ type: 'divider' });
    }

    // Slack Block Kit hard limit is 50 blocks — enforce it here
    const safeBlocks = blocks.slice(0, 50);

    // Persist the new message IDs so next run skips them
    // Keep only the last 500 IDs to avoid unbounded growth
    const updatedIds = [...sentIds, ...newEmails.map(e => e.id)].slice(-500);
    await $.db.set('sent_message_ids', updatedIds);

    return {
      blocks: safeBlocks,
      email_count: newEmails.length
    };
  }
});

Workflow Canvas > + Step > Flow Control > Filter

Add a Condition to Skip Empty Digests

Click '+' below the code step and choose 'Filter' (listed under 'Flow Control'). Set the condition to check if the email array length is greater than 0. Reference the Gmail step output: use '{{steps.gmail.$return_value.length}}' and set the condition to 'greater than' '0'. This prevents Pipedream from posting an empty 'No new emails' message to Slack on quiet days — which quickly becomes noise that trains your team to ignore the channel.

1. 1Click '+' below the Node.js code step
2. 2Select 'Flow Control' then 'Filter'
3. 3Set the left value to '{{steps.gmail.$return_value.length}}'
4. 4Set the condition to 'greater than' and the right value to '0'
5. 5Click 'Test' with a scenario that has emails to confirm it passes

Workflow Canvas > + Step > Slack > Send Message (Block Kit) > Connect Account

Connect Your Slack Workspace

Click '+' below the Filter step and search for 'Slack'. Select the 'Send Message (Block Kit)' action — not the basic 'Send Message', which only accepts plain text. Click 'Connect Account' and authorize Pipedream to your Slack workspace. You'll be redirected to Slack's OAuth screen where you select the workspace and approve the bot permissions. Pipedream creates a Slack bot named 'Pipedream' that will post the digest.

1. 1Click '+' below the Filter step
2. 2Search 'Slack' and select it
3. 3Choose 'Send Message (Block Kit)'
4. 4Click 'Connect Account' and select your Slack workspace
5. 5Click 'Allow' on the Slack permissions screen

Workflow Canvas > Slack Step > Channel + Blocks Fields

Configure the Slack Message

In the Slack step, set the 'Channel' field to your target channel name or ID — use the format '#ops-alerts' or paste the channel ID (starts with 'C'). In the 'Blocks' field, reference the formatted blocks from your Node.js step: type '{{steps.nodejs.$return_value.blocks}}'. Set the 'Text' field (used as a fallback for notifications) to something like 'Daily Gmail Digest — {{steps.nodejs.$return_value.email_count}} emails'. This fallback text appears in Slack push notifications and in channels that don't render Block Kit.

1. 1Type your channel name in the 'Channel' field, e.g. '#ops-alerts'
2. 2Click the 'Blocks' field and enter '{{steps.nodejs.$return_value.blocks}}'
3. 3Set the 'Text' field to 'Daily Gmail Digest — {{steps.nodejs.$return_value.email_count}} emails'
4. 4Click 'Test' to send a real message to the channel

Workflow Canvas > Step Menu (···) > Add Error Handler

Add Error Handling with a Notification Step

Click the three-dot menu on any step and select 'Add error handler'. Alternatively, add a final Slack step at the workflow level that fires only on failure. Configure it to post to a separate channel like '#automation-alerts' with the error message and workflow name. Without this, a failed Gmail API call — common when tokens expire — will silently stop the digest with no indication to your team.

1. 1Click the three-dot '···' menu on the Gmail step
2. 2Select 'Add error handler'
3. 3Add a Slack step inside the error handler
4. 4Set it to post to '#automation-alerts' with message 'Gmail Digest failed: {{error.message}}'
5. 5Click 'Deploy' to save the error handler

Workflow Canvas > Deploy > Workflow Overview > Run Now

Deploy and Verify the First Run

Click the blue 'Deploy' button in the top-right of the workflow canvas. Pipedream activates the schedule and the workflow is now live. To verify without waiting for the cron time, click 'Run Now' from the workflow overview page — this triggers an immediate execution. Check your Slack channel for the digest message and review the execution log in Pipedream's 'Logs' tab to confirm each step returned a 200 status.

1. 1Click 'Deploy' in the top-right corner of the workflow canvas
2. 2Navigate to the workflow overview page
3. 3Click 'Run Now' to trigger an immediate test execution
4. 4Open the Slack channel to confirm the digest appears
5. 5Click 'Logs' in Pipedream to review the step-by-step execution results