How to Send Daily Close Pipeline Updates 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-right corner. You'll land on the workflow canvas with an empty trigger slot at the top. Give your workflow a name immediately — something like 'Daily Close Pipeline Digest' — using the pencil icon next to 'Untitled Workflow' at the top of the page. Naming it now prevents confusion when you have multiple workflows running.

1. 1Click 'New Workflow' in the top-right corner of the Workflows dashboard
2. 2Click the pencil icon next to 'Untitled Workflow' at the top of the canvas
3. 3Type 'Daily Close Pipeline Digest' and press Enter

Workflow Canvas > Add a trigger > Schedule > Cron Expression

Set the Schedule trigger

Click the 'Add a trigger' block at the top of the canvas. In the trigger search panel, type 'Schedule' and select the 'Schedule' source built into Pipedream. Choose 'Cron Expression' for full control over timing — the simple interval option doesn't let you target specific days of the week. Enter a cron expression for your desired time, for example '0 8 * * 1-5' fires at 8:00 AM UTC Monday through Friday. Adjust the UTC offset to match your team's timezone.

1. 1Click 'Add a trigger' on the canvas
2. 2Type 'Schedule' in the search box and select the Pipedream-native Schedule source
3. 3Select 'Cron Expression' as the schedule type
4. 4Enter '0 8 * * 1-5' in the cron field (adjust UTC offset for your timezone)
5. 5Click 'Save and continue'

Workflow Canvas > + Add a step > Apps > Close > Make API Request

Connect your Close account

Click '+ Add a step' below the trigger block. Search for 'Close' and select the Close app. Choose the action 'Make API Request' — this gives you direct access to Close's REST API, which is more flexible than the pre-built actions for this reporting use case. In the step configuration panel, connect your Close account by clicking 'Connect Account' and entering your Close API key (found in Close under Settings > API). Pipedream stores this as a Connected Account you can reuse across workflows.

1. 1Click '+ Add a step' and search for 'Close'
2. 2Select the Close app from the results
3. 3Choose 'Make API Request' as the action
4. 4Click 'Connect Account' in the step panel
5. 5Paste your Close API key and click 'Connect'

Close Step > Method > URL > Query Parameters

Fetch open pipeline opportunities from Close

In the Close 'Make API Request' step, configure the request to hit the Opportunities endpoint. Set the Method to GET and the URL to 'https://api.close.com/api/v1/opportunity/?status_type=active&_limit=200'. This returns up to 200 active opportunities with their value, status, assigned user, and expected close dates. You'll use this data to calculate pipeline totals and identify deals by rep in later steps. Add a query parameter '_fields' with value 'id,lead_id,lead_name,value,status_label,user_name,date_won,close_date,updated' to keep the response payload small.

1. 1Set Method to 'GET'
2. 2Set URL to 'https://api.close.com/api/v1/opportunity/?status_type=active&_limit=200'
3. 3Add query parameter '_fields' with value 'id,lead_id,lead_name,value,status_label,user_name,date_won,close_date,updated'
4. 4Click 'Test' to run the step and confirm data returns

Workflow Canvas > + Add a step > Apps > Close > Make API Request

Fetch overdue and today's tasks from Close

Add a second Close 'Make API Request' step. This call targets the Tasks endpoint to retrieve activities due today or overdue. Set the URL to 'https://api.close.com/api/v1/task/?is_complete=false&_order_by=due_date&_limit=100'. You'll filter in the next step using JavaScript, but pulling all incomplete tasks here gives you the full dataset. Close tasks include type (call, email, follow-up), due date, assigned user, and the associated lead name — all fields you need for the daily digest.

1. 1Click '+ Add a step' and select Close again
2. 2Choose 'Make API Request'
3. 3Set Method to 'GET'
4. 4Set URL to 'https://api.close.com/api/v1/task/?is_complete=false&_order_by=due_date&_limit=100'
5. 5Click 'Test' to confirm task objects return with due_date and assigned_to fields

Workflow Canvas > + Add a step > Code > Run Node.js code

Add a Node.js step to calculate pipeline metrics

Click '+ Add a step' and choose 'Run Node.js code'. This is the core logic step — it takes the raw Close API responses from steps 4 and 5 and computes the numbers you'll post to Slack. You'll calculate total open pipeline value, count deals per rep, identify deals with close dates that have already passed, and split tasks into 'due today' vs 'overdue' buckets. Paste the code from the pro tip section into this step. The step references previous step outputs using Pipedream's 'steps' object.

1. 1Click '+ Add a step'
2. 2Select 'Code' from the step type options
3. 3Choose 'Run Node.js code'
4. 4Paste the provided code into the editor
5. 5Click 'Test' and confirm the output object contains pipelineTotal, dealsByRep, overdueTasks, and todayTasks keys

Workflow Canvas > + Add a step > Code > Run Node.js code

Format the Slack message with Block Kit

Add another Node.js code step specifically for message formatting. Close API values come back with amount in cents for currency fields — you must divide by 100 to get dollars. Build a Slack Block Kit payload here rather than a plain text string. Block Kit lets you use bold headers, dividers, and bullet lists that render cleanly on both desktop and mobile Slack. This step outputs a single 'blocks' array that the next step passes directly to the Slack API.

1. 1Click '+ Add a step' and select 'Run Node.js code'
2. 2Rename the step to 'format_message' using the step header
3. 3Build the blocks array using the metrics from the previous step output
4. 4Click 'Test' and verify the output contains a valid 'blocks' array with header, section, and divider types

Workflow Canvas > + Add a step > Apps > Slack > Send Message to a Channel

Connect your Slack account

Add a new step and search for 'Slack'. Select the 'Send Message to a Channel' action. Click 'Connect Account' and authorize Pipedream to post to your Slack workspace. Pipedream uses OAuth and will redirect you to Slack's permission screen. Grant the 'chat:write' and 'chat:write.public' scopes — you need both to post to channels your Slack app hasn't been explicitly added to. After authorization, you'll return to Pipedream with a Connected Account badge.

1. 1Click '+ Add a step' and search for 'Slack'
2. 2Select 'Send Message to a Channel'
3. 3Click 'Connect Account' and follow the Slack OAuth flow
4. 4Confirm 'chat:write' and 'chat:write.public' are included in the permission screen
5. 5Click 'Allow' and return to Pipedream

Slack Step > Channel > Notification Text > Blocks

Configure the Slack message step

In the Slack step, select your target channel from the Channel dropdown — for example '#sales-pipeline' or '#daily-standup'. Set the 'Notification Text' field to something like 'Daily Pipeline Update — see below' (this appears in push notifications and desktop alerts). In the 'Blocks' field, reference the output of your format_message step using the expression picker: type '{{' and select 'steps.format_message.$return_value.blocks'. Leave 'Text' blank since you're using blocks. Toggle 'unfurl_links' off to prevent Slack from expanding any lead URLs in the message.

1. 1Select your target Slack channel from the Channel dropdown
2. 2Set Notification Text to 'Daily Pipeline Update — see message below'
3. 3Click into the Blocks field and type '{{' to open the expression picker
4. 4Navigate to steps.format_message.$return_value.blocks and select it
5. 5Set unfurl_links to false

Workflow Canvas > Test Workflow button (top of canvas)

Test the full workflow end-to-end

Click 'Test Workflow' at the top of the canvas to run all steps in sequence using a simulated trigger event. Watch each step go green or red in order. If the Close steps succeed but the Slack step fails, the error message in the step panel will tell you whether it's a channel permission issue or a malformed blocks payload. Once all steps are green, click the Slack channel to confirm the message posted and that formatting looks correct on mobile and desktop. Fix any field alignment or text truncation issues in the format_message code step before deploying.

1. 1Click 'Test Workflow' at the top of the canvas
2. 2Watch each step's status indicator turn green sequentially
3. 3Open your Slack channel and confirm the message rendered correctly
4. 4Check the message on mobile Slack to confirm Block Kit renders cleanly
5. 5Return to Pipedream and fix any formatting issues in the format_message step

Workflow Canvas > Deploy button (top-right)

Deploy the workflow

Click the blue 'Deploy' button in the top-right of the canvas. The yellow 'Draft' badge changes to green 'Active'. Pipedream will now execute this workflow automatically on your cron schedule. Verify the next scheduled run time shown in the trigger block matches your intention — for '0 8 * * 1-5' UTC, you should see the next weekday at 08:00 UTC listed. Set up a Pipedream error alert under Settings > Notifications so you get an email if the workflow fails silently on a given morning.

1. 1Click the blue 'Deploy' button in the top-right corner
2. 2Confirm the badge changes from yellow 'Draft' to green 'Active'
3. 3Check the trigger block for the 'Next run' timestamp
4. 4Go to Settings > Notifications and enable error email alerts
5. 5Wait for the first scheduled run and confirm the Slack message arrives

Paste this into a single Node.js code step between your Close fetch steps and the Slack step. It handles pagination for pipelines over 200 deals, splits tasks into overdue vs. today buckets, formats currency correctly, and builds the full Block Kit payload in one pass. Reference it downstream in the Slack step as steps.build_digest.$return_value.blocks.

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

import axios from 'axios';

export default defineComponent({
  async run({ steps, $ }) {
    const apiKey = steps.fetch_opportunities.$auth.api_key;
    const authHeader = 'Basic ' + Buffer.from(apiKey + ':').toString('base64');

    // Paginate Close opportunities if > 200 deals exist
    let allOpps = [];
    let skip = 0;
    const limit = 200;
    while (true) {
      const res = await axios.get('https://api.close.com/api/v1/opportunity/', {
        headers: { Authorization: authHeader },
        params: {
          status_type: 'active',
          _limit: limit,
          _skip: skip,
          _fields: 'id,lead_name,value,status_label,user_name,close_date,updated',
        },
      });
      const data = res.data?.data ?? [];
      allOpps = allOpps.concat(data);
      if (data.length < limit) break;
      skip += limit;
    }

    // Pipeline totals
    const pipelineTotal = allOpps.reduce((sum, o) => sum + (o.value || 0), 0) / 100;
    const today = new Date();
    today.setHours(0, 0, 0, 0);

    const overdueDeals = allOpps.filter(o => o.close_date && new Date(o.close_date) < today);

    // Group deals by rep
    const byRep = {};
    for (const opp of allOpps) {
      const rep = opp.user_name || 'Unassigned';
      if (!byRep[rep]) byRep[rep] = { count: 0, value: 0 };
      byRep[rep].count++;
      byRep[rep].value += (opp.value || 0) / 100;
    }

    // Split tasks
    const rawTasks = steps.fetch_tasks.$return_value?.data ?? [];
    const todayStr = today.toISOString().split('T')[0];
    const overdueTasks = rawTasks.filter(t => t.due_date && t.due_date < todayStr);
    const todayTasks = rawTasks.filter(t => t.due_date && t.due_date === todayStr);

    const fmt = (n) => n.toLocaleString('en-US', { style: 'currency', currency: 'USD', maximumFractionDigits: 0 });

    // Build Block Kit payload
    const blocks = [
      {
        type: 'header',
        text: { type: 'plain_text', text: `📊 Daily Pipeline Update — ${today.toDateString()}` },
      },
      { type: 'divider' },
      {
        type: 'section',
        fields: [
          { type: 'mrkdwn', text: `*Total Open Pipeline*\n${fmt(pipelineTotal)}` },
          { type: 'mrkdwn', text: `*Active Deals*\n${allOpps.length}` },
          { type: 'mrkdwn', text: `*Overdue Deals*\n${overdueDeals.length}` },
          { type: 'mrkdwn', text: `*Tasks Due Today*\n${todayTasks.length}` },
        ],
      },
      { type: 'divider' },
      {
        type: 'section',
        text: { type: 'mrkdwn', text: '*Pipeline by Rep*' },
      },
      ...Object.entries(byRep).map(([rep, data]) => ({
        type: 'section',
        text: {
          type: 'mrkdwn',
          text: `• *${rep}*: ${data.count} deals — ${fmt(data.value)}`,
        },
      })),
      { type: 'divider' },
      {
        type: 'section',
        text: { type: 'mrkdwn', text: `*Overdue Tasks (${overdueTasks.length})*` },
      },
      ...overdueTasks.slice(0, 10).map(t => ({
        type: 'section',
        text: {
          type: 'mrkdwn',
          text: `⚠️ ${t.type} — *${(t.lead_name || 'Unknown').slice(0, 40)}* | ${t.assigned_to || 'Unassigned'} | Due: ${t.due_date}`,
        },
      })),
      { type: 'divider' },
      {
        type: 'section',
        text: { type: 'mrkdwn', text: `*Due Today (${todayTasks.length})*` },
      },
      ...todayTasks.slice(0, 10).map(t => ({
        type: 'section',
        text: {
          type: 'mrkdwn',
          text: `📋 ${t.type} — *${(t.lead_name || 'Unknown').slice(0, 40)}* | ${t.assigned_to || 'Unassigned'}`,
        },
      })),
    ];

    return { blocks, pipelineTotal, dealCount: allOpps.length };
  },
});