Receive SMS and MMS Messages

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

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

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

app.post('/webhooks', async (req, res) => {
  const { data } = req.body;

  if (data.event_type === 'message.received') {
    const { payload } = data;
    const from = payload.from.phone_number;
    const to = payload.to[0].phone_number;

    // Send auto-reply
    await client.messages.send({
      from: to,   // Reply from the number that received the message
      to: from,   // Reply to the sender
      text: `Thanks for your message! We received: "${payload.text}"`
    });

    console.log(`Auto-reply sent to ${from}`);
  }

  res.sendStatus(200);
});

app.listen(5000);

import os
from flask import Flask, request
from telnyx import Telnyx

app = Flask(__name__)
client = Telnyx(api_key=os.environ.get("TELNYX_API_KEY"))

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

    if data.get('event_type') == 'message.received':
        payload = data.get('payload', {})
        sender = payload['from']['phone_number']
        recipient = payload['to'][0]['phone_number']

        # Send auto-reply
        client.messages.send(
            from_=recipient,
            to=sender,
            text=f'Thanks for your message! We received: "{payload.get("text")}"'
        )

        print(f"Auto-reply sent to {sender}")

    return '', 200

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

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

Telnyx.api_key = ENV['TELNYX_API_KEY']

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

  if data['event_type'] == 'message.received'
    payload = data['payload']
    sender = payload['from']['phone_number']
    recipient = payload['to'][0]['phone_number']

    Telnyx::Message.create(
      from: recipient,
      to: sender,
      text: "Thanks for your message! We received: \"#{payload['text']}\""
    )

    puts "Auto-reply sent to #{sender}"
  end

  status 200
end

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"net/http"
	"os"

	"github.com/team-telnyx/telnyx-go"
	"github.com/team-telnyx/telnyx-go/option"
)

func main() {
	client := telnyx.NewClient(
		option.WithAPIKey(os.Getenv("TELNYX_API_KEY")),
	)

	http.HandleFunc("/webhooks", func(w http.ResponseWriter, r *http.Request) {
		var event WebhookEvent
		json.NewDecoder(r.Body).Decode(&event)

		if event.Data.EventType == "message.received" {
			p := event.Data.Payload
			sender := p.From.PhoneNumber
			recipient := p.To[0].PhoneNumber

			client.Messages.Send(context.TODO(), telnyx.MessageSendParams{
				From: recipient,
				To:   sender,
				Text: fmt.Sprintf("Thanks for your message! We received: \"%s\"", p.Text),
			})

			fmt.Printf("Auto-reply sent to %s\n", sender)
		}

		w.WriteHeader(http.StatusOK)
	})

	fmt.Println("Server running on port 5000")
	http.ListenAndServe(":5000", nil)
}

import fs from 'fs';

async function downloadMedia(mediaUrl, apiKey) {
  const response = await fetch(mediaUrl, {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  });

  const buffer = Buffer.from(await response.arrayBuffer());
  const filename = mediaUrl.split('/').pop();
  fs.writeFileSync(filename, buffer);
  console.log(`Downloaded: ${filename} (${buffer.length} bytes)`);
}

// In your webhook handler:
for (const media of payload.media) {
  await downloadMedia(media.url, process.env.TELNYX_API_KEY);
}

import requests
import os

def download_media(media_url, api_key):
    response = requests.get(
        media_url,
        headers={"Authorization": f"Bearer {api_key}"}
    )
    filename = media_url.split("/")[-1]
    with open(filename, "wb") as f:
        f.write(response.content)
    print(f"Downloaded: {filename} ({len(response.content)} bytes)")

# In your webhook handler:
for media in payload.get("media", []):
    download_media(media["url"], os.environ["TELNYX_API_KEY"])

func downloadMedia(mediaURL, apiKey string) error {
	req, _ := http.NewRequest("GET", mediaURL, nil)
	req.Header.Set("Authorization", "Bearer "+apiKey)

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		return err
	}
	defer resp.Body.Close()

	parts := strings.Split(mediaURL, "/")
	filename := parts[len(parts)-1]

	file, _ := os.Create(filename)
	defer file.Close()

	written, _ := io.Copy(file, resp.Body)
	fmt.Printf("Downloaded: %s (%d bytes)\n", filename, written)
	return nil
}

require 'net/http'
require 'uri'

def download_media(media_url, api_key)
  uri = URI.parse(media_url)
  request = Net::HTTP::Get.new(uri)
  request['Authorization'] = "Bearer #{api_key}"

  response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
    http.request(request)
  end

  filename = File.basename(uri.path)
  File.open(filename, 'wb') { |f| f.write(response.body) }
  puts "Downloaded: #{filename} (#{response.body.bytesize} bytes)"
end

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.file.Path;

public static void downloadMedia(String mediaUrl, String apiKey) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create(mediaUrl))
        .header("Authorization", "Bearer " + apiKey)
        .build();

    String filename = mediaUrl.substring(mediaUrl.lastIndexOf('/') + 1);
    client.send(request, HttpResponse.BodyHandlers.ofFile(Path.of(filename)));
    System.out.println("Downloaded: " + filename);
}

using var httpClient = new HttpClient();
httpClient.DefaultRequestHeaders.Authorization =
    new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", apiKey);

var response = await httpClient.GetAsync(mediaUrl);
var bytes = await response.Content.ReadAsByteArrayAsync();
var filename = new Uri(mediaUrl).Segments.Last();
await File.WriteAllBytesAsync(filename, bytes);
Console.WriteLine($"Downloaded: {filename} ({bytes.Length} bytes)");

<?php
$ch = curl_init($mediaUrl);
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer $apiKey"]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$data = curl_exec($ch);
curl_close($ch);

$filename = basename(parse_url($mediaUrl, PHP_URL_PATH));
file_put_contents($filename, $data);
echo "Downloaded: $filename (" . strlen($data) . " bytes)\n";

curl -o downloaded-media.png \
  -H "Authorization: Bearer YOUR_API_KEY" \
  "https://media.telnyx.com/example-image.png"

import Telnyx from 'telnyx';

const telnyx = new Telnyx('YOUR_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(400);
  }
});

import telnyx

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 as e:
        print(f"Signature verification failed: {e}")
        return '', 400

require 'telnyx'

Telnyx.api_key = 'YOUR_API_KEY'
Telnyx.public_key = 'YOUR_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 => e
    puts "Signature verification failed: #{e.message}"
    status 400
  end
end

using Telnyx;

app.MapPost("/webhooks", async (HttpRequest request) =>
{
    var payload = await new StreamReader(request.Body).ReadToEndAsync();
    var signature = request.Headers["telnyx-signature-ed25519"].ToString();
    var timestamp = request.Headers["telnyx-timestamp"].ToString();

    try
    {
        var webhookEvent = Webhook.ConstructEvent(payload, signature, timestamp);
        Console.WriteLine($"Verified event: {webhookEvent.EventType}");
        return Results.Ok();
    }
    catch (TelnyxSignatureVerificationException e)
    {
        Console.WriteLine($"Signature verification failed: {e.Message}");
        return Results.BadRequest();
    }
});

<?php
require_once 'vendor/autoload.php';

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

try {
    $event = \Telnyx\Webhook::constructEvent($payload, $signature, $timestamp);
    echo "Verified event: " . $event['data']['event_type'];
    http_response_code(200);
} catch (\Telnyx\Exception\SignatureVerificationException $e) {
    echo "Signature verification failed: " . $e->getMessage();
    http_response_code(400);
}

import express from 'express';
import { createClient } from 'redis';

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

const redis = createClient();
await redis.connect();

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

  const { data } = req.body;
  const messageId = data.payload?.id;

  // Deduplicate using Redis (TTL: 24 hours)
  if (messageId) {
    const exists = await redis.get(`msg:${messageId}`);
    if (exists) return; // Already processed
    await redis.set(`msg:${messageId}`, '1', { EX: 86400 });
  }

  // Process asynchronously
  try {
    await processMessage(data);
  } catch (err) {
    console.error(`Failed to process ${messageId}:`, err);
    // Log to dead letter queue for manual review
    await redis.lpush('webhook:failed', JSON.stringify({ data, error: err.message }));
  }
});

import redis
import json
import threading
from flask import Flask, request

app = Flask(__name__)
r = redis.Redis()

def process_async(data, message_id):
    """Process webhook in background thread."""
    try:
        process_message(data)
    except Exception as e:
        print(f"Failed to process {message_id}: {e}")
        r.lpush("webhook:failed", json.dumps({"data": data, "error": str(e)}))

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

    # Deduplicate
    if message_id:
        if r.get(f"msg:{message_id}"):
            return '', 200
        r.set(f"msg:{message_id}", "1", ex=86400)

    # Process in background thread — return 200 immediately
    # For production, use Celery or RQ instead of threads
    threading.Thread(target=process_async, args=(data, message_id)).start()

    return '', 200