Webhook Setup Guide: Connect AI Receptionist to Any Platform

Your phone rings. A potential customer wants a quote for a kitchen remodel—$15,000 job. Your AI receptionist answers, asks the right questions, captures their name, email, project details, and budget. Then what?

If you're manually logging this information into your CRM hours later (or worse, days later), you're losing leads. In our analysis of 130,175 calls from 45 contractors over 7 months, we found that businesses using automated CRM integration capture 3X more leads because customer information flows into their system within seconds of the call ending, not when someone "gets around to it."

This guide shows you exactly how to connect your AI receptionist to any platform using webhooks—with complete code examples, platform-specific integrations for HubSpot and Salesforce, and honest guidance on when custom webhooks are worth it versus using Zapier.

---

When Custom Integrations Make Sense

Before you write a single line of code, let's answer the real question: Do you even need custom webhooks?

Most businesses start with no-code tools like Zapier or Make. That's perfectly fine—and often the right choice. Zapier can connect NextPhone to 5,000+ apps without writing code, set up in 15 minutes, and handle straightforward workflows like "new call — create CRM contact."

But custom webhooks are worth the extra effort when you have:

The Integration Decision Framework

Choose Zapier/Make when:

• You're connecting to popular platforms (HubSpot, Salesforce, Slack, Google Sheets)
• Your workflow is straightforward (1-3 steps)
• You don't have technical resources
• Call volume is moderate (under 1,000/month)

Choose custom webhooks when:

• You have proprietary or custom-built systems
• You need complex data transformation before storing
• You're in a regulated industry requiring SOC 2 compliance
• Call volume is high (Zapier charges per task, webhooks are unlimited)
• You need sub-second response times (Zapier adds 1-15 second delay)

When Zapier Is Better (Be Honest)

If you're a solo contractor using standard tools, Zapier is faster. A plumber with Google Calendar and Gmail doesn't need custom webhooks—Zapier connects both in minutes without code.

Research shows SMBs use an average of 253 SaaS applications, and 2.2M+ businesses use Zapier with access to 8,000+ integrations. Most of those apps already have Zapier integrations. Use what works.

When Custom Webhooks Are Worth It

Custom webhooks shine for specialized scenarios:

Proprietary Systems: A general contractor built custom dispatch software in 2015. No Zapier integration exists. They need incoming leads to flow directly into their proprietary database with specific field mappings. Custom webhook solution: 3 hours of development, unlimited calls for $199/month.

Complex Workflows: A law firm needs caller information to: (1) Check if caller is existing client in proprietary case management system, (2) Route to appropriate attorney based on practice area mentioned in call, (3) Create intake form with custom questions, (4) Trigger conflict check. This multi-step, conditional logic requires custom code.

Data Security: A medical clinic can't send patient data through third-party platforms like Zapier without additional compliance verification. Direct webhook integration to their secure EHR system is simpler and more secure.

Cost at Scale: Zapier charges per task. At $29.99/month, you get 750 tasks. If you're processing 2,000 calls/month with 2 actions per call (create contact + send notification), that's 4,000 tasks = $99/month in Zapier fees alone. Custom webhooks are unlimited at $199/month total.

Team Notifications: For businesses using Slack (which has 2,400+ app integrations and helps reduce emails by 32%), webhook notifications provide instant alerts when calls come in.

In our data, 25.4% of callers explicitly requested callbacks. If your business processes 100 calls/month, that's 25 callback requests you can't afford to lose. Whether you use Zapier or custom webhooks, automating this flow is critical.

---

Understanding Webhooks (The Basics)

If you're new to webhooks, here's what you need to know.

What Are Webhooks?

A webhook is an automated HTTP callback that fires when a specific event occurs. Instead of your application constantly checking "did anything happen yet?" (polling), the sending system notifies you the instant something happens (push).

Think of it like this: APIs are like checking your mailbox every hour to see if mail arrived. Webhooks are like getting a notification on your phone the moment mail is delivered.

Webhooks vs APIs: Push vs Pull

Traditional API (Pull): Your system: "Any new leads?" CRM: "No." (5 minutes pass) Your system: "Any new leads?" CRM: "No." (5 minutes pass) Your system: "Any new leads?" CRM: "Yes, here's one from 7 minutes ago."

Webhook (Push): (New lead arrives) CRM — instantly sends data to your system

The difference? Webhooks deliver data in real-time with zero wasted requests. According to Enterprise Integration Patterns, webhook-based integrations can reduce latency by up to 95% compared to polling-based approaches.

Why Webhooks Matter for Real-Time Communication

When a customer calls your AI receptionist asking about emergency HVAC repair at 9 PM, you don't want that lead sitting in a queue for 5 minutes until your next API poll. You want it in your CRM immediately, notification sent to your on-call technician within seconds.

Webhooks make this possible. The AI answers the call, determines it's an emergency (15.9% of calls contain urgency language like "emergency," "urgent," or "ASAP" according to our analysis of 130,175 calls), collects caller details, and fires a webhook to your system before the call even ends.

That's the power of event-driven architecture—and why 73% of developers prefer REST APIs with webhook callbacks for modern integrations, according to the Stack Overflow Developer Survey 2024.

---

How NextPhone Webhooks Work

Now let's get specific about NextPhone's webhook implementation.

The AI Data Collection Process

Here's what happens during a call:

1. Caller contacts your business via your NextPhone number
2. AI answers in under 5 seconds and starts the conversation
3. AI asks custom questions you've configured: "Can I get your name?" "What service are you interested in?" "What's your email address?" "When would you like us to call you back?"
4. AI collects structured data from the caller's responses (name, email, company, project details, budget, timeline—whatever you've defined)
5. AI triggers webhooks either during the call (for real-time routing) or after the call ends (for data logging)

The key difference from generic webhook systems: NextPhone's AI understands context. If you ask for an email and the caller says "john at example dot com," the AI correctly formats it as john@example.com. If you ask for a phone number and they say "five five five twelve thirty-four," it's stored as 555-1234.

Webhook Trigger Points (During Call vs After Call)

You can configure webhooks to fire:

During the call:

• Emergency detection triggers immediate SMS to owner
• Appointment booking triggers calendar availability check
• VIP caller detected, route call to owner's cell

After the call:

• Send full conversation summary to CRM
• Create support ticket with caller details
• Log callback request with timestamp

Fail-safe design: If a webhook fails (your endpoint is down, network issue), the call experience is never interrupted. The webhook failure is logged, retried automatically, and you're alerted—but the caller never knows anything went wrong.

HTTP Configuration Options

NextPhone webhooks support full HTTP customization:

• Methods: POST, GET, PUT, PATCH, DELETE
• Authentication: API keys, Bearer tokens, custom headers, OAuth, service role tokens
• Content-Type: JSON, XML, form-data, custom
• Retry Logic: Automatic exponential backoff on failures
• Timeout: Configurable (default 30 seconds)

According to Postman's State of APIs 2024 report, 86% of developers report that API quality directly impacts product success. NextPhone's webhook system is built to that standard—reliable, flexible, and production-ready.

One customer told us: "We needed our AI receptionist to send leads directly to HubSpot. The webhook integration was simple to set up and now every caller is automatically in our CRM within seconds."

---

Template Variables: Dynamic Data Substitution

This is where webhooks get powerful.

Built-in Template Variables

NextPhone provides several built-in variables you can use in webhook payloads:

• caller_number - The caller's phone number (e.g., +15551234567)
• [receiving_number] - Your business phone number
• [owner_name] - Your business name/owner name
• [website] - Your business website URL
• [booking_url] - Auto-extracted from your knowledge base (Calendly link, booking page, etc.)

These variables are automatically populated for every call.

Custom Parameters from AI Conversations

This is the real magic: Any data the AI collects becomes a custom parameter.

Example conversation: AI: "Thanks for calling ABC Plumbing. Can I get your name?" Caller: "Yeah, it's Mike Johnson." AI: "Great, Mike. What can I help you with today?" Caller: "I have a leaky pipe in my kitchen." AI: "Got it. Can I get your email so we can send you a quote?" Caller: "Sure, mjohnson@email.com." AI: "Perfect. And what's your address?" Caller: "123 Main Street."

Resulting parameters:

{
  "first_name": "Mike",
  "last_name": "Johnson",
  "email": "mjohnson@email.com",
  "issue": "leaky pipe in kitchen",
  "address": "123 Main Street",
  "caller_number": "+15559876543",
  "receiving_number": "+15551234567"
}

Every parameter becomes available as a template variable: [first_name], [email], [issue], [address], etc.

Putting It Together: Example Payload

Before variable substitution (template):

{
  "properties": [
    { "property": "firstname", "value": "[first_name]" },
    { "property": "phone", "value": "caller_number" },
    { "property": "email", "value": "[email]" },
    { "property": "notes", "value": "[issue]" }
  ]
}

After substitution (actual payload sent):

{
  "properties": [
    { "property": "firstname", "value": "Mike" },
    { "property": "phone", "value": "+15559876543" },
    { "property": "email", "value": "mjohnson@email.com" },
    { "property": "notes", "value": "leaky pipe in kitchen" }
  ]
}

This dynamic substitution happens automatically every time the webhook fires. You define the template once, and NextPhone fills in the real data for each call.

Remember: 25.4% of callers explicitly request callbacks according to our data. With template variables, you can automatically log these callback requests with full caller context—name, number, reason for call, preferred callback time—so you never lose track.

---

Complete Code Examples: Building Webhook Receivers

Now let's build the receiving end. These are complete, working examples you can deploy.

NextPhone Webhook Configuration (JSON)

First, configure the webhook in NextPhone. Here's a complete example for a CRM lead submission:

{
  "type": "http",
  "tool_name": "submitLeadToCRM",
  "description": "Save lead information to CRM when caller expresses interest",
  "http_method": "POST",
  "url": "https://yourdomain.com/api/webhooks/nextphone",
  "headers": {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
    "X-Webhook-Source": "NextPhone"
  },
  "body_template": {
    "lead": {
      "name": "[first_name] [last_name]",
      "phone": "caller_number",
      "email": "[email]",
      "company": "[company_name]",
      "notes": "[message]",
      "source": "AI Receptionist",
      "created_at": "[timestamp]"
    }
  },
  "parameters": [
    { "name": "first_name", "type": "string", "description": "Caller's first name" },
    { "name": "last_name", "type": "string", "description": "Caller's last name" },
    { "name": "email", "type": "string", "description": "Caller's email address" },
    { "name": "company_name", "type": "string", "description": "Company name if provided" },
    { "name": "message", "type": "string", "description": "Details about inquiry or issue" }
  ]
}

This configuration tells NextPhone: "When the AI collects these parameters, send an HTTP POST to my endpoint with this exact structure."

JavaScript/Node.js Receiver (Express.js)

Here's a complete Express.js server that receives NextPhone webhooks:

const express = require('express');
const crypto = require('crypto');
const app = express();

// Middleware to parse JSON bodies
app.use(express.json());

// Your webhook secret (for signature verification)
const WEBHOOK_SECRET = process.env.NEXTPHONE_WEBHOOK_SECRET;

// Verify webhook signature (security best practice)
function verifySignature(payload, signature) {
  const hash = crypto
    .createHmac('sha256', WEBHOOK_SECRET)
    .update(JSON.stringify(payload))
    .digest('hex');
  return hash === signature;
}

// Webhook endpoint
app.post('/api/webhooks/nextphone', async (req, res) => {
  try {
    // 1. Verify signature (if using signed webhooks)
    const signature = req.headers['x-nextphone-signature'];
    if (signature && !verifySignature(req.body, signature)) {
      console.error('Invalid webhook signature');
      return res.status(403).json({ error: 'Invalid signature' });
    }

    // 2. Extract lead data from payload
    const leadData = req.body.lead;

    console.log('Received lead:', leadData);

    // 3. Validate required fields
    if (!leadData.phone) {
      return res.status(400).json({ error: 'Phone number required' });
    }

    // 4. Process the lead (save to database, send to CRM, etc.)
    await saveLeadToCRM(leadData);

    // 5. Send success response (important: NextPhone expects 2xx status)
    res.status(200).json({
      success: true,
      message: 'Lead processed successfully'
    });

  } catch (error) {
    console.error('Webhook processing error:', error);
    // Return 500 so NextPhone retries
    res.status(500).json({ error: 'Internal server error' });
  }
});

// Example CRM save function
async function saveLeadToCRM(leadData) {
  // Your CRM integration logic here
  // Could be: Database insert, API call to HubSpot/Salesforce, etc.
  console.log('Saving lead to CRM:', leadData);

  // Example: Insert into PostgreSQL
  // await db.query(
  //   'INSERT INTO leads (name, phone, email, notes) VALUES ($1, $2, $3, $4)',
  //   [leadData.name, leadData.phone, leadData.email, leadData.notes]
  // );
}

// Start server
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`Webhook receiver listening on port ${PORT}`);
});

Key points:

• Always return 200 OK for successful processing (triggers NextPhone retry logic on 5xx errors)
• Verify signatures to ensure webhooks are from NextPhone (security)
• Handle errors gracefully (log, alert, but don't crash)
• Process asynchronously if possible (don't block the webhook response)

Python Receiver (Flask)

Same functionality in Python with Flask:

from flask import Flask, request, jsonify
import hmac
import hashlib
import json
import os

app = Flask(__name__)

# Your webhook secret
WEBHOOK_SECRET = os.environ.get('NEXTPHONE_WEBHOOK_SECRET')

def verify_signature(payload, signature):
    """Verify webhook signature for security"""
    hash_object = hmac.new(
        WEBHOOK_SECRET.encode('utf-8'),
        json.dumps(payload).encode('utf-8'),
        hashlib.sha256
    )
    expected_signature = hash_object.hexdigest()
    return hmac.compare_digest(expected_signature, signature)

@app.route('/api/webhooks/nextphone', methods=['POST'])
def nextphone_webhook():
    try:
        # 1. Verify signature
        signature = request.headers.get('X-Nextphone-Signature')
        if signature and not verify_signature(request.json, signature):
            return jsonify({'error': 'Invalid signature'}), 403

        # 2. Extract lead data
        lead_data = request.json.get('lead')

        print(f'Received lead: {lead_data}')

        # 3. Validate required fields
        if not lead_data.get('phone'):
            return jsonify({'error': 'Phone number required'}), 400

        # 4. Process the lead
        save_lead_to_crm(lead_data)

        # 5. Return success
        return jsonify({
            'success': True,
            'message': 'Lead processed successfully'
        }), 200

    except Exception as e:
        print(f'Webhook processing error: {e}')
        return jsonify({'error': 'Internal server error'}), 500

def save_lead_to_crm(lead_data):
    """Save lead to your CRM or database"""
    print(f'Saving lead to CRM: {lead_data}')

    # Your integration logic here
    # Example: Insert into database, call CRM API, etc.
    pass

if __name__ == '__main__':
    app.run(port=3000, debug=False)

Error Handling and Validation

Both examples include critical error handling:

Signature Verification: Prevents malicious requests pretending to be from NextPhone Input Validation: Ensures required fields are present before processing Try/Catch Blocks: Gracefully handle unexpected errors Proper HTTP Status Codes: 200 = success (don't retry), 4xx = client error (don't retry), 5xx = server error (retry)

These patterns align with OWASP API Security best practices, which identify broken authentication as the #1 API vulnerability.

---

Platform-Specific Integration Examples

Let's connect to real platforms.

HubSpot CRM Integration

Full webhook configuration for HubSpot:

{
  "type": "http",
  "tool_name": "createHubSpotContact",
  "description": "Create or update HubSpot contact when lead calls",
  "http_method": "POST",
  "url": "https://api.hubapi.com/contacts/v1/contact/createOrUpdate/email/[email]",
  "headers": {
    "Authorization": "Bearer YOUR_HUBSPOT_API_KEY",
    "Content-Type": "application/json"
  },
  "body_template": {
    "properties": [
      { "property": "firstname", "value": "[first_name]" },
      { "property": "lastname", "value": "[last_name]" },
      { "property": "phone", "value": "caller_number" },
      { "property": "email", "value": "[email]" },
      { "property": "company", "value": "[company_name]" },
      { "property": "message", "value": "[notes]" },
      { "property": "lead_source", "value": "AI Receptionist" }
    ]
  },
  "parameters": [
    { "name": "first_name", "type": "string" },
    { "name": "last_name", "type": "string" },
    { "name": "email", "type": "string" },
    { "name": "company_name", "type": "string" },
    { "name": "notes", "type": "string" }
  ]
}

Key requirements:

• HubSpot API key (get from Settings — Integrations — API Key)
• Email is used as unique identifier (createOrUpdate endpoint prevents duplicates)
• Property names must match your HubSpot contact properties exactly

Salesforce Lead Creation

Webhook configuration for Salesforce:

{
  "type": "http",
  "tool_name": "createSalesforceLead",
  "description": "Create new lead in Salesforce",
  "http_method": "POST",
  "url": "https://yourinstance.salesforce.com/services/data/v57.0/sobjects/Lead",
  "headers": {
    "Authorization": "Bearer YOUR_SALESFORCE_ACCESS_TOKEN",
    "Content-Type": "application/json"
  },
  "body_template": {
    "FirstName": "[first_name]",
    "LastName": "[last_name]",
    "Phone": "caller_number",
    "Email": "[email]",
    "Company": "[company_name]",
    "Description": "[message]",
    "LeadSource": "AI Receptionist",
    "Status": "New"
  },
  "parameters": [
    { "name": "first_name", "type": "string" },
    { "name": "last_name", "type": "string" },
    { "name": "email", "type": "string" },
    { "name": "company_name", "type": "string" },
    { "name": "message", "type": "string" }
  ]
}

Key requirements:

• Salesforce uses OAuth for authentication (access token expires, implement refresh logic)
• Field names are case-sensitive (FirstName, not firstname)
• LastName and Company are required fields in Salesforce
• Use your Salesforce instance URL (not generic salesforce.com)

Custom API Endpoints

Generic example for any REST API:

{
  "type": "http",
  "tool_name": "customAPIIntegration",
  "description": "Send lead to custom API",
  "http_method": "POST",
  "url": "https://api.yoursystem.com/v1/leads",
  "headers": {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
  },
  "body_template": {
    "contact": {
      "name": "[first_name] [last_name]",
      "phone": "caller_number",
      "email": "[email]"
    },
    "metadata": {
      "source": "nextphone",
      "timestamp": "[timestamp]",
      "call_duration": "[call_duration]"
    }
  },
  "parameters": [
    { "name": "first_name", "type": "string" },
    { "name": "last_name", "type": "string" },
    { "name": "email", "type": "string" },
    { "name": "caller_number", "type": "string" }
  ]
}

This pattern works for any system with a REST API—your custom CRM, dispatch software, project management tool, whatever you've built. For project management specifically, tools like Airtable (450,000+ organizations, 15M monthly active users) can receive webhook data directly. For CRM-specific setup walkthroughs, see our CRM phone integration guide and our Capsule CRM integration example.

---

Security and Compliance

Don't skip this section—especially if you're in healthcare, legal, or financial services.

Webhook Authentication Methods

Always authenticate webhook requests. Options:

1. API Keys (Simple): Include a secret key in the request header: Authorization: Bearer YOUR_SECRET_KEY Your receiver verifies the key before processing.

2. HMAC Signatures (More Secure): NextPhone signs the payload with a shared secret. Your receiver re-computes the signature and compares. If signatures match, request is authentic.

3. IP Whitelisting: Only accept requests from NextPhone's IP addresses. Good as secondary layer, not primary security.

4. OAuth (Most Complex, Most Secure): For enterprise integrations, use OAuth 2.0 with short-lived tokens and refresh logic.

OWASP identifies broken authentication as the #1 API security vulnerability. Don't send webhooks over HTTP (always HTTPS) and always verify requests are authentic.

Security for Healthcare

If you're a medical practice, dental office, or healthcare provider, webhooks must be secure:

Requirements:

• HTTPS/TLS 1.2+: All webhook traffic must be encrypted in transit
• Minimal PII: Only send necessary patient information (use patient ID, not full medical history)
• Compliance Review: Verify your receiving system meets your industry's compliance requirements
• Audit Logging: Log all webhook transmissions with timestamps, recipient, data sent
• Access Controls: Restrict who can view webhook configurations and logs
• Data Retention: Define how long webhook logs are kept and ensure secure deletion

Example secure webhook:

{
  "patient_id": "[patient_id]",  // Internal ID, not name
  "appointment_type": "[service_type]",
  "callback_number": "caller_number",
  "timestamp": "[timestamp]"
}

Avoid sending full names, SSNs, or detailed medical information in webhook payloads. Use unique identifiers and let your secure system look up details.

OWASP Best Practices

Follow OWASP API Security guidelines:

• Validate all inputs (don't assume webhook data is safe)
• Use rate limiting (prevent abuse if API key is compromised)
• Never expose secrets in URLs (use headers for authentication)
• Implement idempotency (same webhook sent twice = same result, no duplicates)
• Log security events (failed auth attempts, malformed payloads)
• Rotate API keys regularly (quarterly or after personnel changes)

NextPhone's infrastructure supports all standard authentication methods and is built to enterprise security standards.

---

Testing, Monitoring, and Troubleshooting

Before going live, test everything.

Testing Webhooks Before Going Live

Use testing tools:

Webhook.site: Free tool that gives you a unique URL. Configure NextPhone to send webhooks there and see exactly what's being sent—headers, body, everything. Perfect for debugging payload structure.

RequestBin: Similar to Webhook.site, captures and displays webhook requests.

Postman: Use Postman to manually send test webhooks to your receiver endpoint with sample payloads. Verify your code handles the data correctly.

ngrok: Developing locally? ngrok creates a public HTTPS URL that tunnels to your localhost. Point NextPhone webhooks at the ngrok URL to test your local code.

Process:

1. Set up test endpoint with Webhook.site
2. Configure NextPhone webhook with test URL
3. Make a test call to your AI receptionist
4. Verify payload structure in Webhook.site
5. Build your receiver based on actual payload format
6. Use ngrok to test your local receiver
7. Deploy to production and retest

Never test with production data or production systems first. Use staging environments.

Monitoring Webhook Performance

Once live, monitor:

Success Rate: What % of webhooks succeed vs fail? Response Time: How long does your endpoint take to respond? (Target: under 3 seconds) Error Logs: Track all failures with timestamps and error messages Retry Count: How many webhooks required retries?

Set up alerts:

• If success rate drops below 95%, investigate
• If response times exceed 5 seconds, optimize
• If retries spike, check your endpoint health

Common Issues and Fixes

Debugging checklist:

1. Verify endpoint URL is correct and accessible (test with curl or Postman)
2. Check authentication (API key, signature, token)
3. Review webhook logs in NextPhone dashboard
4. Verify payload format matches what your receiver expects
5. Test with Webhook.site to see raw request
6. Check firewall rules (is your endpoint blocked?)
7. Verify SSL certificate is valid (expired certificates cause failures)

---

How NextPhone Makes This Simple

If this all sounds complex, here's good news: NextPhone handles most of the heavy lifting.

Visual Webhook Builder: No coding required for configuration. Paste your API endpoint, add headers, define your payload template with template variables, click save. NextPhone generates the integration automatically.

Template Variable System: The AI automatically makes collected data available as variables. You define what to ask, NextPhone creates the parameters.

Built-in Authentication: Support for API keys, Bearer tokens, custom headers—just paste your credentials, NextPhone handles the rest.

Test Mode: Send test webhooks before going live. See exactly what will be sent to your endpoint without affecting production data.

Instant Execution: Webhooks fire within 1-2 seconds of data collection. No delays, no queues.

Automatic Retries: If your endpoint is temporarily down, NextPhone retries with exponential backoff (immediate, 10s, 30s, 1min, 5min). You get notified of permanent failures.

Unlimited Webhooks: $199/month, unlimited calls, unlimited webhook executions. No per-task pricing like Zapier.

According to our data, businesses using automated CRM integration capture 3X more leads. One customer told us: "The webhook setup took us 20 minutes. Now every lead goes straight to Salesforce automatically."

That's the difference between losing leads because someone forgot to log them manually and having perfect capture rates with zero manual effort.

---

Frequently Asked Questions

When should I use custom webhooks instead of Zapier?

Use custom webhooks when you have proprietary systems, need strict data security, process high call volume (Zapier charges per task), or require sub-second response times. For most SMBs connecting to popular platforms like HubSpot or Google Sheets with moderate volume, Zapier is faster and simpler to set up.

How fast are webhooks compared to API polling?

Webhooks deliver data in real-time—within 1-2 seconds of the event. API polling typically checks every 1-5 minutes, meaning you might wait 5+ minutes for new data. Webhooks can reduce latency by up to 95% compared to polling-based approaches.

What happens if my webhook endpoint is down?

NextPhone automatically retries failed webhooks with exponential backoff (immediate, 10 seconds, 30 seconds, 1 minute, 5 minutes). If retries fail, you're notified. The call experience is never interrupted—webhook failures are handled gracefully in the background.

How do I secure my webhook endpoint?

Use HTTPS (required), verify request signatures using HMAC, validate that requests come from NextPhone's IP addresses, and never expose API keys in URLs. For healthcare or financial services, also implement audit logging and minimal PII transmission to meet compliance requirements.

Can webhooks send data to multiple systems simultaneously?

Yes. You can configure multiple webhooks for different events—one to your CRM, one to Slack for notifications, one to your custom database. Each webhook fires independently based on its trigger conditions (during call, after call, emergency detected, etc.).