Can multiple team members use /followup at the same time without conflicts?

Yes. Each Slack command fires a separate webhook POST to Make, and Make runs each scenario execution independently. There's no queue conflict. The only risk is two people creating duplicate tasks for the same contact — there's no deduplication built into this workflow, so set a team norm around who creates tasks for which prospects.

What happens if the contact doesn't exist in Copper yet?

The Copper Search People step returns an empty array, and the Router sends an error message back to Slack. You have two options: extend the scenario to also create a new Copper person record if none is found, or tell your team to add the contact to Copper first. The former adds about 3 more Make modules and increases operations per run.

Can I link tasks to Copper Opportunities (deals) instead of People?

Yes. Change the Related Resource Type field in the Copper Create a Task module from 'person' to 'opportunity', and swap the Search People module for Copper's Search Opportunities module. Everything else stays the same. You'd also update the slash command convention to pass a deal name instead of a contact name.

How do I map the Slack user to the right Copper assignee?

Copper uses numeric user IDs, not Slack usernames. The cleanest approach is to add a Make Data Store with a table mapping Slack user_id to Copper assignee_id — you populate this once manually. In the scenario, do a Data Store lookup using the Slack user_id before the Create a Task module. Without this, all tasks default to the account owner of the API key.

Will this work in private Slack channels?

Slash commands work in private channels, but your Slack bot must be explicitly invited to the private channel with /invite @YourAppName. The chat:write scope alone isn't enough for private channels — if you see 'channel_not_found' errors in Make, that's the cause. Add the bot to the channel and the error clears immediately.

Beginner~12 min setupCommunication & CRMVerified April 2026

How to Create Copper Tasks from Slack with Make

Trigger a Copper task creation instantly when a team member uses a Slack slash command or adds a specific emoji reaction to a message about a prospect.

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

Make

Also on:Zapier N8n Power-automate Pipedream

Best for

Sales teams who discuss deals in Slack and want follow-up tasks in Copper without switching apps mid-conversation.

Not ideal for

Teams already using a native Copper-Slack integration or those who need two-way task sync back into Slack.

Sync type

real-time

Use case type

routing

Real-World Example

💡

A 12-person SaaS sales team discusses prospects in a #pipeline Slack channel. Before this automation, reps had to open Copper separately after each conversation and manually create a follow-up task — about 4 minutes per task, often skipped entirely. Now a rep types /followup @Acme Corp - Send proposal by Friday and a Copper task appears in under 10 seconds, linked to the right person record.

What Will This Cost?

Drag the slider to your expected monthly volume.

Monthly workflow runs

/mo

505005K50K

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

$30/mo if billed monthly

Pipedream

$29/mo

Basic plan

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 account with API access enabled — find your API key under Settings > Integrations > API Keys

Slack workspace where you have permission to create and install apps (workspace admin or app manager role)

Make account on Core plan or higher — free plan delays webhook execution by up to 15 minutes

Copper API key scoped for read (people search) and write (task creation) — the same key covers both

Slack bot token scopes: commands, chat:write, chat:write.public — set under OAuth & Permissions before installing the app

Field Mapping

Map these fields between your apps.

Field	API Name	Description
Required
Task Name	`name`	The core description of what needs to be done — parsed from the text after ' - ' in the slash command
Related Resource Type	`related_resource[type]`	Tells Copper what kind of record to link the task to — use 'person' when matching against a Copper contact
Related Resource ID	`related_resource[id]`	The numeric Copper person ID returned from Search People — this links the task to the correct contact record
Due Date	`due_date`	When the task needs to be completed — Copper requires this in Unix timestamp or ISO 8601 format; use Make's formatDate() to convert

5 optional fields▸ show

Assignee ID	`assignee_id`	The Copper user ID of the person responsible for the task — defaults to the API key owner if left blank, which may not be the Slack user who ran the command
Status	`status`	Initial task status — set to 'Open' for all new tasks created from Slack commands
Priority	`priority`	Task urgency level — can be parsed from the command text (e.g., if the message contains 'urgent') or hardcoded to 'Medium'
Details	`details`	Optional longer description — can include the Slack channel name and user who created the task for full traceability
Remind Date	`remind_date`	Copper can send a reminder before the due date — set this to 1 day before due_date using Make's addDays() formula

Step-by-Step Setup

api.slack.com/apps > Your App > Slash Commands > Create New Command

Create a Slack app and configure a slash command

Go to api.slack.com/apps and click 'Create New App'. Choose 'From scratch', name it something like 'Copper Tasks', and select your workspace. Once created, go to 'Slash Commands' in the left sidebar and click 'Create New Command'. Set the command to /followup and leave the Request URL blank for now — you'll add the Make webhook URL in step 3.

1Go to api.slack.com/apps and click 'Create New App'
2Select 'From scratch', enter app name, choose your workspace
3In the left sidebar click 'Slash Commands'
4Click 'Create New Command' and set command to /followup
5Set Short Description to 'Create a Copper follow-up task' and save

✓ What you should see: You should see the /followup command listed under Slash Commands with a yellow 'Request URL not set' warning — this is expected at this stage.

⚠

Common mistake — The Slack app must be installed in your workspace before slash commands fire. You will install it in step 5 — do not skip to that step early or the OAuth scopes won't be set correctly.

make.com > Scenarios > + Create a new scenario > + > Webhooks > Custom Webhook

Create a new Make scenario

Log into Make at make.com and click '+ Create a new scenario' in the top right of the Scenarios dashboard. When the blank canvas opens, click the large '+' circle in the center to add your first module. Search for 'Webhooks' and select the 'Custom Webhook' module. This will be your trigger — Make will generate a unique HTTPS endpoint that Slack will POST to every time someone uses /followup.

1Click '+ Create a new scenario' in the top right
2Click the '+' circle in the canvas center
3Search for 'Webhooks' and select it
4Choose 'Custom Webhook' as the trigger module
5Click 'Add' to create a new webhook, name it 'Slack Followup Command'

✓ What you should see: Make shows a green webhook URL in a modal, something like https://hook.eu1.make.com/abc123xyz. Copy this URL — you need it in the next step.

api.slack.com/apps > Your App > Slash Commands > Edit /followup

Paste the webhook URL into your Slack slash command

Go back to api.slack.com/apps, open your app, and navigate to 'Slash Commands'. Click the pencil icon next to /followup to edit it. Paste the Make webhook URL you copied into the 'Request URL' field. Slack requires the URL to respond with HTTP 200 within 3 seconds, which Make handles automatically. Save the command.

1Open api.slack.com/apps and select your app
2Click 'Slash Commands' in the left sidebar
3Click the pencil icon next to /followup
4Paste the Make webhook URL into the Request URL field
5Click 'Save'

✓ What you should see: The /followup row now shows your Make URL in the Request URL column. The yellow warning about the missing URL disappears.

⚠

Common mistake — Slack validates the URL on save by sending a test POST. If Make's webhook isn't active yet (scenario not running), the save may still succeed but actual commands will fail silently. Run the scenario in Make before testing the command in Slack.

Make Canvas > Run once button (bottom left)

Test the webhook and capture the Slack payload

In Make, click 'Run once' at the bottom of the scenario canvas — this puts the webhook into listening mode for one trigger. Go to your Slack workspace and type /followup Acme Corp - Send proposal by Friday in any channel. Make will capture the raw payload Slack sends. You'll see the webhook module light up with a data bundle containing fields like text, user_name, channel_id, and user_id.

1In Make, click 'Run once' at the bottom left of the canvas
2Switch to Slack and type /followup Acme Corp - Send proposal by Friday in any channel
3Press Enter to submit the command
4Return to Make and click the webhook bubble to inspect captured data

✓ What you should see: The Custom Webhook module shows a speech bubble with '1' on it. Clicking it reveals the full Slack payload including text: 'Acme Corp - Send proposal by Friday', user_name, and channel_id.

⚠

Common mistake — Slack's slash command payload sends text as a raw string — it does NOT parse the contact name or due date for you. You must parse these yourself using Make's text functions in the next step.

Make

▶ Run once

executed

✓

Slack

✓

Copper

🔔 notification

received

Make Canvas > Click '+' after Webhook > Tools > Set Multiple Variables

Parse the command text into task fields

Add a 'Set Variable' or 'Tools > Set Multiple Variables' module after the webhook. You'll use Make's built-in formula functions to split the text field into a contact name and task description. The convention /followup [Contact] - [Task] works well. Use substring() and indexOf() to extract each part. This step creates two clean variables — contactName and taskNote — that you'll pass to Copper.

1Click the '+' icon to the right of the webhook module
2Search for 'Tools' and select 'Set Multiple Variables'
3Add variable 'contactName' with value: {{trim(substring(1.text; 0; indexOf(1.text; " - ")))}}
4Add variable 'taskNote' with value: {{trim(substring(1.text; add(indexOf(1.text; " - "); 3); length(1.text)))}}
5Click OK to save the module

✓ What you should see: When you run the scenario again with test data, the Set Multiple Variables module shows contactName: 'Acme Corp' and taskNote: 'Send proposal by Friday' as two separate clean values.

⚠

Common mistake — If the Slack message doesn't contain ' - ' as a separator, indexOf() returns -1 and substring() breaks. Add an if() guard in the next step or document the exact command format for your team.

Slack fields

text

user

channel

thread_ts

available as variables:

1.props.text

1.props.user

1.props.channel

1.props.ts

1.props.thread_ts

Make Canvas > '+' > Copper > Search People

Search for the matching contact in Copper

Add a Copper module after the variable parser. Click '+', search for 'Copper', and choose 'Search People'. Connect your Copper account using your Copper API key (found under Copper Settings > Integrations > API). In the Search field, map your contactName variable. This returns the matching Copper person record including their ID, which you need to link the task to the right contact.

1Click '+' after the Set Multiple Variables module
2Search 'Copper' and select it from the app list
3Choose 'Search People' as the action
4Click 'Add' to connect your Copper account, enter your API key
5In the Name field, map {{contactName}} from the previous module

✓ What you should see: The Copper module shows a connected badge and, after a test run, returns a people array with the matched contact's id, name, and email populated in the output bundle.

⚠

Common mistake — Copper's Search People returns an array. If your contact name matches multiple records, you'll get multiple results. The next module will use the first result — make sure your team types exact contact names in the slash command to avoid attaching tasks to the wrong person.

Make Canvas > '+' > Flow Control > Router

Add a Router to handle no-match results

After the Copper Search People module, add a Router. The Router splits the flow into two paths: one where a contact was found (array length > 0) and one where nothing matched. On the 'no match' path, add a Slack 'Send a Message' module that posts an ephemeral error back to the user who ran the command — something like 'No contact found for Acme Corp. Check the spelling and try again.' This prevents silent failures.

1Click '+' after the Copper Search People module
2Search 'Router' under Flow Control and add it
3On Route 1, click the filter icon and set condition: length({{3.array}}) greater than 0
4On Route 2 (the else path), click '+' and add Slack > Send a Message
5Configure the Slack message to post to the original channel_id with the error text

✓ What you should see: The canvas shows two paths branching from the Router. Route 1 continues toward task creation. Route 2 leads to the Slack error message module.

⚠

Common mistake — Copper's Search People module returns an empty array (not an error) when no match is found — Make will NOT automatically stop the scenario. Without this Router, the task creation step will run with a null contact ID and silently create an unlinked task.

Make Canvas > Route 1 > '+' > Copper > Create a Task

Create the Copper task

On Route 1 (contact found), click '+' and add a Copper 'Create a Task' module. Map the fields: set Name to your taskNote variable, set Related Resource Type to 'person', and set Related Resource ID to the id from the first Search People result. Set Assignee to the Copper user ID of whoever ran the command — you'll need a lookup table or a hardcoded default for now. Set Due Date using Make's addDays() formula to set it 3 business days out by default, or parse a date from the command text if your team includes one.

1Click '+' on Route 1 after the Router
2Search 'Copper' and choose 'Create a Task'
3Set Name field to {{taskNote}} from the Set Multiple Variables module
4Set Related Resource Type to 'person' and Related Resource ID to {{3.id}} (first result)
5Set Due Date to {{formatDate(addDays(now; 3); "YYYY-MM-DD")}}

✓ What you should see: After a test run, a real task appears in Copper linked to the matched contact with the name, due date, and status set correctly. You can verify by opening Copper and checking the contact's activity feed.

⚠

Common mistake — Copper tasks require a due date — leaving it blank will throw a 422 validation error. Always provide a fallback date even if the command text doesn't include one.

Make Canvas > Route 1 > '+' > Slack > Send a Message

Send a confirmation message back to Slack

Still on Route 1, add a Slack 'Send a Message' module after the Copper task creation. Post to the channel_id captured from the original webhook payload. Write a confirmation message that includes the task name, contact name, and due date so the user knows it worked. Use Make's formatDate() to display the due date in a readable format. Make this an ephemeral message if you don't want to clutter the channel — use the Send an Ephemeral Message module instead.

1Click '+' after the Copper Create a Task module on Route 1
2Search 'Slack' and choose 'Send a Message' (or 'Send an Ephemeral Message')
3Set Channel to {{1.channel_id}} from the webhook payload
4Set Message to: ✅ Task created in Copper: '{{taskNote}}' for {{contactName}}, due {{formatDate(addDays(now; 3); "MMM D, YYYY")}}
5If using ephemeral, also set User to {{1.user_id}}

✓ What you should see: After the full scenario runs, a confirmation message appears in the Slack channel (or only for the user) within about 5-8 seconds of running /followup.

⚠

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

Email: [email protected]

Company: Acme Corp

Make Canvas > Scheduling > Immediately > Toggle ON

Set the scenario schedule and activate

Since this scenario is webhook-driven, it runs on-demand — not on a schedule. Click 'Scheduling' at the bottom of the canvas and confirm it's set to 'Immediately' (not a cron interval). Toggle the scenario from OFF to ON using the blue toggle in the bottom left. The scenario will now fire within 1-2 seconds every time someone uses /followup in Slack.

1Click 'Scheduling' in the bottom toolbar
2Confirm 'Immediately' is selected (not a fixed interval)
3Click the blue toggle switch in the bottom left to activate the scenario
4Confirm the toggle shows green/ON state

✓ What you should see: The scenario status shows 'ON' in the scenarios list. The next /followup command in Slack triggers a full run visible in the scenario's execution history.

⚠

Common mistake — Make's free plan limits you to 1,000 operations per month and scenarios can only run every 15 minutes on that plan — but webhook-triggered scenarios on paid plans run instantly. If you're on the free plan, switch to at least the Core plan ($9/month) or the webhook will queue and fire up to 15 minutes late.

api.slack.com/apps > Your App > OAuth & Permissions > Install to Workspace

Install the Slack app to your workspace

Go back to api.slack.com/apps and open your app. Click 'OAuth & Permissions' in the left sidebar. Under Bot Token Scopes, add commands, chat:write, and chat:write.public. Then click 'Install to Workspace' at the top of the page and authorize the app. Once installed, the /followup command becomes available in all channels. Test it one final time end-to-end.

1Open your Slack app at api.slack.com/apps
2Click 'OAuth & Permissions' in the left sidebar
3Under Bot Token Scopes, add: commands, chat:write, chat:write.public
4Click 'Install to Workspace' and click 'Allow' on the authorization screen
5Go to any Slack channel and type /followup Test Contact - Final end-to-end test

✓ What you should see: The /followup command appears in Slack's autocomplete. Submitting it creates a task in Copper and sends a confirmation message back within 10 seconds.

⚠

Common mistake — If your Slack workspace requires admin approval for new apps, you'll need a workspace admin to approve the install before anyone else can use /followup. Submit the request through Slack's App Approval flow and notify your admin.

Paste this into a Make 'Tools > Set Multiple Variables' module. It parses the raw Slack text into contactName and taskNote, extracts an optional due date if the user writes 'by [date]', and falls back to 3 days from now. Map the output variables directly into the Copper Create a Task fields.

JavaScript — Custom Function{{-- Variable: contactName --}}

▸ Show code

{{-- Variable: contactName --}}
{{trim(substring(1.text; 0; indexOf(1.text; " - ")))}}
{{-- Variable: taskNote --}}

... expand to see full code

{{-- Variable: contactName --}}
{{trim(substring(1.text; 0; indexOf(1.text; " - ")))}}

{{-- Variable: taskNote --}}
{{if(contains(1.text; " - "); trim(substring(if(contains(1.text; " by "); 1.text; substring(1.text; 0; length(1.text))); add(indexOf(1.text; " - "); 3); if(contains(1.text; " by "); indexOf(1.text; " by "); length(1.text)))); "Follow up")}}

{{-- Variable: dueDateRaw --}}
{{if(contains(1.text; " by "); trim(substring(1.text; add(indexOf(1.text; " by "); 4); length(1.text))); "")}}

{{-- Variable: dueDate (ISO 8601 for Copper API) --}}
{{if(length(dueDateRaw) > 0; formatDate(parseDate(dueDateRaw; "dddd"; "en"); "YYYY-MM-DD"); formatDate(addDays(now; 3); "YYYY-MM-DD"))}}

{{-- Variable: slackContext --}}
{{"Created via Slack by " + 1.user_name + " in channel " + 1.channel_id}}

Going live

Production Checklist

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

Toggle the Make scenario ON before announcing /followup to your team — webhook triggers only fire when the scenario is active

Applies when: webhook

Confirm the Slack bot is invited to every channel where /followup will be used — uninvited bots cannot post confirmation messages

Test with a contact name that has multiple Copper matches and confirm the Router's error path sends a useful Slack message rather than silently picking the wrong record

Set up a Make error notification (Scenario > Settings > Error Notifications) to email you if the Copper API returns a 4xx or 5xx — Copper's API occasionally returns 503 during maintenance windows

Document the exact /followup format for your team: /followup [Exact Contact Name] - [Task Description] — paste it into the slash command's hint field in the Slack app settings so it appears in autocomplete

Verify your Copper API key has not hit its rate limit — Copper allows 1 request per second on most plans; rapid-fire /followup commands within the same second will return 429 errors

Applies when: webhook

Check Make's Operations usage after the first week — each scenario run uses approximately 4-6 operations (webhook + parse + Copper search + Copper create + Slack message)

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 your team wants conditional logic built into the task creation flow — specifically the Router that handles no-match contacts, the text parsing with substring() and indexOf(), and the Slack confirmation message all in one visual canvas. Make's webhook triggers fire in under 2 seconds on paid plans, which matters when a rep is mid-conversation and expects instant feedback. You also get clean error handling without writing a single line of backend code. The one scenario where you'd skip Make: if your team already uses Zapier for everything else and the per-task volume is low. Zapier's Slack trigger handles slash commands the same way and the simpler UI will get a non-technical admin to production faster — at the cost of flexibility.

Cost

Each /followup command consumes roughly 5 Make operations: 1 for the webhook receive, 1 for the Set Multiple Variables, 1 for Copper Search People, 1 for Copper Create a Task, and 1 for the Slack confirmation. At 20 tasks per day across your team, that's 100 operations/day or about 3,000/month. Make's Core plan includes 10,000 operations/month for $9 — you're well under that limit. Zapier would charge per task: at 3,000 tasks/month you'd need the Professional plan at $49/month. Make is $40/month cheaper for the same volume, and that gap grows fast if your team scales.

Tradeoffs

Zapier has one real advantage here: the Slack slash command trigger is pre-built and requires no Slack app setup — Zapier hosts the OAuth and endpoint for you, saving about 20 minutes of Slack app configuration. n8n gives you full JavaScript in a Code node, so parsing complex command formats (e.g., multiple due date syntaxes) is much easier than Make's formula functions. Power Automate has no native Slack trigger — you'd need a third-party connector or a custom HTTP action, which adds friction. Pipedream is worth considering if your team already writes Node.js: their Slack source handles slash commands natively and the Copper API step is cleaner to customize. Make still wins for non-coding teams who need the Router's visual branching and want to maintain the scenario without touching code.

Three things you'll hit after going live. First, Copper's Search People API is case-insensitive but punctuation-sensitive — 'Acme Corp.' and 'Acme Corp' return different results if one has a trailing period. Standardize your Copper contact names before deploying. Second, Slack's slash command POST only stays alive for 3 seconds before timing out on the user's end — Make typically responds in 1-2 seconds on paid plans, but if Copper's API is slow (it does go above 1 second during peak hours), the user sees a timeout error even though the task still gets created in the background. Add a note to your team that a timeout doesn't mean failure. Third, Make's webhook URL is permanent until you delete the webhook module — but if you accidentally recreate the module, you get a new URL and the Slack slash command breaks silently. Keep the webhook URL documented somewhere so you're not hunting for it later.

Ideas for what to build next

→
Add Copper Activity Logging — Extend the scenario to also log an Activity on the Copper contact record when the task is created — this gives managers a full audit trail of when and why tasks were added from Slack.
→
Route by Emoji Reaction Instead of Slash Command — Build a parallel Make scenario using Slack's Events API to watch for a specific emoji reaction (e.g., 📋) on any message — when a rep reacts, the message text becomes the task description automatically without needing a slash command format.
→
Sync Completed Copper Tasks Back to Slack — Use a second Make scenario on a polling trigger to check for Copper tasks marked 'Completed' in the last hour and post a summary to a #wins Slack channel — closes the loop so the team sees follow-through in real time.