How to Send Daily Copper Pipeline Updates to Slack with n8n

n8n Dashboard > New Workflow

Create a new n8n workflow

Log into your n8n instance and click the orange 'New Workflow' button in the top right of the Workflows dashboard. Name it something descriptive like 'Daily Copper Pipeline → Slack'. You'll build the workflow left to right: trigger first, then Copper fetch, then data transformation, then Slack post. Keep this tab open — you'll be switching between n8n and both app credential screens.

1. 1Click 'New Workflow' in the top right of the n8n dashboard
2. 2Click the workflow title at the top and rename it to 'Daily Copper Pipeline → Slack'
3. 3Click the canvas to deselect and confirm the name saved

Canvas > + > Schedule Trigger

Add the Schedule trigger

Click the '+' node button in the center of the canvas to open the node picker. Search for 'Schedule Trigger' and select it. Set the trigger to run on a Cron schedule. For a daily 8:00 AM weekday digest, enter the cron expression '0 8 * * 1-5'. This fires Monday through Friday at 8:00 AM in whatever timezone your n8n server runs in — check your server timezone before setting this.

1. 1Click the '+' button on the blank canvas
2. 2Type 'Schedule' in the search bar and select 'Schedule Trigger'
3. 3Set 'Trigger Interval' to 'Custom (Cron)'
4. 4Enter '0 8 * * 1-5' in the cron expression field
5. 5Click 'Test Step' to confirm the trigger node shows a valid next-run time

Copper App > Settings > Integrations > API Keys

Connect Copper credentials

Add an HTTP Request node (Copper does not have a native n8n node, so you'll call the Copper REST API directly). Click '+' after the Schedule Trigger and search for 'HTTP Request'. In the node settings, you'll need to configure Header Auth with your Copper API key and your registered email. In Copper, go to Settings > Integrations > API Keys to generate a key if you don't have one.

1. 1In Copper, navigate to Settings > Integrations > API Keys
2. 2Click 'Generate API Key' and copy the key
3. 3Back in n8n, add an HTTP Request node after the Schedule Trigger
4. 4In the HTTP Request node, set Authentication to 'Header Auth'
5. 5Add two headers: 'X-PW-AccessToken' with your API key, and 'X-PW-UserEmail' with your Copper account email
6. 6Add a third header: 'X-PW-Application' set to 'developer_api'

HTTP Request Node > Parameters

Fetch open opportunities from Copper

Configure the HTTP Request node to POST to Copper's opportunities search endpoint. Use the URL 'https://api.copper.com/developer_api/v1/opportunities/search'. Set the method to POST and the body to JSON. Send a search payload that filters for open opportunities — set 'assignee_ids' to empty to get all reps, and set 'status' to 'Open'. You can also filter by pipeline ID if you have multiple pipelines and only want one.

1. 1Set Method to 'POST'
2. 2Set URL to 'https://api.copper.com/developer_api/v1/opportunities/search'
3. 3Set Body Content Type to 'JSON'
4. 4Paste the following JSON body: {"page_size": 200, "status": "Open", "sort_by": "close_date", "sort_direction": "asc"}
5. 5Click 'Test Step' to execute the request

Canvas > + after Opportunities Node > HTTP Request

Fetch pipeline stage names

Copper returns 'pipeline_stage_id' as a numeric ID, not a human-readable name. Add a second HTTP Request node to fetch your pipeline stages so you can map IDs to names in the next step. Call GET 'https://api.copper.com/developer_api/v1/pipeline_stages' with the same three auth headers. This returns a flat array of all stages across all pipelines — you'll filter by pipeline ID in the code node.

1. 1Add a new HTTP Request node after the opportunities fetch node
2. 2Set Method to 'GET'
3. 3Set URL to 'https://api.copper.com/developer_api/v1/pipeline_stages'
4. 4Add the same three Copper auth headers as Step 3
5. 5Click 'Test Step' to confirm stage data returns

Canvas > + > Code

Transform data with a Code node

Add a Code node after both HTTP Request nodes. This is where you build the pipeline summary: group deals by stage, sum monetary values, count deals per stage, flag deals closing within 7 days, and resolve stage IDs to stage names using the stages array from Step 5. Connect both HTTP Request nodes into the Code node using n8n's 'Merge' approach — or pass the stages data via a Set node into a variable. The Code node outputs a single structured object ready to format into a Slack message.

1. 1Add a Code node after the pipeline stages HTTP Request node
2. 2Set the Code node language to 'JavaScript'
3. 3Paste the transformation code from the Pro Tip section below
4. 4Click 'Test Step' to verify the output object contains stage summaries and totals

Paste this into the Code node (Step 6). It expects two inputs: index 0 is the opportunities array from Copper, index 1 is the pipeline stages array. It groups deals by stage, sums values, flags deals closing within 7 days, calculates a weighted forecast using win_probability, and returns a single structured object ready for the Slack Block Kit message.

// Code node — expects:
// $input.all()[0] = Copper opportunities array
// $input.all()[1] = Copper pipeline stages array

// Code node — expects:
// $input.all()[0] = Copper opportunities array
// $input.all()[1] = Copper pipeline stages array

const opportunitiesInput = $input.all()[0].json;
const stagesInput = $input.all()[1].json;

// Build a stage ID → stage object map
const stageMap = {};
for (const stage of stagesInput) {
  stageMap[stage.id] = stage;
}

// Group deals by stage
const stageGroups = {};
let totalForecast = 0;
let weightedForecast = 0;
const now = Math.floor(Date.now() / 1000);
const sevenDays = 7 * 24 * 60 * 60;
const closingSoon = [];

for (const deal of opportunitiesInput) {
  const stageId = deal.pipeline_stage_id;
  const stage = stageMap[stageId] || { name: 'Unknown Stage', win_probability: 0 };
  const value = deal.monetary_value || 0;

  if (!stageGroups[stageId]) {
    stageGroups[stageId] = {
      stageName: stage.name,
      dealCount: 0,
      stageTotal: 0,
      winProbability: stage.win_probability || 0
    };
  }

  stageGroups[stageId].dealCount += 1;
  stageGroups[stageId].stageTotal += value;
  totalForecast += value;
  weightedForecast += value * ((stage.win_probability || 0) / 100);

  // Flag deals closing within 7 days
  if (deal.close_date && deal.close_date - now <= sevenDays && deal.close_date >= now) {
    closingSoon.push({
      name: deal.name,
      closeDate: new Date(deal.close_date * 1000).toLocaleDateString('en-US', { month: 'long', day: 'numeric', year: 'numeric' }),
      value: `$${value.toLocaleString()}`,
      stage: stage.name,
      assigneeId: deal.assignee_id
    });
  }
}

// Sort closing-soon by close date ascending
closingSoon.sort((a, b) => a.closeDate.localeCompare(b.closeDate));

// Build stage summary array sorted by total value descending
const stageSummary = Object.values(stageGroups).sort((a, b) => b.stageTotal - a.stageTotal);

const reportDate = new Date().toLocaleDateString('en-US', { weekday: 'long', month: 'long', day: 'numeric', year: 'numeric' });

return [{
  json: {
    reportDate,
    totalDeals: opportunitiesInput.length,
    totalForecast: `$${Math.round(totalForecast).toLocaleString()}`,
    weightedForecast: `$${Math.round(weightedForecast).toLocaleString()}`,
    stageSummary: stageSummary.map(s => ({
      stageName: s.stageName,
      dealCount: s.dealCount,
      stageTotal: `$${Math.round(s.stageTotal).toLocaleString()}`
    })),
    closingSoon,
    hasClosingSoon: closingSoon.length > 0
  }
}];

Canvas > + > Slack > Credentials > Create New

Connect Slack credentials

Add a Slack node after the Code node. Click '+' and search for 'Slack'. Select the 'Send a Message' operation. Click 'Create New Credential' and choose 'OAuth2'. n8n will walk you through authorizing a Slack app — you'll need to either use an existing Slack app with a bot token or create one at api.slack.com/apps. The bot needs the 'chat:write' scope at minimum. If you want the bot to post to private channels, add it to those channels first.

1. 1Add a Slack node after the Code node
2. 2Set Operation to 'Send a Message'
3. 3Click 'Create New Credential' and select 'Slack OAuth2 API'
4. 4Click 'Connect my account' and authorize through the Slack OAuth screen
5. 5Confirm the credential shows a green 'Connected' status

Slack Node > Parameters > Message Type

Configure the Slack message

In the Slack node, set the 'Channel' field to the channel where the digest should post (e.g. '#sales-pipeline' or 'C0123456789' for a channel ID — channel IDs are more reliable than names). Set 'Message Type' to 'Blocks' to use Slack Block Kit for formatted output. You'll build a message with a header section showing the date, a fields section with total deal count and forecast value, and a list of deals closing within 7 days.

1. 1Set 'Channel' to your target Slack channel (e.g. '#sales-pipeline')
2. 2Set 'Message Type' to 'Blocks'
3. 3In the Blocks field, click the expression editor (toggle icon) and paste your Block Kit JSON referencing the Code node output
4. 4Include a header block with today's date using the expression '{{ $now.toFormat("MMMM d, yyyy") }}'
5. 5Add a divider block and a section block for each stage summary

HTTP Request Node > Right-click > Add Error Output

Add error handling with a fallback node

Scheduled workflows that fail silently are worse than no automation. Right-click the HTTP Request node for opportunities and select 'Add Error Output'. Connect that error output to a second Slack node configured to post to a #alerts or #dev-ops channel when the workflow fails. Set a static message like 'Daily pipeline workflow failed — check n8n execution log'. Do the same for the Slack posting node.

1. 1Right-click the Copper opportunities HTTP Request node
2. 2Select 'Add Error Output'
3. 3Add a new Slack node connected to the error output
4. 4Set the channel to a monitoring channel (e.g. '#workflow-alerts')
5. 5Set the message to 'Daily Copper pipeline workflow failed. Check n8n execution log for details.'
6. 6Repeat for the main Slack posting node

n8n Canvas > Test Workflow (top toolbar)

Test the full workflow end-to-end

Click 'Test Workflow' (not 'Test Step') in the top toolbar to run every node in sequence. Watch the execution panel on the right — green nodes passed, red nodes failed. Click any node to inspect its input and output data. Confirm the Slack message arrives in the target channel with correct deal counts, stage names, and forecast totals. Check that the closing-soon list shows only deals within 7 days.

1. 1Click 'Test Workflow' in the top toolbar
2. 2Watch each node turn green in sequence
3. 3Click the Code node to verify 'totalForecast' is a number (not a string)
4. 4Open Slack and confirm the message posted with correct data
5. 5Compare one deal's value in the Slack message against the same deal in Copper

n8n Canvas > Active toggle (top right)

Activate the workflow

Once the test run looks correct, click the toggle in the top right of the n8n editor to switch the workflow from 'Inactive' to 'Active'. n8n will now run this automatically at every scheduled time. Go to the 'Executions' tab to monitor runs. After the first live run the next morning, open that execution and verify the output matches the test run. Set a reminder to check executions manually for the first 3 days.

1. 1Click the 'Inactive' toggle in the top right to flip it to 'Active'
2. 2Confirm the toggle turns green and shows 'Active'
3. 3Navigate to the Executions tab and verify the workflow appears in the upcoming schedule
4. 4Set a calendar reminder to check the Executions tab the following morning