Receiving Inbound Messages via the message.received Webhook

import express from 'express';

const app = express();
app.use(express.json());

app.post('/webhooks/sent', async (req, res) => {
  res.sendStatus(200); // Always acknowledge quickly

  const { field, event, payload } = req.body;

  if (field === 'message' && event === 'message.received') {
    const { message_id, inbound_number, outbound_number, text, channel, received_at } = payload;

    // Store inbound for your CRM / conversation view
    await db.inbound.insert({ messageId: message_id, from: inbound_number, to: outbound_number, text, channel, receivedAt: received_at });

    // Optionally trigger a follow-up flow
    const COMPLIANCE_KEYWORDS = ['stop', 'cancel', 'unsubscribe', 'quit', 'end', 'start', 'unstop', 'subscribe', 'help', 'info'];
    if (text && !COMPLIANCE_KEYWORDS.includes(text.toLowerCase().trim())) {
      await triggerResponseFlow({ from: inbound_number, channel });
    }
  }
});

from flask import Flask, request

app = Flask(__name__)

@app.route('/webhooks/sent', methods=['POST'])
def handle_webhook():
    data = request.json

    if data['field'] == 'message' and data.get('event') == 'message.received':
        p = data['payload']
        db.inbound.insert(
            message_id=p['message_id'],
            from_number=p['inbound_number'], to=p['outbound_number'],
            text=p.get('text'), channel=p['channel'],
            received_at=p['received_at']
        )

        compliance_keywords = {'STOP', 'CANCEL', 'UNSUBSCRIBE', 'QUIT', 'END', 'START', 'UNSTOP', 'SUBSCRIBE', 'HELP', 'INFO'}
        text = p.get('text')
        if text and text.strip().upper() not in compliance_keywords:
            trigger_response_flow(from_number=p['inbound_number'], channel=p['channel'])

    return '', 200

package main

import (
    "encoding/json"
    "net/http"
    "strings"
)

type Payload struct {
    MessageID      string `json:"message_id"`
    InboundNumber  string `json:"inbound_number"`
    OutboundNumber string `json:"outbound_number"`
    Text           string `json:"text"`
    Channel        string `json:"channel"`
    ReceivedAt     string `json:"received_at"`
}

type WebhookEvent struct {
    Field   string  `json:"field"`
    Event   string  `json:"event"`
    Payload Payload `json:"payload"`
}

func webhookHandler(w http.ResponseWriter, r *http.Request) {
    var event WebhookEvent
    if err := json.NewDecoder(r.Body).Decode(&event); err != nil {
        w.WriteHeader(http.StatusBadRequest)
        return
    }
    w.WriteHeader(http.StatusOK)

    if event.Field == "message" && event.Event == "message.received" {
        p := event.Payload
        db.Inbound.Insert(p.MessageID, p.InboundNumber, p.OutboundNumber, p.Text, p.Channel, p.ReceivedAt)

        complianceKeywords := map[string]bool{
            "STOP": true, "CANCEL": true, "UNSUBSCRIBE": true, "QUIT": true, "END": true,
            "START": true, "UNSTOP": true, "SUBSCRIBE": true, "HELP": true, "INFO": true,
        }
        if p.Text != "" && !complianceKeywords[strings.ToUpper(strings.TrimSpace(p.Text))] {
            triggerResponseFlow(p.InboundNumber, p.Channel)
        }
    }
}

[HttpPost("/webhooks/sent")]
public async Task<IActionResult> HandleWebhook([FromBody] JsonElement body)
{
    var field = body.GetProperty("field").GetString();
    var evt = body.GetProperty("event").GetString();

    if (field == "message" && evt == "message.received")
    {
        var payload = body.GetProperty("payload");
        var messageId = payload.GetProperty("message_id").GetString();
        var from = payload.GetProperty("inbound_number").GetString();
        var to = payload.GetProperty("outbound_number").GetString();
        var text = payload.TryGetProperty("text", out var t) ? t.GetString() : null;
        var channel = payload.GetProperty("channel").GetString();
        var receivedAt = payload.GetProperty("received_at").GetString();

        await _db.Inbound.InsertAsync(new InboundMessage
        {
            MessageId = messageId, From = from, To = to, Text = text,
            Channel = channel, ReceivedAt = receivedAt
        });

        var complianceKeywords = new HashSet<string>
            { "STOP", "CANCEL", "UNSUBSCRIBE", "QUIT", "END", "START", "UNSTOP", "SUBSCRIBE", "HELP", "INFO" };
        if (text != null && !complianceKeywords.Contains(text.Trim().ToUpper()))
        {
            await _flowService.TriggerResponseFlowAsync(from, channel);
        }
    }

    return Ok();
}