Integrate DNSRadar with Zapier

Zapier is a workflow automation platform that connects to thousands of apps. By integrating DNSRadar with Zapier, you can automate responses to DNS changes with powerful multi-step workflows called "Zaps".

Architecture Overview

The integration works through webhooks:

  1. DNSRadar detects a DNS change
  2. DNSRadar sends webhook to Zapier
  3. Zapier workflow processes the event
  4. Zapier triggers downstream actions (notifications, tickets, API calls, etc.)

Setting Up the Integration

Step 1: Create a Zapier Webhook

In your Zapier account:

  1. Create a new Zap
  2. Search for and select Webhooks by Zapier as the trigger app
  3. Choose Catch Hook as the trigger event
  4. Click Continue
  5. Copy the Custom Webhook URL (e.g., https://hooks.zapier.com/hooks/catch/123456/abcdef/)
  6. Leave the Zapier editor open to test the webhook

Step 2: Create DNSRadar Webhook

Create a webhook in DNSRadar pointing to your Zapier webhook:

curl -X POST https://api.dnsradar.dev/webhooks \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "url": "https://hooks.zapier.com/hooks/catch/123456/abcdef/",
  "method": "POST",
  "secret": "your-secure-webhook-secret",
  "groups": [
    "production-dns"
  ]
}'

DNSRadar will use the secret to sign each request with HMAC SHA256, sending the signature in the X-DNSRadar-Signature header along with a X-Webhook-Timestamp header to prevent replay attacks.

Step 3: Test the Integration

Test your webhook to send a sample payload to Zapier:

curl -X POST https://api.dnsradar.dev/webhooks/wh_abc123/test \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{}'

Return to Zapier and click Test trigger to see if the webhook was received. You should see the sample data appear in Zapier.

Understanding the Webhook Payload

DNSRadar sends this payload to Zapier:

{
  "uuid": "req_abc123...",
  "webhook_uuid": "wh_abc123...",
  "created": "2026-01-08T10:35:22Z",
  "event": {
    "event_uuid": "evt_xyz789",
    "monitor_uuid": "mon_abc123",
    "domain": "piedpiper.com",
    "subdomain": "www",
    "record_type": "A",
    "expected_value": ["1.2.3.4"],
    "previous_value": ["1.2.3.4"],
    "current_value": ["5.6.7.8"],
    "old_state": "VALID",
    "new_state": "MISMATCH",
    "occurred": "2026-01-08T10:35:22Z",
    "incidence_count": 1
  }
}

Payload Structure

FieldDescription
uuidUnique webhook request identifier
webhook_uuidThe webhook that sent this request
createdWhen the webhook request was created (ISO 8601)
eventThe DNS change event details (nested object)

Event Object Fields

All DNS change data is nested within the event object:

FieldDescription
event_uuidUnique event identifier
monitor_uuidMonitor that detected the change
domainDomain name (e.g., "piedpiper.com")
subdomainSubdomain (e.g., "www")
record_typeDNS record type (A, AAAA, CNAME, MX, TXT, SPF, DMARC)
expected_valueExpected DNS values (array)
previous_valuePrevious DNS values (array)
current_valueCurrent DNS values (array)
old_statePrevious monitor state
new_stateCurrent monitor state
occurredWhen the DNS change occurred (ISO 8601)
incidence_countTotal incident count for this monitor

Access these values in Zapier using the field picker. For nested event fields, use Event prefix in Zapier (e.g., Event Domain, Event New State).

Example Zaps

1. Slack Notification

Goal: Send Slack message when DNS changes

Zap Setup:

  1. Trigger: Webhooks by Zapier - Catch Hook
  2. Action: Slack - Send Channel Message

Slack message configuration:

  • Channel: #dns-alerts
  • Message Text:
DNS Alert: {{event__domain}}.{{event__subdomain}}

Record Type: {{event__record_type}}
Expected: {{event__expected_value}}
Current: {{event__current_value}}
State: {{event__new_state}}

Time: {{event__occurred}}
Event ID: {{event__event_uuid}}
Request ID: {{uuid}}

Optional: Add a Filter step between trigger and action:

  • Field: Event New State
  • Condition: Exactly matches
  • Value: MISMATCH

2. Gmail Email Notification

Goal: Send email alerts for DNS changes

Zap Setup:

  1. Trigger: Webhooks by Zapier - Catch Hook
  2. Action: Gmail - Send Email

Email configuration:

A DNS change has been detected:

Domain: {{event__domain}}.{{event__subdomain}}
Record Type: {{event__record_type}}

Expected Value: {{event__expected_value}}
Previous Value: {{event__previous_value}}
Current Value: {{event__current_value}}

State: {{event__old_state}} → {{event__new_state}}
Incident Count: {{event__incidence_count}}
Occurred: {{event__occurred}}

Event ID: {{event__event_uuid}}
Monitor ID: {{event__monitor_uuid}}
Request ID: {{uuid}}

3. Google Sheets Logging

Goal: Track all DNS changes in a spreadsheet

Zap Setup:

  1. Trigger: Webhooks by Zapier - Catch Hook
  2. Action: Google Sheets - Create Spreadsheet Row

Spreadsheet columns:

  • Request UUID: {{uuid}}
  • Webhook UUID: {{webhook_uuid}}
  • Created: {{created}}
  • Event UUID: {{event__event_uuid}}
  • Monitor UUID: {{event__monitor_uuid}}
  • Domain: {{event__domain}}
  • Subdomain: {{event__subdomain}}
  • Record Type: {{event__record_type}}
  • Expected Value: {{event__expected_value}}
  • Current Value: {{event__current_value}}
  • Old State: {{event__old_state}}
  • New State: {{event__new_state}}
  • Occurred: {{event__occurred}}
  • Incident Count: {{event__incidence_count}}

4. Jira Ticket Creation

Goal: Create Jira tickets for DNS changes

Zap Setup:

  1. Trigger: Webhooks by Zapier - Catch Hook
  2. Filter: Only continue if Event New State is MISMATCH
  3. Action: Jira - Create Issue

Jira issue configuration:

  • Project: DNS-OPS
  • Issue Type: Task
  • Summary: DNS Change - {{event__domain}}.{{event__subdomain}}
  • Description:
Domain: {{event__domain}}.{{event__subdomain}}
Record Type: {{event__record_type}}

Previous Value: {{event__previous_value}}
Current Value: {{event__current_value}}

State Change: {{event__old_state}} → {{event__new_state}}
Occurred: {{event__occurred}}

Event UUID: {{event__event_uuid}}
Monitor UUID: {{event__monitor_uuid}}
Request ID: {{uuid}}
  • Priority: High (for MISMATCH)

5. PagerDuty Incident

Goal: Create PagerDuty incidents for critical DNS issues

Zap Setup:

  1. Trigger: Webhooks by Zapier - Catch Hook
  2. Filter: Only continue if Event New State is MISMATCH
  3. Action: PagerDuty - Create Incident

PagerDuty configuration:

  • Service: Your DNS on-call service
  • Title: DNS Mismatch: {{event__domain}}.{{event__subdomain}}
  • Urgency: High
  • Body:
Domain: {{event__domain}}.{{event__subdomain}}
Record Type: {{event__record_type}}
Expected: {{event__expected_value}}
Current: {{event__current_value}}
State: {{event__new_state}}
Event: {{event__event_uuid}}
Request: {{uuid}}

6. Microsoft Teams Notification

Goal: Alert team in Microsoft Teams

Zap Setup:

  1. Trigger: Webhooks by Zapier - Catch Hook
  2. Action: Microsoft Teams - Send Channel Message

Teams message:

  • Team: Operations
  • Channel: DNS Monitoring
  • Message:
**DNS Alert Detected**

**Domain**: {{event__domain}}.{{event__subdomain}}
**Record Type**: {{event__record_type}}
**State**: {{event__old_state}} → {{event__new_state}}

**Expected**: {{event__expected_value}}
**Current**: {{event__current_value}}

**Time**: {{event__occurred}}
**Event ID**: {{event__event_uuid}}
**Request ID**: {{uuid}}

7. Trello Card Creation

Goal: Track DNS changes as Trello cards

Zap Setup:

  1. Trigger: Webhooks by Zapier - Catch Hook
  2. Action: Trello - Create Card

Trello card configuration:

  • Board: DNS Operations
  • List: New Alerts
  • Card Name: DNS Change - {{event__domain}}.{{event__subdomain}}
  • Description:
Record Type: {{event__record_type}}
State: {{event__old_state}} → {{event__new_state}}

Expected: {{event__expected_value}}
Current: {{event__current_value}}

Occurred: {{event__occurred}}
Event: {{event__event_uuid}}
Request: {{uuid}}
  • Labels: Based on Event New State (use Formatter to map states to label names)

8. Discord Notification

Goal: Send alerts to Discord server

Zap Setup:

  1. Trigger: Webhooks by Zapier - Catch Hook
  2. Action: Discord - Send Channel Message

Discord message:

  • Channel: dns-alerts
  • Message Text:
:warning: **DNS Change Detected**

**Domain**: {{event__domain}}.{{event__subdomain}}
**Type**: {{event__record_type}}
**Status**: {{event__new_state}}

**Expected**: `{{event__expected_value}}`
**Current**: `{{event__current_value}}`

**Time**: {{event__occurred}}
**Event ID**: {{event__event_uuid}}

Advanced Patterns

Multi-Path Workflows

Route events based on severity using Paths:

Zap Setup:

  1. Trigger: Webhooks by Zapier - Catch Hook
  2. Paths by Zapier:
    • Path A (Critical): Event New State = MISMATCH
      • Send to PagerDuty
      • Send to Slack
    • Path B (Warning): Event New State = NOT_FOUND
      • Send to Email
      • Create Jira ticket
    • Path C (Info): Event New State = TIMEOUT
      • Log to Google Sheets

Adding Context with Formatter

Transform data before sending:

Example: Format domain display name

  1. Trigger: Webhooks by Zapier - Catch Hook
  2. Formatter by Zapier: Text - Replace
    • Input: {{event__domain}}.{{event__subdomain}}
    • Find: Empty subdomain text
    • Replace: Clean format
  3. Action: Send notification with formatted domain

Example: Create custom message based on state

  1. Trigger: Webhooks by Zapier - Catch Hook
  2. Formatter by Zapier: Utilities - Lookup Table
    • Lookup Value: {{event__new_state}}
    • Lookup Table:
      • MISMATCH → Critical DNS mismatch detected
      • NOT_FOUND → DNS record not found
      • TIMEOUT → DNS query timeout
      • VALID → DNS record restored to valid state
  3. Action: Use formatted message

Combining Multiple Actions

Send to multiple channels for critical events:

Zap Setup:

  1. Trigger: Webhooks by Zapier - Catch Hook
  2. Filter: Event New State = MISMATCH
  3. Action 1: Slack - Send message
  4. Action 2: PagerDuty - Create incident
  5. Action 3: Gmail - Send email
  6. Action 4: Google Sheets - Log event

Delay and Digest Pattern

Batch alerts to prevent notification fatigue:

Zap Setup:

  1. Trigger: Webhooks by Zapier - Catch Hook
  2. Append Entry and Schedule Digest by Zapier:
    • Digest Key: dns-alerts-hourly
    • Schedule: Every 1 hour
  3. When digest fires, send summary to Slack with all events

Using Storage for Deduplication

Track recent alerts to avoid duplicates:

Zap Setup:

  1. Trigger: Webhooks by Zapier - Catch Hook
  2. Storage by Zapier: Get Value
    • Key: alert-{{event__monitor_uuid}}
  3. Filter: Only continue if storage value is empty or old
  4. Action: Send alert
  5. Storage by Zapier: Set Value
    • Key: alert-{{event__monitor_uuid}}
    • Value: {{event__occurred}}

Webhook Security and Validation

Understanding DNSRadar Webhook Signatures

DNSRadar signs webhook requests using HMAC SHA256 for security:

curl -X POST https://api.dnsradar.dev/webhooks \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "url": "https://hooks.zapier.com/hooks/catch/123456/abcdef/",
  "method": "POST",
  "secret": "your-secure-webhook-secret",
  "groups": [
    "production-dns"
  ]
}'

DNSRadar includes these security headers:

  • X-DNSRadar-Signature: HMAC SHA256 signature of the request body
  • X-Webhook-Timestamp: UTC timestamp to prevent replay attacks

Validating Signatures in Zapier

Use Code by Zapier to verify the webhook signature:

Zap Setup:

  1. Trigger: Webhooks by Zapier - Catch Hook
  2. Code by Zapier: Run Python
import hmac
import hashlib
import json
from datetime import datetime, timezone

# Get headers and body
signature = input_data.get('headers', {}).get('X-Dnsradar-Signature', '')
timestamp = input_data.get('headers', {}).get('X-Webhook-Timestamp', '')
secret = 'your-secure-webhook-secret'

# Verify timestamp (prevent replay attacks - within 5 minutes)
try:
    event_time = datetime.fromisoformat(timestamp.replace('Z', '+00:00'))
    now = datetime.now(timezone.utc)

    if (now - event_time).total_seconds() > 300:
        raise Exception('Webhook request too old')
except:
    raise Exception('Invalid timestamp')

# Verify signature
body = json.dumps(input_data).encode('utf-8')
expected_signature = hmac.new(
    secret.encode('utf-8'),
    body,
    hashlib.sha256
).hexdigest()

if not hmac.compare_digest(signature, expected_signature):
    raise Exception('Invalid webhook signature')

# Return data if validation passes
return input_data
  1. Continue with actions

Optional: Custom Headers

You can still add custom headers for additional authentication layers:

curl -X POST https://api.dnsradar.dev/webhooks \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "url": "https://hooks.zapier.com/hooks/catch/123456/abcdef/",
  "method": "POST",
  "secret": "your-secure-webhook-secret",
  "headers": {
    "X-DNSRadar-Source": "production"
  },
  "groups": [
    "production-dns"
  ]
}'

Working with Arrays

DNSRadar sends expected_value, previous_value, and current_value as arrays within the event object. Handle them in Zapier:

Display Array Values

Use Formatter to join arrays:

  1. Formatter by Zapier: Text - Join
    • Input: {{event__expected_value}}
    • Separator: ,
    • Output: Use in subsequent steps

Compare Array Values

Use Code by Zapier for complex comparisons:

event = input_data.get('event', {})
expected = event.get('expected_value', [])
current = event.get('current_value', [])

if set(expected) == set(current):
    result = "Match"
else:
    result = "Mismatch"

return {'comparison': result, 'details': f"Expected: {expected}, Got: {current}"}

Troubleshooting

Webhook Not Triggering

Check these items:

  1. Zapier webhook URL is correct in DNSRadar
  2. Webhook is enabled in DNSRadar
  3. Zap is turned ON (not paused)
  4. Check Zapier's Zap History for errors

Test Your Webhook

From DNSRadar, send a test event:

curl -X POST https://api.dnsradar.dev/webhooks/wh_abc123/test \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{}'

Check Zapier's Zap History to see if it was received.

Missing Data in Zapier

If fields aren't appearing:

  1. Send a test webhook from DNSRadar
  2. In Zapier, click "Retest trigger" to refresh sample data
  3. Verify the field names match the webhook payload
  4. Check if the field contains data in the sample

Zap Not Continuing

Common causes:

  1. Filter blocking execution: Check filter conditions
  2. Required field empty: Ensure all required action fields have data
  3. Authentication failed: Reconnect the app account
  4. Rate limits: Check if you've hit API rate limits

View Zap History

Check execution logs:

  1. Open your Zap
  2. Click "Zap History" tab
  3. Review recent runs for errors
  4. Click individual runs to see detailed logs

Debug with Formatter

Add a Formatter step to inspect data:

  1. Formatter by Zapier: Utilities - Line Item to Text
    • Input: All webhook data
  2. Email by Zapier: Send yourself the formatted output
  3. Review what data is actually being received

Best Practices

Security

Implement webhook signature validation:

  1. Always provide a secret when creating webhooks
  2. Add signature validation using Code by Zapier
  3. Verify timestamps to prevent replay attacks
  4. Store webhook secrets in environment variables or secure storage

Error Handling

Set up error notifications:

  1. In Zap settings, enable "Send Zap error emails"
  2. Create a separate error-handling Zap
  3. Use try-catch in Code steps

Testing

Before going live:

  1. Test with DNSRadar webhook test endpoint
  2. Verify all actions complete successfully
  3. Check that notifications arrive correctly
  4. Validate formatting and data accuracy

Performance

Optimize your Zaps:

  1. Use Filters early to avoid unnecessary actions
  2. Consider digest patterns for high-volume events
  3. Use multi-step Zaps instead of multiple single-step Zaps
  4. Monitor task usage to stay within plan limits

Next Steps

External Resources