How to Receive Webhooks

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

app.use(express.json());

// `durableQueue` stands for your own durable storage (a message queue or a
// database table). It is not part of any LigueLead SDK.
app.post('/webhooks/liguelead', async (req, res) => {
  try {
    // Persist BEFORE acknowledging: a notification answered with 2xx is not
    // retried, so whatever is only in memory when you answer is lost if this
    // process restarts. Keep the delivery id with it, to drop a retry you
    // already have.
    await durableQueue.enqueue({
      deliveryId: req.get('X-LigueLead-Delivery-Id'),
      payload: req.body,
    });
    res.status(200).json({ received: true });
  } catch (error) {
    // Not stored. A 500 makes LigueLead send this notification again later,
    // for about 45 minutes; log enough to reconcile if it never gets through.
    console.error('Could not store webhook:', error, req.body);
    res.status(500).json({ error: 'Internal server error' });
  }
});

// A separate worker consumes `durableQueue`, skips a deliveryId it already
// processed, and calls routeEvent() with the stored payload.
function routeEvent(payload) {
  switch (payload.event) {
    case 'campaign.status':
      // The same URL receives every channel; keep only SMS and SMS Flash here.
      if (['sms', 'sms_flash'].includes(payload.campaign?.type)) {
        processStatus(payload);
      }
      break;
    case 'sms.inbound':
      processReply(payload);
      break;
    default:
      // Other events and future ones: acknowledged above, ignored here.
      break;
  }
}

function processStatus(payload) {
  const { campaign, occurred_at } = payload;
  const { id: campaign_id, type: campaign_type, phone, status } = campaign;

  console.log(`Campaign ${campaign_id} (${campaign_type}) ${phone}: ${status} at ${occurred_at}`);

  switch (status) {
    case 'delivered':
      handleDelivered(payload);
      break;
    case 'failed':
      handleFailed(payload);
      break;
    default:
      // Accept statuses you do not handle yet instead of rejecting them.
      console.info(`Unhandled SMS status: ${status}`);
  }
}

function processReply(payload) {
  const { id: campaign_id, phone, message } = payload.campaign;

  // campaign_id is the send this reply answers, or '' when it could not be matched.
  console.log(`Reply from ${phone} to campaign ${campaign_id || '(unknown)'}: ${message}`);
}

function handleDelivered(payload) {
  // Update status in database
  // Send notification to user
  // Trigger next workflow action
}

function handleFailed(payload) {
  // Exceptional — look the recipient up with
  // GET /v1/campaigns/{campaign_id}/recipients?phone=...
}

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

from fastapi import FastAPI, Request
from pydantic import BaseModel
import logging

app = FastAPI()

class SmsCampaign(BaseModel):
    id: str
    type: str  # "sms" or "sms_flash"
    source: str
    phone: str
    message: str
    credits_required: int
    sent_at: str  # ISO 8601 with offset; may be date-only for older sends
    status: str

class SmsReply(BaseModel):
    id: str  # campaign_id of the send this reply answers; may be ""
    phone: str
    message: str

# `durable_queue` stands for your own durable storage (a message queue or a
# database table). It is not part of any LigueLead SDK.
@app.post("/webhooks/liguelead")
async def receive_webhook(request: Request):
    payload = await request.json()

    # Persist BEFORE acknowledging: a notification answered with 2xx is not
    # retried, so whatever is only in memory when you answer is lost if this
    # process restarts. Keep the delivery id with it, to drop a retry you already
    # have. If enqueue raises, FastAPI answers 500 and LigueLead sends the
    # notification again later, for about 45 minutes.
    await durable_queue.enqueue({
        "delivery_id": request.headers.get("X-LigueLead-Delivery-Id"),
        "payload": payload,
    })

    return {"received": True}

# A separate worker consumes `durable_queue`, skips a delivery_id it already
# processed, and calls route_event() with the stored payload.
async def route_event(payload: dict):
    event = payload.get("event")
    campaign = payload.get("campaign") or {}

    if event == "campaign.status" and campaign.get("type") in ("sms", "sms_flash"):
        await process_status(SmsCampaign(**campaign))
    elif event == "sms.inbound":
        await process_reply(SmsReply(**campaign))
    # Other channels and events: ignored here.

async def process_status(campaign: SmsCampaign):
    logging.info(f"Campaign {campaign.id} ({campaign.type}) {campaign.phone}: {campaign.status}")

    if campaign.status == "delivered":
        await handle_delivered(campaign)
    elif campaign.status == "failed":
        await handle_failed(campaign)
    else:
        # Accept statuses you do not handle yet instead of rejecting them.
        logging.info(f"Unhandled SMS status: {campaign.status}")

async def process_reply(reply: SmsReply):
    logging.info(f"Reply from {reply.phone} to campaign {reply.id or '(unknown)'}: {reply.message}")

async def handle_delivered(campaign: SmsCampaign):
    # Implement successful delivery logic
    pass

async def handle_failed(campaign: SmsCampaign):
    # Exceptional — look the recipient up with
    # GET /v1/campaigns/{campaign_id}/recipients?phone=...
    pass

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

app.use(express.json());

app.post('/webhooks/liguelead', (req, res) => {
  try {
    const payload = req.body;

    // RCS endpoints handle two event families:
    //   - 'campaign.status'         → delivery lifecycle (sent / delivered / read / undelivered / failed / insufficient_credits)
    //   - 'rcs.inbound.postback'    → user tapped a reply button on a card
    switch (payload.event) {
      case 'campaign.status':
        processStatus(payload);
        break;
      case 'rcs.inbound.postback':
        processPostback(payload);
        break;
      default:
        console.warn(`Unknown event: ${payload.event}`);
    }

    // Illustration only: in production, persist the payload durably before
    // answering and process it from there (see the warning above)
    res.status(200).json({ received: true });

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

function processStatus(payload) {
  const { campaign } = payload;

  // Filter out non-RCS deliveries
  if (!['rcs_single', 'rcs_basic'].includes(campaign.type)) return;

  console.log(`RCS ${campaign.id}: ${campaign.status}`);

  switch (campaign.status) {
    case 'sent':        return handleSent(payload);
    case 'delivered':   return handleDelivered(payload);
    case 'read':        return handleRead(payload);
    case 'undelivered': return handleUndelivered(payload);
    case 'failed':      return handleFailed(payload);
    case 'insufficient_credits': return handleInsufficientCredits(payload);
    default:
      console.warn(`Unknown RCS status: ${campaign.status}`);
  }
}

function processPostback(payload) {
  const { campaign } = payload;
  const postbackData = campaign.inbound.postback_data;

  // postback_data is the opaque value you set on the `reply` suggestion
  // when creating the template — use it to route the user's intent.
  console.log(`RCS postback ${campaign.id}: ${postbackData}`);

  // Example: route to handlers based on the postback discriminator
  if (postbackData === 'KNOW_MORE') {
    handleKnowMore(payload);
  } else if (postbackData.startsWith('CONFIRM_')) {
    handleConfirmation(payload, postbackData);
  }
}

function handleSent(payload)        { /* RCS accepted by the gateway */ }
function handleDelivered(payload)   { /* Device received the message */ }
function handleRead(payload)        { /* User opened the message — RCS-only */ }
function handleUndelivered(payload) { /* Carrier could not deliver (TTL, offline, ...) */ }
function handleFailed(payload)      { /* Provider/gateway error */ }
function handleInsufficientCredits(payload) { /* Not sent: the RCS balance did not cover this message */ }

function handleKnowMore(payload)        { /* User tapped "Quero saber mais" */ }
function handleConfirmation(payload, postbackData) { /* User confirmed something */ }

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

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import Optional
import logging

app = FastAPI()

class InboundPostback(BaseModel):
    type: str
    postback_data: str

class RcsCampaign(BaseModel):
    id: str
    type: str
    source: str
    phone: str
    credits_required: int
    sent_at: str
    status: Optional[str] = None
    message: Optional[str] = None
    template_id: Optional[str] = None
    template_title: Optional[str] = None
    inbound: Optional[InboundPostback] = None

class WebhookPayload(BaseModel):
    event: str
    app_id: str
    occurred_at: str
    campaign: RcsCampaign

@app.post("/webhooks/liguelead")
async def receive_webhook(payload: WebhookPayload):
    try:
        if payload.event == "campaign.status":
            if payload.campaign.type in ("rcs_single", "rcs_basic"):
                await process_status(payload)
        elif payload.event == "rcs.inbound.postback":
            await process_postback(payload)
        else:
            logging.warning(f"Unknown event: {payload.event}")

        return {"received": True}

    except Exception as e:
        logging.error(f"Webhook processing error: {e}")
        raise HTTPException(status_code=500, detail="Internal server error")

async def process_status(payload: WebhookPayload):
    status = payload.campaign.status
    logging.info(f"RCS {payload.campaign.id}: {status}")

    handlers = {
        "sent":        handle_sent,
        "delivered":   handle_delivered,
        "read":        handle_read,
        "undelivered": handle_undelivered,
        "failed":      handle_failed,
        "insufficient_credits": handle_insufficient_credits,
    }
    handler = handlers.get(status)
    if handler:
        await handler(payload)

async def process_postback(payload: WebhookPayload):
    postback_data = payload.campaign.inbound.postback_data
    logging.info(f"RCS postback {payload.campaign.id}: {postback_data}")
    # Route based on the value you declared on the `reply` suggestion.

async def handle_sent(payload):        pass  # RCS accepted by the gateway
async def handle_delivered(payload):   pass  # Device received the message
async def handle_read(payload):        pass  # User opened the message — RCS-only
async def handle_undelivered(payload): pass  # Carrier could not deliver
async def handle_failed(payload):      pass  # Provider/gateway error
async def handle_insufficient_credits(payload): pass  # Not sent: the RCS balance did not cover this message

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

app.use(express.json());

app.post('/webhooks/liguelead', (req, res) => {
  try {
    const payload = req.body;

    // Validate payload structure
    if (!isValidPayload(payload)) {
      return res.status(400).json({ error: 'Invalid payload' });
    }

    // Process webhook based on status
    processWebhook(payload);

    // Illustration only: in production, persist the payload durably before
    // answering and process it from there (see the warning above)
    res.status(200).json({ received: true });

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

function isValidPayload(payload) {
  const requiredFields = ['event', 'app_id', 'occurred_at'];

  // duration_sec is optional — it is only present on answered calls.
  const campaignFields = [
    'id', 'type', 'status', 'source', 'phone',
    'audio_title', 'audio_time', 'audio_id',
    'credits_required', 'sent_at'
  ];

  return requiredFields.every(field => payload.hasOwnProperty(field))
    && payload.campaign
    && campaignFields.every(field => payload.campaign.hasOwnProperty(field));
}

function processWebhook(payload) {
  const { campaign, occurred_at } = payload;
  const { id: campaign_id, type: campaign_type, status } = campaign;

  console.log(`Campaign ${campaign_id} (${campaign_type}): ${status} at ${occurred_at}`);

  switch (status) {
    case 'answer':
      handleAnswered(payload);
      break;
    case 'no_answer':
      handleNoAnswer(payload);
      break;
    case 'invalid_number':
      handleInvalidNumber(payload);
      break;
    case 'failed':
      handleFailed(payload);
      break;
    case 'sent':
      handleSent(payload);
      break;
    default:
      console.warn(`Unknown status: ${status}`);
  }
}

function handleAnswered(payload) {
  // Call was answered — update status, trigger follow-up actions
  console.log(`Call answered: ${payload.campaign.id}`);
}

function handleNoAnswer(payload) {
  // Call not answered — schedule retry or notify
  console.log(`Call not answered: ${payload.campaign.id}`);
}

function handleInvalidNumber(payload) {
  // Invalid number — remove or flag in your contact list
  console.log(`Invalid number: ${payload.campaign.phone}`);
}

function handleFailed(payload) {
  // Call failed — log error, update metrics, notify
  console.log(`Call failed: ${payload.campaign.id}`);
}

function handleSent(payload) {
  // Call queued — update campaign status in your system
  console.log(`Call queued: ${payload.campaign.id}`);
}

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

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import logging

app = FastAPI()

class Campaign(BaseModel):
    id: str
    type: str
    source: str
    phone: str
    audio_title: str
    audio_time: str
    audio_id: int
    credits_required: int
    sent_at: str
    status: str
    duration_sec: int | None = None  # only on answered calls

class WebhookPayload(BaseModel):
    event: str
    app_id: str
    campaign: Campaign
    occurred_at: str

@app.post("/webhooks/liguelead")
async def receive_webhook(payload: WebhookPayload):
    try:
        # Validate event type
        if payload.event != "campaign.status":
            raise HTTPException(status_code=400, detail="Invalid event type")

        # Process webhook asynchronously
        await process_webhook(payload)

        return {"received": True}

    except Exception as e:
        logging.error(f"Webhook processing error: {e}")
        raise HTTPException(status_code=500, detail="Internal server error")

async def process_webhook(payload: WebhookPayload):
    logging.info(f"Campaign {payload.campaign.id} ({payload.campaign.type}): {payload.campaign.status}")

    if payload.campaign.status == "answer":
        await handle_answered(payload)
    elif payload.campaign.status == "no_answer":
        await handle_no_answer(payload)
    elif payload.campaign.status == "invalid_number":
        await handle_invalid_number(payload)
    elif payload.campaign.status == "failed":
        await handle_failed(payload)
    elif payload.campaign.status == "sent":
        await handle_sent(payload)

async def handle_answered(payload: WebhookPayload):
    # Call was answered — update status, trigger follow-up actions
    pass

async def handle_no_answer(payload: WebhookPayload):
    # Call not answered — schedule retry or notify
    pass

async def handle_invalid_number(payload: WebhookPayload):
    # Invalid number — remove or flag in your contact list
    pass

async def handle_failed(payload: WebhookPayload):
    # Call failed — log error, update metrics
    pass

async def handle_sent(payload: WebhookPayload):
    # Call queued — update campaign status in your system
    pass

function processVoiceAiWebhook(payload) {
  const { campaign } = payload;
  const { id, status, action_executed, transcript, recording_url } = campaign;

  console.log(`AI call ${id}: ${status}, action=${action_executed}`);

  // `transcript` and `recording_url` only exist when the call produced them.
  if (transcript?.length) {
    console.log(`Conversation with ${transcript.length} turns`);
  }
  if (recording_url) {
    storeRecording(id, recording_url);
  }

  switch (action_executed) {
    case 'schedule_event':
      onMeetingBooked(payload);
      break;
    case 'transfer_call':
      onTransferredToHuman(payload);
      break;
    case 'send_email':
      onEmailSent(payload);
      break;
    case 'send_sms':
      onSmsSent(payload);
      break;
    case 'http_webhook':
      onAgentWebhookCalled(payload);
      break;
    case 'voice_mail':
    case 'virtual_assistant':
      // Nobody human picked up — worth a retry on another window.
      onMachineAnswered(payload);
      break;
    case 'silence_timeout':
      onRecipientWentSilent(payload);
      break;
    case 'check_availability':
      onAvailabilityChecked(payload);
      break;
    case 'end_call':
    case 'none':
      onNoAction(payload);
      break;
    default:
      // New actions may appear; treat the unknown as no action.
      console.warn(`Unknown action: ${action_executed}`);
      onNoAction(payload);
  }
}

MACHINE_ANSWERED = {"voice_mail", "virtual_assistant"}
NO_ACTION = {"end_call", "none"}

def process_voice_ai_webhook(payload: dict) -> None:
    campaign = payload["campaign"]
    campaign_id = campaign["id"]
    action = campaign.get("action_executed", "none")

    print(f"AI call {campaign_id}: {campaign['status']}, action={action}")

    # `transcript` and `recording_url` only exist when the call produced them.
    transcript = campaign.get("transcript") or []
    if transcript:
        print(f"Conversation with {len(transcript)} turns")
    if campaign.get("recording_url"):
        store_recording(campaign_id, campaign["recording_url"])

    if action == "schedule_event":
        on_meeting_booked(payload)
    elif action == "transfer_call":
        on_transferred_to_human(payload)
    elif action == "send_email":
        on_email_sent(payload)
    elif action == "send_sms":
        on_sms_sent(payload)
    elif action == "http_webhook":
        on_agent_webhook_called(payload)
    elif action in MACHINE_ANSWERED:
        on_machine_answered(payload)
    elif action == "silence_timeout":
        on_recipient_went_silent(payload)
    elif action == "check_availability":
        on_availability_checked(payload)
    elif action in NO_ACTION:
        on_no_action(payload)
    else:
        # New actions may appear; treat the unknown as no action.
        print(f"Unknown action: {action}")
        on_no_action(payload)