How to Route Competitor Price Alerts into Your Stack with Webhooks

Why Email-Only Alerts Create a Bottleneck

Email is the minimum viable alert. It works, it's universal, and it requires no technical setup. But email has a structural weakness: it requires a human to read it, understand it, and take action.

In practice, this means a competitor price change fires an alert at 2pm on a Friday, lands in a shared inbox, gets triaged on Monday morning, and reaches the person who can act on it by Tuesday afternoon. That's 90+ hours of latency between the market event and the business response.

Webhooks break this bottleneck. Instead of sending an alert to a human inbox, a webhook sends structured data to a URL you control — which can trigger an automated workflow, route to the right Slack channel, log to a spreadsheet, or call your repricing API. The latency drops from 90 hours to 90 seconds.

If email alerts are the floor, webhooks are the ceiling on how fast your organization can respond to competitive intelligence.

What a DiffScout Webhook Payload Looks Like

When a price change is detected, DiffScout POSTs a JSON payload to your configured webhook URL. The structure looks like this:

```json

{

"event": "price_change",

"timestamp": "2026-02-18T14:32:11Z",

"monitor": {

"id": "mon_abc123",

"name": "Gymshark Vital Shorts - Black",

"url": "https://gymshark.com/products/vital-shorts-black",

"product_name": "Vital Shorts Black Medium"

},

"price_change": {

"previous_price": 45.00,

"current_price": 32.00,

"currency": "GBP",

"change_amount": -13.00,

"change_percent": -28.9,

"direction": "decrease"

},

"check": {

"checked_at": "2026-02-18T14:30:00Z",

"extraction_method": "dom"

}

}

```

Key fields to use in your workflows:

• `change_percent` — filter on this to only act on significant moves (e.g., >10%)
• `direction` — route "decrease" differently from "increase"
• `monitor.name` — use your human-readable monitor name in Slack messages
• `price_change.current_price` — the live price to use in repricer or reporting tools

4 Routing Destinations

1. Zapier — No-code automation for 99% of use cases

Zapier can receive a webhook and connect it to 5,000+ apps. Best for: Slack notifications, Google Sheets logging, email routing, CRM ticketing.

2. Make (formerly Integromat) — More powerful multi-step routing

Make supports complex conditional logic and multi-branch routing. Best for: routing different alerts to different teams, conditional repricing triggers, multi-step workflows with error handling.

3. Slack direct (via Slack Incoming Webhooks)

If your only goal is Slack notification, you don't need Zapier or Make. Slack's built-in Incoming Webhooks accept a simple JSON POST. Best for: lean teams who want alerts in Slack without middleware.

4. Custom API endpoint

If you have engineering resources, receiving the webhook in your own backend unlocks full control — write to your database, trigger your repricing engine, update your CRM, post to multiple destinations simultaneously. Best for: teams with engineering resources and specific integration requirements.

Tutorial: Zapier Setup in 5 Steps

Goal: Post to a Slack channel when a competitor drops price by more than 10%.

Step 1: Create a new Zap with "Webhooks by Zapier" trigger

In Zapier, click "Create Zap" → search for "Webhooks by Zapier" → select "Catch Hook" as the trigger event. Zapier gives you a unique webhook URL. Copy it.

Step 2: Add your webhook URL to DiffScout

In DiffScout, go to Settings → Webhooks → Add Webhook URL. Paste the Zapier URL. Select which monitors should send to this webhook (or "all monitors").

Step 3: Test the trigger

In DiffScout, open a monitor and click "Send Test Webhook." Return to Zapier and click "Test Trigger" — you should see the sample payload appear. Zapier will now know the field names.

Step 4: Add a Filter step

Add a Zapier "Filter" step. Set the condition: only continue if change_percent is less than -10 (a decrease of 10% or more). This prevents noise from minor rounding adjustments.

Step 5: Add a Slack action

Add a "Send Channel Message" action for Slack. Authenticate your workspace. Select the channel (e.g., #competitor-alerts). Compose the message using dynamic fields:

```

🔻 Price drop detected

*{{monitor__name}}*

{{price_change__previous_price}} → {{price_change__current_price}} ({{change_percent}}%)

<{{monitor__url}}|View product>

```

Save and enable the Zap. From this point, every time DiffScout detects a 10%+ price drop, a formatted Slack message appears within 30 seconds of the webhook firing.

Tutorial: Make Scenario for Multi-Team Routing

Goal: Route price alerts to different Slack channels based on which team owns the category.

Scenario structure:

1. Webhook trigger (receive DiffScout payload)
2. Router module (branch based on monitor name or tag)
3. Branch A: Send to #bfcm-alerts (if monitor name contains "BFCM" tag)
4. Branch B: Send to #saas-pricing (if category is "SaaS")
5. Branch C: Send to #general-pricing (all other alerts)

How to set up the router:

In Make, create a new scenario. Add a Webhooks module as the trigger — copy the provided URL and add it to DiffScout's webhook settings.

Add a Router module. For each branch, add a filter:

• Branch A filter: monitor.name contains BFCM
• Branch B filter: monitor.name contains SaaS (or use a tag field if your monitors are tagged)

Connect each branch to a Slack "Create a Message" module, targeting the appropriate channel.

This setup means your BFCM team only sees alerts from their monitored competitors, and your SaaS pricing team only sees their relevant alerts — no noise.

Advanced: Building a Google Sheets Price Log with Webhook + Zapier

For teams that want a running audit trail of every competitor price change:

Zapier setup:

1. Trigger: Catch Hook (your DiffScout webhook URL)
2. Action: Google Sheets → Create Spreadsheet Row

Columns to map:

Result: every price alert automatically appends a row to your Google Sheet. After 90 days, you have a complete price history audit log in a format your team can filter, chart, and export for reporting.

Sample Node.js Webhook Handler

For teams building a custom integration, here's a minimal Node.js/Express endpoint that receives the DiffScout webhook and logs or processes it:

```javascript

const express = require('express');

const crypto = require('crypto');

const app = express();

app.use(express.json());

// Optional: verify webhook signature if DiffScout provides a signing secret

function verifySignature(payload, signature, secret) {

const expected = crypto

.createHmac('sha256', secret)

.update(payload)

.digest('hex');

return crypto.timingSafeEqual(

Buffer.from(signature),

Buffer.from(expected)

);

}

app.post('/webhooks/price-alert', (req, res) => {

const event = req.body;

// Acknowledge receipt immediately

res.status(200).json({ received: true });

// Process asynchronously

handlePriceChange(event).catch(console.error);

});

async function handlePriceChange(event) {

const { monitor, price_change } = event;

console.log(Price change: ${monitor.name});

console.log( ${price_change.previous_price} → ${price_change.current_price} (${price_change.change_percent}%));

// Route based on change type

if (price_change.direction === 'decrease' && Math.abs(price_change.change_percent) > 15) {

await notifyRepricingEngine(monitor, price_change);

}

// Log to database

await db.priceEvents.insert({

monitorId: monitor.id,

previousPrice: price_change.previous_price,

currentPrice: price_change.current_price,

changePercent: price_change.change_percent,

detectedAt: event.timestamp,

});

}

app.listen(3000, () => console.log('Webhook handler running'));

```

Tips: Idempotency, Retry Handling, and Failure Alerting

Idempotency: Webhook delivery systems sometimes send the same event twice (network retries). Your handler should be idempotent — processing the same event twice should produce the same result as processing it once. Use the monitor.id + timestamp combination as a deduplication key.

Retry handling: If your endpoint returns a non-200 response, DiffScout will retry the webhook delivery. Make sure your endpoint is available and responds quickly (under 5 seconds). Use async processing — acknowledge receipt first, then process.

Alerting on webhook failures: Set up monitoring on your webhook endpoint itself. If it goes down during BFCM week, you're flying blind. A simple uptime monitor on your webhook URL takes 2 minutes to configure.

Testing in production: Use a tool like webhook.site to inspect live payloads before building your integration. It gives you a temporary URL that logs every incoming request — invaluable for understanding the exact payload structure before writing code.

*Webhooks are available on DiffScout's Business plan. View pricing →*