Send SMS with Node.js, Fastify & MessageBird: Complete Tutorial (2025)

Build a production-ready Node.js SMS API using Fastify and MessageBird. This tutorial teaches you to send SMS messages programmatically with Node.js 22, Fastify v5, and the MessageBird SDK. You'll create a high-performance API endpoint that handles SMS delivery, implements proper error handling, and follows security best practices for production deployment.

By the end, you'll have a functional SMS API endpoint (POST /send-sms) that accepts phone numbers and message content, dispatches SMS through MessageBird, and handles edge cases with proper validation and logging. This forms a foundational building block for Node.js applications requiring SMS notifications, two-factor authentication, alerts, or customer communication features.

Project Overview and Goals

• Goal: Create a lightweight Fastify API endpoint (POST /send-sms) that sends SMS messages using the MessageBird Node.js SDK.
• Problem Solved: Provides a simple, programmatic way to integrate SMS sending capabilities into Node.js applications.
• Technologies:
  • Node.js: Asynchronous JavaScript runtime environment.
  • Fastify: A high-performance web framework for Node.js with built-in validation. Fastify v5 (current as of 2025) handles 70,000–80,000 requests per second.
  • MessageBird: A communication platform as a service (CPaaS) providing APIs for SMS, voice, and other channels. (Note: MessageBird has rebranded to "Bird" but the Node.js SDK continues under the MessageBird branding.)
  • dotenv: Loads environment variables from a .env file into process.env.
• Architecture:
     +-----------------+      +--------------------+      +------------------+      +-----------------+
     | Client (e.g.   |----->| Fastify API        |----->| MessageBird API  |----->| SMS Recipient   |
     | curl, Postman)  | POST | (Node.js Server)   |      | (via SDK)        |      | (Mobile Phone)  |
     +-----------------+ /send-sms +--------------------+      +------------------+      +-----------------+
                         {recipient, message}
  
• Prerequisites:
  • Node.js LTS version. As of 2025, Node.js 22 is current (Active LTS until October 2025, Maintenance LTS until April 2027). Node.js 20 remains supported in maintenance mode. Run node --version to check your installed version.
  • npm (bundled with Node.js) or yarn package manager.
  • MessageBird account. Sign up for free at https://messagebird.com.
  • Purchased virtual mobile number (VMN) from MessageBird or verified alphanumeric sender ID (check country restrictions).
  • Text editor (like VS Code).
  • Terminal or command prompt access.

1. Setting up the Project

Initialize your Node.js project and install dependencies.

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

   bash

   # Filename: Terminal Session
   mkdir fastify-messagebird-sms
   cd fastify-messagebird-sms
   

2. Initialize npm Project: Create a package.json file to manage dependencies and scripts.

   bash

   # Filename: Terminal Session
   npm init -y
   

3. Install Dependencies: Install Fastify for the web server, the messagebird SDK for API interaction, and dotenv for configuration management.

   bash

   # Filename: Terminal Session
   npm install fastify messagebird dotenv
   

4. Install Development Dependencies (Optional but Recommended): Install nodemon for automatic server restarts during development and pino-pretty for readable logs.

   bash

   # Filename: Terminal Session
   npm install --save-dev nodemon pino-pretty
   

5. Configure package.json Scripts: Open package.json and add start and dev scripts to the scripts section:

   json

   // Filename: package.json
   {
     // ... other fields
     "scripts": {
       "start": "node server.js",
       "dev": "nodemon server.js | pino-pretty",
       "test": "echo \"Error: no test specified\" && exit 1"
     },
     // ... other fields
   }
   
   • npm start: Runs the application using Node directly (for production).
   • npm run dev: Runs the application using nodemon with auto-reloading and pipes logs through pino-pretty for better readability.

6. Create .gitignore: Prevent committing sensitive files and unnecessary folders. Create a .gitignore file in the project root:

   plaintext

   # Filename: .gitignore
   node_modules
   .env
   npm-debug.log*
   yarn-debug.log*
   yarn-error.log*
   

7. Create Server File: Create the main application file.

   bash

   # Filename: Terminal Session
   touch server.js
   

Your project structure should now look like this:

fastify-messagebird-sms/
├── .gitignore
├── node_modules/
├── package-lock.json
├── package.json
└── server.js

2. Configuration: API Keys and Environment Variables

Never hardcode sensitive information like API keys directly into your source code. Use environment variables managed via a .env file.

1. Create .env and .env.example Files:

   • .env: Holds your actual secrets (not committed to version control).
   • .env.example: Template showing required variables (safe to commit).
   bash

   # Filename: Terminal Session
   touch .env .env.example
   

2. Define Environment Variables: Add these variables to both .env.example (with placeholder values) and .env (with your actual values).

   bash

   # Filename: .env.example
   # MessageBird API Configuration
   MESSAGEBIRD_API_KEY=YOUR_LIVE_API_KEY_HERE
   MESSAGEBIRD_ORIGINATOR=YOUR_SENDER_ID_OR_NUMBER_HERE
   
   # Server Configuration
   PORT=3000
   

   How to Obtain Values:

   • MESSAGEBIRD_API_KEY:

     • Purpose: Authenticates your requests with the MessageBird API. Use your Live API key for actual sending.
     • How to Obtain:
       1. Log in to your MessageBird Dashboard.
       2. Navigate to Developers in the left-hand menu, then API access.
       3. If you don't have a Live API Key, create one.
       4. Copy the key and paste it into your .env file.

   • MESSAGEBIRD_ORIGINATOR:

     • Purpose: The sender ID displayed to the recipient. Use a purchased virtual mobile number (in E.164 format, e.g., +12005550199) or an alphanumeric sender ID (e.g., MyApp, max 11 chars).
     • How to Obtain/Set:
       • Number: Go to Numbers in the MessageBird Dashboard and purchase a number with SMS capabilities. Copy the full number in E.164 format (e.g., +12005550199). Purchased numbers (VMN) are more reliable and have fewer restrictions than alphanumeric IDs.
       • Alphanumeric: Set directly here, but check MessageBird's documentation for country-specific support and restrictions. Alphanumeric sender IDs have limited support and may require pre-registration in regions like North America.
       • E.164 Format Requirements: Format phone numbers internationally with the country code, no spaces, dashes, or parentheses. Example: US number (214) 123-4567 with country code +1 becomes +1214123456 or 1214123456 (MessageBird accepts both with or without the + prefix).
     • Paste your chosen originator into the .env file.

   • PORT:

     • Purpose: The network port your Fastify server listens on.
     • How to Set: Choose any available port (3000 is common for development). Your hosting provider may set this automatically in production.

3. Load Environment Variables in server.js: At the very top of server.js, require and configure dotenv.

   javascript

   // Filename: server.js
   'use strict';
   
   // Load environment variables from .env file
   require('dotenv').config();
   
   // ... rest of the server code
   

3. Implementing the Core Functionality with Fastify

Build the Fastify server and the SMS sending endpoint.

1. Initialize Fastify and MessageBird SDK: In server.js, after loading dotenv, require fastify and initialize the messagebird SDK using your API key from the environment variables.

   javascript

   // Filename: server.js
   'use strict';
   
   require('dotenv').config();
   
   // Require Fastify
   const fastify = require('fastify')({
     logger: true // Enable built-in Pino logger
   });
   
   // Initialize MessageBird SDK
   // IMPORTANT: Initialize AFTER dotenv.config() so process.env is populated
   const messagebird = require('messagebird')(process.env.MESSAGEBIRD_API_KEY);
   
   // ... rest of the server code below
   
   • logger: true enables Fastify's efficient Pino logger. During development (npm run dev), pino-pretty formats these logs nicely.

2. Define the /send-sms Route: Create a POST route that accepts a JSON body containing the recipient phone number and the message text. Fastify's schema validation ensures you receive the correct data format.

   javascript

   // Filename: server.js
   // ... (previous initialization code) ...
   
   // Define the schema for the request body
   const sendSmsSchema = {
     body: {
       type: 'object',
       required: ['recipient', 'message'],
       properties: {
         recipient: {
           type: 'string',
           description: 'Recipient phone number in E.164 format (e.g., +12005550199)',
           // Basic E.164 format check (must start with +, followed by 1-9, then 1-14 digits)
           pattern: '^\\+[1-9]\\d{1,14}$'
         },
         message: {
           type: 'string',
           description: 'The text message content',
           minLength: 1,
           maxLength: 1600 // Allows for multiple SMS parts; see SMS limits section below
         }
       }
     },
     response: { // Optional: Define expected success response structure
       200: {
         type: 'object',
         properties: {
           message: { type: 'string' },
           details: { type: 'object' } // To hold the MessageBird response
         }
       },
       // Fastify handles 4xx/5xx schema automatically based on error handling
     }
   };
   
   // Create the POST /send-sms route
   fastify.post('/send-sms', { schema: sendSmsSchema }, async (request, reply) => {
     const { recipient, message } = request.body;
     const originator = process.env.MESSAGEBIRD_ORIGINATOR;
   
     request.log.info(`Attempting to send SMS to ${recipient} from ${originator}`);
   
     const params = {
       originator: originator,
       recipients: [recipient], // Must be an array
       body: message
     };
   
     try {
       // Use a Promise wrapper for the callback-based SDK method
       const response = await new Promise((resolve, reject) => {
         messagebird.messages.create(params, (err, data) => {
           if (err) {
             // Specific MessageBird API error
             request.log.error({ msg: 'MessageBird API Error', error: err });
             return reject(err);
           }
           // Successful API call
           request.log.info({ msg: 'MessageBird API Success', response: data });
           resolve(data);
         });
       });
   
       // Send success response back to the client
       return reply.code(200).send({
         message: 'SMS submitted successfully via MessageBird.',
         details: response // Include MessageBird's response details
       });
   
     } catch (error) {
       // Handle errors (SDK errors, network issues, etc.)
       request.log.error({ msg: 'Error sending SMS', error: error });
   
       // Determine appropriate status code
       let statusCode = 500;
       let errorMessage = 'Failed to send SMS due to an internal server error.';
   
       // Check if it's a structured MessageBird error object
       if (error.errors && Array.isArray(error.errors) && error.errors.length > 0) {
         statusCode = error.statusCode || 400; // Use MB status code if available
         errorMessage = `MessageBird API Error: ${error.errors[0].description}` || 'Failed to send SMS via MessageBird.';
       }
   
       return reply.code(statusCode).send({
         error: errorMessage,
         details: error.errors || error.message // Provide specific error if available
       });
     }
   });
   
   // ... (server start code below) ...
   
   • Schema: Define sendSmsSchema to validate the incoming request.body. It requires recipient (string matching E.164 pattern) and message (non-empty string). Fastify automatically returns 400 Bad Request if validation fails.
   • Async Handler: The route handler is async to use await.
   • Promise Wrapper: Since messagebird.messages.create uses a traditional Node.js callback pattern, wrap it in a Promise to use async/await for cleaner asynchronous flow.
   • Parameter Object: Create the params object required by the MessageBird SDK, ensuring recipients is an array.
   • Error Handling: The try...catch block handles potential errors during the API call. Log errors and send an appropriate HTTP status code (500 for general errors, or 400/specific codes if MessageBird provides them) and message back to the client.

3. Start the Fastify Server: Add the code to start listening for connections at the end of server.js.

   javascript

   // Filename: server.js
   // ... (previous route code) ...
   
   // Run the server
   const start = async () => {
     try {
       const port = process.env.PORT || 3000;
       // Listen on 0.0.0.0 to accept connections from any interface
       await fastify.listen({ port: parseInt(port, 10), host: '0.0.0.0' });
       // Note: fastify.server.address() might be null initially if logger is synchronous
       // Log listening address after listen resolves successfully
       fastify.log.info(`Server listening on port ${fastify.server.address().port}`);
     } catch (err) {
       fastify.log.error(err);
       process.exit(1);
     }
   };
   
   start();
   
   • Wrap the server start logic in an async function start.
   • fastify.listen starts the server. Parse the PORT from environment variables (defaulting to 3000) and listen on 0.0.0.0 to accept connections from outside localhost (important for deployment).
   • Error handling ensures the process exits if the server fails to start.

4. Error Handling and Logging

• Validation Errors: Fastify's schema validation automatically handles these, returning 400 Bad Request with details about the validation failure.
• MessageBird API Errors: The catch block in the route handler looks for the structure of MessageBird errors (error.errors) to provide specific feedback and potentially use status codes returned by MessageBird (like 400 for bad input).
• Network/Other Errors: General errors (network issues, SDK problems) are caught and result in a 500 Internal Server Error.
• Logging: Fastify's built-in logger (request.log.info, request.log.error) provides contextual logging for each request. In development (npm run dev), logs are prettified. In production, the default JSON format suits log aggregation systems.

5. Security Considerations

Consider these security measures for production:

• API Key Security: Never commit your .env file or expose your MESSAGEBIRD_API_KEY. Use environment variables in your deployment environment.

• Input Validation: Basic validation is implemented with Fastify schemas. For more complex scenarios, consider libraries like joi or more specific validation logic. Sanitize any input that might be stored or displayed elsewhere.

• Rate Limiting: Implement rate limiting on the /send-sms endpoint to prevent abuse. The @fastify/rate-limit plugin is excellent for this.

  bash

  # Filename: Terminal Session (Example Installation)
  npm install @fastify/rate-limit
  
  javascript

  // Filename: server.js (Example Usage – place within the async `start` function, before defining routes)
  
  // Import the rate limit plugin
  // Adjust import based on your module system (ESM/CJS) and package version
  const rateLimit = require('@fastify/rate-limit');
  
  // Inside the async `start` function, before fastify.post:
  // await fastify.register(rateLimit, {
  //   max: 10, // Max requests per window per IP
  //   timeWindow: '1 minute'
  // });
  
  • Note: The await fastify.register(...) call must be inside an async function context, like the start function, before routes are defined. Check the @fastify/rate-limit documentation for the correct import/require syntax for your setup.

• Authentication/Authorization: If this API is part of a larger system, protect the endpoint. Ensure only authorized clients or users can trigger SMS sending (e.g., using JWT, API keys for clients, session authentication).

6. Testing the Endpoint

Test the endpoint using tools like curl or Postman.

1. Start the Development Server:

   bash

   # Filename: Terminal Session
   npm run dev
   

   You should see output indicating the server is running, similar to: {"level":30,"time":...,"pid":...,"hostname":"...","msg":"Server listening on port 3000"}

2. Send a Test Request using curl: Open another terminal window. Replace placeholders with your actual test recipient number (in E.164 format) and a message.

   bash

   # Filename: Terminal Session (replace placeholders)
   curl -X POST http://localhost:3000/send-sms \
        -H "Content-Type: application/json" \
        -d '{
              "recipient": "+12005550199",
              "message": "Hello from Fastify and MessageBird!"
            }'
   

3. Check the Response:

   • Success: You should receive a 200 OK response similar to this (details will vary):

     json

     // Example Success Response
     {
       "message": "SMS submitted successfully via MessageBird.",
       "details": {
         "id": "message-id-from-messagebird",
         "href": "...",
         "direction": "mt",
         "type": "sms",
         "originator": "YourSenderID",
         "body": "Hello from Fastify and MessageBird!",
         "reference": null,
         "validity": null,
         "gateway": 10,
         "typeDetails": {},
         "datacoding": "plain",
         "mclass": 1,
         "scheduledDatetime": null,
         "createdDatetime": "2023-10-26T10:00:00+00:00",
         "recipients": {
           "totalCount": 1,
           "totalSentCount": 1,
           "totalDeliveredCount": 0,
           "totalDeliveryFailedCount": 0,
           "items": [
             {
               "recipient": 12005550199,
               "status": "sent",
               "statusDatetime": "2023-10-26T10:00:00+00:00",
               "messagePartCount": 1
             }
           ]
         }
         // ... other fields may be present
       }
     }
     

     You should receive the SMS on the recipient phone shortly after.

   • Validation Error (e.g., missing field):

     bash

     # Filename: Terminal Session (Example: missing message field)
     curl -X POST http://localhost:3000/send-sms \
          -H "Content-Type: application/json" \
          -d '{"recipient": "+12005550199"}'
     

     Response (400 Bad Request):

     json

     // Example Validation Error Response
     {
       "statusCode": 400,
       "error": "Bad Request",
       "message": "body must have required property 'message'"
     }
     

   • MessageBird API Key Error (e.g., invalid key in .env): Response (401 Unauthorized or similar, depending on MessageBird):

     json

     // Example Auth Error Response
     {
       "error": "MessageBird API Error: Authentication failed",
       "details": [ /* MessageBird error details */ ]
     }
     

4. Check Server Logs: Observe the logs in the terminal where npm run dev is running for detailed information about requests and errors.

7. Troubleshooting and Caveats

• Authentication Failed: Double-check your MESSAGEBIRD_API_KEY in .env. Ensure it's a Live key and correctly copied from the dashboard. Verify dotenv.config() is called before initializing the MessageBird SDK.
• Invalid Originator: Ensure MESSAGEBIRD_ORIGINATOR is either a valid E.164 number you own in MessageBird or a permitted alphanumeric ID for the destination country. Check MessageBird's country restrictions – numeric IDs generally have broader support.
• Invalid Recipient: Ensure the recipient number in your test request uses correct E.164 format (+ followed by country code and number, e.g., +447123456789). MessageBird does not validate number format – incorrect formatting may result in delivery to wrong countries or failed delivery.
• Insufficient Balance: Ensure your account has sufficient credit if using paid MessageBird features or sending to certain destinations.
• Network Issues: Ensure the machine running the Fastify server can reach rest.messagebird.com. Firewalls could block outbound connections.
• .env Not Loaded: Verify the .env file exists in the project root and require('dotenv').config(); is at the top of server.js.
• SMS Content Limits:
  • GSM-7 Encoding (Standard): Single SMS limited to 160 characters. Multi-part messages split into 153-character segments (7 characters reserved for message reassembly headers).
  • Unicode/UCS-2 Encoding (Emoji, non-Latin scripts): Single SMS limited to 70 characters. Multi-part messages split into 67-character segments.
  • Extended GSM-7 Characters: Characters like ^, €, ~, [, ], {, }, |, \\ require two character spaces each, effectively reducing message length.
  • Automatic Encoding Detection: If your message contains any Unicode character (emoji, Chinese, Arabic, etc.), the entire message converts to Unicode encoding, reducing the character limit.
  • Billing: MessageBird bills each message segment separately. A 200-character GSM-7 message is billed as 2 SMS parts (153 + 47 characters).
• Rate Limits (MessageBird): MessageBird may impose rate limits on API requests. For high volumes, consult their documentation and consider implementing delays or queuing.

8. Deployment and CI/CD

Deploy this application by running the Node.js process on a server and setting the correct environment variables.

• Platforms: Suitable platforms include Heroku, Vercel (for serverless functions), Render, AWS (EC2, Elastic Beanstalk, Fargate, Lambda), Google Cloud (Cloud Run, App Engine), Azure App Service.
• Build Step: This application doesn't require a build step unless you introduce TypeScript or other transpilation.
• Start Command: Use npm start (which executes node server.js).
• Environment Variables: Configure MESSAGEBIRD_API_KEY, MESSAGEBIRD_ORIGINATOR, and PORT within your hosting platform's settings. Never commit your .env file.
• NODE_ENV: Set the NODE_ENV environment variable to production on your server. This enables optimizations in Fastify and dependencies.
• CI/CD: Set up a pipeline (e.g., using GitHub Actions, GitLab CI, Jenkins) to:
  1. Check out the code.
  2. Install dependencies (npm ci --only=production is recommended for production installs).
  3. Run linters/tests (if added).
  4. Deploy to your hosting platform, ensuring environment variables are securely injected.
• Rollback: Have a strategy to revert to a previous working version if a deployment introduces issues.

9. Verification

After deployment or changes, verify functionality using this checklist:

• Send Test SMS: Use curl or Postman against the deployed API URL to send a test message.
• Receive SMS: Confirm the message arrives on the test recipient's phone.
• Check MessageBird Logs: Log in to the MessageBird Dashboard and navigate to Insights → SMS Log to see the record of the sent message and its status.
• Check Server Logs: Review the logs on your deployment platform for any errors related to the test request.
• Test Error Cases: Send invalid requests (e.g., missing fields, invalid recipient format) to ensure appropriate error responses (4xx) are returned.

Frequently Asked Questions (FAQ)

Q: How do I send SMS using Node.js and Fastify? A: Send SMS using Node.js and Fastify by installing the Fastify framework and MessageBird SDK, creating a POST endpoint with schema validation, and calling messagebird.messages.create() with the recipient number and message body. Configure your MessageBird API key via environment variables and use async/await for clean asynchronous code handling.

Q: What is the best SMS API for Node.js applications? A: MessageBird is an excellent SMS API for Node.js applications due to its official Node.js SDK, competitive pricing, high delivery rates, and support for international messaging. Other popular options include Twilio, Sinch, and Plivo. MessageBird (now "Bird") provides reliable message delivery with detailed error reporting and status tracking.

Q: How many characters can I send in a single SMS message? A: A single SMS supports 160 characters using GSM-7 encoding (standard English text). Multi-part messages use 153 characters per segment (7 characters reserved for reassembly headers). Unicode messages (emoji, Arabic, Chinese) support 70 characters for single SMS or 67 characters per segment in multi-part messages.

Q: Do I need a MessageBird phone number to send SMS? A: You need either a purchased virtual mobile number (VMN) from MessageBird or an alphanumeric sender ID. Virtual mobile numbers are more reliable and have fewer country restrictions. Alphanumeric sender IDs (max 11 characters, like "MyApp") have limited support and may require pre-registration in regions like North America.

Q: How do I handle MessageBird API errors in Node.js? A: Handle MessageBird API errors by wrapping the SDK callback in a Promise, using try/catch blocks, and checking for the error.errors array structure. MessageBird returns structured error objects with status codes and descriptions. Log errors using Fastify's built-in Pino logger and return appropriate HTTP status codes (400 for validation errors, 401 for authentication, 500 for server errors).

Q: What phone number format does MessageBird require? A: MessageBird requires E.164 format: country code followed by the subscriber number with no spaces, dashes, or parentheses. Example: US number (214) 123-4567 becomes +1214123456. MessageBird accepts numbers with or without the + prefix. However, MessageBird doesn't validate format—incorrect formatting may cause delivery to wrong countries.

Q: How do I test SMS sending without using real phone numbers? A: Test SMS sending using MessageBird's Test API key for development (messages won't actually send). For real testing, use your own phone number as the recipient. MessageBird doesn't charge for failed deliveries, so testing with small volumes is cost-effective. Check the MessageBird dashboard's SMS Log under Insights to verify message status.

Q: Can I send SMS to multiple recipients at once with MessageBird? A: Yes, include multiple phone numbers in the recipients array parameter when calling messagebird.messages.create(). Example: recipients: ['+12005550199', '+447123456789']. MessageBird charges per recipient, and each receives the same message. For personalized messages, send separate API requests for each recipient.

Q: How do I implement rate limiting for my SMS API endpoint? A: Implement rate limiting using the @fastify/rate-limit plugin. Install with npm install @fastify/rate-limit, register the plugin before defining routes, and configure max requests per time window (e.g., 10 requests per minute per IP). This prevents API abuse and protects against spam while ensuring legitimate traffic flows smoothly.

Q: What's the difference between MessageBird's Live and Test API keys? A: Test API keys simulate API behavior without sending actual SMS messages or charging your account. Live API keys send real SMS messages and deduct credits from your balance. Use Test keys during development and integration testing, then switch to Live keys for production deployment. Never commit API keys to version control—use environment variables.

Q: How do I deploy a Fastify SMS application to production? A: Deploy Fastify SMS applications by pushing code to platforms like Heroku, Render, AWS (EC2, Elastic Beanstalk, Lambda), or Google Cloud (Cloud Run). Set environment variables (MESSAGEBIRD_API_KEY, PORT, NODE_ENV=production) in your hosting platform's configuration. Use npm start as the start command and ensure your server listens on 0.0.0.0 to accept external connections.

Q: Why am I getting "Authentication failed" errors from MessageBird? A: "Authentication failed" errors occur when your API key is invalid, expired, or incorrectly configured. Verify you're using a Live API key (not Test) for production, check the key is correctly copied from the MessageBird dashboard without extra spaces, and confirm dotenv.config() is called before initializing the MessageBird SDK. Check the API access page in your MessageBird dashboard to regenerate keys if needed.

Complete Code Repository

A complete, working example of this project may be available. Check project documentation or related resources for a link to the code repository if applicable.

Next Steps

This guide covers the basics of sending SMS. Extend this foundation by:

• Implementing more robust error handling and retry logic (e.g., using queues for resilience).
• Adding webhook endpoints to receive incoming SMS messages or delivery reports from MessageBird.
• Integrating this functionality into a larger application UI.
• Adding comprehensive automated tests (unit, integration).
• Implementing stricter security measures like authentication and authorization for the API endpoint.
• Exploring other MessageBird features like Verify API for OTPs or Voice APIs.