Stop polling.
Get notified instantly.

Why webhooks are the foundation for modern network operations

Webhooks aren't just about reducing API calls. They're the event layer that enables everything from simple alerting to fully autonomous network management.

How webhooks work

NCM webhooks are built on the alert system. You create an HTTP destination (your server), configure alert rules for the events you care about, and NCM pushes a notification to your URL when those events fire.

1. Create a destination — tell NCM where to send notifications (your URL + a shared secret)
2. Test the destination — verify NCM can reach your server
3. Create an alert rule — pick which events trigger notifications
4. Link the destination — attach your HTTP destination to the alert rule

When an event fires, NCM sends an HTTP POST to your URL with the alert payload. Your server validates the request using the shared secret and processes the event.

Setup guide

POST https://www.cradlepointecm.com/api/v2/alert_push_destinations/

{
  "name": "My Monitoring Server",
  "address": "https://my-server.example.com/webhooks/ncm",
  "secret": "your-shared-secret-here",
  "enabled": true
}

POST https://www.cradlepointecm.com/api/v2/test_alert_push_destinations/

{
  "destination_config_id": "YOUR_DESTINATION_CONFIG_ID",
  "secret": "your-shared-secret-here"
}

POST https://www.cradlepointecm.com/api/v2/alert_rules/

{
  "name": "Router Online/Offline Alerts",
  "alert_types": ["online_offline_alert"],
  "http_destinations": ["YOUR_DESTINATION_CONFIG_ID"],
  "enabled": true
}

from flask import Flask, request, jsonify

app = Flask(__name__)
SHARED_SECRET = "your-shared-secret-here"

@app.route("/webhooks/ncm", methods=["POST"])
def handle_webhook():
    # Verify the secret matches
    payload = request.json

    # Process the alert
    alert_type = payload.get("alert_type")
    router_name = payload.get("router_name", "Unknown")

    if alert_type == "online_offline_alert":
        state = payload.get("state", "unknown")
        print(f"Router {router_name} is now {state}")

    return jsonify({"status": "ok"}), 200

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

Available alert types

These are the event categories you can subscribe to. Each category contains multiple specific alert types.

Each category links to its full alert type definitions, thresholds, and example alert messages. See the complete Alerting and Reporting documentation for details.

Common recipes

“Alert me when any router goes offline”

This is the #1 reason customers poll. Replace it with a single alert rule.

# 1. Create destination (one-time setup)
POST /api/v2/alert_push_destinations/
{"name": "NOC Dashboard", "address": "https://noc.example.com/hooks", "secret": "s3cret", "enabled": true}

# 2. Create alert rule for online/offline
POST /api/v2/alert_rules/
{"name": "Fleet Online/Offline", "alert_types": ["online_offline_alert"], "http_destinations": ["DEST_CONFIG_ID"], "enabled": true}

# Done. You'll get a POST to your URL within seconds of any router going offline.

“Alert me when signal drops below -90 dBm”

Instead of polling net_device_signal_samples, set a threshold alert.

POST /api/v2/alert_rules/
{
  "name": "Low Signal Alert",
  "alert_types": ["signal_strength_alert"],
  "threshold": -90,
  "http_destinations": ["DEST_CONFIG_ID"],
  "enabled": true
}

“Alert me when a config change is pushed”

Track configuration changes across your fleet without polling configuration_managers.

POST /api/v2/alert_rules/
{
  "name": "Config Change Tracking",
  "alert_types": ["config_push_alert", "config_rejected_alert"],
  "http_destinations": ["DEST_CONFIG_ID"],
  "enabled": true
}

“Alert me on carrier failover”

Know immediately when a device switches from primary to backup WAN.

POST /api/v2/alert_rules/
{
  "name": "Failover Alerts",
  "alert_types": ["failover_alert"],
  "http_destinations": ["DEST_CONFIG_ID"],
  "enabled": true
}

Integration examples

ServiceNow — auto-create incident on device offline

import requests

def handle_ncm_webhook(payload):
    if payload.get("alert_type") == "online_offline_alert":
        if payload.get("state") == "offline":
            # Create ServiceNow incident
            requests.post("https://your-instance.service-now.com/api/now/table/incident",
                json={
                    "short_description": f"Router {payload['router_name']} went offline",
                    "description": f"Device {payload['router_id']} in group {payload.get('group', 'N/A')} went offline at {payload.get('timestamp')}",
                    "urgency": "2",
                    "category": "Network"
                },
                auth=("admin", "password")
            )

Slack — post to a channel on any alert

import requests

SLACK_WEBHOOK = "https://hooks.slack.com/services/YOUR/SLACK/WEBHOOK"

def handle_ncm_webhook(payload):
    router = payload.get("router_name", "Unknown")
    alert = payload.get("alert_type", "unknown")

    requests.post(SLACK_WEBHOOK, json={
        "text": f"NCM Alert: {alert} on router {router}",
        "blocks": [
            {"type": "section", "text": {"type": "mrkdwn",
                "text": f"{alert}\nRouter: {router}\nTime: {payload.get('timestamp', 'N/A')}"
            }}
        ]
    })

API reference

Webhooks are configured through these v2 API endpoints:

• alert_push_destinations — create and manage HTTP destinations (your webhook URLs)
• alert_rules — configure which events trigger notifications
• test_alert_push_destinations — test that NCM can reach your destination
• alerts — view alerts that have been generated
• router_alerts — view device-specific alerts

Authentication for these endpoints uses the v2 API key headers (X-CP-API-ID, X-CP-API-KEY, X-ECM-API-ID, X-ECM-API-KEY).

Firewall configuration

If your webhook destination is behind a firewall, you'll need to allowlist NCM's outbound IP addresses. See the alert_push_destinations documentation for the current list of outbound IPs.