Request OTP

{
  "recipient": { "value": "0555539152" },
  "sender": "YourBrand",
  "channel": "whatsapp"
}

// Complete OTP request flow with error handling
class OTPManager {
  constructor(apiKey, apiSecret) {
    this.auth = 'Basic ' + btoa(apiKey + ':' + apiSecret);
    this.baseUrl = 'https://api.sendexa.co/v1';
  }
  
  async requestOTP(phone, options = {}) {
    const {
      from = 'YourBrand',
      message = 'Your verification code is {code}',
      pinLength = 6,
      pinType = 'NUMERIC',
      expiry = { amount: 10, duration: 'minutes' },
      maxAttempts = 3,
      metadata = {}
    } = options;
    
    try {
      const response = await fetch(`${this.baseUrl}/otp/request`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'Authorization': this.auth
        },
        body: JSON.stringify({
          phone: this.formatPhone(phone),
          from,
          message,
          pinLength,
          pinType,
          expiry,
          maxAmountOfValidationRetries: maxAttempts,
          metadata
        })
      });
      
      const data = await response.json();

      if (!response.ok) {
        // data.error is a flat string code, e.g. "RATE_LIMIT_EXCEEDED" — no nested details object.
        throw new OTPError(data.message, data.error);
      }

      return {
        success: true,
        otpId: data.data.id,
        expiresAt: data.data.expiry.expiresAt,
        ...data.data
      };

    } catch (error) {
      if (error.code === 'RATE_LIMIT_EXCEEDED' || error.code === 'IP_RATE_LIMIT_EXCEEDED') {
        // Fixed rolling-hour window — no retryAfter/resetAt is returned, so
        // just surface the message and let the caller retry later.
        return {
          success: false,
          rateLimited: true,
          message: error.message
        };
      }

      // Note: there's no "active OTP already exists" error — a new request
      // silently invalidates any still-pending OTP for that phone.

      throw error;
    }
  }
  
  formatPhone(phone) {
    // Remove any non-digits
    const cleaned = phone.replace(/D/g, '');
    
    // Convert to international format if needed
    if (cleaned.startsWith('0')) {
      return '233' + cleaned.substring(1);
    }
    
    return cleaned;
  }
}

class OTPError extends Error {
  constructor(message, code) {
    super(message);
    this.code = code;
  }
}

// Usage with retry logic
async function initiateLogin(phone) {
  const otpManager = new OTPManager('api_key', 'api_secret');
  
  const result = await otpManager.requestOTP(phone, {
    from: 'MyApp',
    pinLength: 6,
    expiry: { amount: 5, duration: 'minutes' },
    metadata: { action: 'login' }
  });
  
  if (result.success) {
    // Store OTP ID for verification
    sessionStorage.setItem('otpId', result.otpId);
    sessionStorage.setItem('expiresAt', result.expiresAt);
    
    // Start countdown timer
    startOTPTimer(result.expiresAt);
    
    return { success: true };
  } else if (result.rateLimited) {
    return {
      success: false,
      message: result.message
    };
  }
}