Receiving Webhooks for Messaging

import express from 'express';
import Telnyx from 'telnyx';

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

const telnyx = new Telnyx({ apiKey: process.env.TELNYX_API_KEY });

app.post('/webhooks', (req, res) => {
  const signature = req.headers['telnyx-signature-ed25519'];
  const timestamp = req.headers['telnyx-timestamp'];
  const payload = JSON.stringify(req.body);

  try {
    const event = telnyx.webhooks.constructEvent(
      payload,
      signature,
      timestamp,
      process.env.TELNYX_PUBLIC_KEY
    );
    console.log('Verified event:', event.data.event_type);
    res.sendStatus(200);
  } catch (err) {
    console.error('Signature verification failed:', err.message);
    res.sendStatus(403);
  }
});

app.listen(5000, () => console.log('Server running on port 5000'));

from flask import Flask, request
import telnyx

app = Flask(__name__)
telnyx.api_key = "YOUR_API_KEY"
telnyx.public_key = "YOUR_PUBLIC_KEY"

@app.route('/webhooks', methods=['POST'])
def webhooks():
    payload = request.data
    signature = request.headers.get('telnyx-signature-ed25519')
    timestamp = request.headers.get('telnyx-timestamp')

    try:
        event = telnyx.Webhook.construct_event(payload, signature, timestamp)
        print(f"Verified event: {event['data']['event_type']}")
        return '', 200
    except telnyx.error.SignatureVerificationError:
        return 'Invalid signature', 403

require 'sinatra'
require 'telnyx'
require 'json'

Telnyx.api_key = ENV['TELNYX_API_KEY']
Telnyx.public_key = ENV['TELNYX_PUBLIC_KEY']

post '/webhooks' do
  payload = request.body.read
  signature = request.env['HTTP_TELNYX_SIGNATURE_ED25519']
  timestamp = request.env['HTTP_TELNYX_TIMESTAMP']

  begin
    event = Telnyx::Webhook.construct_event(payload, signature, timestamp)
    puts "Verified event: #{event['data']['event_type']}"
    status 200
  rescue Telnyx::SignatureVerificationError
    status 403
    body 'Invalid signature'
  end
end

package main

import (
	"crypto/ed25519"
	"encoding/base64"
	"fmt"
	"io"
	"net/http"
	"os"
)

func verifySignature(payload, signature, timestamp string, publicKey ed25519.PublicKey) bool {
	signedPayload := timestamp + "|" + payload
	sigBytes, err := base64.StdEncoding.DecodeString(signature)
	if err != nil {
		return false
	}
	return ed25519.Verify(publicKey, []byte(signedPayload), sigBytes)
}

func webhookHandler(w http.ResponseWriter, r *http.Request) {
	body, _ := io.ReadAll(r.Body)
	signature := r.Header.Get("telnyx-signature-ed25519")
	timestamp := r.Header.Get("telnyx-timestamp")

	pubKeyBytes, _ := base64.StdEncoding.DecodeString(os.Getenv("TELNYX_PUBLIC_KEY"))
	publicKey := ed25519.PublicKey(pubKeyBytes)

	if !verifySignature(string(body), signature, timestamp, publicKey) {
		http.Error(w, "Invalid signature", http.StatusForbidden)
		return
	}

	fmt.Println("Webhook verified and received")
	w.WriteHeader(http.StatusOK)
}

func main() {
	http.HandleFunc("/webhooks", webhookHandler)
	fmt.Println("Server running on port 5000")
	http.ListenAndServe(":5000", nil)
}

package com.example.webhook;

import com.sun.net.httpserver.HttpServer;
import java.io.InputStream;
import java.net.InetSocketAddress;
import java.security.*;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;

public class WebhookServer {
    private static boolean verifySignature(String payload, String signature,
                                           String timestamp, String publicKeyBase64) throws Exception {
        byte[] pubKeyBytes = Base64.getDecoder().decode(publicKeyBase64);
        KeyFactory keyFactory = KeyFactory.getInstance("Ed25519");
        PublicKey publicKey = keyFactory.generatePublic(new X509EncodedKeySpec(pubKeyBytes));

        Signature sig = Signature.getInstance("Ed25519");
        sig.initVerify(publicKey);
        sig.update((timestamp + "|" + payload).getBytes());
        return sig.verify(Base64.getDecoder().decode(signature));
    }

    public static void main(String[] args) throws Exception {
        String publicKeyBase64 = System.getenv("TELNYX_PUBLIC_KEY");

        HttpServer server = HttpServer.create(new InetSocketAddress(5000), 0);
        server.createContext("/webhooks", exchange -> {
            InputStream is = exchange.getRequestBody();
            String body = new String(is.readAllBytes());
            String signature = exchange.getRequestHeaders().getFirst("telnyx-signature-ed25519");
            String timestamp = exchange.getRequestHeaders().getFirst("telnyx-timestamp");

            try {
                if (verifySignature(body, signature, timestamp, publicKeyBase64)) {
                    System.out.println("Webhook verified");
                    exchange.sendResponseHeaders(200, -1);
                } else {
                    exchange.sendResponseHeaders(403, -1);
                }
            } catch (Exception e) {
                exchange.sendResponseHeaders(500, -1);
            }
        });

        server.start();
        System.out.println("Server running on port 5000");
    }
}

// Requires: dotnet add package NSec.Cryptography
using System.Text;
using NSec.Cryptography;

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapPost("/webhooks", async (HttpContext context) =>
{
    using var reader = new StreamReader(context.Request.Body);
    var body = await reader.ReadToEndAsync();
    var signature = context.Request.Headers["telnyx-signature-ed25519"].ToString();
    var timestamp = context.Request.Headers["telnyx-timestamp"].ToString();

    var publicKeyBytes = Convert.FromBase64String(
        Environment.GetEnvironmentVariable("TELNYX_PUBLIC_KEY")!);
    var signedPayload = Encoding.UTF8.GetBytes($"{timestamp}|{body}");
    var signatureBytes = Convert.FromBase64String(signature);

    var algorithm = SignatureAlgorithm.Ed25519;
    var publicKey = PublicKey.Import(algorithm, publicKeyBytes, KeyBlobFormat.RawPublicKey);

    if (algorithm.Verify(publicKey, signedPayload, signatureBytes))
    {
        Console.WriteLine("Webhook verified");
        return Results.Ok();
    }

    return Results.StatusCode(403);
});

app.Run("http://0.0.0.0:5000");

<?php
$payload = file_get_contents('php://input');
$signature = $_SERVER['HTTP_TELNYX_SIGNATURE_ED25519'] ?? '';
$timestamp = $_SERVER['HTTP_TELNYX_TIMESTAMP'] ?? '';
$publicKey = getenv('TELNYX_PUBLIC_KEY');

$signedPayload = $timestamp . '|' . $payload;
$sigBytes = base64_decode($signature);
$pubKeyBytes = base64_decode($publicKey);

$valid = sodium_crypto_sign_verify_detached($sigBytes, $signedPayload, $pubKeyBytes);

if (!$valid) {
    http_response_code(403);
    echo 'Invalid signature';
    exit;
}

http_response_code(200);
echo 'Webhook verified';

import express from 'express';

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

app.post('/webhooks', (req, res) => {
  // Respond immediately to avoid timeout
  res.sendStatus(200);

  const { data } = req.body;

  switch (data.event_type) {
    case 'message.received':
      handleInboundMessage(data.payload);
      break;
    case 'message.sent':
      handleMessageSent(data.payload);
      break;
    case 'message.finalized':
      handleDeliveryReceipt(data.payload);
      break;
  }
});

function handleInboundMessage(payload) {
  const from = payload.from.phone_number;
  const text = payload.text;
  console.log(`Inbound from ${from}: ${text}`);

  // Check for MMS media
  if (payload.media?.length > 0) {
    payload.media.forEach(m => console.log(`Media: ${m.url} (${m.content_type})`));
  }
}

function handleMessageSent(payload) {
  console.log(`Message ${payload.id} sent to carrier`);
}

function handleDeliveryReceipt(payload) {
  const status = payload.to[0]?.status;
  console.log(`Message ${payload.id} finalized: ${status}`);

  if (status === 'delivery_failed') {
    console.error('Delivery failed:', payload.errors);
  }
}

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

from flask import Flask, request

app = Flask(__name__)

@app.route('/webhooks', methods=['POST'])
def webhooks():
    data = request.json.get('data', {})
    event_type = data.get('event_type')
    payload = data.get('payload', {})

    if event_type == 'message.received':
        handle_inbound_message(payload)
    elif event_type == 'message.sent':
        handle_message_sent(payload)
    elif event_type == 'message.finalized':
        handle_delivery_receipt(payload)

    return '', 200

def handle_inbound_message(payload):
    from_number = payload['from']['phone_number']
    text = payload.get('text', '')
    print(f"Inbound from {from_number}: {text}")

    for media in payload.get('media', []):
        print(f"Media: {media['url']} ({media['content_type']})")

def handle_message_sent(payload):
    print(f"Message {payload['id']} sent to carrier")

def handle_delivery_receipt(payload):
    status = payload['to'][0]['status']
    print(f"Message {payload['id']} finalized: {status}")

    if status == 'delivery_failed':
        print(f"Delivery failed: {payload.get('errors')}")

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

require 'sinatra'
require 'json'

post '/webhooks' do
  body = JSON.parse(request.body.read)
  data = body['data']
  payload = data['payload']

  case data['event_type']
  when 'message.received'
    puts "Inbound from #{payload['from']['phone_number']}: #{payload['text']}"
    payload['media']&.each { |m| puts "Media: #{m['url']}" }
  when 'message.sent'
    puts "Message #{payload['id']} sent to carrier"
  when 'message.finalized'
    status_val = payload['to'][0]['status']
    puts "Message #{payload['id']} finalized: #{status_val}"
    puts "Errors: #{payload['errors']}" if status_val == 'delivery_failed'
  end

  status 200
end

package main

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

type Webhook struct {
	Data struct {
		EventType string `json:"event_type"`
		Payload   struct {
			ID   string `json:"id"`
			From struct {
				PhoneNumber string `json:"phone_number"`
			} `json:"from"`
			To []struct {
				PhoneNumber string `json:"phone_number"`
				Status      string `json:"status"`
			} `json:"to"`
			Text   string `json:"text"`
			Media  []struct {
				URL         string `json:"url"`
				ContentType string `json:"content_type"`
			} `json:"media"`
			Errors []struct {
				Code   string `json:"code"`
				Title  string `json:"title"`
			} `json:"errors"`
		} `json:"payload"`
	} `json:"data"`
}

func webhookHandler(w http.ResponseWriter, r *http.Request) {
	var wh Webhook
	json.NewDecoder(r.Body).Decode(&wh)

	switch wh.Data.EventType {
	case "message.received":
		fmt.Printf("Inbound from %s: %s\n", wh.Data.Payload.From.PhoneNumber, wh.Data.Payload.Text)
		for _, m := range wh.Data.Payload.Media {
			fmt.Printf("Media: %s (%s)\n", m.URL, m.ContentType)
		}
	case "message.sent":
		fmt.Printf("Message %s sent to carrier\n", wh.Data.Payload.ID)
	case "message.finalized":
		if len(wh.Data.Payload.To) > 0 {
			fmt.Printf("Message %s finalized: %s\n", wh.Data.Payload.ID, wh.Data.Payload.To[0].Status)
		}
	}

	w.WriteHeader(http.StatusOK)
}

func main() {
	http.HandleFunc("/webhooks", webhookHandler)
	fmt.Println("Webhook server running on port 5000")
	http.ListenAndServe(":5000", nil)
}

package com.example.webhook;

import com.sun.net.httpserver.HttpServer;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import java.io.InputStream;
import java.net.InetSocketAddress;

public class WebhookServer {
    public static void main(String[] args) throws Exception {
        HttpServer server = HttpServer.create(new InetSocketAddress(5000), 0);

        server.createContext("/webhooks", exchange -> {
            InputStream is = exchange.getRequestBody();
            String body = new String(is.readAllBytes());
            JsonObject json = JsonParser.parseString(body).getAsJsonObject();
            JsonObject data = json.getAsJsonObject("data");
            String eventType = data.get("event_type").getAsString();
            JsonObject payload = data.getAsJsonObject("payload");

            switch (eventType) {
                case "message.received":
                    String from = payload.getAsJsonObject("from")
                        .get("phone_number").getAsString();
                    String text = payload.get("text").getAsString();
                    System.out.println("Inbound from " + from + ": " + text);
                    break;
                case "message.sent":
                    System.out.println("Message " + payload.get("id").getAsString() + " sent");
                    break;
                case "message.finalized":
                    String status = payload.getAsJsonArray("to").get(0)
                        .getAsJsonObject().get("status").getAsString();
                    System.out.println("Message " + payload.get("id").getAsString()
                        + " finalized: " + status);
                    break;
            }

            exchange.sendResponseHeaders(200, -1);
        });

        server.start();
        System.out.println("Webhook server running on port 5000");
    }
}

using Microsoft.AspNetCore.Mvc;
using System.Text.Json;

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapPost("/webhooks", async (HttpContext context) =>
{
    using var reader = new StreamReader(context.Request.Body);
    var body = await reader.ReadToEndAsync();
    var json = JsonDocument.Parse(body);
    var data = json.RootElement.GetProperty("data");
    var eventType = data.GetProperty("event_type").GetString();
    var payload = data.GetProperty("payload");

    switch (eventType)
    {
        case "message.received":
            var from = payload.GetProperty("from").GetProperty("phone_number").GetString();
            var text = payload.GetProperty("text").GetString();
            Console.WriteLine($"Inbound from {from}: {text}");
            break;
        case "message.sent":
            Console.WriteLine($"Message {payload.GetProperty("id").GetString()} sent");
            break;
        case "message.finalized":
            var status = payload.GetProperty("to")[0].GetProperty("status").GetString();
            Console.WriteLine($"Message {payload.GetProperty("id").GetString()} finalized: {status}");
            break;
    }

    return Results.Ok();
});

app.Run("http://0.0.0.0:5000");

<?php
$body = json_decode(file_get_contents('php://input'), true);
$data = $body['data'] ?? [];
$eventType = $data['event_type'] ?? '';
$payload = $data['payload'] ?? [];

switch ($eventType) {
    case 'message.received':
        $from = $payload['from']['phone_number'];
        $text = $payload['text'] ?? '';
        echo "Inbound from {$from}: {$text}\n";

        foreach ($payload['media'] ?? [] as $media) {
            echo "Media: {$media['url']} ({$media['content_type']})\n";
        }
        break;

    case 'message.sent':
        echo "Message {$payload['id']} sent to carrier\n";
        break;

    case 'message.finalized':
        $status = $payload['to'][0]['status'] ?? 'unknown';
        echo "Message {$payload['id']} finalized: {$status}\n";

        if ($status === 'delivery_failed') {
            echo "Errors: " . json_encode($payload['errors']) . "\n";
        }
        break;
}

http_response_code(200);