curl -X POST https://v2.heppu.ai/api/v1/webhooks \
  -H "x-api-key: $HEPPU_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://api.yourcompany.com/webhooks/heppu",
    "events": ["call.completed", "call.failed", "chat.message.received"],
    "description": "Production webhook endpoint",
    "secret": "whsec_your_secret_key_here"
  }'

const response = await fetch('https://v2.heppu.ai/api/v1/webhooks', {
  method: 'POST',
  headers: {
    'x-api-key': process.env.HEPPU_API_KEY,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    url: 'https://api.yourcompany.com/webhooks/heppu',
    events: ['call.completed', 'call.failed', 'chat.message.received'],
    description: 'Production webhook endpoint',
    secret: 'whsec_your_secret_key_here'
  })
});

const webhook = await response.json();
console.log('Webhook created:', webhook.data.id);

import requests
import os

response = requests.post(
    'https://v2.heppu.ai/api/v1/webhooks',
    headers={'x-api-key': os.environ.get('HEPPU_API_KEY')},
    json={
        'url': 'https://api.yourcompany.com/webhooks/heppu',
        'events': ['call.completed', 'call.failed', 'chat.message.received'],
        'description': 'Production webhook endpoint',
        'secret': 'whsec_your_secret_key_here'
    }
)

webhook = response.json()
print('Webhook created:', webhook['data']['id'])

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

app.post('/webhooks/heppu', express.json(), (req, res) => {
  const event = req.body;
  const webhookId = req.headers['x-webhook-id'];

  console.log('Received webhook:', event.event, 'ID:', webhookId);

  // Process based on event type
  switch (event.event) {
    // Call events
    case 'call.completed':
      handleCallCompleted(event);
      break;
    case 'call.failed':
    case 'call.busy':
    case 'call.no-answer':
      handleCallFailed(event);
      break;

    // Chat events
    case 'chat.completed':
    case 'chat.resolved':
      handleChatCompleted(event);
      break;
    case 'chat.abandoned':
      handleChatAbandoned(event);
      break;

    default:
      console.log('Unknown event type:', event.event);
  }

  // Acknowledge receipt immediately
  res.status(200).json({ received: true });
});

function handleCallCompleted(event) {
  console.log(`Call ${event.conversationId} completed`);
  console.log(`Duration: ${event.duration}s`);
  console.log(`Summary: ${event.summary}`);
  // Update CRM, send follow-up, etc.
}

function handleCallFailed(event) {
  console.log(`Call ${event.conversationId} ${event.event}`);
  const attempts = event.callMetadata?.context?.previousAttempts || 0;
  console.log(`Previous attempts: ${attempts}`);
  // Queue for retry, alert team, etc.
}

function handleChatCompleted(event) {
  console.log(`Chat ${event.conversationId} completed`);
  console.log(`Messages: ${event.messageCount}`);
  console.log(`Resolved: ${event.chatMetadata?.resolved}`);
  // Archive transcript, close ticket, etc.
}

function handleChatAbandoned(event) {
  console.log(`Chat ${event.conversationId} abandoned`);
  // Send follow-up email, update lead score, etc.
}

app.listen(3000, () => {
  console.log('Webhook server listening on port 3000');
});

from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route('/webhooks/heppu', methods=['POST'])
def handle_webhook():
    event = request.json
    webhook_id = request.headers.get('X-Webhook-ID')

    print(f"Received webhook: {event['event']} ID: {webhook_id}")

    # Process based on event type
    event_type = event['event']

    # Call events
    if event_type == 'call.completed':
        handle_call_completed(event)
    elif event_type in ['call.failed', 'call.busy', 'call.no-answer']:
        handle_call_failed(event)

    # Chat events
    elif event_type in ['chat.completed', 'chat.resolved']:
        handle_chat_completed(event)
    elif event_type == 'chat.abandoned':
        handle_chat_abandoned(event)

    else:
        print(f"Unknown event type: {event_type}")

    # Acknowledge receipt
    return jsonify({'received': True}), 200

def handle_call_completed(event):
    print(f"Call {event['conversationId']} completed")
    print(f"Duration: {event.get('duration')}s")
    print(f"Summary: {event.get('summary')}")
    # Update CRM, send follow-up, etc.

def handle_call_failed(event):
    print(f"Call {event['conversationId']} {event['event']}")
    call_meta = event.get('callMetadata', {})
    context = call_meta.get('context', {})
    print(f"Previous attempts: {context.get('previousAttempts', 0)}")
    # Queue for retry, alert team, etc.

def handle_chat_completed(event):
    print(f"Chat {event['conversationId']} completed")
    print(f"Messages: {event.get('messageCount')}")
    chat_meta = event.get('chatMetadata', {})
    print(f"Resolved: {chat_meta.get('resolved')}")
    # Archive transcript, close ticket, etc.

def handle_chat_abandoned(event):
    print(f"Chat {event['conversationId']} abandoned")
    # Send follow-up email, update lead score, etc.

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

// app/api/webhooks/heppu/route.ts
import { NextRequest, NextResponse } from 'next/server';

interface WebhookEvent {
  event: string;
  timestamp: string;
  webhookId: string;
  conversationId: string;
  conversationType: 'phone' | 'chat';
  agentId: string;
  agentName: string;
  status: string;
  outcome: string | null;
  summary: string | null;
  duration: number | null;
  messageCount?: number;
  direction?: 'inbound' | 'outbound';
  callMetadata?: Record<string, any>;
  chatMetadata?: Record<string, any>;
  metadata: Record<string, any>;
  organizationId: string;
}

export async function POST(request: NextRequest) {
  try {
    const event: WebhookEvent = await request.json();
    const webhookId = request.headers.get('x-webhook-id');

    console.log('Received webhook:', event.event, 'ID:', webhookId);

    // Process based on event type
    switch (event.event) {
      // Call events
      case 'call.completed':
        await handleCallCompleted(event);
        break;
      case 'call.failed':
      case 'call.busy':
      case 'call.no-answer':
        await handleCallFailed(event);
        break;

      // Chat events
      case 'chat.completed':
      case 'chat.resolved':
        await handleChatCompleted(event);
        break;
      case 'chat.abandoned':
        await handleChatAbandoned(event);
        break;

      default:
        console.log('Unknown event type:', event.event);
    }

    return NextResponse.json({ received: true });
  } catch (error) {
    console.error('Webhook error:', error);
    return NextResponse.json(
      { error: 'Webhook processing failed' },
      { status: 500 }
    );
  }
}

async function handleCallCompleted(event: WebhookEvent) {
  console.log(`Call ${event.conversationId} completed`);
  console.log(`Duration: ${event.duration}s`);
  console.log(`Summary: ${event.summary}`);
  // Update CRM, send follow-up, etc.
}

async function handleCallFailed(event: WebhookEvent) {
  console.log(`Call ${event.conversationId} ${event.event}`);
  const attempts = event.callMetadata?.context?.previousAttempts || 0;
  console.log(`Previous attempts: ${attempts}`);
  // Queue for retry, alert team, etc.
}

async function handleChatCompleted(event: WebhookEvent) {
  console.log(`Chat ${event.conversationId} completed`);
  console.log(`Messages: ${event.messageCount}`);
  console.log(`Resolved: ${event.chatMetadata?.resolved}`);
  // Archive transcript, close ticket, etc.
}

async function handleChatAbandoned(event: WebhookEvent) {
  console.log(`Chat ${event.conversationId} abandoned`);
  // Send follow-up email, update lead score, etc.
}

const crypto = require('crypto');

function verifyWebhookSignature(payload, signature, timestamp, secret) {
  // Check timestamp (prevent replay attacks)
  const currentTime = Math.floor(Date.now() / 1000);
  const timeDiff = currentTime - parseInt(timestamp);

  if (timeDiff > 300) { // 5 minutes
    throw new Error('Webhook timestamp too old');
  }

  // Parse signature (format: sha256=<hash>)
  if (!signature.startsWith('sha256=')) {
    throw new Error('Invalid signature format');
  }
  const receivedHash = signature.replace('sha256=', '');

  // Compute expected signature
  const expectedHash = crypto
    .createHmac('sha256', secret)
    .update(payload)
    .digest('hex');

  // Compare signatures (constant-time comparison)
  if (!crypto.timingSafeEqual(
    Buffer.from(receivedHash),
    Buffer.from(expectedHash)
  )) {
    throw new Error('Signature verification failed');
  }

  return true;
}

// Express middleware
function webhookVerification(req, res, next) {
  const signature = req.headers['x-webhook-signature-256'];
  const timestamp = req.headers['x-webhook-timestamp'];
  const secret = process.env.WEBHOOK_SECRET;

  // Skip verification if no secret configured
  if (!secret) {
    return next();
  }

  try {
    verifyWebhookSignature(req.rawBody, signature, timestamp, secret);
    next();
  } catch (error) {
    console.error('Webhook verification failed:', error.message);
    return res.status(401).json({ error: 'Invalid signature' });
  }
}

// Usage - must capture raw body before JSON parsing
app.post('/webhooks/heppu',
  express.json({
    verify: (req, res, buf) => { req.rawBody = buf.toString(); }
  }),
  webhookVerification,
  (req, res) => {
    // Process verified webhook
    console.log('Verified webhook:', req.body.event);
    res.status(200).json({ received: true });
  }
);

import hmac
import hashlib
import time
import os
from flask import Flask, request, jsonify, abort

def verify_webhook_signature(payload, signature, timestamp, secret):
    # Check timestamp (prevent replay attacks)
    current_time = int(time.time())
    time_diff = current_time - int(timestamp)

    if time_diff > 300:  # 5 minutes
        raise ValueError('Webhook timestamp too old')

    # Parse signature (format: sha256=<hash>)
    if not signature.startswith('sha256='):
        raise ValueError('Invalid signature format')
    received_hash = signature.replace('sha256=', '')

    # Compute expected signature
    expected_hash = hmac.new(
        secret.encode(),
        payload.encode(),
        hashlib.sha256
    ).hexdigest()

    # Compare signatures (constant-time comparison)
    if not hmac.compare_digest(received_hash, expected_hash):
        raise ValueError('Signature verification failed')

    return True

# Flask route
@app.route('/webhooks/heppu', methods=['POST'])
def handle_webhook():
    signature = request.headers.get('X-Webhook-Signature-256')
    timestamp = request.headers.get('X-Webhook-Timestamp')
    secret = os.environ.get('WEBHOOK_SECRET')

    # Skip verification if no secret configured
    if secret:
        try:
            payload = request.get_data(as_text=True)
            verify_webhook_signature(payload, signature, timestamp, secret)
        except ValueError as error:
            print(f"Webhook verification failed: {error}")
            abort(401)

    # Process verified webhook
    event = request.json
    print(f"Verified webhook: {event['event']}")

    return jsonify({'received': True}), 200

curl https://v2.heppu.ai/api/v1/webhooks \
  -H "x-api-key: $HEPPU_API_KEY"

const response = await fetch('https://v2.heppu.ai/api/v1/webhooks', {
  headers: { 'x-api-key': process.env.HEPPU_API_KEY }
});

const data = await response.json();
console.log('Webhooks:', data.data);

response = requests.get(
    'https://v2.heppu.ai/api/v1/webhooks',
    headers={'x-api-key': os.environ.get('HEPPU_API_KEY')}
)

print('Webhooks:', response.json()['data'])

curl -X PATCH https://v2.heppu.ai/api/v1/webhooks/webhook_pqr678 \
  -H "x-api-key: $HEPPU_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "events": ["call.completed"],
    "status": "active"
  }'

const response = await fetch('https://v2.heppu.ai/api/v1/webhooks/webhook_pqr678', {
  method: 'PATCH',
  headers: {
    'x-api-key': process.env.HEPPU_API_KEY,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    events: ['call.completed'],
    status: 'active'
  })
});

response = requests.patch(
    'https://v2.heppu.ai/api/v1/webhooks/webhook_pqr678',
    headers={'x-api-key': os.environ.get('HEPPU_API_KEY')},
    json={
        'events': ['call.completed'],
        'status': 'active'
    }
)

curl -X DELETE https://v2.heppu.ai/api/v1/webhooks/webhook_pqr678 \
  -H "x-api-key: $HEPPU_API_KEY"

const response = await fetch('https://v2.heppu.ai/api/v1/webhooks/webhook_pqr678', {
  method: 'DELETE',
  headers: { 'x-api-key': process.env.HEPPU_API_KEY }
});

console.log('Webhook deleted:', response.status === 204);

response = requests.delete(
    'https://v2.heppu.ai/api/v1/webhooks/webhook_pqr678',
    headers={'x-api-key': os.environ.get('HEPPU_API_KEY')}
)

print('Webhook deleted:', response.status_code == 204)