Sending SMS with Node.js, Express, and Vonage - code-examples -

Developer Guide: Sending SMS with Node.js, Express, and Vonage

This guide provides a complete walkthrough for building a production-ready Node.js application using the Express framework to send SMS messages via the Vonage API. We'll cover everything from initial project setup to deployment and troubleshooting.

Project Overview and Goals

What We're Building:

We will create a simple REST API endpoint using Node.js and Express. This endpoint will accept a POST request containing a recipient phone number and a message body, and then use the Vonage API to send that message as an SMS.

Problem Solved:

This provides a foundational microservice or API component enabling applications to programmatically send SMS notifications, alerts, verification codes, or other text-based communications to users worldwide.

Technologies Used:

  • Node.js: A JavaScript runtime environment for building server-side applications. Chosen for its asynchronous, event-driven nature, large ecosystem (npm), and popularity in web development.
  • Express: A minimal and flexible Node.js web application framework. Chosen for its simplicity, robustness, and widespread adoption for building APIs in Node.js.
  • Vonage API (SMS API): A communication platform-as-a-service (CPaaS) provider. Chosen for its reliable SMS delivery, developer-friendly SDK, and clear documentation for sending SMS messages. We will specifically use their Node.js SDK.
  • dotenv: A Node.js module to load environment variables from a .env file into process.env. Chosen for securely managing API keys and other configuration outside the codebase.

System Architecture:

![System Architecture Diagram](placeholder_diagram.png ""User -> Node/Express API -> Vonage SDK -> Vonage API -> Recipient Phone"") (Note: Replace the placeholder image above with an actual diagram showing the system architecture.)

Prerequisites:

  • Node.js and npm (or yarn): Installed on your development machine. You can download them from nodejs.org.
  • Vonage API Account: A free Vonage account is sufficient to start. You can sign up at Vonage API Dashboard. You get free credits for testing.
  • Vonage API Key and Secret: Available in your Vonage Dashboard after signing up.
  • A Vonage Virtual Number (or Alphanumeric Sender ID): You can get a virtual number from the Vonage Dashboard (""Numbers"" -> ""Buy numbers""). For trial accounts, you might need to use specific test numbers (see Troubleshooting). Alphanumeric Sender IDs (like ""MyBrand"") are also possible but subject to carrier regulations.
  • Test Recipient Phone Number(s): If using a trial Vonage account, you'll need to whitelist the phone numbers you intend to send messages to in the Vonage dashboard (see Troubleshooting section).
  • Basic Understanding: Familiarity with JavaScript, Node.js, REST APIs, and terminal/command line usage.
  • (Optional) HTTP Client: Tools like Postman or curl for testing the API endpoint.

Final Outcome:

By the end of this guide, you will have a running Node.js Express application with a single API endpoint (/send) capable of sending SMS messages via Vonage when provided with a recipient phone number and message text. The application will securely handle API credentials and provide basic error handling.

1. Setting Up the Project

Let's initialize our Node.js project and install the necessary dependencies.

  1. Create Project Directory: Open your terminal or command prompt and create a new directory for your project. Navigate into it.

    mkdir vonage-sms-sender
cd vonage-sms-sender

  2. Initialize Node.js Project: This command creates a package.json file, which keeps track of project metadata and dependencies. The -y flag accepts default settings.

    npm init -y

  3. Install Dependencies: We need express for the web server/API, @vonage/server-sdk to interact with the Vonage API, and dotenv to manage environment variables.

    npm install express @vonage/server-sdk dotenv --save
    • --save: This flag adds the dependencies to your package.json file.

  4. Enable ES Modules (Optional but Recommended): Using ES Module syntax (import/export) is common in modern Node.js. Open your package.json file and add the following line at the top level:

    // package.json
{
  "name": "vonage-sms-sender",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "type": "module",
  "scripts": {
    "start": "node index.js",
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "dependencies": {
    "@vonage/server-sdk": "^3.10.0",
    "dotenv": "^16.3.0",
    "express": "^4.18.0"
  }
}
    • Why type: "module"? This tells Node.js to treat .js files as ES modules, allowing import/export syntax instead of CommonJS require(). If you prefer require(), omit this line. This guide will use import/export.
    • Why "start": "node index.js"? This defines a convenient script to run your application using npm start.

  5. Create Project Structure: Create the main application file and a file for Vonage-specific logic.

    touch index.js vonageService.js .env .gitignore
    • index.js: The main entry point for our Express application.
    • vonageService.js: A module to encapsulate Vonage SDK initialization and SMS sending logic.
    • .env: Stores sensitive information like API keys (will be ignored by Git).
    • .gitignore: Specifies intentionally untracked files that Git should ignore.

  6. Configure .gitignore: It's crucial never to commit sensitive information like API keys or environment files to version control. Add the following lines to your .gitignore file:

    # .gitignore

# Dependencies
node_modules

# Environment variables
.env

# Optional Mac files
.DS_Store

# Optional Windows files
Thumbs.db

# Log files
*.log

2. Implementing Core Functionality (Sending SMS)

Now, let's write the code to interact with the Vonage SDK.

  1. Initialize Vonage SDK (vonageService.js): Open vonageService.js and add the following code. This initializes the Vonage client using credentials from environment variables and exports a function to send SMS.

    // vonageService.js
import { Vonage } from '@vonage/server-sdk';
import 'dotenv/config'; // Load environment variables from .env

// --- Vonage Client Initialization ---
// Retrieve credentials securely from environment variables
const apiKey = process.env.VONAGE_API_KEY;
const apiSecret = process.env.VONAGE_API_SECRET;
const fromNumber = process.env.VONAGE_VIRTUAL_NUMBER; // Your Vonage number or Sender ID

// Input validation for environment variables
if (!apiKey || !apiSecret || !fromNumber) {
    console.error('FATAL ERROR: Missing Vonage API credentials or virtual number in .env file.');
    console.error('Please ensure VONAGE_API_KEY, VONAGE_API_SECRET, and VONAGE_VIRTUAL_NUMBER are set.');
    process.exit(1); // Exit if critical configuration is missing
}

const vonage = new Vonage({
    apiKey: apiKey,
    apiSecret: apiSecret
});

/**
 * Sends an SMS message using the Vonage API.
 * @param {string} recipient - The recipient's phone number (E.164 format recommended, e.g., +15551234567).
 * @param {string} message - The text message content.
 * @returns {Promise<object&gt;} A promise that resolves with the Vonage API response data on success.
 * @throws {Error} Throws an error if the SMS sending fails or the API returns an error.
 */
export const sendSms = (recipient, message) =&gt; {
    return new Promise((resolve, reject) =&gt; {
        console.log(`Attempting to send SMS from ${fromNumber} to ${recipient}`);

        // Use the vonage.sms.send method (part of the older but simpler SMS API interface within the SDK)
        vonage.sms.send({ to: recipient, from: fromNumber, text: message }, (err, responseData) =&gt; {
            if (err) {
                // Network or SDK-level errors
                console.error('Vonage SDK Error:', err);
                reject(new Error(`Failed to send SMS via Vonage SDK: ${err.message || err}`));
            } else {
                // Check the status within the Vonage response
                // Note: responseData.messages can be an array if sending to multiple recipients (not used here)
                if (responseData.messages[0]['status'] === '0') {
                    console.log('SMS submitted successfully:', responseData.messages[0]);
                    resolve(responseData); // Resolve with the full response data
                } else {
                    // Vonage API returned an error for this message
                    const errorCode = responseData.messages[0]['error-code'];
                    const errorText = responseData.messages[0]['error-code-label'] || responseData.messages[0]['error-text'] || 'Unknown Vonage API error';
                    console.error(`Vonage API Error: Code ${errorCode} - ${errorText}`);
                    reject(new Error(`Vonage API failed to send SMS: ${errorText} (Code: ${errorCode})`));
                }
            }
        });
    });
};

// Optional: Export the 'fromNumber' if needed elsewhere, e.g., for logging
export { fromNumber };
    • Why dotenv/config? Importing this automatically loads variables from the .env file into process.env.
    • Why new Vonage(...)? This creates an instance of the Vonage client, authenticated with your API key and secret.
    • Why vonage.sms.send? This specific method within the SDK is straightforward for sending simple SMS messages using just the API key/secret and a sender/recipient/text. Users needing advanced features like MMS, WhatsApp integration, custom webhook configurations for delivery receipts, or complex failover logic would typically transition to the vonage.messages.send method, which often requires Application ID/Private Key authentication.
    • Why new Promise(...)? The vonage.sms.send method uses a callback pattern. Wrapping it in a Promise allows us to use modern async/await syntax in our Express route handler for cleaner asynchronous code.
    • Why Check responseData.messages[0]['status'] === '0'? Vonage's API indicates success for a message with a status code of '0'. Any other status indicates an error specific to that message, even if the HTTP request itself was successful.
    • Why process.exit(1)? If critical configuration is missing, the application cannot function. Exiting immediately prevents unexpected behavior later.

3. Building the API Layer (Express Server)

Let's create the Express server and the /send endpoint.

  1. Set up Express Server (index.js): Open index.js and add the following code:

    // index.js
import express from 'express';
import 'dotenv/config'; // Ensure environment variables are loaded
import { sendSms, fromNumber as vonageNumber } from './vonageService.js'; // Import the send function

const app = express();
const PORT = process.env.PORT || 3000; // Use port from .env or default to 3000

// --- Middleware ---
// Enable parsing of JSON request bodies
app.use(express.json());
// Enable parsing of URL-encoded request bodies (optional, but good practice)
app.use(express.urlencoded({ extended: true }));

// --- Basic Logging Middleware ---
app.use((req, res, next) =&gt; {
    console.log(`[${new Date().toISOString()}] ${req.method} ${req.url}`);
    next(); // Pass control to the next middleware/route handler
});

// --- Routes ---

// Health Check Endpoint
app.get('/health', (req, res) =&gt; {
    res.status(200).json({ status: 'UP', timestamp: new Date().toISOString() });
});

// SMS Sending Endpoint
app.post('/send', async (req, res) =&gt; {
    // 1. Basic Input Validation
    const { recipient, message } = req.body; // Destructure from JSON body

    if (!recipient || !message) {
        console.warn('Validation Error: Missing recipient or message in request body');
        return res.status(400).json({
            success: false,
            message: 'Bad Request: Both "recipient" and "message" are required in the JSON body.'
        });
    }

    // Basic format check (very lenient - production might need stricter validation like E.164)
    if (typeof recipient !== 'string' || typeof message !== 'string' || recipient.length &lt; 5) {
         console.warn(`Validation Error: Invalid format for recipient or message. Recipient: ${recipient}_ Message: ${message}`);
         return res.status(400).json({
            success: false_
            message: 'Bad Request: "recipient" must be a valid phone number string_ and "message" must be a string.'
         });
    }
    // For robust production validation_ consider using a library like `libphonenumber-js`
    // to parse and validate numbers against the E.164 standard.

    try {
        // 2. Call the Vonage Service
        console.log(`Received request to send SMS to ${recipient}`);
        const vonageResponse = await sendSms(recipient_ message);

        // 3. Send Success Response
        // Extract relevant info (optional_ but cleaner than sending the whole Vonage object)
        const messageInfo = vonageResponse.messages[0];
        res.status(200).json({
            success: true_
            message: 'SMS submitted successfully to Vonage.'_
            details: {
                to: messageInfo.to_
                messageId: messageInfo['message-id']_
                status: messageInfo.status_ // Should be "0"
                remainingBalance: messageInfo['remaining-balance']_
                messagePrice: messageInfo['message-price']_
                network: messageInfo.network
            }
        });

    } catch (error) {
        // 4. Send Error Response
        console.error(`Error processing /send request: ${error.message}`);
        // Determine appropriate status code (500 for server/Vonage errors_ potentially 4xx for others if identifiable)
        res.status(500).json({
            success: false_
            message: `Failed to send SMS: ${error.message}`_ // Pass the specific error from vonageService
            errorDetails: error.toString() // Include full error string for debugging if needed
        });
    }
});

// --- Global Error Handler (Catch-all) ---
// Optional: More sophisticated error handling could go here
app.use((err_ req_ res_ next) =&gt; {
    console.error("Unhandled Error:", err.stack || err);
    res.status(500).json({ success: false, message: 'Internal Server Error' });
});


// --- Start Server ---
app.listen(PORT, () =&gt; {
    console.log(`Server listening on http://localhost:${PORT}`);
    console.log(`Vonage SMS Sender configured: ${vonageNumber || 'UNKNOWN'}`); // Log the sender number
    console.log('Press Ctrl+C to stop the server.');
});
    • Why express.json()? This middleware is essential for parsing incoming requests with Content-Type: application/json. It makes req.body available with the parsed JSON data.
    • Why express.urlencoded()? Parses requests with Content-Type: application/x-www-form-urlencoded. While our primary endpoint uses JSON, it's good practice to include this.
    • Why async/await? We use async on the route handler function and await when calling sendSms because sendSms returns a Promise. This makes asynchronous code look and behave more like synchronous code, improving readability.
    • Why Input Validation? Never trust client input. Basic checks prevent errors and potential abuse. Checking for existence and basic types is the minimum.
    • Why try...catch? This block handles potential errors thrown by the sendSms function (like API failures or network issues), allowing us to send a meaningful error response (HTTP 500) back to the client instead of crashing the server.
    • Why /health endpoint? It's a standard practice for monitoring systems to check if the service is running and responsive.

4. Integrating with Vonage (Credentials)

Securely managing your API credentials is paramount.

  1. Get Vonage API Key and Secret:

    • Log in to your Vonage API Dashboard.
    • Your API Key and API Secret are displayed prominently on the main dashboard page (usually in the ""API settings"" section).
    • Treat your API Secret like a password – do not share it or commit it to Git.

  2. Get Vonage Virtual Number / Sender ID:

    • In the dashboard, navigate to ""Numbers"" -> ""Your numbers"".
    • If you don't have one, click ""Buy numbers"" and purchase an SMS-capable number for your desired country. Note the full number in E.164 format (e.g., +14155551212).
    • Alternatively, for some countries, you can use an Alphanumeric Sender ID (e.g., MyCompany). Check Vonage documentation and local regulations for availability and restrictions.

  3. Configure .env File: Open the .env file you created earlier and add your credentials. Replace the placeholder values with your actual credentials and number.

    # .env file
# Vonage API Credentials
VONAGE_API_KEY=YOUR_ACTUAL_API_KEY
VONAGE_API_SECRET=YOUR_ACTUAL_API_SECRET

# Vonage Virtual Number or Sender ID (e.g., +14155551212 or MyBrand)
VONAGE_VIRTUAL_NUMBER=YOUR_VONAGE_NUMBER_OR_SENDER_ID

# Server Port (Optional, defaults to 3000 if not set)
PORT=3000
    • Security: Ensure this .env file is listed in your .gitignore file.

5. Error Handling and Logging

We've already implemented basic error handling and logging:

  • vonageService.js:
    • Checks for missing environment variables on startup.
    • Rejects the promise with a specific error message if the Vonage SDK or API call fails, including the Vonage error code and text.
    • Uses console.log and console.error for basic tracing.
  • index.js:
    • Uses a try...catch block in the /send route to handle errors from vonageService.js.
    • Sends appropriate HTTP status codes (400 for bad input, 500 for server/Vonage errors).
    • Includes basic request logging middleware.
    • Includes basic input validation.

Further Improvements (Production Considerations):

  • Structured Logging: Use a dedicated logging library like winston or pino for structured JSON logs, different log levels (debug, info, warn, error), and routing logs to files or external services (like Datadog, Splunk).
  • Centralized Error Tracking: Integrate services like Sentry or Bugsnag to automatically capture, aggregate, and alert on unhandled exceptions.
  • More Specific Error Codes: Map specific Vonage API error codes (e.g., invalid number format, insufficient funds) to more specific HTTP status codes or error messages for the client if appropriate.
  • Retry Mechanisms: For transient network errors or specific Vonage rate-limiting errors, implement a retry strategy (e.g., exponential backoff) within vonageService.js before failing the request. Libraries like async-retry can help.

6. Database Schema and Data Layer

For this basic SMS sending service, a database is not strictly necessary. We are simply acting as a proxy to the Vonage API.

When a Database Might Be Needed:

  • Logging Message History: Storing records of sent messages (recipient, timestamp, status, message ID, cost) for auditing or analytics.
  • Managing Scheduled Messages: Storing messages to be sent later.
  • Storing User Preferences: If users could configure notification settings.
  • Tracking Delivery Status: Storing delivery receipts received via Vonage webhooks (requires setting up webhook endpoints, which is beyond this basic guide).

Example Schema (If Logging History):

If you were to add logging, a simple schema using a tool like Prisma or Sequelize might look like this:

  • Table: sms_logs
  • Columns:
    • id (Primary Key, Auto-increment/UUID)
    • recipient (String, Indexed)
    • sender (String)
    • message_body (Text)
    • vonage_message_id (String, Unique, Indexed)
    • vonage_status (String) // Initial status from API response
    • vonage_error_code (String, Nullable)
    • cost (Decimal, Nullable)
    • sent_at (Timestamp, Default: NOW())
    • delivery_status (String, Nullable, Indexed) // Updated via webhook
    • delivered_at (Timestamp, Nullable)

Implementing this involves choosing an ORM (like Prisma, Sequelize), setting up database migrations, and integrating data access logic into the /send route and potentially webhook handlers.

7. Security Features

Security is crucial, especially when handling API keys and sending messages.

  • Secure Credential Management:
    • Done: Using .env file for API keys/secrets.
    • Done: Using .gitignore to prevent committing .env.
    • Production: Use environment variables provided by your deployment platform (Heroku Config Vars, AWS Secrets Manager, etc.) instead of committing a .env file.
  • Input Validation:
    • Done: Basic checks for recipient and message presence and type in index.js.
    • Improvement: Implement stricter validation for phone numbers using libraries like libphonenumber-js to ensure E.164 format. Validate message length against SMS limits (typically 160 GSM characters or 70 UCS-2 characters per segment). Sanitize input to prevent potential injection attacks if message content is ever displayed elsewhere (though less critical for sending-only).
  • Rate Limiting:
    • Needed: Protect your API endpoint and Vonage account from abuse (accidental or malicious). Implement rate limiting on the /send endpoint.
    • Implementation: Use middleware like express-rate-limit. 
      npm install express-rate-limit

      // index.js (add near other middleware)
import rateLimit from 'express-rate-limit';

const apiLimiter = rateLimit({
    windowMs: 15 * 60 * 1000, // 15 minutes
    max: 100, // Limit each IP to 100 requests per windowMs
    message: 'Too many requests from this IP, please try again after 15 minutes',
    standardHeaders: true, // Return rate limit info in the `RateLimit-*` headers
    legacyHeaders: false, // Disable the `X-RateLimit-*` headers
});

// Apply the rate limiting middleware to API calls
app.use('/send', apiLimiter); // Apply specifically to /send
// Or apply to all routes: app.use(apiLimiter);
  • HTTPS:
    • Needed (Deployment): Always run your production application behind HTTPS to encrypt traffic between the client and your server. Deployment platforms often handle this automatically (e.g., Heroku, Render), or you'll need a reverse proxy like Nginx or Caddy with Let's Encrypt.
  • Authentication/Authorization (If Applicable):
    • Our current API is open. If this were part of a larger system, you would protect the /send endpoint.
    • Implementation: Use strategies like API Keys (passed in headers), JWT (JSON Web Tokens), or OAuth forwarded from an upstream API gateway.

8. Handling Special Cases

  • Phone Number Formatting:
    • Vonage Recommendation: Use E.164 format (e.g., +14155551212, +447700900123). While Vonage might handle some local formats, E.164 is unambiguous globally.
    • Action: Enforce or normalize recipient numbers to E.164 format during input validation using libphonenumber-js.
  • Character Limits & Encoding:
    • Standard SMS messages have character limits (160 for GSM-7 encoding, 70 for UCS-2 if non-standard characters are used). Longer messages are split into multiple segments, billed separately.
    • Action: Be aware of limits. You might want to add validation to warn or reject messages that are excessively long, or inform the client about potential multi-segment billing. Vonage handles the segmentation automatically.
  • Alphanumeric Sender IDs:
    • These (e.g., ""MyBrand"") improve branding but aren't supported in all countries (like the US) and often cannot receive replies. Regulations vary.
    • Action: Check Vonage documentation and local carrier rules if using alphanumeric IDs. Use a standard Vonage number if two-way communication or broader compatibility is needed. Set VONAGE_VIRTUAL_NUMBER accordingly.
  • International Sending:
    • Vonage supports global sending, but costs and regulations vary. Ensure your Vonage account is enabled for the destination countries.
    • Action: Check Vonage pricing and country-specific restrictions if sending internationally.

9. Performance Optimizations

For a basic service sending single messages on demand, deep optimization is often premature. Key areas for higher volume would be:

  • Asynchronous Processing:
    • The current implementation handles requests sequentially (await sendSms). For high throughput, you might decouple the API request from the Vonage call.
    • Implementation: The /send endpoint could quickly validate the request and place it onto a message queue (like RabbitMQ, Redis Streams, or AWS SQS). A separate worker process would consume from the queue and make the actual call to Vonage. This makes the API endpoint much faster and resilient to temporary Vonage issues.
  • Vonage SDK Client Reuse:
    • Done: We initialize the Vonage client once (vonageService.js) and reuse that instance for all requests, which is efficient.
  • Connection Pooling (Database):
    • If adding a database (Section 6), use an ORM or database driver that implements connection pooling to avoid the overhead of establishing a new database connection for every request.
  • Caching:
    • Not directly applicable to sending unique SMS messages. Caching might be relevant if fetching configuration or user data frequently.
  • Load Testing:
    • Use tools like k6, artillery, or JMeter to simulate traffic and identify bottlenecks under load before going to production if high volume is expected.

10. Monitoring, Observability, and Analytics

  • Health Checks:
    • Done: Implemented a basic /health endpoint.
    • Improvement: Production health checks might also test connectivity to essential services (like making a cheap Vonage API call like getBalance).
  • Logging:
    • Done: Basic console logging.
    • Needed: Structured logging (Section 5) forwarded to a centralized logging platform (ELK stack, Loki, Datadog Logs, etc.) for searching and analysis.
  • Metrics:
    • Needed: Track key performance indicators (KPIs).
    • Implementation: Use libraries like prom-client to expose metrics (e.g., request count, request duration, error count, Vonage API latency, messages sent count) in a format consumable by Prometheus. Visualize these metrics in Grafana or your monitoring platform.
    • Example Metrics:
      • http_requests_total{method=""POST"", route=""/send"", status_code=""200""}
      • http_request_duration_seconds{method=""POST"", route=""/send""}
      • vonage_sms_sent_total{status=""success/failure""}
      • vonage_api_errors_total{error_code=""<vonage_code&gt;""}
  • Error Tracking:
    • Needed: Integrate with services like Sentry (Section 5) for real-time error reporting and alerting.
  • Alerting:
    • Set up alerts in your monitoring system (e.g., Grafana Alerting, Alertmanager, Datadog Monitors) based on metrics and logs (e.g., high error rate on /send, high Vonage API latency, low server health check success rate, specific Vonage error codes like 'Insufficient Funds').

11. Troubleshooting and Caveats

  • Error: Non-Whitelisted Destination (or similar permission error)
    • Cause: You are likely using a trial Vonage account. Trial accounts can only send SMS messages to phone numbers explicitly verified and added to your account's test number list.
    • Solution:
      1. Go to your Vonage Dashboard.
      2. Navigate to the "Sandbox" or "Test Numbers" section (location might change slightly).
      3. Add the recipient phone number you want to test with. Vonage will send a verification code via SMS or voice call to that number.
      4. Enter the code in the dashboard to verify the number.
      5. Retry sending the SMS.
    • Note: To send to any number, you need to upgrade your account by adding payment details.
  • Error: Authentication Failed / Invalid Credentials
    • Cause: Incorrect VONAGE_API_KEY or VONAGE_API_SECRET in your .env file or environment variables.
    • Solution: Double-check the key and secret in your .env file match exactly those shown in your Vonage Dashboard. Ensure the .env file is being loaded correctly (check for typos in import 'dotenv/config';). If deployed, check the environment variables set in your deployment platform.
  • Error: Invalid Sender / Illegal Sender Address
    • Cause: The VONAGE_VIRTUAL_NUMBER in your .env file is incorrect, not owned by your account, not SMS-capable, or is an alphanumeric sender ID not permitted for the destination country/carrier.
    • Solution: Verify the number/sender ID exists in the "Your numbers" section of the Vonage Dashboard. Ensure it's the correct format (E.164 for numbers). If using alphanumeric, check Vonage documentation for compatibility.
  • Error: Invalid Message / Missing Parameter 'text'
    • Cause: The message field was missing or empty in the POST request to /send, or there was an issue constructing the payload for Vonage.
    • Solution: Ensure your client (Postman, curl, app) is sending a valid JSON body with both recipient and message keys containing string values. Check the server-side code (index.js) isn't accidentally clearing the message.
  • SMS Not Arriving (No Error)
    • Cause: Could be carrier filtering, incorrect recipient number (but valid format), Vonage delays, or issues with the recipient's device/service. Trial accounts might also have restrictions.
    • Solution:
      1. Verify the recipient number is absolutely correct.
      2. Check the Vonage Dashboard ("Logs" -> "Messages") to see the status Vonage reports for the message. It might show "delivered" to the carrier but still fail later.
      3. Try sending to a different number or carrier.
      4. Ensure the recipient device has service and isn't blocking the number.
      5. If using a trial account, ensure the destination is whitelisted.
  • Messages API vs. SMS API: This guide uses the simpler vonage.sms.send method tied to the API Key/Secret. If you need features like MMS, WhatsApp, failover, or more detailed status webhooks, you would use the vonage.messages.send method. This requires creating a Vonage Application in the dashboard, generating a private key file, using the Application ID and private key path for SDK initialization, and setting up Status/Inbound webhooks. See the Vonage Messages API documentation for details.

12. Deployment and CI/CD

Deploying this Node.js application involves running it on a server and making it accessible.