How to Integrate Replit with Nexmo (Vonage API)

1import os
2import vonage
3from vonage.errors import ClientError
4
5# Initialize Vonage client with API key and secret
6client = vonage.Client(
7    key=os.environ["VONAGE_API_KEY"],
8    secret=os.environ["VONAGE_API_SECRET"]
9)
10
11sms = vonage.Sms(client)
12
13def send_sms(to_number: str, message: str, from_number: str = None) -> dict:
14    """
15    Send an SMS message.
16    to_number: E.164 format, e.g., '+14155552671'
17    Returns response dict with status and message_id.
18    """
19    sender = from_number or os.environ.get("VONAGE_BRAND_NUMBER", "Vonage")
20    response = sms.send_message({
21        "from": sender,
22        "to": to_number.replace('+', ''),  # Vonage SMS API omits the +
23        "text": message,
24        "type": "unicode"  # Supports emojis and non-ASCII characters
25    })
26    if response["messages"][0]["status"] == "0":
27        return {
28            "success": True,
29            "message_id": response["messages"][0]["message-id"],
30            "remaining_balance": response["messages"][0].get("remaining-balance")
31        }
32    else:
33        error = response["messages"][0]["error-text"]
34        raise ValueError(f"SMS failed: {error} (status {response['messages'][0]['status']})")
35
36# --- Vonage Verify API for 2FA ---
37
38verify = vonage.Verify(client)
39
40def start_verification(phone_number: str, brand: str = "MyApp") -> str:
41    """
42    Start 2FA verification. Returns request_id to use in check_verification.
43    phone_number: E.164 format without +, e.g., '14155552671'
44    """
45    response = verify.start_verification({
46        "number": phone_number,
47        "brand": brand,
48        "code_length": "6",
49        "lg": "en-us"
50    })
51    if response["status"] == "0":
52        return response["request_id"]
53    raise ValueError(f"Verification failed: {response.get('error_text')}")
54
55def check_verification(request_id: str, code: str) -> bool:
56    """
57    Check a verification code entered by the user.
58    Returns True if code is correct, raises on failure.
59    """
60    response = verify.check({
61        "request_id": request_id,
62        "code": code
63    })
64    if response["status"] == "0":
65        return True
66    # Status 16 = already verified, 17 = too many attempts
67    error_msg = response.get("error_text", "Verification failed")
68    raise ValueError(f"Code check failed: {error_msg} (status {response['status']})")
69
70def cancel_verification(request_id: str) -> bool:
71    """Cancel an ongoing verification request."""
72    response = verify.cancel(request_id)
73    return response.get("status") == "0"
74
75# Example usage
76if __name__ == "__main__":
77    # Test SMS send (replace with a verified number on trial accounts)
78    result = send_sms("+14155550100", "Hello from Replit + Vonage!")
79    print(f"SMS sent: {result['message_id']}")
80    print(f"Balance remaining: {result.get('remaining_balance', 'N/A')}")

1const express = require('express');
2const { Vonage } = require('@vonage/server-sdk');
3const fs = require('fs');
4const path = require('path');
5const os = require('os');
6
7const app = express();
8app.use(express.json());
9
10// Write private key from Replit Secret to a temp file for the SDK
11const privateKeyContent = process.env.VONAGE_PRIVATE_KEY;
12const privateKeyPath = path.join(os.tmpdir(), 'vonage_private.key');
13fs.writeFileSync(privateKeyPath, privateKeyContent);
14
15const vonage = new Vonage({
16  apiKey: process.env.VONAGE_API_KEY,
17  apiSecret: process.env.VONAGE_API_SECRET,
18  applicationId: process.env.VONAGE_APPLICATION_ID,
19  privateKey: privateKeyPath
20});
21
22const FROM_NUMBER = process.env.VONAGE_BRAND_NUMBER; // Your Vonage virtual number
23
24// Send an SMS via the basic SMS API
25app.post('/send-sms', async (req, res) => {
26  const { to, text } = req.body;
27  if (!to || !text) return res.status(400).json({ error: 'to and text are required' });
28
29  try {
30    const response = await vonage.sms.send({
31      from: FROM_NUMBER,
32      to: to.replace('+', ''),
33      text
34    });
35    const msg = response.messages[0];
36    if (msg.status === '0') {
37      res.json({ success: true, messageId: msg['message-id'] });
38    } else {
39      res.status(400).json({ error: msg['error-text'] });
40    }
41  } catch (err) {
42    console.error('SMS error:', err);
43    res.status(500).json({ error: err.message });
44  }
45});
46
47// Send a WhatsApp message via the Messages API
48app.post('/send-whatsapp', async (req, res) => {
49  const { to, text } = req.body;
50  if (!to || !text) return res.status(400).json({ error: 'to and text are required' });
51
52  try {
53    const response = await vonage.messages.send({
54      message_type: 'text',
55      to: to.replace('+', ''),
56      from: FROM_NUMBER,
57      channel: 'whatsapp',
58      text
59    });
60    res.json({ success: true, messageUuid: response.message_uuid });
61  } catch (err) {
62    console.error('WhatsApp error:', err.response?.data);
63    res.status(500).json({ error: err.message });
64  }
65});
66
67// Webhook: receive inbound SMS/WhatsApp messages
68app.post('/webhooks/inbound', (req, res) => {
69  const { from, to, text, channel, message_uuid } = req.body;
70  console.log(`Inbound ${channel || 'SMS'} from ${from} to ${to}: ${text}`);
71  // Process message: save to database, trigger chatbot, route to agent, etc.
72  res.status(200).json({ received: true });
73});
74
75// Webhook: delivery receipt status updates
76app.post('/webhooks/status', (req, res) => {
77  const { to, status, message_uuid } = req.body;
78  console.log(`Delivery status for ${message_uuid}: ${status}`);
79  // Update message status in database
80  res.status(200).json({ received: true });
81});
82
83app.listen(3000, '0.0.0.0', () => {
84  console.log('Vonage integration server running on port 3000');
85});

1from flask import Flask, request, jsonify
2import os
3
4app = Flask(__name__)
5
6@app.route('/webhooks/inbound', methods=['POST', 'GET'])
7def inbound_sms():
8    """Receive inbound SMS messages from Vonage."""
9    # Vonage can send via POST (JSON or form) or GET (query params)
10    if request.method == 'POST':
11        data = request.json or request.form
12    else:
13        data = request.args
14
15    from_number = data.get('msisdn') or data.get('from')
16    to_number = data.get('to')
17    message_text = data.get('text') or data.get('message', {}).get('content', {}).get('text', '')
18    message_id = data.get('messageId') or data.get('message_uuid')
19
20    print(f"Inbound SMS from {from_number} to {to_number}: {message_text}")
21    print(f"Message ID: {message_id}")
22
23    # Process: save to database, trigger autoresponder, etc.
24    # Example: echo back
25    # send_sms(from_number, f'You said: {message_text}')
26
27    return jsonify({'received': True}), 200
28
29@app.route('/webhooks/status', methods=['POST'])
30def delivery_receipt():
31    """Receive delivery status updates for sent messages."""
32    data = request.json or request.form
33    message_id = data.get('messageId') or data.get('message_uuid')
34    status = data.get('status')
35    error_code = data.get('err-code', '0')
36
37    print(f"Delivery receipt: {message_id} — status: {status}, error: {error_code}")
38    # Update message status in database
39
40    return jsonify({'received': True}), 200
41
42if __name__ == '__main__':
43    app.run(host='0.0.0.0', port=3000)