Competitor Monitoring Automation: Build Real-Time Competitive Intelligence Workflows

#!/usr/bin/env python3
"""
RivalCheck -> Slack notification service
Receives webhook events and posts formatted messages to Slack.
"""
from flask import Flask, request
import requests
import os

app = Flask(__name__)
SLACK_WEBHOOK = os.environ["SLACK_WEBHOOK_URL"]

SEVERITY_COLORS = {
    "high": "#dc2626",     # red
    "medium": "#f59e0b",   # amber
    "low": "#6b7280"       # gray
}

CATEGORY_EMOJI = {
    "pricing": "Price change",
    "features": "Feature update",
    "messaging": "Messaging shift",
    "content": "Content update",
    "company": "Company update"
}


@app.route("/webhooks/rivalcheck", methods=["POST"])
def handle():
    event = request.json

    if event["event"] != "change.detected":
        return "OK", 200

    change = event["data"]
    severity = change["severity"]
    category = change["category"]

    payload = {
        "attachments": [{
            "color": SEVERITY_COLORS.get(severity, "#6b7280"),
            "blocks": [
                {
                    "type": "section",
                    "text": {
                        "type": "mrkdwn",
                        "text": (
                            f"*{change['competitor']['name']}* "
                            f"| {CATEGORY_EMOJI.get(category, category)} "
                            f"| Severity: {severity.upper()}\n\n"
                            f"*{change['title']}*\n\n"
                            f"{change['summary']}"
                        )
                    }
                },
                {
                    "type": "context",
                    "elements": [{
                        "type": "mrkdwn",
                        "text": (
                            f"Page: <{change['page_url']}|{change['page_url']}> "
                            f"| Detected: {change['detected_at'][:16]}"
                        )
                    }]
                }
            ]
        }]
    }

    # Add strategic analysis for high-severity changes
    if severity == "high" and change.get("strategic_analysis"):
        payload["attachments"][0]["blocks"].insert(1, {
            "type": "section",
            "text": {
                "type": "mrkdwn",
                "text": f"*Strategic Analysis:*\n>{change['strategic_analysis']}"
            }
        })

    requests.post(SLACK_WEBHOOK, json=payload)
    return "OK", 200


if __name__ == "__main__":
    app.run(port=8080)

// Google Apps Script — runs on a daily trigger
// Pulls pricing changes from RivalCheck and appends to a sheet

const API_KEY = PropertiesService.getScriptProperties()
  .getProperty("RIVALCHECK_API_KEY");
const API_BASE = "https://app.rivalcheck.com/api/v1";

function fetchPricingChanges() {
  const sheet = SpreadsheetApp.getActiveSpreadsheet()
    .getSheetByName("Pricing Changes");

  // Get the date of the last entry to avoid duplicates
  const lastRow = sheet.getLastRow();
  const lastDate = lastRow > 1
    ? sheet.getRange(lastRow, 5).getValue()
    : "2026-01-01";

  // Fetch pricing changes since last entry
  const url = `${API_BASE}/changes?category=pricing&since=${lastDate}`;
  const options = {
    headers: { "Authorization": `Bearer ${API_KEY}` },
    muteHttpExceptions: true
  };

  const response = UrlFetchApp.fetch(url, options);
  const data = JSON.parse(response.getContentText());

  if (!data.changes || data.changes.length === 0) {
    Logger.log("No new pricing changes found.");
    return;
  }

  // Append each change as a row
  const rows = data.changes.map(change => [
    change.competitor.name,
    change.title,
    change.severity,
    change.summary,
    change.detected_at,
    change.page_url,
    change.strategic_analysis || ""
  ]);

  const startRow = sheet.getLastRow() + 1;
  sheet.getRange(startRow, 1, rows.length, 7).setValues(rows);

  // Format severity column with conditional colours
  const severityRange = sheet.getRange(startRow, 3, rows.length, 1);
  const rules = severityRange.getValues().map((row, i) => {
    const cell = sheet.getRange(startRow + i, 3);
    if (row[0] === "high") {
      cell.setBackground("#fecaca");
    } else if (row[0] === "medium") {
      cell.setBackground("#fef3c7");
    }
    return row;
  });

  Logger.log(`Added ${rows.length} pricing changes.`);
}

// Set up daily trigger
function createDailyTrigger() {
  ScriptApp.newTrigger("fetchPricingChanges")
    .timeBased()
    .everyDays(1)
    .atHour(7)
    .create();
}

# HubSpot integration — update deal records on competitive changes
import os
import requests
from flask import Flask, request

app = Flask(__name__)
HUBSPOT_TOKEN = os.environ["HUBSPOT_ACCESS_TOKEN"]

@app.route("/webhooks/rivalcheck", methods=["POST"])
def handle_change():
    event = request.json

    if event["event"] != "change.detected":
        return "OK", 200

    change = event["data"]
    competitor_name = change["competitor"]["name"]

    # Only update CRM for high-severity changes
    if change["severity"] != "high":
        return "OK", 200

    # Search for open deals with this competitor
    search_url = "https://api.hubapi.com/crm/v3/objects/deals/search"
    headers = {
        "Authorization": f"Bearer {HUBSPOT_TOKEN}",
        "Content-Type": "application/json"
    }

    search_body = {
        "filterGroups": [{
            "filters": [
                {
                    "propertyName": "competitor",
                    "operator": "CONTAINS_TOKEN",
                    "value": competitor_name
                },
                {
                    "propertyName": "dealstage",
                    "operator": "NOT_IN",
                    "values": ["closedwon", "closedlost"]
                }
            ]
        }],
        "properties": ["dealname", "hubspot_owner_id", "competitor"]
    }

    deals = requests.post(search_url, json=search_body, headers=headers)
    results = deals.json().get("results", [])

    # Create a note on each deal
    for deal in results:
        note_body = {
            "properties": {
                "hs_note_body": (
                    f"Competitive Alert: {competitor_name}"
                    f"

{change['title']}"
                    f"

Analysis: {change['strategic_analysis']}"
                    f"

Auto-generated by RivalCheck"
                ),
                "hs_timestamp": change["detected_at"]
            },
            "associations": [{
                "to": {"id": deal["id"]},
                "types": [{"associationCategory": "HUBSPOT_DEFINED",
                          "associationTypeId": 214}]
            }]
        }
        requests.post(
            "https://api.hubapi.com/crm/v3/objects/notes",
            json=note_body,
            headers=headers
        )

    return "OK", 200

# Prompt for Claude with RivalCheck MCP tools available

Using the RivalCheck tools, generate a weekly competitive
briefing for our leadership team. Follow this structure:

1. EXECUTIVE SUMMARY (3 sentences max)
   - The single most important competitive development this week
   - Overall competitive landscape temperature (heating up / stable / cooling)

2. TOP COMPETITIVE MOVES (ranked by strategic impact)
   For each: competitor name, what changed, why it matters,
   recommended response

3. PRICING INTELLIGENCE
   - Any pricing changes detected this week
   - How our pricing compares (pull the landscape view)
   - Pricing opportunities or risks

4. BATTLE CARD STATUS
   - Which battle cards were updated and why
   - Any cards flagged as stale

5. RECOMMENDED ACTIONS
   - For Product: features to prioritize or deprioritize
   - For Sales: talking points to update, deals to flag
   - For Marketing: positioning adjustments, content opportunities

Keep the tone executive-friendly. No jargon. Each section
should be scannable in under 30 seconds.

// Node.js webhook handler (Express)
const express = require("express");
const app = express();
app.use(express.json());

const API_KEY = process.env.RIVALCHECK_API_KEY;
const API_BASE = "https://app.rivalcheck.com/api/v1";

app.post("/webhooks/rivalcheck", async (req, res) => {
  const event = req.body;

  if (event.event !== "change.detected") {
    return res.sendStatus(200);
  }

  const { severity, competitor } = event.data;

  // Only regenerate for significant changes
  if (severity !== "high" && severity !== "medium") {
    return res.sendStatus(200);
  }

  console.log(
    `Regenerating battle card for ${competitor.name} ` +
    `(${severity} severity change)`
  );

  try {
    const response = await fetch(
      `${API_BASE}/competitors/${competitor.id}/battle_card/generate`,
      {
        method: "POST",
        headers: {
          "Authorization": `Bearer ${API_KEY}`,
          "Content-Type": "application/json"
        },
        body: JSON.stringify({ force: true })
      }
    );

    const result = await response.json();
    console.log(`Battle card regeneration started: ${result.status}`);
  } catch (error) {
    console.error(`Failed to regenerate: ${error.message}`);
  }

  res.sendStatus(200);
});

app.listen(8080, () => console.log("Listening on :8080"));