Send SMS with Node.js, Express, and MessageBird - code-examples -

This guide provides a step-by-step walkthrough for building a simple Node.js application using the Express framework to send an SMS message via the MessageBird API. We will cover project setup, configuration, implementation, basic error handling, and testing.

By the end of this tutorial, you will have a functional Express API endpoint that accepts a phone number and a message, then uses MessageBird to send the SMS.

Project Overview and Goals

Goal: Create a backend service that can programmatically send SMS messages.

Problem Solved: Provides a simple, repeatable way to integrate SMS sending capabilities into larger applications for notifications, alerts, or basic communication, without needing complex infrastructure.

Technologies Used:

  • Node.js: A JavaScript runtime environment for executing server-side code. Chosen for its widespread adoption, large ecosystem (npm), and asynchronous nature suitable for I/O operations like API calls.
  • Express: A minimal and flexible Node.js web application framework. Chosen for its simplicity in setting up routes and handling HTTP requests, making it ideal for creating API endpoints.
  • MessageBird Node.js SDK: The official library for interacting with the MessageBird API. Chosen to simplify API calls, authentication, and response handling.
  • dotenv: A module to load environment variables from a .env file into process.env. Chosen for securely managing sensitive information like API keys outside of the codebase.

Prerequisites:

  • Node.js and npm (or yarn) installed on your system.
  • A MessageBird account.
  • Access to a terminal or command prompt.
  • A text editor or IDE (like VS Code).

Final Outcome: A running Express server with a single POST endpoint (/send-sms) that takes a recipient phone number and message text, sends the SMS using MessageBird, and returns a success or error response.

1. Setting up the Project

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

  1. Create Project Directory: Open your terminal and create a new directory for the project, then navigate into it.

    mkdir node-messagebird-sms
cd node-messagebird-sms

  2. Initialize Node.js Project: Create a package.json file to manage project dependencies and scripts.

    npm init -y

    (The -y flag accepts the default settings.)

  3. Install Dependencies: We need Express for the server, the MessageBird SDK, and dotenv for environment variables.

    npm install express messagebird dotenv
    • express: The web framework.
    • messagebird: The SDK for interacting with the MessageBird API.
    • dotenv: To load environment variables from a .env file.

  4. Create Project Files: Create the main application file and files for environment variables and Git ignore rules.

    touch index.js .env .gitignore
    • index.js: This will contain our Express server and API logic.
    • .env: This file will store sensitive credentials like your MessageBird API key. It should never be committed to version control.
    • .gitignore: Specifies intentionally untracked files that Git should ignore.

  5. Configure .gitignore: Open .gitignore and add the following lines to prevent committing sensitive information and dependency folders:

    # Environment variables
.env

# Node dependencies
node_modules/

# Optional build/log folders
dist/
logs/
*.log
npm-debug.log*
yarn-debug.log*
yarn-error.log*

    Why: Keeping .env out of Git is crucial for security. node_modules contains installed packages and can be regenerated using npm install, so it doesn't need to be tracked.

  6. Project Structure: Your project directory should now look like this:

    • node-messagebird-sms/
      • .env
      • .gitignore
      • index.js
      • node_modules/
      • package-lock.json
      • package.json

2. Integrating with MessageBird

Now, let's configure the application to use your MessageBird credentials securely.

  1. Obtain MessageBird API Key:

    • Log in to your MessageBird Dashboard.
    • Navigate to the ""Developers"" section in the left-hand menu.
    • Click on the ""API access"" tab.
    • If you don't have a live API key, create one. Click ""Add access key"".
    • Give it a description (e.g., ""Node SMS App Key"") and select ""Live key"". Click ""Add"".
    • Important: Copy the generated API key immediately. You won't be able to see it again after closing the modal.
    • (Note: For initial testing without incurring costs or needing a purchased number, you can use a ""Test key"", but messages won't actually be delivered.)

  2. Obtain an Originator (Sender ID or Number):

    • An SMS message needs a sender, known as the ""originator"". This can be:
      • A Purchased Number: Go to ""Numbers"" in the MessageBird Dashboard, click ""Buy a number"", select your country, ensure ""SMS"" capability is checked, and purchase a virtual mobile number. This is the most reliable option globally.
      • An Alphanumeric Sender ID: A custom name (up to 11 characters, e.g., ""MyApp""). This is configurable in the MessageBird dashboard under SMS -> Sender IDs. Note: Alphanumeric IDs are not supported in all countries (e.g., the US) and recipients cannot reply to them. Check MessageBird's country restrictions documentation.
    • Choose the originator you want to use for sending messages.

  3. Configure Environment Variables: Open the .env file and add your MessageBird API key and chosen originator:

    # .env
MESSAGEBIRD_API_KEY=YOUR_LIVE_API_KEY_HERE
MESSAGEBIRD_ORIGINATOR=YOUR_PURCHASED_NUMBER_OR_SENDER_ID
    • Replace YOUR_LIVE_API_KEY_HERE with the key you copied.
    • Replace YOUR_PURCHASED_NUMBER_OR_SENDER_ID with your virtual number (in international format, e.g., +12005550100) or your registered alphanumeric sender ID.
    • Why .env? This keeps sensitive credentials separate from your code, making it more secure and easier to manage different configurations for development, staging, and production environments.

3. Implementing Core Functionality (Express API Endpoint)

Let's build the Express server and the API endpoint to send the SMS.

  1. Set up Express Server (index.js): Open index.js and add the basic Express server setup and load environment variables using dotenv.

    // index.js
require('dotenv').config(); // Load environment variables from .env file
const express = require('express');
const { initClient } = require('messagebird'); // Import the initClient function

// Validate essential environment variables
if (!process.env.MESSAGEBIRD_API_KEY) {
  console.error('FATAL ERROR: MESSAGEBIRD_API_KEY environment variable is not set.');
  process.exit(1); // Exit if key is missing
}
if (!process.env.MESSAGEBIRD_ORIGINATOR) {
  console.error('FATAL ERROR: MESSAGEBIRD_ORIGINATOR environment variable is not set.');
  process.exit(1); // Exit if originator is missing
}

// Initialize MessageBird client
const messagebird = initClient(process.env.MESSAGEBIRD_API_KEY);

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

// Middleware to parse JSON request bodies
app.use(express.json());

// Simple root route
app.get('/', (req, res) => {
  res.send('SMS Sending Service is running!');
});

// --- SMS Sending Endpoint will go here ---

// Start the server
app.listen(port, () => {
  console.log(`Server listening on port ${port}`);
});
    • require('dotenv').config();: Loads variables from .env. Must be called early.
    • const { initClient } = require('messagebird');: Imports the specific function for initializing the client.
    • initClient(...): Initializes the MessageBird SDK with your API key.
    • express(): Creates an Express application instance.
    • app.use(express.json());: Enables the server to parse incoming JSON payloads in request bodies. This is crucial for our API endpoint.
    • Basic validation checks ensure the required environment variables are present before starting.

  2. Create the SMS Sending Endpoint (index.js): Add the POST /send-sms route handler within index.js, below the app.use(express.json()); line and before app.listen(...).

    // index.js (continued)

// --- SMS Sending Endpoint ---
app.post('/send-sms', (req, res) => {
  const { recipient, message } = req.body; // Extract recipient number and message text

  // Basic Input Validation
  if (!recipient || !message) {
    return res.status(400).json({
      error: 'Missing required fields: recipient and message',
    });
  }

  // Construct message parameters
  const params = {
    originator: process.env.MESSAGEBIRD_ORIGINATOR,
    recipients: [recipient], // Must be an array
    body: message,
  };

  console.log(`Attempting to send SMS to ${recipient}...`);

  // Send the message using MessageBird SDK (Callback Pattern)
  messagebird.messages.create(params, (err, response) => {
    if (err) {
      // Handle API errors
      console.error('MessageBird API Error:', err);
      // Check if MessageBird provided structured errors and extract the first description
      const errorMessage = err.errors && Array.isArray(err.errors) && err.errors.length > 0
                         ? err.errors[0].description
                         : 'Failed to send SMS due to API error.';
      return res.status(500).json({
        error: 'MessageBird API error',
        details: errorMessage, // Provide specific details from MessageBird if possible
        // Consider removing rawError in production for security
        // rawError: err,
      });
    }

    // Handle successful sending
    console.log('MessageBird API Success:', response);
    res.status(200).json({
      message: 'SMS sent successfully!',
      details: {
        id: response.id,
        recipients: response.recipients.totalSentCount,
        // Add other relevant details from the response if needed
      },
    });
  });
  // (Note: The MessageBird SDK also supports Promises. You could alternatively use
  // `messagebird.messages.create(params).then(response => {...}).catch(err => {...})`
  // or `async/await` with this method for a different asynchronous handling style.)
});

// --- End SMS Sending Endpoint ---

// Start the server (already present from step 1)
// app.listen(port, () => { ... });
    • app.post('/send-sms', ...): Defines a route that listens for HTTP POST requests at the /send-sms path.
    • req.body: Express makes the parsed JSON payload available here (thanks to express.json() middleware). We destructure recipient and message.
    • Validation: A simple check ensures both required fields are present. A 400 Bad Request status is returned if not.
    • params: An object containing the necessary data for the MessageBird API call (originator, recipients, body). Note that recipients must be an array, even for a single number.
    • messagebird.messages.create(params, callback): This is the core SDK function call. It's asynchronous.
      • callback(err, response): This function is executed once MessageBird responds.
      • if (err): If the API call fails (invalid key, network issue, invalid number, etc.), the err object contains details. We log the error and return a 500 Internal Server Error. We attempt to extract a user-friendly description from the error object, checking its structure first.
      • else: If successful, the response object contains information about the sent message (like its ID). We log the success and return a 200 OK status with relevant details.
    • Promise/Async Alternative: A note is added indicating that the SDK also supports .then().catch() and async/await.

4. Implementing Error Handling and Logging

We've already added basic error handling within the /send-sms route:

  • Input Validation: Checking for missing recipient or message fields and returning a 400 Bad Request.
  • API Error Handling: Using the err object provided by the MessageBird SDK callback to detect API errors, logging them (console.error), and returning a 500 Internal Server Error with details if possible.
  • Logging: Using console.log for informational messages (attempting send, success) and console.error for errors.

Optional Enhancements / Production Considerations:

  • More Robust Validation: Use a library like joi or express-validator for more complex validation (e.g., checking if the recipient number format is valid according to E.164 standards).
  • Structured Logging: Implement a dedicated logging library (like winston or pino) for structured logs (JSON format), different log levels (debug, info, warn, error), and outputting to files or external logging services (like Datadog, Loggly).
  • Centralized Error Handler: Use Express error-handling middleware for a consistent way to catch and format errors across different routes, reducing code duplication.
  • Retry Mechanisms: For potentially transient network errors when calling the MessageBird API, consider implementing a simple retry strategy (e.g., retry once after a short delay) or use libraries like async-retry for more complex exponential backoff strategies. This is generally more relevant for critical notifications.

5. Adding Security Features

While this is a simple example, basic security is important:

  • API Key Security: Already handled by using environment variables (dotenv) and .gitignore to keep the key out of version control. Ensure the .env file has restricted permissions on the server (e.g., chmod 600 .env).
  • Input Validation: The check for recipient and message prevents basic errors.
    • Sanitization (Optional but Recommended): Although MessageBird's API likely handles its own input sanitization, if you were storing or displaying user-provided message content elsewhere in your application, you should sanitize it to prevent Cross-Site Scripting (XSS) attacks (e.g., using libraries like dompurify if rendering as HTML, or ensuring proper escaping in databases).
  • Rate Limiting (Production Consideration): To prevent abuse (intentional or accidental) of the SMS sending endpoint, implement rate limiting. Middleware like express-rate-limit can restrict how many requests a single IP address (or authenticated user) can make within a specific time window (e.g., 10 requests per minute). This helps control costs and prevent spamming.

6. Handling Special Cases

  • Originator Restrictions: As mentioned, alphanumeric sender IDs are not supported everywhere. If you use one, test delivery to different countries/carriers. Using a purchased virtual number is generally more reliable. Ensure numbers are in the correct international format (e.g., +14155552671).
  • Character Limits & Concatenation: A standard SMS message using the GSM-7 character set is limited to 160 characters. If you use characters outside this set (like emojis or non-Latin characters), the encoding switches to UCS-2, limiting the message to 70 characters. Longer messages are automatically split into multiple parts (concatenated SMS) by the network, and MessageBird typically bills for each part. Be mindful of message length to manage costs. The response object from MessageBird might contain details about the number of message parts (message.mccmnc).
  • Invalid Recipient Numbers: MessageBird's API will return an error if the recipient number format is invalid or the number is recognized as non-existent or unreachable. Our current error handling catches this and attempts to return the description provided by MessageBird.

7. Verification and Testing

  1. Start the Server: Open your terminal in the project directory and run:

    node index.js

    You should see Server listening on port 3000.

  2. Test with curl: Open another terminal window and use curl (or a tool like Postman/Insomnia) to send a POST request to your endpoint. Replace YOUR_RECIPIENT_PHONE_NUMBER with a real phone number (in international format, e.g., +14155552671) you can check.

    curl -X POST http://localhost:3000/send-sms \
     -H ""Content-Type: application/json"" \
     -d '{
           ""recipient"": ""YOUR_RECIPIENT_PHONE_NUMBER"",
           ""message"": ""Hello from my Node.js app! Testing MessageBird.""
         }'

  3. Check Results:

    • Terminal 1 (Server): You should see logs like: 
      Attempting to send SMS to YOUR_RECIPIENT_PHONE_NUMBER...
MessageBird API Success: { id: '...', href: '...', ... recipients: { totalCount: 1, totalSentCount: 1, ... } ... }
      Or, if there's an error: 
      Attempting to send SMS to ...
MessageBird API Error: { ... errors: [ { code: 21, description: 'Authentication failed', parameter: null } ], ... }
    • Terminal 2 (curl):
      • On success, you'll get a JSON response: 
        {
  ""message"": ""SMS sent successfully!"",
  ""details"": {
    ""id"": ""some-message-id"",
    ""recipients"": 1
  }
}
      • On input validation error (e.g., missing field): 
        {
  ""error"": ""Missing required fields: recipient and message""
}
        (Status Code: 400 Bad Request)
      • On MessageBird API error (e.g., bad API key): 
        {
  ""error"": ""MessageBird API error"",
  ""details"": ""Authentication failed""
}
        (Status Code: 500 Internal Server Error)
    • Recipient Phone: Check the phone associated with YOUR_RECIPIENT_PHONE_NUMBER. You should receive the SMS within seconds (if using a live key, a valid originator for the destination, and have sufficient balance).

8. Troubleshooting and Caveats

  • Error: FATAL ERROR: MESSAGEBIRD_API_KEY environment variable is not set.
    • Cause: The .env file is missing, not named correctly (.env), not located in the root directory where node index.js is executed, or the MESSAGEBIRD_API_KEY line is missing/commented out. The require('dotenv').config(); call might be missing or placed after the variable is accessed.
    • Solution: Verify the .env file's presence, name, location, and content. Ensure require('dotenv').config(); is at the very top of index.js.
  • Error: Authentication failed (from MessageBird API Response)
    • Cause: The MESSAGEBIRD_API_KEY in your .env file is incorrect, has been revoked, or is a test key being used when a live key is required (or vice-versa).
    • Solution: Double-check the API key in your .env file against the active key in your MessageBird Dashboard (Developers -> API access). Ensure you are using the correct type of key (live vs. test).
  • Error: message submission failed, invalid originator / Originator not allowed
    • Cause: The MESSAGEBIRD_ORIGINATOR specified in .env is not a valid purchased number associated with your MessageBird account, or it's an alphanumeric sender ID that is not permitted for the recipient's country or mobile carrier. Alphanumeric IDs also cannot be used in some countries (like the US).
    • Solution: Verify the originator value in .env. Ensure purchased numbers are entered in the correct international E.164 format (+ followed by country code and number, e.g., +447123456789). Check MessageBird's documentation on country restrictions for alphanumeric sender IDs or switch to using a purchased virtual number.
  • Error: invalid recipient / recipient not found
    • Cause: The recipient phone number provided in the API request body is not in a valid international format (e.g., missing the + prefix or country code), contains invalid characters, or represents a number that does not exist or is unreachable.
    • Solution: Ensure the client application sending the request provides the phone number in the correct E.164 international format (e.g., +14155552671). Verify the number itself is correct.
  • SMS Not Received:
    • Cause: Using a test API key (messages are simulated but not delivered); recipient number is incorrect or cannot receive SMS; insufficient funds in your MessageBird account; country/carrier restrictions blocking the message (especially with alphanumeric senders or to certain networks); the originator number is blocked by the recipient; potential temporary MessageBird platform issues (check their official status page).
    • Solution: Confirm you're using a live API key. Double-check the recipient number's format and validity. Check your MessageBird account balance. Try using a purchased number as the originator if using an alphanumeric ID. Consult MessageBird support if issues persist after checking common causes.
  • Request Timeout/Network Error:
    • Cause: Local machine network connectivity issues; firewall blocking outbound connections; temporary MessageBird API service disruption or latency.
    • Solution: Check your server's internet connection. Ensure firewalls allow outbound HTTPS traffic (typically port 443). Consider adding retry logic (as mentioned in Section 4) for production applications to handle transient network glitches.

9. Deployment

Deploying this application involves running the Node.js server in a production environment (like a cloud virtual machine or a Platform-as-a-Service) and ensuring the environment variables are configured securely.

  • Platforms: Common choices include Heroku, Vercel (especially for serverless functions), Render, AWS (EC2, Elastic Beanstalk, Lambda), Google Cloud (App Engine, Cloud Run, Compute Engine), Azure (App Service, Functions).
  • Environment Variables: Crucially, do not commit your .env file to Git or upload it directly. Use the deployment platform's specific mechanism for setting environment variables (e.g., Heroku config vars, AWS Parameter Store/Secrets Manager, Vercel Environment Variables). Set MESSAGEBIRD_API_KEY and MESSAGEBIRD_ORIGINATOR in the production environment. You might also want to set NODE_ENV=production.
  • Build Step: For this simple application, no explicit build step is required unless you introduce TypeScript or other transpilation.
  • Start Command: Ensure the platform is configured to start your application using node index.js. Alternatively, define a start script in your package.json (""start"": ""node index.js"") and configure the platform to run npm start.
  • Port: The code uses process.env.PORT || 3000. Most PaaS platforms automatically set the PORT environment variable, which your application will correctly bind to.

Example (Conceptual Heroku Deployment):

  1. Ensure you have the Heroku CLI installed and logged in (heroku login).
  2. Initialize a Git repository if you haven't already (git init, git add ., git commit -m ""Initial commit"").
  3. Create a Heroku app: heroku create your-unique-sms-app-name
  4. Set the required environment variables on Heroku: 
    heroku config:set MESSAGEBIRD_API_KEY=YOUR_ACTUAL_LIVE_KEY
heroku config:set MESSAGEBIRD_ORIGINATOR=YOUR_ACTUAL_SENDER_ID_OR_NUMBER
# Optional: Set Node environment
heroku config:set NODE_ENV=production
  5. Deploy your code: git push heroku main (or master, depending on your branch name).
  6. Heroku will build and deploy your app. You can check logs with heroku logs --tail.

10. Next Steps

You have successfully built a basic service to send SMS messages using Node.js, Express, and MessageBird. From here, you can expand its capabilities:

Explore More MessageBird Features:

  • Receive SMS: Set up a MessageBird webhook to point to another endpoint in your Express app to process incoming SMS messages.
  • Check Delivery Status: Implement webhooks to receive real-time delivery reports (DLRs) for sent messages.
  • Send MMS: Adapt the code to send Multimedia Messages (requires different API parameters and MMS-enabled numbers).
  • Verify API: Use MessageBird's Verify API for sending One-Time Passwords (OTP) for user verification.
  • Voice & WhatsApp: Explore MessageBird's APIs for making automated voice calls or sending WhatsApp messages.

Enhance Security:

  • Implement proper API authentication/authorization for your /send-sms endpoint (e.g., using API keys, JWT tokens) so only trusted clients can use it.
  • Implement robust rate limiting (as discussed in Section 5).

Improve Robustness:

  • Add structured logging (Section 4).
  • Implement comprehensive error handling and monitoring/alerting.
  • Consider adding request queuing (e.g., using Redis or RabbitMQ) if you expect high volumes of SMS requests, to decouple the API request from the actual sending process.

Integrate:

  • Connect this microservice to your main applications (e.g., e-commerce platform, monitoring system) to trigger SMS notifications based on specific events (order confirmation, server down alerts, appointment reminders).

Remember to replace placeholders like YOUR_LIVE_API_KEY_HERE, YOUR_PURCHASED_NUMBER_OR_SENDER_ID, and YOUR_RECIPIENT_PHONE_NUMBER with your actual values during setup and testing.