From Alert to Action: Setting Up Real-Time Threat Notifications

Your security tool just blocked a prompt injection attempt against your production support bot. Do you know about it?

If the answer is "I'll check the dashboard tomorrow morning"—you have a visibility problem.

Security events are time-sensitive. A blocked injection might be a one-off from a curious user. Or it might be the first probe in a systematic attack. The difference is in the pattern, and you can only see the pattern if you know about each event as it happens.

PromptGuard supports two alerting channels: email and webhooks. This guide focuses on webhooks, which give you real-time notifications with structured data you can route, filter, and act on.

The Webhook Payload

When PromptGuard blocks a request (or detects a threat with high confidence), it fires a webhook to your configured URL. The payload is JSON and designed to be Slack-compatible out of the box:

{
  "event": "threat_detected",
  "threat_type": "prompt_injection",
  "decision": "block",
  "confidence": 0.94,
  "reason": "Prompt injection detected: instruction override pattern with 94% confidence",
  "project": "Support Bot v3",
  "timestamp": "2026-01-25T14:32:17Z",
  "text": "[PromptGuard] Prompt Injection in *Support Bot v3* (94%, block)"
}

The text field is formatted for Slack's markdown syntax (bold with *asterisks*). If you point the webhook at a Slack incoming webhook URL, it just works—no transformation needed.

Setting Up Slack Alerts (5 Minutes)

Step 1: Create a Slack Incoming Webhook

1. Go to api.slack.com/apps
2. Create a new app (or use an existing one)
3. Enable "Incoming Webhooks"
4. Add a webhook to your desired channel (e.g., #security-alerts)
5. Copy the webhook URL: https://hooks.slack.com/services/T.../B.../xxx

Step 2: Configure in PromptGuard

In the PromptGuard dashboard:

1. Navigate to your project settings
2. Paste the Slack webhook URL in the "Webhook URL" field
3. Save

That's it. The next time PromptGuard blocks a request for this project, you'll see a message in your Slack channel:

[PromptGuard] Prompt Injection in Support Bot v3 (94%, block)

Step 3: Customize the Channel

For production applications, we recommend separate channels for different severity levels:

• #security-critical — High-confidence blocks (>0.90), data exfiltration attempts, fraud detection
• #security-alerts — All blocks and high-confidence detections
• #security-log — All events including redactions (high volume)

You can route to different channels using a webhook relay (like Zapier, n8n, or a simple serverless function) that inspects the confidence and threat_type fields and routes accordingly.

Setting Up Custom Webhook Handlers

For non-Slack destinations—PagerDuty, Opsgenie, Discord, Microsoft Teams, or your own backend—you can build a handler that processes the webhook payload.

Example: Express.js Webhook Handler

import express from 'express';

const app = express();
app.use(express.json());

app.post('/promptguard-webhook', (req, res) => {
  const { event, threat_type, decision, confidence, project, reason } = req.body;

  console.log(`[${project}] ${threat_type}: ${decision} (${confidence})`);

  // Route based on severity
  if (confidence >= 0.90 && decision === 'block') {
    // Critical: page the on-call engineer
    pagerduty.trigger({
      summary: `High-confidence ${threat_type} blocked in ${project}`,
      severity: 'critical',
      details: req.body
    });
  } else if (decision === 'block') {
    // Standard: log to security dashboard
    securityDashboard.log(req.body);
  }

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

Example: Python Webhook Handler

from fastapi import FastAPI, Request

app = FastAPI()

@app.post("/promptguard-webhook")
async def handle_webhook(request: Request):
    payload = await request.json()

    threat_type = payload.get("threat_type")
    confidence = payload.get("confidence", 0)
    decision = payload.get("decision")
    project = payload.get("project")

    # Log all events
    logger.info(
        f"[{project}] {threat_type}: {decision} "
        f"(confidence: {confidence})"
    )

    # Escalate high-severity events
    if confidence >= 0.90 and decision == "block":
        await notify_security_team(payload)

    # Track patterns
    if threat_type == "prompt_injection":
        await increment_injection_counter(project)

    return {"status": "ok"}

Building a Threat Response Workflow

Raw alerts are useful. A structured response workflow is better.

Level 1: Automated Logging

Every webhook event should be logged to your security information system. This creates an audit trail for compliance and enables pattern analysis.

# Log to your SIEM, database, or analytics platform
async def log_security_event(payload):
    await db.security_events.insert({
        "timestamp": payload["timestamp"],
        "project": payload["project"],
        "threat_type": payload["threat_type"],
        "decision": payload["decision"],
        "confidence": payload["confidence"],
        "reason": payload["reason"]
    })

Level 2: Pattern Detection

Individual events are less informative than patterns. Set up rules to detect:

Sustained attacks: 10+ blocks from the same project in 5 minutes suggests a coordinated attack, not a random user.

async def check_attack_pattern(payload):
    recent_count = await db.security_events.count({
        "project": payload["project"],
        "timestamp": {"$gte": five_minutes_ago()},
        "decision": "block"
    })

    if recent_count >= 10:
        await escalate("Sustained attack detected", payload)

New threat types: If you see data_exfiltration for the first time in a project that usually only triggers prompt_injection, someone is escalating their attack sophistication.

Confidence drift: If average block confidence is dropping over time, attackers may be finding increasingly subtle evasion techniques. This is a signal to review your detection configuration.

Level 3: Automated Response

For high-confidence, repeated attacks, consider automated responses:

async def auto_respond(payload):
    if payload["confidence"] >= 0.95 and payload["decision"] == "block":
        # Check if this is a repeat offender
        recent_blocks = await count_blocks_from_same_source(
            payload, window_minutes=60
        )

        if recent_blocks >= 5:
            # Automatically enable rate limiting for this project
            await enable_strict_rate_limiting(payload["project"])
            await notify_team(
                f"Auto-enabled strict rate limiting for {payload['project']} "
                f"after {recent_blocks} high-confidence blocks in 1 hour"
            )

Email Alerts

In addition to webhooks, PromptGuard sends email alerts to the project owner. Email alerting is configured per-user with three levels:

For most teams, we recommend critical for email (to avoid alert fatigue) and webhooks for everything else (to maintain real-time visibility without inbox overload).

Monitoring Your Alerting Pipeline

Alerting systems have a meta-problem: how do you know your alerts are working?

Webhook delivery failures are logged but silent—if your webhook endpoint is down, you won't receive the alert telling you it's down.

We recommend:

1. Health check your webhook endpoint independently (UptimeRobot, Pingdom, etc.)
2. Send a test alert weekly to verify the full pipeline works
3. Monitor alert volume — a sudden drop to zero might mean your webhook is broken, not that attacks stopped
4. Set up a dead man's switch — if you don't receive at least one alert per day (even a test), escalate

Conclusion

The gap between "threat detected" and "threat responded to" is where damage happens. A blocked injection at 2 AM is a data point. A Slack message at 2 AM is actionable intelligence.

Set up webhooks. Route them to Slack. Build pattern detection. Automate responses for high-confidence repeated attacks. And test your alerting pipeline regularly—because the worst time to discover your alerts are broken is during an actual incident.

Security isn't just about blocking threats. It's about knowing you're blocking them.