Node js OTP Api Fast2Sms : A Step-by-Step Guide

Welcome to our Node.js OTP API tutorial! In this guide, we’ll walk you through the process of creating a robust and secure One-Time Password (OTP) API using Node.js. Discover how to implement OTP for enhanced authentication, bolstering the security of your applications. Follow along for a step-by-step journey to strengthen your Node.js projects with the power of time-sensitive, one-time passwords.

Node js OTP Api

Implementing a OTP API adds an extra layer of security to your application by generating one-time passwords for user authentication. This approach enhances protection against unauthorized access, mitigates password-related risks, and aligns with modern security standards. The use of OTPs is crucial for implementing two-factor authentication, complying with security regulations, and instilling user confidence in the overall security of your platform.

It can be used to enhance security in applications by implementing one-time passwords for:

1. User Authentication
2. Account Recovery
3. Financial Transactions
4. Secure API Access
5. Remote Access and VPNs
6. E-commerce Transactions
7. Healthcare Systems
8. Employee Access
9. Cloud Services
10. Educational Platforms

This adds an extra layer of protection, especially in scenarios dealing with sensitive data, online transactions, and user access to various systems and services.

Implementing a Node.js OTP API enhances the security of your application, builds user trust, and ensures compliance with industry standards. It reduces the risk of unauthorized access, secures transactions, and provides a versatile solution for various authentication scenarios, contributing to an overall improved user experience and robust security posture.

Let’s jump into the code.

Otpsend.js

const express = require('express');
const router = express.Router();
const supabase = require('../db/db'); // Adjust the path as needed
const authorize = require('../middleware/authorize');
const axios = require('axios'); // Import axios
require('dotenv').config();

router.post('/send-otp', async (req, res) => {
  const { phoneNumber } = req.body;
  const smsApi = process.env.FATS2SMS;

  // Generate a random 6-digit OTP
  const otp = String(Math.floor(1000 + Math.random() * 9000));

  // Store the OTP in Supabase
  const { data, error } = await supabase
    .from('otp')
    .upsert(
      [
        {
          phone_number: phoneNumber,
          otp: otp,
        },
      ],
      { onConflict: ['phone_number'], updateAll: ['otp'] }
    );

  if (error) {
    return res.status(500).json({ error: 'Failed to send OTP' });
  }

  // Send the OTP via Fast2SMS
  const fast2smsEndpoint = 'https://www.fast2sms.com/dev/bulkV2';

  try {
    const response = await axios.post(
      fast2smsEndpoint,
      {
        variables_values: otp,
        route: 'otp',
        numbers: phoneNumber,
      },
      {
        headers: {
          Authorization: smsApi, // Replace with your Fast2SMS API key
        },
      }
    );

    // Check if Fast2SMS request was successful
    if (response.status === 200) {
      // For testing purposes, we'll just return the OTP in the response
      return res.json({ message: 'OTP has been sent successfully.' });
    } else {
      return res.status(500).json({ error: 'Failed to send OTP' });
    }
  } catch (error) {
    console.error(error);
    return res.status(500).json({ error: 'Failed to send OTP' });
  }
});

module.exports = router;

VerifyOtp.js

const express = require('express');
const router = express.Router();
const supabase = require('../db/db'); // Adjust the path as needed


router.post('/verify-otp', async (req, res) => {
    const { phoneNumber, otp } = req.body;
  
    // Retrieve the OTP from Supabase
    const { data: otpData, error } = await supabase
      .from('otp')
      .select('*')
      .eq('phone_number', phoneNumber)
     
  
    if (error) {
      return res.status(500).json({error: 'Failed to verify OTP' });

    }
    const otpNum = otpData[0] && otpData[0].otp;

    if (otpNum  != otp) {
      return res.status(400).json({ error: 'OTP is incorrect' });
      
    }
  
    // OTP is correct; you can proceed with further actions
    res.status(200).json({ message: 'OTP is correct' });
    
  });

  module.exports = router;

Conclusion:

In conclusion, a Node.js OTP API provides a robust and scalable solution for implementing secure authentication in web applications. By leveraging the strengths of Node.js for server-side development, it offers developers the tools to seamlessly integrate OTP functionality, enhancing the overall security posture of their applications. The API’s versatility allows for customization based on the specific needs of the application, providing a reliable and efficient means of implementing OTP-based authentication.

Original post read here.

#Fast2SMS in Node.js,#fast2smsapi,#fast2smsotpapi,#fast2smsnodejsapi,#nodejsotpapi,