How fast does the Slack alert fire after a deal changes stage in Close?

Typically 5-10 seconds. Close fires the webhook within 1-2 seconds of the stage change, and Pipedream processes it nearly instantly since it runs on persistent infrastructure rather than polling. The main variable is Close's internal webhook queue during peak usage.

Can I send alerts for multiple stages — like both 'Won' and 'Proposal' — in the same workflow?

Yes. In the Filter step, change your single condition to an OR group: `status_label equals 'Won' OR status_label equals 'Proposal'`. Then in the Node.js code step, use the stage-to-emoji map to post differently styled messages per stage. You can also route each stage to a different Slack channel with an if/else block in the code step.

Will this workflow fire for every field change on an opportunity, or only stage changes?

The Close webhook fires for all opportunity updates, including note edits and minor field changes. The Filter step is what limits it to stage changes. If you only set a stage condition, any update to a deal already in that stage will also trigger an alert — to prevent this, also check that `previous_status_label !== current_status_label` in your code step.

What happens if Pipedream goes down and a deal changes stage during the outage?

Pipedream queues webhook events and processes them when the service recovers — you won't lose events from brief outages. For extended outages, Close retries failed webhook deliveries for up to 72 hours. Check Pipedream's status page at status.pipedream.com and Close's webhook retry logs if you suspect missed events.

Can I include a Slack message thread reply instead of a new top-level message for follow-up stages?

Yes, but it requires extra logic. You'd need to store the original Slack message timestamp (`message.ts`) in Pipedream's data store when the first alert fires, keyed to the Close opportunity ID. On subsequent stage changes for the same deal, fetch that timestamp and use Slack's `thread_ts` parameter to post as a reply. This creates a clean conversation thread per deal.

Intermediate~15 min setupCommunication & CRMVerified April 2026

How to Send Close Deal Alerts to Slack with Pipedream

Fires a Slack notification instantly when a Close deal changes stage or crosses a value threshold, routing the alert to the right channel with deal owner, value, and next steps.

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

Pipedream

Also on:Make Zapier N8n Power-automate

Best for

Inside sales teams of 5-50 reps who need instant visibility into pipeline movement without keeping Close open all day.

Not ideal for

Teams that only need a daily digest — schedule a Pipedream workflow to batch-summarize instead of using webhooks.

Sync type

real-time

Use case type

notification

Real-World Example

💡

A 12-person SaaS sales team posts to #deals-won in Slack the moment a Close opportunity moves to 'Won' and posts to #deals-at-risk when a deal over $10,000 stalls in 'Proposal' for more than 7 days. Before this workflow, the sales manager checked Close manually twice a day and regularly missed same-day wins, which meant delayed commission confirmations and no team celebration moment. Now the alert fires within 8 seconds of the stage change and includes the deal value, owner name, and a direct link back to the Close lead.

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

Pipedreamthis guide

$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 Pipedream

Copy the pre-built Pipedream blueprint and paste it straight into Pipedream. 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.

Close API key with read access to opportunities and users — found in Close under Settings > API Keys

Slack account with permission to install apps to your workspace — typically requires Workspace Admin or Owner role

Pipedream account on any plan — the free tier includes 10,000 credits/month which covers roughly 3,300 workflow runs

Target Slack channel already created and, if private, Pipedream bot invited to it via /invite @Pipedream

Optional

At least one Close opportunity in a testable stage so you can trigger a live end-to-end test before going to production

Field Mapping

Map these fields between your apps.

Field	API Name	Description
Required
Deal Name	`opportunity.name`	The opportunity name displayed in the Slack alert — the first thing recipients read to identify the deal
Stage / Status Label	`opportunity.status_label`	The human-readable pipeline stage name — used in the Filter step to determine whether the alert should fire
Deal Owner User ID	`opportunity.user_id`	The internal Close user ID of the assigned rep — must be resolved to a display name before including in the Slack message
Deal Owner Display Name	`user.display_name`	Human-readable name of the rep who owns the deal — fetched from Close Users API using the user_id field
Lead Name	`opportunity.lead_name`	The company or contact name associated with the deal — gives context for who the deal is with
Lead ID	`opportunity.lead_id`	Used to construct a direct deep link back to the lead record in Close, included as a clickable URL in the Slack message

4 optional fields▸ show

Deal Value	`opportunity.value`	Monetary value of the opportunity — shown in the Slack message and optionally used as a threshold filter
Close Date	`opportunity.date_won`	Expected close date of the deal — useful for urgency context in the Slack alert, especially for deals approaching their deadline
Updated At Timestamp	`opportunity.date_updated`	ISO timestamp of the update — used for deduplication logic to prevent duplicate Slack alerts for the same event
Confidence Score	`opportunity.confidence`	Close's percentage confidence field — optionally included in the Slack message to show deal win probability

Step-by-Step Setup

pipedream.com > Workflows > New Workflow

Create a new Pipedream workflow

Go to pipedream.com and sign in. Click 'New Workflow' in the top-right corner of the dashboard. You'll land on the workflow builder canvas with an empty trigger slot at the top. Give the workflow a name — something like 'Close Deal Stage Alert to Slack' — so it's easy to find later. Pipedream saves drafts automatically, so you won't lose work if you navigate away.

1Click 'New Workflow' in the top-right corner
2Click the workflow name field at the top and type 'Close Deal Stage Alert to Slack'
3Click the trigger slot labeled 'Add a trigger'

✓ What you should see: You should see the trigger selection panel open on the right side of the screen, showing a search box and a list of app categories.

Workflow Builder > Add Trigger > Close > New Event (Instant)

Add the Close webhook trigger

Search for 'Close' in the trigger search box and select the Close CRM app. Choose the trigger type 'New Event (Instant)' — this uses Close's native webhook system rather than polling, which gives you sub-10-second alert times. Connect your Close account by clicking 'Connect Account' and entering your Close API key. Pipedream stores this as a Connected Account and reuses it across workflows.

1Type 'Close' in the trigger search box
2Click the Close CRM app tile
3Select 'New Event (Instant)' as the trigger type
4Click 'Connect Account' and paste your Close API key into the field
5Click 'Save' to confirm the connected account

✓ What you should see: You should see a green checkmark next to your Close account name and a webhook URL generated in the trigger configuration panel.

⚠

Common mistake — Close API keys are workspace-scoped, not user-scoped. Use an API key from Settings > API Keys in Close — not a personal OAuth token. If you use the wrong key type, the webhook registration will succeed but events will never fire.

Pipedream

click +

search apps

Slack

Add the Close webhook trigger

Slack

module added

Workflow Builder > Trigger Config > Event Object Type > opportunity

Configure the Close event subscription

In the trigger configuration, set the Event Object Type to 'opportunity' and the Event Action to 'updated'. This tells Pipedream to register a webhook in Close that fires on every opportunity (deal) update. You can also select 'created' if you want alerts for brand-new deals — but for stage-change alerts, 'updated' is the right choice. Pipedream automatically handles the webhook registration and deregistration with Close's API when you deploy or pause the workflow.

1Set 'Event Object Type' to 'opportunity'
2Set 'Event Action' to 'updated'
3Click 'Generate Test Event' to pull a recent opportunity update as sample data

✓ What you should see: You should see a sample Close opportunity payload appear in the trigger output panel on the right, including fields like status_label, value, lead_name, and user_name.

⚠

Common mistake — Close sends webhook payloads for ALL opportunity updates, including minor field changes like note edits. You must add a filter step downstream — otherwise your Slack channel will get flooded with noise.

This code goes in the Node.js code step (Step 5) that runs between the Filter and the Slack send action. It formats the Close payload into a Slack Block Kit message with an emoji header, deal details section, and a direct link to the lead. Paste it directly into the Pipedream code editor and adjust the `CLOSE_BASE_URL` and emoji map to match your pipeline stages.

JavaScript — Code Stepimport axios from 'axios';

▸ Show code

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

... expand to see full code

import axios from 'axios';

export default defineComponent({
  async run({ steps, $ }) {
    const event = steps.trigger.event?.data || {};

    // Resolve deal value — Close may send in dollars or cents depending on account config
    const rawValue = event.value ?? 0;
    const formattedValue = rawValue > 0
      ? new Intl.NumberFormat('en-US', { style: 'currency', currency: 'USD', maximumFractionDigits: 0 }).format(rawValue)
      : 'Value not set';

    // Map stage labels to emojis for visual scannability
    const stageEmoji = {
      'Won': '🏆',
      'Proposal': '📄',
      'Demo Scheduled': '📅',
      'Negotiation': '🤝',
      'Lost': '❌',
    };
    const emoji = stageEmoji[event.status_label] ?? '🔔';

    // Resolve owner name — prefer user_name from payload, fallback to user_id
    const ownerName = steps.resolve_owner?.ownerName ?? event.user_name ?? event.user_id ?? 'Unassigned';

    // Build Close deep link
    const CLOSE_BASE_URL = 'https://app.close.com/lead';
    const leadUrl = event.lead_id
      ? `${CLOSE_BASE_URL}/${event.lead_id}/`
      : null;

    // Construct Slack Block Kit payload
    const blocks = [
      {
        type: 'header',
        text: {
          type: 'plain_text',
          text: `${emoji} Deal ${event.status_label ?? 'Updated'} — ${event.name ?? 'Unnamed Deal'}`,
          emoji: true,
        },
      },
      {
        type: 'section',
        fields: [
          { type: 'mrkdwn', text: `*Company:*\n${event.lead_name ?? 'Unknown'}` },
          { type: 'mrkdwn', text: `*Value:*\n${formattedValue}` },
          { type: 'mrkdwn', text: `*Owner:*\n${ownerName}` },
          { type: 'mrkdwn', text: `*Stage:*\n${event.status_label ?? 'Unknown'}` },
        ],
      },
      ...(leadUrl ? [{
        type: 'actions',
        elements: [{
          type: 'button',
          text: { type: 'plain_text', text: 'View in Close', emoji: true },
          url: leadUrl,
          action_id: 'view_in_close',
        }],
      }] : []),
      { type: 'divider' },
    ];

    // Fallback text for notifications and screen readers
    const text = `Deal ${event.status_label ?? 'Updated'}: ${event.name ?? 'Unnamed'} | ${formattedValue} | Owner: ${ownerName}`;

    return { blocks, text };
  },
});

Workflow Builder > Add Step > Flow Control > Filter

Add a filter step for stage and value conditions

Click the '+' button below the trigger to add a new step. Select 'Filter' from the built-in Pipedream helpers (it appears under 'Flow Control'). This step will stop the workflow — and prevent the Slack message — if the deal doesn't meet your criteria. You'll configure two conditions: the opportunity's status_label must match your target stage (e.g., 'Won' or 'Proposal'), and optionally the value must exceed a threshold like 10000. Pipedream's Filter step short-circuits execution cleanly with zero credits wasted on downstream steps.

1Click the '+' icon below the trigger step
2Click 'Flow Control' in the step category list
3Select 'Filter'
4Set Condition 1: select the path trigger.event.data.status_label and set it to equal 'Won'
5Click 'Add Condition' if you want to add a value threshold and set trigger.event.data.value to greater than 10000

✓ What you should see: The Filter step should show 'Condition met — workflow will continue' when you test it against the sample Won opportunity, and 'Condition not met — workflow will end' when tested against an unmatched stage.

⚠

Common mistake — Close stores deal values in cents by default for some account configurations. Test your sample data to confirm whether `value` is 10000 (dollars) or 1000000 (cents) before setting your threshold.

Slack

trigger

filter

Condition

matches criteria?

yes — passes through

no — skipped

notified

Workflow Builder > Add Step > Run Node.js Code

Add a Node.js code step to build the Slack message

Click '+' below the Filter step and select 'Run Node.js code'. This is where you construct a structured Slack Block Kit message using data from the Close webhook payload. Using Block Kit instead of plain text gives you a formatted card with the deal name, owner, value, stage, and a clickable link back to the lead in Close. Paste the code from the Pro Tip section below into this step — it handles value formatting, fallback text for missing fields, and constructs the full Block Kit payload.

1Click the '+' icon below the Filter step
2Select 'Run Node.js code'
3Delete the placeholder code in the editor
4Paste the Pro Tip code into the editor
5Click 'Test' to verify the output shows a valid Slack Block Kit object

✓ What you should see: After clicking Test, you should see a JSON object in the output panel with keys blocks, text, and attachments — this is the formatted Slack payload ready to send.

⚠

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.

JavaScript — Code Stepimport axios from 'axios';

▸ Show code

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

... expand to see full code

import axios from 'axios';

export default defineComponent({
  async run({ steps, $ }) {
    const event = steps.trigger.event?.data || {};

    // Resolve deal value — Close may send in dollars or cents depending on account config
    const rawValue = event.value ?? 0;
    const formattedValue = rawValue > 0
      ? new Intl.NumberFormat('en-US', { style: 'currency', currency: 'USD', maximumFractionDigits: 0 }).format(rawValue)
      : 'Value not set';

    // Map stage labels to emojis for visual scannability
    const stageEmoji = {
      'Won': '🏆',
      'Proposal': '📄',
      'Demo Scheduled': '📅',
      'Negotiation': '🤝',
      'Lost': '❌',
    };
    const emoji = stageEmoji[event.status_label] ?? '🔔';

    // Resolve owner name — prefer user_name from payload, fallback to user_id
    const ownerName = steps.resolve_owner?.ownerName ?? event.user_name ?? event.user_id ?? 'Unassigned';

    // Build Close deep link
    const CLOSE_BASE_URL = 'https://app.close.com/lead';
    const leadUrl = event.lead_id
      ? `${CLOSE_BASE_URL}/${event.lead_id}/`
      : null;

    // Construct Slack Block Kit payload
    const blocks = [
      {
        type: 'header',
        text: {
          type: 'plain_text',
          text: `${emoji} Deal ${event.status_label ?? 'Updated'} — ${event.name ?? 'Unnamed Deal'}`,
          emoji: true,
        },
      },
      {
        type: 'section',
        fields: [
          { type: 'mrkdwn', text: `*Company:*\n${event.lead_name ?? 'Unknown'}` },
          { type: 'mrkdwn', text: `*Value:*\n${formattedValue}` },
          { type: 'mrkdwn', text: `*Owner:*\n${ownerName}` },
          { type: 'mrkdwn', text: `*Stage:*\n${event.status_label ?? 'Unknown'}` },
        ],
      },
      ...(leadUrl ? [{
        type: 'actions',
        elements: [{
          type: 'button',
          text: { type: 'plain_text', text: 'View in Close', emoji: true },
          url: leadUrl,
          action_id: 'view_in_close',
        }],
      }] : []),
      { type: 'divider' },
    ];

    // Fallback text for notifications and screen readers
    const text = `Deal ${event.status_label ?? 'Updated'}: ${event.name ?? 'Unnamed'} | ${formattedValue} | Owner: ${ownerName}`;

    return { blocks, text };
  },
});

message template

🔔 New Record: {{text}} {{user}}
channel: {{channel}}
ts: {{ts}}

#sales

🔔 New Record: Jane Smith

Email: [email protected]

Company: Acme Corp

Workflow Builder > Add Step > Run Node.js Code (before message step)

Resolve the deal owner's name from Close

The Close webhook payload includes user_id for the deal owner, not a display name. You need to make a one-time lookup call to Close's Users API to resolve this to a readable name. Add another Node.js step above the message-building step and fetch https://api.close.com/api/v1/me/ or cache a user map at workflow start. Alternatively, if your Close plan returns user_name directly in the opportunity payload (many do), check the sample data first — if user_name is present and populated, you can skip this step entirely.

1Check the trigger sample output for a user_name field
2If user_name is null or missing, click '+' to add a Node.js step before the message builder
3Use the Close API key from your Connected Account to call GET https://api.close.com/api/v1/user/{user_id}/
4Extract display_name from the response and pass it to the next step via $.export('ownerName', response.display_name)

✓ What you should see: The step output should show ownerName set to a readable string like 'Sarah Mitchell' rather than a raw ID like 'user_abc123xyz'.

⚠

Common mistake — Close rate-limits API calls to 60 requests per minute on most plans. If you have high deal volume, cache the user list in Pipedream's built-in `$.data` store rather than fetching per-event.

JavaScript — Code Stepimport axios from 'axios';

▸ Show code

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

... expand to see full code

import axios from 'axios';

export default defineComponent({
  async run({ steps, $ }) {
    const event = steps.trigger.event?.data || {};

    // Resolve deal value — Close may send in dollars or cents depending on account config
    const rawValue = event.value ?? 0;
    const formattedValue = rawValue > 0
      ? new Intl.NumberFormat('en-US', { style: 'currency', currency: 'USD', maximumFractionDigits: 0 }).format(rawValue)
      : 'Value not set';

    // Map stage labels to emojis for visual scannability
    const stageEmoji = {
      'Won': '🏆',
      'Proposal': '📄',
      'Demo Scheduled': '📅',
      'Negotiation': '🤝',
      'Lost': '❌',
    };
    const emoji = stageEmoji[event.status_label] ?? '🔔';

    // Resolve owner name — prefer user_name from payload, fallback to user_id
    const ownerName = steps.resolve_owner?.ownerName ?? event.user_name ?? event.user_id ?? 'Unassigned';

    // Build Close deep link
    const CLOSE_BASE_URL = 'https://app.close.com/lead';
    const leadUrl = event.lead_id
      ? `${CLOSE_BASE_URL}/${event.lead_id}/`
      : null;

    // Construct Slack Block Kit payload
    const blocks = [
      {
        type: 'header',
        text: {
          type: 'plain_text',
          text: `${emoji} Deal ${event.status_label ?? 'Updated'} — ${event.name ?? 'Unnamed Deal'}`,
          emoji: true,
        },
      },
      {
        type: 'section',
        fields: [
          { type: 'mrkdwn', text: `*Company:*\n${event.lead_name ?? 'Unknown'}` },
          { type: 'mrkdwn', text: `*Value:*\n${formattedValue}` },
          { type: 'mrkdwn', text: `*Owner:*\n${ownerName}` },
          { type: 'mrkdwn', text: `*Stage:*\n${event.status_label ?? 'Unknown'}` },
        ],
      },
      ...(leadUrl ? [{
        type: 'actions',
        elements: [{
          type: 'button',
          text: { type: 'plain_text', text: 'View in Close', emoji: true },
          url: leadUrl,
          action_id: 'view_in_close',
        }],
      }] : []),
      { type: 'divider' },
    ];

    // Fallback text for notifications and screen readers
    const text = `Deal ${event.status_label ?? 'Updated'}: ${event.name ?? 'Unnamed'} | ${formattedValue} | Owner: ${ownerName}`;

    return { blocks, text };
  },
});

Workflow Builder > Add Step > Slack > Send Message to Channel

Connect your Slack account

Click '+' below the message-building step and search for 'Slack'. Select the Slack app and choose the action 'Send Message to Channel'. Click 'Connect Account' and authorize Pipedream's Slack app via OAuth — this opens a Slack authorization screen where you select the workspace and grant the chat:write and chat:write.public scopes. Once authorized, the connected account appears in the step and your workspace's channels become selectable from a dropdown.

1Click '+' below the Node.js code step
2Search for 'Slack' and select the Slack app
3Choose the action 'Send Message to Channel'
4Click 'Connect Account' and complete the Slack OAuth flow
5Select your workspace from the Slack authorization screen and click 'Allow'

✓ What you should see: You should see your Slack workspace name appear next to a green checkmark in the account field, and a channel dropdown should now populate with your workspace's channels.

⚠

Common mistake — Pipedream's Slack app must be invited to private channels before they appear in the dropdown. Run `/invite @Pipedream` in any private channel first, otherwise it will appear as missing from the list.

Pipedream settings

Connection

Choose a connection…Add

click Add

Slack

Authorize Pipedream

popup window

✓

Connected

green checkmark

Workflow Builder > Slack Step > Channel + Blocks + Text

Configure the Slack message action

In the Slack step, select the target channel from the dropdown — for example #deals-won or #sales-team. Set the 'Blocks' field to reference the Block Kit output from your Node.js code step (use the path selector to pick steps.build_message.$return_value.blocks). Set the 'Text' field to the fallback string from the same output — Slack uses this for notifications and accessibility when blocks don't render. Leave 'Username' and 'Icon' fields blank unless you want a custom bot name like 'DealBot'.

1Select the target channel from the 'Channel' dropdown (e.g., #deals-won)
2Click the 'Blocks' field and select the path steps.build_message.$return_value.blocks
3Click the 'Text' field and select steps.build_message.$return_value.text
4Optionally set 'Username' to 'DealBot' for a custom sender name

✓ What you should see: When you click 'Test', a formatted Slack message should appear in your chosen channel within 3-5 seconds, showing the deal name, value, stage, owner, and a link to the lead in Close.

⚠

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.

pipedream.com > Workflows > [Your Workflow] > Event History

Test the full workflow end to end

In Close, find a test deal and manually move it to the stage you configured in the Filter step. Watch the Pipedream workflow run log — a new execution should appear within 8 seconds. Click the run to inspect each step's input and output. Confirm the Filter step passed, the Node.js step produced a valid Block Kit object, and the Slack step returned a 200 OK with a message.ts timestamp. Then check your Slack channel to verify the message looks correct.

1In Close, open a test opportunity and change its status to your target stage
2Switch back to Pipedream and click the workflow's 'Event History' tab
3Click the new execution entry to open the run inspector
4Expand each step to verify input/output at every stage
5Confirm the Slack message appeared in the correct channel

✓ What you should see: You should see a green checkmark on all steps in the run inspector, and the Slack channel should contain a formatted deal card with accurate data.

⚠

Common mistake — If the workflow runs but the Slack message shows 'null' for the deal value, the Close payload sent value as 0 during a stage-only change. Add a null-check in your Node.js step to display 'Value not set' instead of '$0'.

Pipedream

▶ Deploy & test

executed

✓

Slack

✓

🔔 notification

received

Workflow Builder > Deploy (top-right button)

Deploy the workflow

Click the green 'Deploy' button in the top-right corner of the workflow builder. Pipedream activates the Close webhook subscription and starts listening for live events. The workflow moves from 'Development' to 'Active' status. You'll see the workflow listed in your Workflows dashboard with a green 'Active' badge. From this point, every qualifying Close opportunity update fires the workflow in real time — no manual intervention needed.

1Click the green 'Deploy' button in the top-right corner
2Confirm the deployment modal by clicking 'Deploy' again
3Navigate to pipedream.com > Workflows to confirm the 'Active' badge appears next to your workflow

✓ What you should see: The workflow dashboard should show your workflow with a green 'Active' badge and a 'Last event' timestamp that updates after the next Close deal change.

Going live

Production Checklist

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

Confirm the Close webhook is registered under Settings > Integrations > Webhooks in Close after deploying — Pipedream should auto-register it, but verify it's pointing to the correct endpoint URL

Applies when: webhook

Add a Pipedream data store deduplication check using the opportunity ID + date_updated timestamp to block duplicate Slack messages from Close firing multiple events per action

Applies when: webhook

Test the Filter step with both a matching stage and a non-matching stage to confirm it correctly stops execution — a misconfigured filter is the #1 cause of Slack channel spam

Verify deal value format against your Close account config — some accounts report value in cents, which would make a $48,000 deal appear as '$4,800,000' in Slack

Invite the Pipedream Slack bot to every private channel you plan to post to before going live — missing this causes silent failures with no error in the Pipedream run log

Set up Pipedream error notifications under workflow Settings > Error Handling so failed runs email you immediately rather than silently dropping alerts

Check your Pipedream credit budget — at 100 Close deal updates per day, you'll consume roughly 900 credits/day and exhaust the free tier in 11 days

Troubleshooting

Common errors and how to fix them.

Frequently Asked Questions

Common questions about this workflow.

Analysis

VerdictWhy n8n for this workflow

Use Pipedream for this if your team has at least one person comfortable reading JavaScript, or if you want conditional routing logic that goes beyond 'send to one channel.' Pipedream's webhook processing is genuinely faster than Zapier or Make for this use case — Close fires the event, Pipedream picks it up in under 2 seconds, no polling interval involved. The code step also lets you build a proper Block Kit message with buttons and formatted sections rather than a plain-text string. The one scenario where you'd skip Pipedream: if your entire team is non-technical and wants to maintain this themselves long-term. In that case, use Zapier — the setup is less flexible but doesn't require anyone to understand async/await.

Cost

Pipedream's free tier gives you 10,000 credits per month. Each workflow run for this use case costs roughly 3 credits (trigger + filter + code step + Slack step). That means 3,333 qualifying deal updates per month before you hit the ceiling. Most inside sales teams of under 20 reps won't break 500 qualifying events/month, so the free tier holds comfortably. If you do hit the limit, Pipedream's Basic plan is $19/month for 100,000 credits — that covers about 33,000 runs/month, which is more than enough for any team short of a full SDR call center. Zapier's equivalent plan for this volume runs $49-$73/month. Make's free tier handles this workflow for free up to 1,000 operations/month, which is lower than Pipedream's ceiling for this specific run structure.

Tradeoffs

Zapier's advantage here is a no-code Slack formatter with named variables — non-technical teammates can edit the message template without touching code. Make's advantage is its visual router module, which lets you branch to different Slack channels per stage without writing conditionals. n8n's advantage is self-hosting: if your Close data is sensitive and you don't want it passing through third-party servers, n8n on your own infrastructure keeps it internal. Power Automate has no meaningful advantage for this specific workflow — its Slack connector is limited and Close has no native Power Automate action. Pipedream is still the right call here because the Block Kit formatting and the user ID resolution lookup both need real code, and Pipedream is the only platform where that code runs natively in the same workflow without a separate serverless function.

Three things you'll hit after go-live. First, Close fires the opportunity.updated webhook for every field change — a rep editing a note on a Won deal will re-fire your Won alert. Fix this in the code step by comparing status_label against previous_data.status_label in the webhook payload and only proceeding if they differ. Second, Close's webhook payload for value uses the raw currency value without the account's configured currency symbol — you need to hardcode the currency in your Intl.NumberFormat call or fetch it from the Close account settings endpoint. Third, if you add a second workflow later (say, a deal-at-risk alert), both workflows will share the same Close webhook subscription type and you may see duplicate processing. Keep related alerts in one workflow with internal branching rather than creating separate workflows per stage — it's easier to debug and costs fewer credits.

Ideas for what to build next

→
Route alerts to different channels by deal size — Add conditional logic in the Node.js step to send deals over $50,000 to #enterprise-deals and smaller deals to #sales-team. This takes about 10 minutes to add and eliminates the need to filter manually in Slack.
→
Add a daily pipeline digest — Create a second Pipedream workflow on a scheduled trigger that queries the Close API at 8am each morning and posts a summary of all open deals by stage to #sales-standup. This pairs well with the real-time alerts — real-time for wins, digest for pipeline review.
→
Post a Slack message reply when a deal closes and log it to a Google Sheet — Extend the Won stage alert to also append a row to a Google Sheet with deal name, value, owner, and close date. After 30 days you'll have a clean win log without any manual data entry from the sales team.