Build an AI Agent That Monitors Competitors: Stalkr + Claude Webhooks

What this guide covers: Build a production-ready agent that watches competitor mentions across social platforms, classifies urgency, and notifies your team — all automated with webhooks and zero manual checking.

Time to implement: 2-3 hours
Requirements: Node.js 18+, Anthropic API key, Stalkr account ($29-99/month)
Real outcome: Competitor mentions → classified → team notified in <2 minutes

The Problem (And Why Manual Monitoring Fails)

You have three competitors. Every week, they launch features. Sometimes they beat you to a market. Sometimes they steal your messaging. Sometimes a customer publicly complains about them, and you have no idea.

Your options today:

• Google Alerts: Free, but miss 80% of relevant mentions. No filtering. No context.
• Hootsuite/Sprout Social: $500/month. Overkill for a bootstrapped team. You end up not using it.
• Build it yourself: Write a scraper for each platform. Twitter/X API costs $100/month minimum. LinkedIn blocks scrapers. Reddit throttles requests. The cost isn't the problem. The problem is you don't know what you're missing.

Then you see a Twitter thread with 50K likes: competitor just announced a feature that directly competes with yours. Your team finds out from a customer email. Not ideal.

The Solution: Webhooks + AI Agent Loop

Stalkr watches 4 platforms (X, Reddit, YouTube, LinkedIn) for your tracked keywords. When it finds a mention, it sends a webhook with the full details. Your Claude agent:

1. Receives the webhook (REST endpoint)
2. Analyzes the mention (is it a threat, an opportunity, or noise?)
3. Classifies urgency (critical, medium, low)
4. Takes action (posts to Slack, creates Notion task, updates CRM, triggers email) What makes this work:

• Real-time: Mentions hit your agent within 90 seconds
• Context-aware: Claude reads full mention thread, determines if it's actionable
• Actionable: Not just alerts. The agent decides what to do with the info
• Cheap: Stalkr is $29-99/month. API calls cost <$0.01 per mention. Total cost: ~$35/month

Architecture: How The Pieces Talk

Stalkr monitors X, Reddit, YouTube, LinkedIn
    ↓ (webhook POST when mention found)
Your Express server (receives JSON payload)
    ↓ (forward to Claude)
Claude agent (ReAct loop)
    ↓ (calls tools based on urgency)
Slack + Notion + Email + CRM APIs
    ↓ (team sees the alert)
Human decides: respond, ignore, or escalate

The agent acts as a filter + classifier + dispatcher. Without it, you get 20 alerts a day and ignore 19. With it, you get 2-3 actually-important alerts and respond to each.

Real Metrics (What Actually Happens)

Tested with 3 competitors tracked across 5 keywords each:

The $35/month buys you:

• Stalkr: $29 (or $99 if you add YouTube/SEO)
• Claude API: ~$6 (average 50 mentions/month × ~$0.001)
• Slack/Notion webhooks: free Without this automation, your option is hiring someone ($2k-3k/month) to manually check 4 platforms daily.

When To Use This (And When Not To)

Use this if:

• You have 2-5 specific competitors you want to track
• You care about social signals (what customers say about competitors)
• You ship fast and need to react quickly to competitive moves
• Your team is <10 people (time-sensitive decisions are better made together)
• You've tried Google Alerts and kept missing things Don't use this if:
• You just want high-level market research (hire an analyst instead)
• You need to monitor 50+ keywords (scales poorly; consider Sprout Social)
• You need historical data archives (Stalkr keeps 7 days; long-term = use DataBox)
• You need compliance reporting (SaaS monitoring tools have audit trails; this doesn't)

Cost Breakdown: Stalkr + Claude vs Alternatives

The trade-off: Stalkr is 15x cheaper than Sprout Social. You lose 5-10% recall (some mentions still slip through) but gain speed and stay under 2-person headcount.

Step-by-Step Build

Step 1: Create Stalkr Monitor (2 minutes)

1. Sign up at stalkr.ai
2. Click "Create Monitor"
3. Add keywords (competitor names, product names, your category)
4. Select platforms: X, Reddit, YouTube, LinkedIn
5. Set webhook URL: https://your-app.com/api/mentions
6. Copy your Stalkr API key (you'll use it to verify webhook signatures) Stalkr will POST to your endpoint when it finds mentions.

Step 2: Set Up Express Webhook Receiver

import express from 'express';
import { Anthropic } from '@anthropic-ai/sdk';
 
const app = express();
app.use(express.json());
 
const client = new Anthropic();
const STALKR_API_KEY = process.env.STALKR_API_KEY;
 
// Verify webhook signature (Stalkr includes x-stalkr-signature header)
function verifySignature(req) {
  const signature = req.headers['x-stalkr-signature'];
  if (!signature) return false;
  // Stalkr signs with HMAC-SHA256
  const crypto = require('crypto');
  const hash = crypto.createHmac('sha256', STALKR_API_KEY)
    .update(JSON.stringify(req.body))
    .digest('hex');
  return hash === signature;
}
 
app.post('/api/mentions', async (req, res) => {
  // Verify it's really from Stalkr
  if (!verifySignature(req)) {
    return res.status(401).json({ error: 'Invalid signature' });
  }
 
  const mention = req.body; // Contains: text, url, platform, posted_at, source_handle
  
  try {
    // Send to Claude agent
    await processMentionWithAgent(mention);
    res.status(200).json({ ok: true });
  } catch (err) {
    console.error('Error processing mention:', err);
    res.status(500).json({ error: err.message });
  }
});
 
app.listen(3000, () => console.log('Webhook ready on :3000'));

Step 3: Build the Claude Agent Loop

async function processMentionWithAgent(mention) {
  const systemPrompt = `You are a competitive intelligence agent. 
You receive mentions of competitors from social platforms.
Your job:
1. Understand the mention (what is being said?)
2. Classify urgency (critical=feature announcement/major complaint, 
   medium=pricing change/hiring, low=commentary)
3. Decide action (slack alert, create Notion task, email founder, log only)
 
Be concise. No fluff.`;
 
  const userMessage = `
Platform: ${mention.platform}
Author: @${mention.source_handle}
Time: ${mention.posted_at}
URL: ${mention.url}
Text: "${mention.text}"
 
Analyze this mention. Respond ONLY as valid JSON:
{
  "summary": "one-liner of what this is about",
  "urgency": "critical|medium|low",
  "is_actionable": true|false,
  "action": "slack|notion|email|ignore",
  "reason": "why this urgency/action"
}`;
 
  const response = await client.messages.create({
    model: 'claude-opus-5',
    max_tokens: 300,
    system: systemPrompt,
    messages: [{ role: 'user', content: userMessage }],
  });
 
  // Parse JSON response
  const jsonText = response.content[0].text;
  const analysis = JSON.parse(jsonText);
 
  // Act on the analysis
  if (analysis.action === 'slack') {
    await sendToSlack(mention, analysis);
  } else if (analysis.action === 'notion') {
    await createNotionTask(mention, analysis);
  } else if (analysis.action === 'email') {
    await sendEmail(mention, analysis);
  }
  
  // Log all mentions to database for later review
  await logMentionToDatabase(mention, analysis);
}

Step 4: Add Tool Integrations (Slack Example)

async function sendToSlack(mention, analysis) {
  const slackWebhook = process.env.SLACK_WEBHOOK_URL;
  
  const payload = {
    text: `🚨 **${analysis.urgency.toUpperCase()}** | ${analysis.summary}`,
    blocks: [
      {
        type: 'header',
        text: {
          type: 'plain_text',
          text: `${analysis.urgency.toUpperCase()}: ${mention.source_handle}`,
        },
      },
      {
        type: 'section',
        text: {
          type: 'mrkdwn',
          text: `*What:* ${analysis.summary}\n*Platform:* ${mention.platform}\n*Reason:* ${analysis.reason}`,
        },
      },
      {
        type: 'section',
        text: {
          type: 'mrkdwn',
          text: `> "${mention.text}"`,
        },
      },
      {
        type: 'actions',
        elements: [
          {
            type: 'button',
            text: { type: 'plain_text', text: 'Read Full Thread' },
            url: mention.url,
          },
        ],
      },
    ],
  };
 
  const res = await fetch(slackWebhook, {
    method: 'POST',
    body: JSON.stringify(payload),
    headers: { 'Content-Type': 'application/json' },
  });
 
  if (!res.ok) throw new Error(`Slack API error: ${res.status}`);
}

Step 5: Add Rate Limiting + Error Handling

import pLimit from 'p-limit';
 
// Prevent Claude API rate limits (5 concurrent requests max)
const limit = pLimit(5);
 
// Retry with exponential backoff
async function retryWithBackoff(fn, maxAttempts = 3) {
  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
    try {
      return await fn();
    } catch (err) {
      if (attempt === maxAttempts) throw err;
      const delay = Math.pow(2, attempt - 1) * 1000; // 1s, 2s, 4s
      await new Promise(r => setTimeout(r, delay));
    }
  }
}
 
// Use in webhook handler
app.post('/api/mentions', async (req, res) => {
  // ... signature check ...
  
  // Queue the mention for processing (don't wait for it)
  limit(() => 
    retryWithBackoff(() => processMentionWithAgent(req.body))
      .catch(err => console.error('Failed after retries:', err))
  );
  
  res.status(202).json({ status: 'queued' });
});

Real Example: What Happens In Practice

Mention arrives:

Platform: X
Author: @ProductHunt
Text: "New competitor just launched AI-powered customer support. 
Uses OpenAI. More affordable than Intercom. 1000+ upvotes."

Agent classifies:

{
  "summary": "Direct competitor launched cheaper alternative to main product",
  "urgency": "critical",
  "is_actionable": true,
  "action": "slack",
  "reason": "New market entrant with lower pricing; needs immediate team response"
}

Action taken: Slack notification to #competitive-intel with link to full thread.

What happens next: Your team reads it, decides: respond on X, or accelerate your roadmap, or understand their pricing. They have full context in <2 minutes. Without the agent, you might not see this for 3 days (if you're checking Twitter that day).

Troubleshooting

Webhook not firing?

• Check Stalkr dashboard → "Test webhook" button
• Verify your URL is publicly accessible (not localhost)
• Check Stalkr logs for HTTP errors (Stalkr retries 3x then stops) Claude keeps hallucinating the urgency?
• Be more specific in your system prompt
• Show examples: Critical examples: price drop, feature launch. Medium: hiring, blog post.
• Use JSON mode: responses are structured, harder to misinterpret Too many false positives?
• Refine keywords in Stalkr (avoid overly broad terms)
• Add exclusions ("monitoring" keyword but NOT "employee monitoring")
• Make agent smarter: ignore if <100 likes and <5 replies (filter out noise) High Claude API costs?
• Most teams see <$10/month. If higher:
  • Switch to Claude Sonnet 5 instead of Opus 5 ($2/$10 vs $5/$25 = 60% cost cut). Handles mention classification 95% as well.
  • Reduce Stalkr keywords (fewer mentions = fewer API calls)
  • Cache mentions using Redis (dedupe if same mention hits multiple keywords)
  • Use Batch API (process daily at 2 AM, 50% discount)

When This Wins vs When It Loses

This wins:

• You react to competitive threats before your customers ask
• You catch pricing moves (margin opportunity)
• You find feature announcements before press releases
• You see what customers actually say (raw unfiltered feedback) This loses:
• You still miss private/closed community mentions
• LinkedIn posts require premium access (Stalkr gets headlines only)
• You get noise if your category has common words ("AI" has 5M+ posts/day)
• Requires ongoing prompt tuning (agent gets better with feedback)

Next Steps

1. Set up: Stalkr account → webhook endpoint → Claude agent (2-3 hours)
2. Test: Add one competitor, watch what triggers alerts for a week
3. Refine: Adjust keyword lists, tweak urgency classifications
4. Scale: Add more competitors, integrate more tools (Notion, email, CRM)
5. Measure: After one month, ask: did we catch anything valuable? Did we avoid surprises? Start with Slack-only integration. Add Notion/email/CRM later once you see the signal quality.