How to Integrate Replit with Bandwidth

1// check-bandwidth-secrets.js
2const required = [
3  'BANDWIDTH_ACCOUNT_ID',
4  'BANDWIDTH_API_TOKEN',
5  'BANDWIDTH_API_SECRET',
6  'BANDWIDTH_PHONE_NUMBER',
7  'BANDWIDTH_APPLICATION_ID'
8];
9for (const key of required) {
10  if (!process.env[key]) {
11    throw new Error(`Missing secret: ${key}. Add it in Replit Secrets (lock icon 🔒).`);
12  }
13}
14console.log('All Bandwidth secrets are configured.');
15console.log('Account ID:', process.env.BANDWIDTH_ACCOUNT_ID);
16console.log('Phone Number:', process.env.BANDWIDTH_PHONE_NUMBER);

1// bandwidth-send.js — Send SMS and MMS via Bandwidth API
2const Bandwidth = require('@bandwidth/sdk');
3
4const client = new Bandwidth.ApiClient();
5client.authentications['Basic'].username = process.env.BANDWIDTH_API_TOKEN;
6client.authentications['Basic'].password = process.env.BANDWIDTH_API_SECRET;
7
8const messagingApi = new Bandwidth.MessagesApi(client);
9
10const ACCOUNT_ID = process.env.BANDWIDTH_ACCOUNT_ID;
11const FROM_NUMBER = process.env.BANDWIDTH_PHONE_NUMBER;
12const APP_ID = process.env.BANDWIDTH_APPLICATION_ID;
13
14// Send a simple SMS
15async function sendSMS(to, text) {
16  const messageRequest = new Bandwidth.MessageRequest();
17  messageRequest.applicationId = APP_ID;
18  messageRequest.from = FROM_NUMBER;
19  messageRequest.to = [to]; // Bandwidth uses array for recipients
20  messageRequest.text = text;
21
22  try {
23    const response = await messagingApi.createMessage(ACCOUNT_ID, messageRequest);
24    const message = response.body;
25    console.log(`SMS sent: ${message.id} (status: ${message.status})`);
26    return message.id;
27  } catch (err) {
28    if (err.response) {
29      console.error('Bandwidth API error:', err.response.status, err.response.body);
30    }
31    throw err;
32  }
33}
34
35// Send an MMS with media
36async function sendMMS(to, text, mediaUrls) {
37  const messageRequest = new Bandwidth.MessageRequest();
38  messageRequest.applicationId = APP_ID;
39  messageRequest.from = FROM_NUMBER;
40  messageRequest.to = [to];
41  messageRequest.text = text;
42  messageRequest.media = mediaUrls; // Array of publicly accessible URLs
43
44  const response = await messagingApi.createMessage(ACCOUNT_ID, messageRequest);
45  return response.body.id;
46}
47
48(async () => {
49  try {
50    const messageId = await sendSMS('+15559876543', 'Hello from Replit + Bandwidth!');
51    console.log('Message ID:', messageId);
52  } catch (err) {
53    console.error('Error:', err.message);
54  }
55})();

1# bandwidth_send.py — Send SMS via Bandwidth API from Replit
2import os
3import bandwidth
4from bandwidth.models import MessageRequest
5from bandwidth.exceptions import ApiException
6
7# Configure authentication
8configuration = bandwidth.Configuration(
9    username=os.environ['BANDWIDTH_API_TOKEN'],
10    password=os.environ['BANDWIDTH_API_SECRET']
11)
12
13ACCOUNT_ID = os.environ['BANDWIDTH_ACCOUNT_ID']
14FROM_NUMBER = os.environ['BANDWIDTH_PHONE_NUMBER']
15APP_ID = os.environ['BANDWIDTH_APPLICATION_ID']
16
17def send_sms(to: str, text: str) -> str:
18    """Send an SMS via Bandwidth and return the message ID."""
19    with bandwidth.ApiClient(configuration) as api_client:
20        messages_api = bandwidth.MessagesApi(api_client)
21        message_request = MessageRequest(
22            application_id=APP_ID,
23            to=[to],  # Bandwidth requires array even for single recipient
24            from_=FROM_NUMBER,
25            text=text
26        )
27        try:
28            response = messages_api.create_message(ACCOUNT_ID, message_request)
29            print(f'SMS sent: {response.id}')
30            return response.id
31        except ApiException as e:
32            print(f'Bandwidth API error {e.status}: {e.reason}')
33            print(f'Error body: {e.body}')
34            raise
35
36def send_mms(to: str, text: str, media_urls: list) -> str:
37    """Send an MMS with media attachments."""
38    with bandwidth.ApiClient(configuration) as api_client:
39        messages_api = bandwidth.MessagesApi(api_client)
40        message_request = MessageRequest(
41            application_id=APP_ID,
42            to=[to],
43            from_=FROM_NUMBER,
44            text=text,
45            media=media_urls
46        )
47        response = messages_api.create_message(ACCOUNT_ID, message_request)
48        return response.id
49
50if __name__ == '__main__':
51    msg_id = send_sms('+15559876543', 'Hello from Replit + Bandwidth (Python)!')
52    print(f'Message ID: {msg_id}')

1// bandwidth-webhook.js — Receive Bandwidth SMS callbacks with Express
2const express = require('express');
3const app = express();
4app.use(express.json());
5
6// Simple security: verify a shared secret token in the path
7const WEBHOOK_SECRET = process.env.BANDWIDTH_WEBHOOK_SECRET || 'change-me';
8
9// Configure this URL in your Bandwidth Application:
10// https://yourapp.replit.app/bandwidth/messages/{WEBHOOK_SECRET}
11app.post('/bandwidth/messages/:secret', (req, res) => {
12  if (req.params.secret !== WEBHOOK_SECRET) {
13    return res.status(403).json({ error: 'Unauthorized' });
14  }
15
16  // Bandwidth sends an array of callback events
17  const events = Array.isArray(req.body) ? req.body : [req.body];
18
19  for (const event of events) {
20    const type = event.type;
21    console.log('Bandwidth event type:', type);
22
23    if (type === 'message-received') {
24      const { from, to, text, media } = event.message;
25      console.log(`Inbound SMS from ${from}: ${text}`);
26      if (media && media.length > 0) {
27        console.log('MMS media URLs:', media);
28      }
29      // TODO: add your inbound message handling logic here
30      // e.g., look up user by phone number, trigger workflow
31
32    } else if (type === 'message-delivered') {
33      const messageId = event.message.id;
34      console.log(`Message ${messageId} delivered successfully`);
35      // TODO: update delivery status in database
36
37    } else if (type === 'message-failed') {
38      const { id, errorCode } = event.message;
39      console.error(`Message ${id} failed with error code: ${errorCode}`);
40      // TODO: handle failure — retry, alert, or log
41
42    } else {
43      console.log('Unhandled event type:', type, JSON.stringify(event, null, 2));
44    }
45  }
46
47  // Must return 200 quickly
48  res.status(200).json({ received: true });
49});
50
51app.listen(3000, '0.0.0.0', () => {
52  console.log('Bandwidth webhook server running on port 3000');
53  console.log(`Configure callback URL in Bandwidth App: https://yourapp.replit.app/bandwidth/messages/${WEBHOOK_SECRET}`);
54});

1# .replit — deployment configuration for Bandwidth webhook server
2# Add this to your .replit file
3
4# For Node.js:
5# [[ports]]
6# internalPort = 3000
7# externalPort = 80
8#
9# [deployment]
10# run = ["node", "bandwidth-webhook.js"]
11# deploymentTarget = "cloudrun"
12
13# For Python/Flask:
14# [[ports]]
15# internalPort = 3000
16# externalPort = 80
17#
18# [deployment]
19# run = ["gunicorn", "app:app", "--bind", "0.0.0.0:3000", "--workers", "2"]
20# deploymentTarget = "cloudrun"
21
22# Python Flask webhook receiver
23from flask import Flask, request, jsonify
24import os
25
26app = Flask(__name__)
27WEBHOOK_SECRET = os.environ.get('BANDWIDTH_WEBHOOK_SECRET', 'change-me')
28
29@app.route('/bandwidth/messages/<secret>', methods=['POST'])
30def bandwidth_callback(secret):
31    if secret != WEBHOOK_SECRET:
32        return jsonify({'error': 'Unauthorized'}), 403
33
34    events = request.json
35    if not isinstance(events, list):
36        events = [events]
37
38    for event in events:
39        event_type = event.get('type')
40        print(f'Bandwidth event: {event_type}')
41
42        if event_type == 'message-received':
43            msg = event.get('message', {})
44            print(f'Inbound from {msg.get("from")}: {msg.get("text")}')
45        elif event_type == 'message-delivered':
46            print(f'Delivered: {event["message"]["id"]}')
47        elif event_type == 'message-failed':
48            print(f'Failed: {event["message"]["id"]} code={event["message"].get("errorCode")}')
49
50    return jsonify({'received': True}), 200
51
52if __name__ == '__main__':
53    app.run(host='0.0.0.0', port=3000)