How to Send Daily Copper Pipeline Updates to Slack with Pipedream

pipedream.com > Workflows > New Workflow

Create a new Pipedream workflow

Go to pipedream.com and click 'New Workflow' in the top-right corner. You'll land on the workflow canvas, which shows a trigger slot at the top and empty step slots below. Give the workflow a name like 'Daily Copper Pipeline Digest to Slack' — this label shows up in logs and makes debugging faster. Save the name before adding the trigger.

1. 1Click 'New Workflow' in the top-right corner of the Pipedream dashboard
2. 2Click the workflow title field at the top and type 'Daily Copper Pipeline Digest to Slack'
3. 3Press Enter to save the name

Workflow Canvas > Add Trigger > Schedule

Set a daily schedule trigger

Click the 'Add Trigger' slot and search for 'Schedule'. Select the 'Schedule' source from the Pipedream core sources list — not any app-specific trigger. Choose 'Every day' and set the time to 07:00 in your local timezone. Pipedream runs schedule triggers in UTC by default, so if your team is in EST (UTC-5), enter 12:00 UTC to hit 7am EST. Double-check this — a wrong timezone offset means your digest posts mid-afternoon.

1. 1Click the 'Add Trigger' slot on the canvas
2. 2Type 'Schedule' in the search box
3. 3Select 'Schedule' from Pipedream's core sources
4. 4Choose 'Every day' from the interval dropdown
5. 5Set the time field to your target UTC time (e.g. 12:00 for 7am EST)
6. 6Click 'Save and continue'

Workflow Canvas > + Add Step > Run Node.js code

Add a Node.js step to query Copper for open opportunities

Click '+ Add Step' below the trigger and choose 'Run Node.js code'. This step calls the Copper REST API directly — Pipedream has no native Copper app with pre-built actions, so you'll write a short fetch call. You'll use the Copper Opportunities endpoint with a filter for 'Open' status. Store your Copper API key and user email as Pipedream environment variables before writing the code — never hardcode credentials in a step.

1. 1Click '+ Add Step' below the Schedule trigger
2. 2Select 'Run Node.js code' from the step type list
3. 3Click the step title and rename it to 'fetch_copper_opportunities'
4. 4Open Pipedream Settings > Environment Variables and add COPPER_API_KEY and COPPER_USER_EMAIL
5. 5Paste your API fetch code into the code editor (see Pro Tip section)

Workflow Canvas > + Add Step > Run Node.js code

Add a second Node.js step to query Copper for recent activities

Click '+ Add Step' again and add another 'Run Node.js code' step. This step hits the Copper Activities endpoint filtered to the past 24 hours — this powers the 'who logged activity yesterday' section of the digest. Set the min_activity_date filter to Date.now() minus 86400000 milliseconds converted to a Unix timestamp in seconds. Reference the previous step's output using steps.fetch_copper_opportunities.$return_value to get assignee IDs for cross-referencing.

1. 1Click '+ Add Step' below the fetch_copper_opportunities step
2. 2Select 'Run Node.js code'
3. 3Rename the step to 'fetch_copper_activities'
4. 4Set the date filter to yesterday using Math.floor((Date.now() - 86400000) / 1000)
5. 5Click 'Test' to confirm activity records appear in the output panel

Workflow Canvas > + Add Step > Run Node.js code

Add a Node.js step to aggregate pipeline metrics

Add a third 'Run Node.js code' step and rename it 'aggregate_metrics'. This step pulls from both previous steps' outputs and computes: total open pipeline value, count of deals closing within 7 days, and a list of rep IDs who logged zero activity in the past 24 hours. Use steps.fetch_copper_opportunities.$return_value and steps.fetch_copper_activities.$return_value to access prior outputs. Export a clean summary object — this is what gets formatted into the Slack message.

1. 1Click '+ Add Step' below fetch_copper_activities
2. 2Select 'Run Node.js code' and rename it to 'aggregate_metrics'
3. 3Reference prior steps using steps.fetch_copper_opportunities.$return_value and steps.fetch_copper_activities.$return_value
4. 4Export a summary object with totalPipelineValue, dealsClosingThisWeek, and inactiveReps
5. 5Click 'Test' and verify the output panel shows your computed summary object

Workflow Canvas > + Add Step > Slack > Send Message (chat.postMessage)

Connect Slack via a Pipedream Connected Account

Click '+ Add Step' and search for 'Slack'. Select the Slack app and choose the 'Send Message' action. In the step configuration panel, click 'Connect Account' under the Slack section — this opens an OAuth popup that asks you to authorize Pipedream to post messages on behalf of your workspace. You need to be a Slack workspace admin or have the bot:write and chat:write scopes available. Pipedream stores the token under Connected Accounts once authorized.

1. 1Click '+ Add Step' below aggregate_metrics
2. 2Search for 'Slack' in the app search box
3. 3Select the 'Slack' app
4. 4Choose the 'Send Message' action (chat.postMessage)
5. 5Click 'Connect Account' in the step config panel
6. 6Authorize Pipedream in the OAuth popup that appears

Workflow Canvas > Slack Step > Step Configuration Panel

Configure the Slack message content and target channel

In the Slack Send Message step, set the Channel field to your target channel (e.g. #sales-leadership or #pipeline). For the Text field, reference steps.aggregate_metrics.$return_value to build the message body. Use Slack's mrkdwn format for bold and bullet formatting — wrap section headers in *asterisks* and use newline characters to separate sections. Build the message string inside the step's prop fields using Pipedream's expression editor (the double-brace {{ }} syntax).

1. 1Type your channel name in the 'Channel' field (e.g. #sales-leadership)
2. 2Click the 'Text' field and switch to expression mode using the {{ }} toggle
3. 3Reference steps.aggregate_metrics.$return_value.totalPipelineValue for the pipeline total
4. 4Add mrkdwn formatting: wrap section headers in *asterisks*
5. 5Set 'Username' to 'Pipeline Bot' and optionally add a chart emoji as the icon

Workflow Canvas > + Add Step > Slack > Send Message (error fallback)

Add error handling with a fallback notification step

Copper's API occasionally times out or returns 429 rate-limit errors. Without a fallback, a failed run produces a silent failure — no digest posts, no alert. Add a final Slack step below the main Send Message step. In its settings, set it to run 'on failure' using Pipedream's step-level error routing. This fallback step posts a short error message to a separate ops channel (e.g. #automation-alerts) with the error type and timestamp so someone knows the digest failed.

1. 1Click '+ Add Step' below the main Slack Send Message step
2. 2Select 'Slack' > 'Send Message' again
3. 3Click the step settings gear icon and enable 'Run this step on error'
4. 4Set the channel to #automation-alerts
5. 5Set the text to 'Pipeline digest failed at {{steps.trigger.context.ts}} — check Pipedream logs'

Workflow Canvas > Test Workflow (top toolbar)

Test the full workflow end-to-end

Click 'Test Workflow' at the top of the canvas. Pipedream runs all steps in sequence using live data from Copper's API and posts a real message to your Slack channel. Check each step's output panel for errors before checking Slack — the output panel shows exactly what each step returned. Verify the Slack message shows realistic numbers, not nulls or [object Object], which means a field reference path is broken.

1. 1Click the 'Test Workflow' button in the top toolbar
2. 2Watch the step execution status indicators turn green sequentially
3. 3Click each step's output panel to inspect the returned data
4. 4Check your target Slack channel to confirm the digest message posted
5. 5Verify numbers match what you see in Copper's pipeline view

Workflow Canvas > Deploy > Logs Tab

Deploy and verify the schedule

Click 'Deploy' in the top-right corner. The workflow status changes from 'Draft' to 'Active' and the Schedule trigger shows the next run time. Go to the workflow's 'Logs' tab after the first scheduled run to confirm the execution completed without errors. Pipedream retains logs for 30 days on the free tier and indefinitely on paid plans — check logs the morning after deployment to confirm the digest posted at the right time.

1. 1Click the 'Deploy' button in the top-right corner of the canvas
2. 2Confirm the workflow status shows 'Active'
3. 3Note the 'Next run' timestamp shown in the Schedule trigger block
4. 4The following morning, open the workflow's 'Logs' tab to confirm a successful run
5. 5Cross-check the Slack channel to confirm the digest posted at the expected time

Paste this into a single Node.js step called 'fetch_and_aggregate' to replace steps 3–5. It handles Copper API pagination, resolves assignee IDs to names in one batch call, computes weighted forecast, and returns a ready-to-format summary object. Place it directly after the Schedule trigger step on the Pipedream canvas.

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

import axios from 'axios';

export default defineComponent({
  async run({ steps, $ }) {
    const headers = {
      'X-PW-AccessToken': process.env.COPPER_API_KEY,
      'X-PW-UserEmail': process.env.COPPER_USER_EMAIL,
      'X-PW-Application': 'developer_api',
      'Content-Type': 'application/json',
    };

    // Fetch all open opportunities (handles up to 500 via 3 pages)
    let opportunities = [];
    for (let page = 1; page <= 3; page++) {
      const res = await axios.post(
        'https://api.copper.com/developer_api/v1/opportunities/search',
        { page_size: 200, page_number: page, statuses: ['Open'] },
        { headers }
      );
      opportunities = opportunities.concat(res.data);
      if (res.data.length < 200) break; // no more pages
      await new Promise(r => setTimeout(r, 500)); // respect rate limit
    }

    // Fetch users to resolve assignee IDs to display names
    const usersRes = await axios.get(
      'https://api.copper.com/developer_api/v1/users',
      { headers }
    );
    const userMap = {};
    for (const user of usersRes.data) {
      userMap[user.id] = user.name;
    }

    // Fetch yesterday's activities
    const yesterday = Math.floor((Date.now() - 86400000) / 1000);
    const activitiesRes = await axios.post(
      'https://api.copper.com/developer_api/v1/activities/search',
      { page_size: 200, min_activity_date: yesterday },
      { headers }
    );
    const activeUserIds = new Set(
      activitiesRes.data.map(a => a.user_id)
    );

    // Aggregate metrics
    const now = Date.now() / 1000;
    const sevenDays = now + 7 * 86400;
    let totalPipeline = 0;
    let weightedForecast = 0;
    const closingThisWeek = [];
    const allAssigneeIds = new Set();

    for (const deal of opportunities) {
      const value = parseFloat(deal.monetary_value || 0);
      const prob = (deal.win_probability || 0) / 100;
      totalPipeline += value;
      weightedForecast += value * prob;
      allAssigneeIds.add(deal.assignee_id);
      if (deal.close_date && deal.close_date <= sevenDays) {
        closingThisWeek.push({
          name: deal.name,
          value,
          rep: userMap[deal.assignee_id] || `ID:${deal.assignee_id}`,
        });
      }
    }

    const inactiveReps = [...allAssigneeIds]
      .filter(id => !activeUserIds.has(id))
      .map(id => userMap[id] || `ID:${id}`);

    return $.flow.exit({
      totalPipeline: Math.round(totalPipeline),
      weightedForecast: Math.round(weightedForecast),
      closingThisWeek,
      inactiveReps,
      dealCount: opportunities.length,
      date: new Date().toLocaleDateString('en-US', { month: 'long', day: 'numeric', year: 'numeric' }),
    });
  },
});