Beginner~12 min setupCommunication & CRMVerified April 2026
Slack logo
Copper logo

How to Send Daily Copper Pipeline Updates to Slack with Make

Every morning, Make pulls deal data from Copper, formats a pipeline summary with forecasts and activity counts, and posts it to a Slack channel automatically.

Steps and UI details are based on platform versions at time of writing — check each platform for the latest interface.

Best for

Sales teams of 5–30 people who run their CRM in Copper and want leadership to see a pipeline snapshot every morning without anyone pulling a manual report.

Not ideal for

Teams needing real-time deal alerts — use a webhook-based Copper-to-Slack trigger for that instead.

Sync type

scheduled

Use case type

reporting

Real-World Example

💡

A 12-person B2B SaaS sales team uses this to post a 7am pipeline digest to #sales-leadership every weekday. Before automation, the sales manager spent 20–30 minutes each morning pulling deal data from Copper and copying numbers into a Slack message by hand. Now the scenario runs at 6:55am, pulls all open opportunities grouped by stage, and posts a formatted summary with total pipeline value, deals closing this week, and yesterday's activity count — all before the team's standup.

What Will This Cost?

Drag the slider to your expected monthly volume.

/mo
505005K50K

Each platform counts differently — Zapier: 1 task per trigger. Make: 1 operation per module per record. n8n: 1 execution per run.

Prices shown for annual billing. Based on published pricing as of April 2026.

Estimated ROI

1000

min saved/mo

$583

labor value/mo

Free

no platform cost

Based on ~2 min manual effort per operation at $35/hr fully loaded labor cost.

Implementation

Skip the setup

Import this workflow directly into Make

Copy the pre-built Make blueprint and paste it straight into Make. All modules, filters, and field mappings are already configured — you just need to connect your accounts.

Before You Start

Make sure you have everything ready.

Copper API key — found in Copper under Settings > Integrations > API Keys. You need Admin access in Copper to generate one.
Copper Google Workspace email — the exact email you use to log into Copper. Required alongside the API key for Make's Copper connection.
Slack app installation permissions — your Slack admin must allow new app connections, or you need to be a Slack admin yourself. Make needs chat:write and channels:read scopes.
Make account with an active plan — the Free plan supports scheduled scenarios but limits you to 1,000 operations/month. A team running this daily across 100+ deals will need the Core plan ($9/month).
A dedicated Slack channel for pipeline updates — create #pipeline-digest or #sales-leadership before setup so you have the exact channel name ready to paste.

Field Mapping

Map these fields between your apps.

FieldAPI Name
Required
Deal Namename
Monetary Valuemonetary_value
Close Dateclose_date
Pipeline Stagepipeline_stage_id
4 optional fields▸ show
Assigneeassignee_id
Win Probabilitywin_probability
Last Activity Datedate_last_contacted
Company Namecompany_name

Step-by-Step Setup

1

make.com > Scenarios > Create a new scenario

Create a new Make scenario

Log into Make at make.com and click the blue 'Create a new scenario' button in the top right of the Scenarios dashboard. You'll land on an empty canvas with a single grey circle in the middle — that's your trigger placeholder. This scenario will run on a schedule, not in response to an event, so you won't be connecting a webhook here. Name the scenario 'Daily Copper Pipeline to Slack' using the pencil icon near the top left so it's easy to find later.

  1. 1Click the blue 'Create a new scenario' button in the top right
  2. 2Click the pencil icon next to 'New scenario' and type 'Daily Copper Pipeline to Slack'
  3. 3Click the grey circle in the canvas center to open the module picker
What you should see: You should see a blank canvas with the module search dialog open and your scenario name saved in the top bar.
Common mistake — Don't click 'Use a template' — templates for Copper are outdated and will add extra modules you'll need to delete.
2

Canvas > Module picker > Tools > Schedule

Add the Schedule trigger

In the module picker, search for 'Schedule' and select the built-in 'Schedule' trigger — it's listed under the Tools category, not under any specific app. This trigger fires your scenario at whatever interval you set. Click the module after adding it to configure timing. Set it to run at 6:55am Monday through Friday in your team's local timezone. Make sure the timezone dropdown matches your team's location — it defaults to UTC, which will catch most people off guard.

  1. 1Type 'Schedule' in the module search bar
  2. 2Click 'Schedule' under the Tools section
  3. 3Click the Schedule module on the canvas to open settings
  4. 4Set 'Run scenario' to 'At regular intervals' and choose 'Days'
  5. 5Set time to 06:55, check Mon–Fri only, and set timezone to your team's local zone
What you should see: The Schedule module should show your configured time and days in a small summary below the module icon on the canvas.
Common mistake — Make's Schedule trigger uses a 24-hour clock. Entering '6:55' without specifying AM/PM correctly defaults to 06:55 — double-check this or your digest will fire at 6:55 PM instead.
Make
+
click +
search apps
Slack
SL
Slack
Add the Schedule trigger
Slack
SL
module added
3

Canvas > + > Copper > Search Opportunities

Connect Copper and search for open opportunities

Click the '+' button to the right of the Schedule module to add the next module. Search for 'Copper' and select the 'Search Opportunities' action. You'll be prompted to create a Copper connection — click 'Add' and enter your Copper API key and your Google Workspace email address (the one you use to log into Copper). Copper's API key is found in Copper under Settings > Integrations > API Keys. After connecting, configure the search to return opportunities with a status of 'Open' so you're only pulling active pipeline.

  1. 1Click the '+' icon to the right of the Schedule module
  2. 2Search 'Copper' and select the Copper app
  3. 3Choose 'Search Opportunities' as the action
  4. 4Click 'Add' next to the Connection field to create a new connection
  5. 5Paste your Copper API key and Google email, then click 'Save'
  6. 6Set the 'Status' filter to 'Open'
What you should see: After saving the connection, you should see 'Connected' appear next to your email address and the module fields will populate with Copper field options.
Common mistake — Copper requires both an API key AND the matching Google Workspace email for authentication — using a personal Gmail will fail even if the API key is valid.
4

Canvas > Copper: Search Opportunities module > Limit field

Set result limit and sort order

Still inside the 'Search Opportunities' module, scroll down to the 'Limit' field and set it to 500. This ensures you're capturing the full pipeline if your team has a large number of open deals. Set the sort field to 'Close Date' ascending so the most time-sensitive deals surface first in your data. If you leave the limit at the default (which is often 10 or 20), your summary totals will be wrong because you'll only be aggregating a fraction of your pipeline.

  1. 1Scroll to the 'Limit' field inside the Search Opportunities module
  2. 2Type '500' in the Limit field
  3. 3Set 'Sort By' to 'Close Date'
  4. 4Set 'Sort Direction' to 'Ascending'
  5. 5Click 'OK' to save the module
What you should see: The module card on the canvas should show the filter summary: 'Status: Open, Limit: 500, Sort: Close Date ASC'.
5

Canvas > + > Tools > Numeric Aggregator

Add a numeric aggregator for pipeline totals

Click '+' after the Copper module and add a 'Numeric Aggregator' from the Tools section. This module will iterate over every opportunity returned by Copper and add up a value you choose — in this case, the deal monetary value. Map the 'Value' field to Copper's opportunity monetary value output (it will appear in the dynamic field picker as something like '{{3.monetary_value}}'). The aggregator will output a single total you can reference in your Slack message. Label this aggregator 'Total Pipeline Value' using the module label field.

  1. 1Click '+' after the Copper Search Opportunities module
  2. 2Search 'Numeric Aggregator' and select it from Tools
  3. 3Set 'Source Module' to the Copper Search Opportunities module
  4. 4Map the 'Value' field to '{{copper.monetary_value}}' from the dynamic picker
  5. 5Set the label to 'Total Pipeline Value'
  6. 6Click 'OK' to save
What you should see: The Numeric Aggregator appears on the canvas and shows 'Source: Copper – Search Opportunities' in its summary line.
Common mistake — Copper returns monetary values as strings in some API responses, not numbers. If your aggregator total comes back as 0 or NaN, wrap the value in Make's parseNumber() formula: parseNumber({{3.monetary_value}}).
6

Canvas > + > Tools > Numeric Aggregator

Add a second aggregator for deal count

Add a second 'Numeric Aggregator' module after the first one, but set its source back to the same Copper Search Opportunities module (step 3). This time, map the 'Value' field to the number 1 — just type '1' directly in the field. Every iteration adds 1, giving you a total count of open deals. This count will appear in your Slack message alongside the pipeline dollar total. Label this module 'Open Deal Count'.

  1. 1Click '+' after the Total Pipeline Value aggregator
  2. 2Add another Numeric Aggregator from Tools
  3. 3Set 'Source Module' to Copper Search Opportunities (the same source as step 5)
  4. 4Type '1' directly in the 'Value' field
  5. 5Label the module 'Open Deal Count'
  6. 6Click 'OK'
What you should see: You now have two aggregator modules on the canvas side by side, both sourced from the Copper search module.
Common mistake — If you set the source module to the first Numeric Aggregator instead of Copper directly, you'll get a count of 1 every time — always source count aggregators back to the original iterator.
7

Canvas > + (parallel branch) > Copper > Search Opportunities

Add a filter for deals closing this week

Before the Slack message step, add a separate Copper 'Search Opportunities' module that filters for deals with a close date within the current week. Click '+' from the canvas (not from the aggregator chain — add a parallel branch by clicking on empty canvas space and connecting it to the first Copper module output). Set the close date filter to use Make's built-in date formula: set Close Date 'greater than or equal to' {{formatDate(now; 'YYYY-MM-DD')}} and Close Date 'less than or equal to' {{formatDate(addDays(now; 7); 'YYYY-MM-DD')}}. Set the limit to 100. Add a Numeric Aggregator after this to count those deals — label it 'Closing This Week'.

  1. 1Click on empty canvas space to deselect all modules
  2. 2Click '+' to add a new module not connected to the aggregator chain
  3. 3Add another Copper 'Search Opportunities' module
  4. 4Set Status filter to 'Open'
  5. 5Add Close Date >= {{formatDate(now; 'YYYY-MM-DD')}}
  6. 6Add Close Date <= {{formatDate(addDays(now; 7); 'YYYY-MM-DD')}}
  7. 7Add a Numeric Aggregator after it, value = 1, label 'Closing This Week'
What you should see: You'll see a second branch on the canvas running parallel to the first, ending in its own aggregator module.
Common mistake — Make's formatDate uses semicolons as separators inside formulas (not commas). Using a comma here — formatDate(now, 'YYYY-MM-DD') — will throw a parse error when you try to run the scenario.
Slack
SL
trigger
filter
Deal Stage
matches criteria?
yes — passes through
no — skipped
Copper
CO
notified
8

Canvas > + > Slack > Create a Message

Connect all branches to a Slack module

Now you need to merge your aggregated values into one Slack message. Add a 'Slack: Create a Message' module at the end of the canvas and connect it manually to all three aggregator modules by dragging the connection handles. In the Channel field, type the exact Slack channel name where you want to post (e.g. #sales-leadership). In the Text field, you'll build the message using the output variables from each aggregator. Use the dynamic variable picker to pull in the totals from each aggregator module.

  1. 1Click '+' and search for 'Slack', then choose 'Create a Message'
  2. 2Connect the Slack module to all three aggregator outputs by dragging connector lines
  3. 3Authenticate Slack by clicking 'Add' next to the Connection field and authorizing via OAuth
  4. 4Set 'Channel' to your target channel name (e.g. #sales-leadership)
  5. 5Build the message text using the field mapping described in step 9
What you should see: The Slack module should show all three aggregator modules connected to it as incoming paths, and the Connection field should show your Slack workspace name.
Common mistake — Slack's OAuth in Make requires the channels:write and chat:write scopes — if your Slack admin has restricted app installations, you'll need IT approval before the connection will succeed.
9

Canvas > Slack: Create a Message > Text field

Build the Slack message template

In the Slack module's Text field, paste your message template using Slack's mrkdwn formatting. Use the dynamic variable picker to insert values from your aggregators. A working template is shown in the pro_tip_code section below. At minimum, include: total open deal count, total pipeline value formatted as currency, and deals closing this week. Use Make's formatNumber() formula to add commas and currency symbols to the monetary total — raw Copper values come through as plain integers like 142500.

  1. 1Click inside the Text field of the Slack module
  2. 2Type or paste your message template
  3. 3Use the dynamic picker (click the variable icon) to insert aggregator output values
  4. 4Wrap monetary values in formatNumber({{5.result}}; 2; '.'; ',') to format as currency
  5. 5Click 'OK' to save the module
What you should see: The Text field should show a mix of static text and orange dynamic variable tokens representing your aggregated Copper data.
Common mistake — Map fields using the variable picker — don't type field names manually. Hand-typed variable names often have invisible spacing errors that produce blank output.
Message template
📬 New entry: {{1.name}}
Email: {{1.email}}
Details: {{1.description}}
message template
🔔 New Record: {{text}} {{user}}
channel: {{channel}}
ts: {{ts}}
#sales
🔔 New Record: Jane Smith
Company: Acme Corp
10

Canvas > Run once button (bottom left)

Run a test and verify the Slack message

Click 'Run once' in the bottom left of the Make canvas. Make will execute the scenario immediately using live Copper data. Watch the execution flow — each module should show a green checkmark and a bubble with the number of records processed. Click on the Slack module bubble to verify the message content before it goes to your actual channel. If everything looks correct, check Slack to confirm the message arrived in the right channel with the right numbers.

  1. 1Click the blue 'Run once' button in the bottom-left toolbar
  2. 2Watch each module light up with a processing indicator
  3. 3Click the bubble above the Slack module to inspect the outgoing message payload
  4. 4Open Slack and check the target channel for the test message
  5. 5Verify deal count, pipeline total, and closing-this-week count match what you'd expect from Copper
What you should see: The Slack channel should show a new message with your pipeline summary. Each number in the message should match what you'd see in Copper's pipeline view.
Common mistake — The test message posts to your real Slack channel — give your team a heads up or temporarily point the channel to a private #test channel before running.
Message template
📬 New entry: {{1.name}}
Email: {{1.email}}
Details: {{1.description}}
Make
▶ Run once
executed
Slack
Copper
Copper
🔔 notification
received
11

Canvas > Scheduling toggle (bottom left) > Scenario History tab

Activate the scenario and confirm scheduling

Toggle the scenario from 'Off' to 'On' using the switch in the bottom-left corner of the canvas. Make will now run the scenario automatically at your configured schedule. Click on the Schedule module one more time to confirm the time, days, and timezone are exactly right. Then go to the scenario's 'History' tab to verify the next scheduled run time is what you expect. Scenarios that are 'On' will also show a blue indicator next to their name in the Scenarios list.

  1. 1Click the grey toggle switch in the bottom-left to activate (it turns blue)
  2. 2Click the Schedule module to double-check time and timezone settings
  3. 3Click 'Scenario Detail' in the top menu, then open the 'History' tab
  4. 4Confirm the 'Next run' timestamp matches your intended schedule
What you should see: The scenario status in the Scenarios list should show as 'Active' with a blue indicator, and the History tab should show a pending next-run timestamp.

Paste this formula into Make's Text field inside the Slack: Create a Message module. It builds the full pipeline digest with currency formatting, weighted forecast calculation, and a stale deal flag — all using Make's native formula syntax without any external code steps.

JavaScript — Custom Function*📊 Daily Pipeline Report — {{formatDate(now; 'dddd, MMM D')}}*
▸ Show code
*📊 Daily Pipeline Report — {{formatDate(now; 'dddd, MMM D')}}*
*Open Pipeline:* {{6.result}} deals | ${{formatNumber(5.result; 0; '.'; ',')}} total
*Weighted Forecast:* ${{formatNumber(round(multiply(5.result; divide(averageWinProbability; 100))); 0; '.'; ',')}}

... expand to see full code

*📊 Daily Pipeline Report — {{formatDate(now; 'dddd, MMM D')}}*

*Open Pipeline:* {{6.result}} deals | ${{formatNumber(5.result; 0; '.'; ',')}} total
*Weighted Forecast:* ${{formatNumber(round(multiply(5.result; divide(averageWinProbability; 100))); 0; '.'; ',')}}
*Closing This Week:* {{7.result}} deal(s)

*Stage Breakdown:*
• Proposal Sent: {{if(contains(3.pipeline_stage_id; 'Proposal'); 1; 0)}} deal(s)
• Negotiation: {{if(contains(3.pipeline_stage_id; 'Negotiation'); 1; 0)}} deal(s)
• Discovery: {{if(contains(3.pipeline_stage_id; 'Discovery'); 1; 0)}} deal(s)

*⚠️ Stale Deals (no activity 7+ days):*
{{if(dateDifference(now; parseDate(3.date_last_contacted; 'YYYY-MM-DD'); 'days') > 7; '• ' + 3.name + ' — Last contact: ' + formatDate(3.date_last_contacted; 'MMM D'); '')}}

Scaling Beyond 300+ open opportunities in Copper+ Records

If your volume exceeds 300+ open opportunities in Copper records, apply these adjustments.

1

Increase the Copper search limit to 500

Make's Copper Search Opportunities module defaults to a low result count. For teams with 300+ open deals, set the limit to 500 explicitly. If you have more than 500 open deals, you'll need to add pagination logic using Copper's page_number parameter and a Make iterator — the aggregator alone won't capture everything.

2

Watch your operation count

Each record returned by Copper counts as one operation as it passes through modules. A scenario with 5 modules running against 300 deals uses 1,500 operations per run, roughly 7,500 per week. Make's Core plan includes 10,000 operations/month — you'll hit that ceiling in 5 weeks with this volume. The Pro plan at $16/month gives you 40,000 operations and is worth it at this deal count.

3

Use Make's data store to cache stage names

Copper returns pipeline_stage_id as a numeric ID, not a human-readable stage name. At high volume, doing an individual lookup API call per deal to resolve stage names will consume operations fast. Instead, load your stage ID-to-name mapping once into a Make data store at the start of the scenario and reference it locally for each deal.

Going live

Production Checklist

Before you turn this on for real, confirm each item.

Troubleshooting

Common errors and how to fix them.

Frequently Asked Questions

Common questions about this workflow.

Analysis

VerdictWhy Make for this workflow

Use Make for this if you want to aggregate data across multiple Copper API calls and format it into a structured Slack message without writing backend code. Make's visual canvas makes it straightforward to run parallel branches — one for total pipeline value, one for deal count, one for closing-this-week — and merge them all into a single Slack post. It also handles Copper's pagination quirks better than Zapier because you can build iterator loops natively. The one scenario where you'd skip Make: if your team already runs everything in Power Automate and has a Microsoft 365 license, Power Automate can do this for $0 incremental cost instead of $9/month.

Cost

The cost math is straightforward. This scenario has roughly 6 modules. Running against 150 open deals, that's 900 operations per run. Five days a week = 4,500 operations/week = ~18,000 operations/month. Make's Free plan allows 1,000 operations/month — you'll exceed that in two days. The Core plan at $9/month gives you 10,000 operations, which handles up to ~83 open deals at this module count. If you have 200+ open deals, you need the Pro plan at $16/month (40,000 operations). Zapier would cost $19.99/month minimum for a multi-step scheduled Zap, so Make is cheaper at every tier here.

Tradeoffs

Zapier has one real advantage: its 'Schedule by Zapier' trigger is simpler to configure and less likely to have timezone mistakes. n8n handles this better than Make if you want to write JavaScript to calculate weighted forecasts or format complex message blocks — the Code node gives you full control that Make's formula syntax can't match. Power Automate's 'Recurrence' trigger is more reliable for enterprise environments with strict scheduling requirements, and it connects to Copper via HTTP actions if you use the API directly. Pipedream is the best choice if you want to store historical pipeline snapshots in a database alongside posting to Slack. Make still wins for this specific use case because the visual branch-and-merge approach maps directly to how the workflow is structured — pull data in parallel, aggregate, post once.

Three things you'll hit after the scenario goes live. First, Copper's API rate limit is 600 requests per minute — you won't hit it with one scenario, but if you duplicate this for multiple teams, you will. Second, pipeline_stage_id comes back as a numeric ID in Make's Copper module, not a label like 'Proposal Sent'. You need to either hardcode a mapping or do a secondary API call to Copper's /pipeline_stages endpoint. Third, Copper's date_last_contacted field is unreliable for activity tracking — it only updates when contacts are explicitly logged, not when emails are sent via Gmail. If your team relies on Gmail integration for activity, verify this field actually reflects real rep activity before using it in a stale deal flag.

Ideas for what to build next

  • Add a weekly digest variantDuplicate the scenario and change the Schedule trigger to run once on Monday mornings with a 30-day lookback window. Post this to a #weekly-pipeline channel for a broader review cadence that complements the daily summary.
  • Add error notificationsClick the wrench icon on any module and add an error handler route that posts a message to a private #automation-alerts Slack channel if the scenario fails. Right now, if Copper's API times out, your team gets no message and no warning.
  • Log pipeline snapshots to Google SheetsAdd a Google Sheets module at the end of the scenario to append each day's pipeline totals to a spreadsheet. After 30 runs, you'll have a historical trend you can chart — something neither Copper nor Slack gives you out of the box.

Related guides

Was this guide helpful?
Slack + Copper overviewMake profile →