Monitoring Make (Integromat) with Vigilmon: Webhook Uptime, Scenario Health, SSL Certificates & Platform Status

Make (formerly Integromat) orchestrates complex multi-step automations across your SaaS stack — routing data between apps, transforming payloads, and triggering business logic in response to external events. When a Make webhook receiver goes offline or a scenario stops responding to triggers, the automation chain breaks silently. No crashed server, no 500 error in your own logs — just events piling up unprocessed or disappearing entirely. Vigilmon gives you external uptime monitoring over Make's reachable surfaces: your webhook trigger URLs, the platform status API, and any custom domains in your Make setup. Know about automation failures before the affected team notices data missing.

What You'll Build

• Uptime monitors on Make webhook trigger URLs
• A Vigilmon check on Make's platform status endpoint
• SSL certificate monitoring for custom Make domains
• Alerting that separates Make platform incidents from scenario-level failures
• A structured checklist for identifying which scenarios need monitoring

Prerequisites

• A Make account with at least one scenario that uses a Webhook trigger (found under Add a trigger → Webhooks in the Make scenario editor)
• The webhook URL(s) for scenarios you want to monitor (format: https://hook.eu2.make.com/<your-webhook-token> or https://hook.make.com/<token>)
• A free account at vigilmon.online

Step 1: Identify Critical Make Webhook URLs

Make scenarios that use a Custom webhook or Mailhook trigger expose a unique URL. External services send payloads to this URL to trigger the scenario. Find webhook URLs in the scenario editor by clicking the Webhooks trigger module — the URL is displayed in the module config panel.

Make uses regional webhook domains depending on your data-center selection:

| Data center | Webhook domain | |---|---| | US | hook.make.com | | EU | hook.eu1.make.com or hook.eu2.make.com | | Custom (Enterprise) | Your custom domain |

Test a webhook URL to confirm it is receiving:

curl -X POST https://hook.eu2.make.com/your-webhook-token \
  -H "Content-Type: application/json" \
  -d '{"test": true}'

A healthy Make webhook returns Accepted with HTTP 200. Note the URLs for all revenue-critical or data-pipeline scenarios.

Step 2: Create a Vigilmon Monitor for Each Critical Webhook

For each Make webhook trigger you want to monitor:

1. Log in to Vigilmon → Add Monitor → HTTP.
2. URL: your Make webhook URL (e.g., https://hook.eu2.make.com/your-webhook-token).
3. Method: GET (Vigilmon probes with GET; Make will return a response confirming the endpoint exists).
4. Check interval: 5 minutes.
5. Response timeout: 15 seconds.
6. Expected status: 200.
7. Keyword: Accepted (Make webhook endpoints return this string on success).
8. Label: name it after the scenario, e.g., Make: Shopify order sync.
9. Click Save.

Side-effect awareness: A GET probe to a Make webhook does run the scenario if it accepts GET requests. For scenarios where running from a probe payload would cause side effects (sending emails, writing to a database), add a guard step at the top: check if the payload matches a probe signature (e.g., {"_probe": true}) and route those to an immediate success response without executing the automation logic.

Step 3: Monitor Make's Platform Status

Make publishes a machine-readable status endpoint. Add a Vigilmon monitor to detect platform-wide incidents automatically:

curl https://status.make.com/api/v2/status.json

Expected healthy response:

{
  "status": {
    "indicator": "none",
    "description": "All Systems Operational"
  }
}

Add the monitor:

1. Add Monitor → HTTP.
2. URL: https://status.make.com/api/v2/status.json.
3. Check interval: 60 seconds.
4. Expected status: 200.
5. Keyword: none (matches indicator when all systems are operational).
6. Label: Make Platform Status.
7. Click Save.

When your webhook monitors fire at the same time as this status check, the root cause is a Make platform incident — not a configuration issue in your scenario. When only a specific webhook monitor fires, the issue is scenario-level: the scenario is paused, at its operation limit, or the source service stopped sending events.

Step 4: Monitor the Make App Domain

Make's application domain (www.make.com and the API endpoint api.eu1.make.com / api.make.com) serves scenario scheduling, module configuration, and the management UI. External service webhooks delivered to Make pass through the Make webhook ingestion layer — not the app domain — so a degraded app domain may not immediately break running scenarios, but it will prevent you from making changes or diagnosing issues:

1. Add Monitor → HTTP.
2. URL: https://www.make.com (or https://www.make.com/api/v2/users/me if you want to probe the API layer).
3. Check interval: 5 minutes.
4. Expected status: 200.
5. Label: Make App.
6. Click Save.

Step 5: Monitor SSL Certificates

Make's default webhook domains use Make-managed SSL. If you use a custom domain (available on Enterprise plans), that certificate is your responsibility. A lapsed certificate causes all webhook delivery attempts to fail with SSL errors — senders will see certificate verify failed and stop retrying:

1. Add Monitor → SSL Certificate.
2. Domain: your custom Make webhook domain (e.g., hooks.your-company.com).
3. Alert when expiry is within: 30 days.
4. Alert again: 14 days, 7 days, 3 days, 1 day.
5. Click Save.

If you use only Make's default domains (hook.make.com, hook.eu2.make.com), Make manages SSL and you can skip this step.

Step 6: Configure Alerting

In Vigilmon under Settings → Notifications, configure alert channels:

| Monitor | Trigger | Action | |---|---|---| | Make Platform Status | indicator not none | Check status.make.com; notify data team of potential automation gaps | | Webhook trigger URL | Non-200 or Accepted missing | Verify scenario is active; check Make operation limits for current billing period | | Make App | Non-200 | Platform management degraded; check status.make.com before making scenario changes | | SSL Certificate | < 30 days to expiry | Renew certificate; verify ACME automation for custom webhook domain |

Alert sensitivity: 2 consecutive failures for webhook monitors (single transient failures are common on less-trafficked Make webhooks). 1 failure for the platform status monitor since that indicates a broad incident.

Monitoring Make Operation Limits

Make bills by operations (the number of module executions per month). When a team hits its operation limit, Make pauses scenario execution — but webhook URLs stay reachable and return 200, so your endpoint monitors will stay green even though scenarios have stopped running.

To catch operation-limit issues:

• Set up a Make notification email under Account → Notifications for when you reach 80% of your operation limit.
• Add an internal Vigilmon monitor on a probe scenario that writes to an external endpoint you control (e.g., a simple Cloudflare Worker that accepts a POST and returns 200). If that probe scenario stops executing, the external endpoint will stop receiving its regular heartbeat.

This two-layer approach — external endpoint monitoring via Vigilmon plus Make's internal operation notifications — covers both network-level and quota-level failures.

Common Make Failure Modes and What Vigilmon Catches

| Scenario | Vigilmon monitor | |---|---| | Make platform incident | Status monitor fires; webhook monitors may fire simultaneously | | Scenario paused by owner | Webhook URL stays reachable but scenario stops executing; internal probe pattern catches this | | Operation limit reached | Webhook URL returns 200 but executions stop; use internal probe + Make notifications | | Custom domain SSL expires | SSL monitor fires at 30-day threshold | | Webhook URL changed or scenario deleted | Webhook monitor gets 404 or non-200 | | Regional datacenter degraded | Regional webhook monitors (hook.eu2) fire; US monitors (hook.make.com) stay green | | DNS misconfiguration on custom domain | All custom-domain monitors fire simultaneously |

Make scenarios are the connective tissue between your SaaS tools — when they fail silently, the impact shows up downstream as missing records, unsent notifications, and stalled pipelines. Vigilmon gives you an external safety net: reachability checks on your webhook trigger endpoints, platform status monitoring, and SSL certificate alerts so you catch Make failures before they become data-loss incidents.

Start monitoring Make in under 5 minutes — register free at vigilmon.online.