Will this trigger if a deal is moved back to an earlier stage?

Yes. The Pipedrive 'Updated' webhook fires on any stage change regardless of direction. If you only want to notify on forward progress, add a condition in the Router branch filter that checks the previous stage ID is lower than the current stage ID — you'll need to know your stage IDs in order to set this up.

Can I notify a specific Slack user (like the deal owner) instead of a channel?

Yes, but it requires an extra step. Use Make's Slack 'Find a User' module to look up the user by their email address (map the Pipedrive owner email from the Get a Deal output). Then use the returned user ID in the Slack 'Send a Message' channel field — Slack accepts user IDs as DM recipients. This adds one operation per run.

How many Make operations does one deal stage change consume?

Four operations at minimum: 1 for the Pipedrive trigger, 1 for Get a Deal, 1 for the Router, and 1 for the Slack Send a Message module. If you add an early-exit filter between the trigger and Get a Deal, filtered-out events consume only 1 operation (the trigger) instead of 4, which matters if you have a high volume of non-stage deal updates.

What happens if Slack is down when a deal stage changes?

Make will log an incomplete execution. With 'Allow storing incomplete executions' enabled in Scenario Settings, you can manually re-run failed executions from the Execution History tab once Slack recovers. Make does not automatically retry webhook-triggered scenarios — you have to trigger the re-run manually.

Can I use this across multiple Pipedrive pipelines?

Yes. The 'Watch Events' trigger fires for deals across all pipelines. Add a pipeline_id check as an additional AND condition in each Router branch filter to make sure stage ID 10 in Pipeline A doesn't accidentally trigger the same branch as stage ID 10 in Pipeline B — Pipedrive stage IDs are unique across the account, but double-checking with pipeline_id is safer.

Beginner~12 min setupCommunication & CRMVerified April 2026

How to Send Pipedrive Deal Stage Alerts to Slack with Make

Triggers a formatted Slack channel message the moment a deal moves to a new pipeline stage in Pipedrive, with deal value, owner, and stage details included.

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 of 5–50 reps who need instant, stage-specific Slack alerts without building internal tooling.

Not ideal for

Teams that only care about Won/Lost events — a simpler single-trigger Zapier zap covers that in less time.

Sync type

real-time

Use case type

notification

Real-World Example

💡

A 12-person B2B SaaS sales team routes deal-stage alerts to three separate Slack channels: #deals-early-stage, #deals-negotiation, and #wins. Before this automation, managers pulled up Pipedrive twice a day to check pipeline movement and still missed same-day stage changes 30% of the time. Now every stage change posts within 90 seconds, including deal value and the rep's name, so managers can jump into deal reviews while context is fresh.

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.

Pipedrive account on Essential plan or higher — API access is required for webhooks and is not available on the free trial

Pipedrive API token with read access to Deals, Pipelines, Stages, and Users

Slack workspace admin rights or permission to install OAuth apps — needed to authorize Make's Slack connection

Make account with at least the Free tier — Free supports instant webhooks but caps at 1,000 operations/month; Core ($9/mo) is recommended for active sales teams

Slack channels created in advance for each pipeline stage you want to notify on (e.g., #deals-qualified, #deals-negotiation, #wins)

Field Mapping

Map these fields between your apps.

Field	API Name	Description
Required
Deal ID	`id`	Unique identifier for the deal — used to construct the direct Pipedrive link in the Slack message
Deal Title	`title`	The deal name as entered by the rep — primary identifier in the Slack notification
Deal Value	`value`	Monetary value of the deal — critical context for managers assessing pipeline impact
Current Stage ID	`stage_id`	Numeric ID of the stage the deal just moved into — used in Router branch filters to direct messages to the right Slack channel
Stage Name	`stage_name`	Human-readable stage label — displayed in the Slack message body so recipients don't need to interpret an ID
Owner Name	`owner_name`	Full name of the deal owner — tells the team who is responsible and who to congratulate or assist

4 optional fields▸ show

Currency	`currency`	Currency code (USD, EUR, GBP) — pair with value to display correctly formatted amounts
Pipeline ID	`pipeline_id`	Numeric ID of the pipeline the deal belongs to — needed when multiple pipelines share stage names to prevent cross-pipeline routing errors
Expected Close Date	`expected_close_date`	Projected close date — adds urgency context to the Slack message, especially useful for Negotiation and Proposal stages
Deal Status	`status`	Open, Won, or Lost — used specifically in the Won branch filter as an alternative or supplement to stage ID filtering

Step-by-Step Setup

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 your Scenarios dashboard. You'll land on a blank canvas with a large '+' icon in the center — this is where you add your trigger module. Give the scenario a name now by clicking the default title at the top of the screen (e.g., 'Untitled Scenario') and typing something like 'Pipedrive → Slack Deal Stage Alerts'. Naming it early prevents confusion if you have multiple scenarios running.

1Click 'Create a new scenario' in the top right
2Click the pencil icon next to the default scenario title
3Type a descriptive name like 'Pipedrive → Slack Deal Stage Alerts'
4Press Enter to save the name

✓ What you should see: You should see a blank canvas with your named scenario title and a single '+' module placeholder in the center.

Canvas > + > Search: Pipedrive > Watch Events (Instant)

Add the Pipedrive 'Watch Events' trigger

Click the central '+' on the canvas to open the module picker. Search for 'Pipedrive' and select it. From the list of triggers, choose 'Watch Events (Instant)' — this is a webhook-based trigger, not polling, so it fires within seconds of a stage change. Do not choose 'Watch Deals' (scheduled polling) — that adds up to 15 minutes of delay. You'll be prompted to connect your Pipedrive account if you haven't already.

1Click the '+' module placeholder on the canvas
2Type 'Pipedrive' in the search bar
3Select 'Pipedrive' from the results
4Click 'Watch Events (Instant)' from the trigger list
5Click 'Add' to create a new Pipedrive connection

✓ What you should see: A Pipedrive module appears on the canvas with a clock/lightning icon indicating it is an instant (webhook) trigger. A connection dialog opens asking for your Pipedrive API credentials.

⚠

Common mistake — Make registers a webhook in Pipedrive automatically, but only if your Pipedrive account has API access enabled. Free Pipedrive plans do not include API access — you need at least the Essential plan.

Make

click +

search apps

Slack

Add the Pipedrive 'Watch Eve…

Slack

module added

Pipedrive module > Connection > Add > API Token

Connect your Pipedrive account

In the connection dialog, click 'Add' and enter your Pipedrive API token. Find your API token in Pipedrive under your profile avatar > Personal Preferences > API. Copy the token and paste it into Make's connection field. Name this connection something identifiable like 'Pipedrive - [Your Company]' so you can reuse it across other scenarios. Click 'Save' to establish the connection.

1Open Pipedrive in a new tab
2Click your avatar in the top right > Personal Preferences > API
3Copy your API token
4Return to Make and paste the token into the API Token field
5Click 'Save' to confirm the connection

✓ What you should see: The connection dropdown now shows your Pipedrive account name. The module configuration panel stays open for event selection.

⚠

Common mistake — If your company uses Pipedrive's EU data center (app.eu.pipedrive.com), select 'EU' in the data center dropdown before entering your token — using the wrong region will authenticate but return empty webhook payloads.

Make settings

Connection

Choose a connection…Add

click Add

Slack

Authorize Make

popup window

✓

Connected

green checkmark

Pipedrive module > Event Object: Deal > Event Action: Updated

Configure the trigger for deal stage changes

With the Pipedrive module open, set the 'Event Object' to 'Deal' and the 'Event Action' to 'Updated'. This captures every deal update — including stage changes. Make will now receive a webhook payload every time any deal field changes. You'll filter specifically for stage changes in a later step using a Router, so don't try to filter here. Leave 'Current User Only' unchecked so the trigger fires regardless of which rep owns the deal.

1Set 'Event Object' dropdown to 'Deal'
2Set 'Event Action' dropdown to 'Updated'
3Leave 'Current User Only' unchecked
4Click 'OK' to save the module configuration

✓ What you should see: The Pipedrive trigger module on the canvas shows 'Watch Events (Instant) - Deal Updated' as its label.

⚠

Common mistake — The 'Updated' event fires for ANY deal field change — title edits, value updates, note additions. The Router in Step 6 is what isolates actual stage changes. Skipping the Router means your Slack channel gets flooded with every minor deal edit.

Canvas > Hover Pipedrive trigger > Drag connector > Search: Pipedrive > Get a Deal

Add a Pipedrive 'Get a Deal' module to fetch full deal data

The Watch Events payload includes change metadata but not the full deal record. Add a second Pipedrive module: 'Get a Deal'. Connect it to the trigger by hovering over the trigger module's right edge and dragging the connector arrow to a new module. In the 'Deal ID' field, map the ID from the trigger output — click inside the field, then select 'ID' from the trigger's data panel on the right. This fetches the complete deal record including deal title, value, owner name, pipeline, and current stage.

1Hover over the right edge of the Pipedrive trigger module until an arrow appears
2Click the arrow to add a connected module
3Search for 'Pipedrive' and select 'Get a Deal'
4Click inside the 'Deal ID' field in the module config
5Select '1. ID' from the trigger output panel on the right side

✓ What you should see: A second Pipedrive module labeled 'Get a Deal' appears connected to the trigger. The Deal ID field shows the mapped value as '{{1.id}}'.

Canvas > Add Module > Flow Control > Router

Add a Router to split by pipeline stage

Add a Router module after 'Get a Deal' — search for 'Router' in the module picker (it's under Flow Control, not an app). The Router lets you create separate branches for each stage you want to notify on: Qualified, Proposal Sent, Negotiation, Won. Each branch will point to a different Slack channel. Click the '+' on each Router branch to name it — use the stage name as the branch label for clarity. You can have up to 10 branches on a single Router.

1Click the right edge of the 'Get a Deal' module to add a new module
2Search 'Router' in the module picker
3Select 'Router' under Flow Control
4Click the Router to open it — you'll see two default branches
5Add additional branches with the '+' button for each stage you want to handle

✓ What you should see: A diamond-shaped Router module appears connected to 'Get a Deal' with two or more outgoing branches visible on the canvas.

⚠

Common mistake — Router branch order matters — Make evaluates them top to bottom and stops at the first match. Put your most specific conditions (e.g., 'Won') before general catch-all branches, or a broad filter will consume events that should route elsewhere.

Router > Branch wrench icon > Filter setup

Set filter conditions on each Router branch

Click the wrench icon on the first Router branch to open its filter. Set the filter to: 'Stage ID' (from the Get a Deal output) 'Equal to' [your target stage ID]. To find stage IDs, go to Pipedrive > Settings > Pipeline > hover over each stage — the ID appears in the URL. Repeat for each branch, using the stage ID that corresponds to that channel. For the 'Won' branch, you can alternatively filter on 'Status' equals 'won' instead of a stage ID, which is more reliable.

1Click the wrench icon on the first Router branch
2Set condition field to '2. Stage ID' from the Get a Deal module output
3Set operator to 'Equal to (number)'
4Enter the numeric stage ID (find it in Pipedrive > Settings > Pipeline)
5Click 'OK' to save the filter, then repeat for each branch

✓ What you should see: Each Router branch shows a filter label beneath it summarizing the condition, e.g., 'Stage ID = 4'. Branches without a filter set will show a warning icon.

⚠

Common mistake — Stage IDs in Pipedrive are integers and are pipeline-specific. If your company has multiple pipelines with similarly named stages (e.g., two pipelines both have a 'Proposal' stage), the IDs will differ — filter by both Stage ID and Pipeline ID to avoid cross-pipeline false positives.

Slack

trigger

filter

Condition

matches criteria?

yes — passes through

no — skipped

Pipedrive

notified

Router branch > Add module > Search: Slack > Send a Message

Add a Slack 'Send a Message' module to each branch

On each Router branch, add a Slack 'Send a Message' module. Connect your Slack workspace when prompted — Make uses OAuth, so you'll be redirected to Slack to authorize. Set the 'Channel' field to the specific Slack channel for that stage (e.g., #deals-negotiation). In the 'Text' field, compose the message using mapped fields from the Get a Deal output: deal title, value, owner name, and stage name. Use Slack's mrkdwn formatting for bold and line breaks.

1Click the '+' at the end of the first Router branch
2Search 'Slack' and select 'Send a Message'
3Click 'Add' to connect your Slack workspace via OAuth
4Set 'Channel' to the target Slack channel name (e.g., #deals-negotiation)
5Build the message text by mapping fields from the '2. Get a Deal' output panel

✓ What you should see: A Slack module appears at the end of each Router branch. The message preview in the config panel shows your mapped field values populated with sample data.

⚠

Common mistake — Make requires the Slack bot to be invited to private channels before it can post. If the channel is private, open Slack, go to the channel, type '/invite @Make' and hit enter — otherwise the module will throw a 'channel_not_found' error even if the channel name is typed correctly.

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

Slack module > Text field > Map from Get a Deal output

Build the Slack message template

In the Slack 'Send a Message' module's Text field, map fields from the Pipedrive 'Get a Deal' module output. A clear message format includes: deal title, value (formatted with currency), owner full name, current stage name, and a direct link to the deal. Use the following structure as a starting point and adapt it for each stage branch. The deal URL can be constructed by concatenating 'https://[yourcompany].pipedrive.com/deal/' with the deal ID from the payload.

1Click inside the 'Text' field of the Slack module
2Type '*Deal moved to [Stage Name]:* ' then click the deal Title field from the right panel
3Press Enter and type '*Value:* ' then map the Value field
4Press Enter and type '*Owner:* ' then map Owner Name
5Press Enter and type '*Link:* https://[yourcompany].pipedrive.com/deal/' then map the deal ID

✓ What you should see: The Text field shows a mix of static text and orange mapped-field pills, e.g.: '*Deal moved to Negotiation:* {{2.title}}\n*Value:* {{2.value}}\n*Owner:* {{2.owner.name}}'

⚠

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}}

Canvas bottom toolbar > Run once

Run a test with a live deal stage change

Click 'Run once' in the bottom left of the Make canvas to activate the scenario for a single test run. Make will wait for an incoming webhook event — you'll see a pulsing animation on the Pipedrive trigger module. Switch to Pipedrive and manually move a deal to one of your target stages. Return to Make within 30 seconds. The scenario should execute and you'll see green checkmarks on each module that ran successfully, with the execution data visible by clicking each module.

1Click 'Run once' in the bottom left toolbar
2Switch to Pipedrive in another tab
3Open any deal and drag it to one of your target pipeline stages
4Return to Make and watch for the execution to trigger
5Click each module's bubble to inspect the input/output data

✓ What you should see: All modules show green checkmarks. The Slack module shows '1 bundle processed'. Check your Slack channel — the message should appear within 90 seconds of the stage change.

⚠

Common mistake — If you test by editing a deal's stage in Pipedrive's list view rather than the deal's own page, the webhook may not fire reliably. Always test by opening the deal record and changing the stage from within the deal view or the pipeline Kanban board.

Make

▶ Run once

executed

✓

Slack

✓

Pipedrive

🔔 notification

received

Canvas bottom toolbar > Toggle ON > Scenarios dashboard

Activate the scenario and set scheduling

After a successful test, click the toggle at the bottom of the canvas to switch the scenario from OFF to ON. Because this scenario uses an instant webhook trigger, there is no polling interval to set — it runs automatically the moment Pipedrive sends an event. Confirm the scenario status shows 'Active' in green. Navigate to Scenarios > your scenario name to verify it appears in your active scenario list with a green status indicator.

1Click the toggle switch in the bottom left toolbar to switch from OFF to ON
2Confirm the toggle turns green and shows 'Active'
3Navigate to the Scenarios list page
4Verify the scenario shows a green 'Active' badge

✓ What you should see: The scenario is listed as Active in your Scenarios dashboard. The next time a deal stage changes in Pipedrive, Make will fire automatically with no manual intervention.

Going live

Production Checklist

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

Confirm Make's webhook URL appears in Pipedrive > Settings > Integrations > Webhooks before activating

Applies when: webhook

Invite the Make Slack bot to every private channel you're posting to — do this before activating or the first real deal alert will silently fail

Add an early-exit filter after the Pipedrive trigger to discard non-stage-change updates (compare previous_stage_id to current stage_id) — saves operations on high-activity pipelines

Enable 'Allow storing incomplete executions' in Make Scenario Settings so failed Slack posts don't disappear — review the Incomplete Executions tab weekly

Verify each Router branch filter uses integer comparison ('Equal to number') not text comparison — stage IDs are integers and text comparison will silently fail

Test each Router branch independently by moving a deal through every target stage in Pipedrive — don't assume a single test covers all branches

Document your Pipedrive stage IDs in a shared team doc — they are not visible in the Pipedrive UI by default and you'll need them again if you rebuild or clone this scenario

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 stage-specific routing to multiple Slack channels from a single scenario. Make's Router module is the reason — it handles the conditional logic of 'Won goes to #wins, Negotiation goes to #deals-negotiation' inside one scenario without needing separate automations. Make also gives you the visual canvas to inspect exactly which data the Pipedrive webhook is sending, which saves significant debugging time compared to digging through Zapier's execution logs. The one scenario where you'd skip Make: if you only care about Won deals and want a five-minute setup. A Zapier two-step zap (Pipedrive Deal Won → Slack Message) is faster to configure and costs zero for under 100 won deals per month.

Cost

Cost math: each deal stage change runs 4 Make operations (trigger + Get a Deal + Router + Slack). A team closing 50 deals per month through 5 stages each is 250 stage changes = 1,000 operations. Make's Free tier caps at 1,000 operations/month, so you'll likely need the Core plan at $9/month. At 100 deals per month through 5 stages, that's 2,000 operations — Core at $9/month covers 10,000 operations, so you have plenty of headroom. Zapier's equivalent would cost $19.99/month (Professional) just to get multi-step zaps with filters. Make is cheaper by $10.99/month for this use case at any volume above the Free tier.

Tradeoffs

Zapier has one genuine edge here: its Pipedrive integration has a dedicated 'Updated Deal Stage' trigger, which means you skip building the early-exit filter Make requires to avoid processing non-stage updates. That saves setup time and operations. n8n does this better than both if you self-host — zero per-run cost, native Pipedrive nodes, and you can write JavaScript directly in the workflow to format currency and dates without formula gymnastics. Power Automate has a Pipedrive connector but it's a premium connector requiring a $15/user/month Power Automate plan — overkill unless your company already runs on Microsoft 365. Pipedream is excellent for developers who want to write the routing logic in Node.js but is harder to hand off to a non-technical sales ops person. Make is the right choice when your sales ops team wants to own and modify the workflow themselves without writing code, and when the per-operation cost model makes more sense than Zapier's per-task pricing.

Three things you'll hit after going live. First, Pipedrive's webhook payload does not include the previous stage name — only the previous stage ID. If you want your Slack message to say 'moved from Qualified to Proposal', you need to either maintain a stage ID-to-name lookup table in Make's data store or make a second Pipedrive API call, which adds another operation per run. Second, Pipedrive rate-limits API calls to 100 requests per 10 seconds per company token — not a problem for normal usage, but if you're running multiple Make scenarios all using the same API token and have a large team making rapid pipeline updates, you will see 429 errors in your execution history. Use separate API tokens for separate scenarios to spread the rate limit. Third, if a deal is manually created directly in the 'Won' stage (some reps do this to log historical deals), the 'Updated' trigger won't fire — only a deal that transitions between stages triggers the webhook. You'll need a separate scenario watching 'Added' events to catch this edge case.

Ideas for what to build next

→
Add a Daily Pipeline Digest to Slack — Build a second Make scenario on a scheduled trigger that runs each morning at 9am, queries all open deals via Pipedrive's 'Search Deals' module, groups them by stage, and posts a single summary message to #sales-ops — so managers get a structured overview without channel noise from individual updates.
→
Post to Microsoft Teams Instead (or Alongside Slack) — Clone this scenario and replace the Slack modules with Make's Microsoft Teams 'Send a Message' modules to cover sales managers who live in Teams rather than Slack — both can run simultaneously from the same Pipedrive trigger without any changes to the Pipedrive connection or Router logic.
→
Log Stage Changes to a Google Sheet for Reporting — Add a Google Sheets 'Add a Row' module to each Router branch so every stage change is logged with a timestamp, deal value, and owner — this gives you a full history of pipeline velocity that Pipedrive's native reporting doesn't surface without an advanced subscription.