Opt-in WhatsApp Authentication

🇪🇬 FREE for Egyptian Startups Until 2025!

Special Offer for Egyptian Startups

We're excited to offer completely FREE WhatsApp OTP delivery for Egyptian-based startups until the end of 2025! This promotion supports Egypt's growing tech ecosystem and helps startups reduce operational costs during their growth phase.

Eligibility & How to Apply

• Egyptian-based startup: Company must be operating in Egypt and if registered, must be registered in Egypt.
• Startup verification: Proof of startup status (business registration (if found), website, accelerator participation, etc.)
• Valid until: December 31, 2025
• Automatic SMS fallback: Included at no cost when WhatsApp is unavailable

Overview

Akedly's Opt-in WhatsApp Authentication is an innovative, cost-effective authentication method that leverages Meta's WhatsApp Business API while ensuring full compliance with their opt-in policies. This solution allows users to receive OTP codes via WhatsApp by initiating the conversation themselves, making it significantly more affordable than traditional SMS-based authentication.

What Makes It Special

• User-initiated conversation: Users send a WhatsApp message first, complying with Meta's opt-in requirements
• Intelligent fallback: Automatically switches to SMS/Email if WhatsApp is unavailable on the user's number
• Cost-effective: Currently FREE for Egyptian startups until end of 2025
• Global coverage: Works nationally and internationally for all clients
• No extra templates needed: Uses utility messaging after user opt-in

Benefits & Innovation

Revolutionary Cost Structure

• Zero cost for WhatsApp delivery (during promotional period)
• Pay-per-success model: Only charged when authentication succeeds
• Smart fallback included: SMS backup at no additional cost during fallback

Technical Advantages

• Seamless user experience: Single-click WhatsApp integration
• High delivery rates: Multi-channel approach ensures message delivery
• Instant delivery: WhatsApp messages arrive immediately
• Enhanced security: Same security standards as traditional SMS authentication

Business Benefits

• Significant cost savings: Especially beneficial for high-volume authentication needs
• Better conversion rates: WhatsApp has higher open and engagement rates
• Modern user experience: Aligns with user preferences for messaging apps
• Competitive advantage: Innovative approach that differentiates your service

Pros & Cons

Advantages ✅

• Cost-effective: Dramatically reduces OTP delivery costs
• High reliability: Automatic fallback ensures delivery
• User-friendly: Most users prefer WhatsApp over SMS
• Instant delivery: No carrier delays
• Global reach: Works internationally
• Compliant: Fully adheres to Meta's opt-in policies
• Future-proof: Designed for scalability and pricing flexibility

Considerations ⚠️

• Extra user step: Users must click WhatsApp link and send message
• WhatsApp dependency: Requires WhatsApp Business API availability
• User education: May need to explain the process to first-time users
• Mobile-first: Optimized for mobile devices (desktop WhatsApp Web support available)

Implementation Guide - 4-Step Process

Step 1: Create Authentication Transaction

Start by creating an authentication transaction. To signal your intent to use the opt-in flow, you must include the optin: true attribute in your request.

{
  "APIKey": "your-api-key",
  "pipelineID": "your-pipeline-id",
  "verificationAddress": {
    "phoneNumber": "+201234567890"
  },
  "digits": 6,
  "optin": true
}

{
  "status": "success",
  "data": {
    "transactionID": "1a06b7354719818fbfc765baa7679869d3a13ccd3ed5fff80daddb05a8446e34"
  },
  "message": "Main transaction created successfully"
}

Step 2: Generate Opt-in Link (with Intelligent WhatsApp Detection)

Use the transactionID from Step 1 to generate either a WhatsApp opt-in link or automatically activate SMS/Email fallback:

GET /api/v1/transactions/optin-link/1a06b7354719818fbfc765baa7679869d3a13ccd3ed5fff80daddb05a8446e34

Response A: WhatsApp Available (Opt-in Flow)

When WhatsApp is available on the user's number, you'll receive an opt-in link:

{
  "status": "success",
  "message": "WhatsApp opt-in link generated successfully",
  "method": "whatsapp_optin",
  "hasWhatsApp": true,
  "fallbackUsed": false,
  "data": {
    "whatsappLink": "https://wa.me/201508717690?text=Hi%2C%20I%20want%20to%20receive%20my%20OTP%20for%201a06b7354719818fbfc765baa7679869d3a13ccd3ed5fff80daddb05a8446e34",
    "transactionID": "1a06b7354719818fbfc765baa7679869d3a13ccd3ed5fff80daddb05a8446e34",
    "transactionReqID": "68960a62e7acbde475fcef23",
    "companyName": "Akedly",
    "expirationDate": "2025-08-08T14:34:56.573Z",
    "instructions": "Click the link below to send a WhatsApp message and receive your OTP instantly. After receiving the OTP, Paste it here to verify."
  }
}

Response B: WhatsApp Not Available (Automatic SMS Fallback)

When WhatsApp isn't available, the system automatically sends OTP via SMS/Email:

{
  "status": "success",
  "message": "WhatsApp not available on this number, OTP sent via SMS/Email",
  "method": "sms_email",
  "hasWhatsApp": false,
  "fallbackUsed": true,
  "WhatsApp": false,
  "email": true,
  "sms": true,
  "data": {
    "_id": "68960a62e7acbde475fcef23",
    "mainTransactionID": "1a06b7354719818fbfc765baa7679869d3a13ccd3ed5fff80daddb05a8446e34",
    "sentVerification": true,
    "status": "Pending"
  },
  "comments": [
    "OTP sent via SMS Successfully",
    "OTP sent via Email Successfully"
  ]
}

Step 3A: WhatsApp User Interaction (Only for Response A)

When you receive Response A (WhatsApp available), present the WhatsApp link to your user:

1. User clicks the whatsappLink - Opens WhatsApp with pre-filled message
2. User sends the message - Message is automatically generated: "Hi, I want to receive my OTP for [transactionID]"
3. Akedly processes the request - Our webhook validates the phone number and transaction
4. User receives confirmation - "Hi! We've received your OTP request from [CompanyName]"
5. OTP is delivered - Sent in a separate message for easy copying

Step 3B: SMS/Email Processing (Only for Response B)

When you receive Response B (fallback used):

• No user action required - OTP is already sent automatically
• Skip directly to Step 4 for verification
• User receives OTP via SMS and/or Email immediately

Step 4: Verify OTP

Use the transactionReqID from Step 2 response to verify the user's OTP:

{
  "otp": "379884"
}

{
  "message": "OTP verified successfully",
  "status": "success",
  "data": {
    "frontendCallbackURL": "https://qaapp.akedly.io/account/verify/result?transactionID=1a06b7354719818fbfc765baa7679869d3a13ccd3ed5fff80daddb05a8446e34&status=Successful",
    "mainTransaction": {
      "verificationAddress": {
        "phoneNumber": "+201556452491"
      },
      "status": "Successful",
      "optinActivated": true,
      "OTP": "379884",
      "transactionID": "1a06b7354719818fbfc765baa7679869d3a13ccd3ed5fff80daddb05a8446e34"
    },
    "transactionReq": {
      "_id": "68960a62e7acbde475fcef23",
      "status": "Successful",
      "mainTransactionID": "1a06b7354719818fbfc765baa7679869d3a13ccd3ed5fff80daddb05a8446e34",
      "sentVerification": true,
      "inputOTP": "379884"
    }
  }
}

Complete Server Setup

Node.js Express Server

const express = require('express')
const axios = require('axios')
const cors = require('cors')
require('dotenv').config()

const app = express()

// Middleware
app.use(cors())
app.use(express.json())

// Configuration
const AKEDLY_API_KEY = process.env.AKEDLY_API_KEY
const AKEDLY_PIPELINE_ID = process.env.AKEDLY_PIPELINE_ID

// Rate limiting storage (use Redis in production)
const rateLimitStore = new Map()

// Rate limiting middleware
const rateLimit = (req, res, next) => {
  const phoneNumber = req.body.phoneNumber
  const now = Date.now()
  const lastRequest = rateLimitStore.get(phoneNumber)

  if (lastRequest && now - lastRequest < 60000) {
    const remainingTime = Math.ceil((60000 - (now - lastRequest)) / 1000)
    return res.status(429).json({
      success: false,
      error: 'Rate limit exceeded',
      timeRemaining: remainingTime,
    })
  }

  rateLimitStore.set(phoneNumber, now)
  next()
}

// Step 1: Initialize authentication
app.post('/api/auth/init', rateLimit, async (req, res) => {
  const { phoneNumber, digits = 6 } = req.body

  if (!phoneNumber || !/^\+[1-9]\d{1,14}$/.test(phoneNumber)) {
    return res.status(400).json({
      success: false,
      error: 'Valid phone number with country code required',
    })
  }

  try {
    const response = await axios.post(
      'https://api.akedly.io/api/v1/transactions/',
      {
        APIKey: AKEDLY_API_KEY,
        pipelineID: AKEDLY_PIPELINE_ID,
        verificationAddress: { phoneNumber },
        digits,
        optin: true,
      },
    )

    res.json({
      success: true,
      transactionID: response.data.data.transactionID,
    })
  } catch (error) {
    res.status(400).json({
      success: false,
      error: error.response?.data?.message || error.message,
    })
  }
})

// Step 2: Generate opt-in link
app.post('/api/auth/optin', async (req, res) => {
  const { transactionID } = req.body

  if (!transactionID) {
    return res.status(400).json({
      success: false,
      error: 'Transaction ID required',
    })
  }

  try {
    const response = await axios.get(
      `https://api.akedly.io/api/v1/transactions/optin-link/${transactionID}`,
    )

    const responseData = response.data

    res.json({
      success: true,
      method: responseData.method,
      hasWhatsApp: responseData.hasWhatsApp,
      fallbackUsed: responseData.fallbackUsed,
      data: {
        whatsappLink: responseData.data?.whatsappLink,
        instructions: responseData.data?.instructions,
        transactionReqID:
          responseData.data?.transactionReqID || responseData.data?._id,
        companyName: responseData.data?.companyName,
        expirationDate: responseData.data?.expirationDate,
        comments: responseData.comments,
      },
    })
  } catch (error) {
    res.status(400).json({
      success: false,
      error: error.response?.data?.message || error.message,
    })
  }
})

// Step 3: Verify OTP
app.post('/api/auth/verify', async (req, res) => {
  const { transactionReqID, otp } = req.body

  if (!transactionReqID || !otp) {
    return res.status(400).json({
      success: false,
      error: 'Transaction request ID and OTP are required',
    })
  }

  try {
    const response = await axios.post(
      `https://api.akedly.io/api/v1/transactions/verify/${transactionReqID}`,
      { otp },
    )

    res.json({
      success: true,
      message: 'Authentication successful',
      data: response.data,
    })
  } catch (error) {
    res.status(400).json({
      success: false,
      error: error.response?.data?.message || error.message,
    })
  }
})

// Health check
app.get('/health', (req, res) => {
  res.json({ status: 'healthy', timestamp: new Date().toISOString() })
})

const PORT = process.env.PORT || 3000
app.listen(PORT, () => {
  console.log(`Akedly Auth Server running on port ${PORT}`)
})

Frontend Implementation Requirements

OTP Input Form - Required for Both Methods

Important: Regardless of whether you use WhatsApp opt-in or SMS fallback, you MUST show an OTP input form to collect the user's verification code.

import React, { useState, useEffect } from 'react'

const AkedlyAuthComponent = () => {
  const [step, setStep] = useState('phone')
  const [phoneNumber, setPhoneNumber] = useState('')
  const [otp, setOtp] = useState('')
  const [loading, setLoading] = useState(false)
  const [error, setError] = useState('')
  const [authData, setAuthData] = useState(null)
  const [transactionReqID, setTransactionReqID] = useState('')
  const [countdown, setCountdown] = useState(0)

  useEffect(() => {
    if (countdown > 0) {
      const timer = setTimeout(() => setCountdown(countdown - 1), 1000)
      return () => clearTimeout(timer)
    }
  }, [countdown])

  const handlePhoneSubmit = async (e) => {
    e.preventDefault()
    setLoading(true)
    setError('')

    try {
      // Step 1: Initialize
      const initResponse = await fetch('/api/auth/init', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ phoneNumber, digits: 6 }),
      })

      const initData = await initResponse.json()
      if (!initData.success) throw new Error(initData.error)

      // Step 2: Generate opt-in link
      const optinResponse = await fetch('/api/auth/optin', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ transactionID: initData.transactionID }),
      })

      const optinData = await optinResponse.json()
      if (!optinData.success) throw new Error(optinData.error)

      setAuthData(optinData)
      setTransactionReqID(optinData.data.transactionReqID)
      setStep('otp')
    } catch (err) {
      setError(err.message)
      if (err.message.includes('Rate limit')) {
        setCountdown(60)
      }
    } finally {
      setLoading(false)
    }
  }

  const handleOTPSubmit = async (e) => {
    e.preventDefault()
    setLoading(true)
    setError('')

    try {
      const response = await fetch('/api/auth/verify', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ transactionReqID, otp }),
      })

      const data = await response.json()
      if (data.success) {
        setStep('success')
      } else {
        throw new Error(data.error)
      }
    } catch (err) {
      setError(err.message)
    } finally {
      setLoading(false)
    }
  }

  const handleWhatsAppClick = () => {
    if (authData?.data?.whatsappLink) {
      window.open(authData.data.whatsappLink, '_blank')
    }
  }

  if (step === 'phone') {
    return (
      <div className="auth-container">
        <h2>Phone Verification</h2>
        <form onSubmit={handlePhoneSubmit}>
          <input
            type="tel"
            value={phoneNumber}
            onChange={(e) => setPhoneNumber(e.target.value)}
            placeholder="+1234567890"
            required
            disabled={loading}
          />
          {error && <div className="error">{error}</div>}
          <button type="submit" disabled={loading || countdown > 0}>
            {loading
              ? 'Processing...'
              : countdown > 0
                ? `Wait ${countdown}s`
                : 'Send OTP'}
          </button>
        </form>
      </div>
    )
  }

  if (step === 'otp') {
    return (
      <div className="auth-container">
        <h2>Verify OTP</h2>

        {authData?.hasWhatsApp && (
          <div className="whatsapp-section">
            <p>{authData.data.instructions}</p>
            <button onClick={handleWhatsAppClick} className="whatsapp-btn">
              📱 Open WhatsApp
            </button>
          </div>
        )}

        {authData?.fallbackUsed && (
          <div className="info">OTP sent via SMS/Email</div>
        )}

        <form onSubmit={handleOTPSubmit}>
          <input
            type="text"
            value={otp}
            onChange={(e) =>
              setOtp(e.target.value.replace(/\D/g, '').slice(0, 6))
            }
            placeholder="123456"
            maxLength="6"
            required
            disabled={loading}
          />
          {error && <div className="error">{error}</div>}
          <button type="submit" disabled={loading || otp.length !== 6}>
            {loading ? 'Verifying...' : 'Verify OTP'}
          </button>
        </form>
      </div>
    )
  }

  if (step === 'success') {
    return (
      <div className="auth-container success">
        <h2>✓ Verified!</h2>
        <p>Phone number verified successfully</p>
      </div>
    )
  }
}

export default AkedlyAuthComponent

Resend Functionality with 60-Second Cooldown

Resend Logic: When user clicks "Resend OTP", you should:

1. For WhatsApp method: Call the opt-in link API again (/optin-link/{transactionID})
2. For SMS fallback: Recreate the entire flow (new transaction + opt-in call)
3. Rate limiting: 60-second cooldown enforced per phone number

// Resend implementation with cooldown
let lastResendTime = 0
const COOLDOWN_SECONDS = 60

function handleResend(transactionID, method) {
  const now = Date.now()
  const timeSinceLastResend = (now - lastResendTime) / 1000

  if (timeSinceLastResend < COOLDOWN_SECONDS) {
    const remainingTime = COOLDOWN_SECONDS - Math.floor(timeSinceLastResend)
    showError(`Please wait ${remainingTime} seconds before resending`)
    return
  }

  if (method === 'whatsapp_optin') {
    // Re-call opt-in link API
    requestOptinLink(transactionID)
  } else {
    // Recreate entire flow for SMS
    createNewTransaction()
  }

  lastResendTime = now
}

Quick Setup Guide

1. Backend Setup

# Clone or create your project
mkdir akedly-auth && cd akedly-auth

# Initialize package.json
npm init -y

# Install dependencies
npm install express axios cors dotenv

# Install development dependencies
npm install --save-dev nodemon

# Create server.js (copy from Complete Server Setup above)
# Create .env file with your Akedly credentials
echo "AKEDLY_API_KEY=your-api-key" > .env
echo "AKEDLY_PIPELINE_ID=your-pipeline-id" >> .env

# Start the server
npm run dev

2. Frontend Integration

Choose your frontend framework and copy the corresponding component from the examples above:

• React: Copy the React Complete Component
• React Native: Copy the React Native Complete Component
• Flutter: Copy the Flutter Complete Widget

3. Environment Variables

Backend (.env):

AKEDLY_API_KEY=your-actual-api-key-here
AKEDLY_PIPELINE_ID=your-actual-pipeline-id-here
PORT=3000

Frontend (React/React Native):

// For React (usually in .env.local)
REACT_APP_API_BASE_URL=http://localhost:3000

// For React Native
const API_BASE_URL = __DEV__
  ? 'http://localhost:3000'  // Development
  : 'https://your-production-api.com';  // Production

Flutter:

// In your Flutter app
const String apiBaseUrl = kDebugMode
    ? 'http://localhost:3000'  // Development
    : 'https://your-production-api.com';  // Production

4. Usage Examples

React:

import AkedlyAuthComponent from './components/AkedlyAuthComponent'

function App() {
  return (
    <div className="App">
      <AkedlyAuthComponent />
    </div>
  )
}

React Native:

import AkedlyAuthRN from './components/AkedlyAuthRN'

export default function App() {
  return <AkedlyAuthRN apiBaseUrl="http://your-server.com" />
}

Flutter:

import 'package:flutter/material.dart';
import 'akedly_auth_flutter.dart';

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        body: AkedlyAuthFlutter(
          apiBaseUrl: 'http://your-server.com',
          onSuccess: (data) {
            print('Auth successful: $data');
          },
        ),
      ),
    );
  }
}

After Promotion Period (Egyptian Startups)

• Transparent pricing: Pay-per-successful-authentication model continues
• Competitive rates: Significantly lower than traditional SMS rates
• Granular control: Set your own rate limits and budget controls

Integration Best Practices

Frontend Implementation

Your frontend needs to handle both response types from Step 2:

// Example frontend integration
async function requestOTP(transactionID) {
  const response = await fetch(
    `/api/v1/transactions/optin-link/${transactionID}`,
  )
  const result = await response.json()

  if (result.hasWhatsApp) {
    // Show WhatsApp opt-in UI
    showWhatsAppOption(result.data.whatsappLink, result.data.instructions)
  } else {
    // OTP already sent via SMS/Email
    showOTPInputForm(result.data._id)
  }
}

Error Handling & Debugging

Quick Debug Checklist

Step 1 Errors: Transaction Creation

400 Bad Request - Invalid Digits

{
  "message": "Digits should be either 4 or 6"
}

Cause: The digits parameter is not 4 or 6
Solution: Ensure the digits field is either 4 or 6

403 Forbidden - Quota Issues

{
  "message": "It looks like your subscription has expired or you have exhausted your remaining quota, please re-subscribe"
}

Cause: User quota depleted or subscription expired
Solution: Check your account quota in the Akedly dashboard and top up if needed

404 Not Found - Invalid API Key

{
  "message": "User not found"
}

Cause: Invalid or incorrect API key
Solution: Verify your API key from the Akedly dashboard

500 Internal Server Error - Configuration

{
  "message": "Pipeline not found"
}

Cause: Invalid pipeline ID or pipeline doesn't belong to your account
Solution: Verify the pipeline ID from your dashboard

Step 2 Errors: Opt-in Link Generation

400 Bad Request - Missing Phone

{
  "status": "error",
  "message": "Phone number is required for opt-in WhatsApp authentication"
}

Cause: Transaction was created without a phone number
Solution: Include phoneNumber in verificationAddress when creating the transaction

403 Forbidden - Expired Transaction

{
  "message": "Transaction has expired. Please request a new transaction as this one has exceeded the 2-minute activation window."
}

Cause: More than 2 minutes passed since transaction creation
Solution: Create a new transaction - the old one is no longer valid

429 Rate Limited - Too Many Requests

{
  "status": "error",
  "message": "Rate limit exceeded. Please wait 35 seconds before requesting another OTP for this phone number.",
  "rateLimited": true,
  "timeRemaining": 35,
  "phoneNumber": "+201234567890"
}

Cause: Another opt-in request for the same phone number within 60 seconds
Solution: Wait for timeRemaining seconds before allowing user to retry

Frontend Implementation:

if (response.rateLimited) {
  const countdown = response.timeRemaining
  showMessage(`Please wait ${countdown} seconds before retrying`)
  startCountdown(countdown)
}

Step 3 Errors: WhatsApp Processing

When users send WhatsApp messages, they might receive error responses directly in WhatsApp:

Transaction Not Found

WhatsApp Message: "Sorry, we couldn't find your OTP request. Please make sure you're using the correct link and the request hasn't expired."

Cause: Invalid transaction ID in the WhatsApp message
Solution: User should click the WhatsApp link again from your app

Phone Number Mismatch

WhatsApp Message: "Sorry, this phone number doesn't match the one used for the OTP request. Please use the correct phone number."

Cause: User's WhatsApp phone number doesn't match the one in the transaction
Solution: User must use the same phone number that was used to create the transaction

Step 4 Errors: OTP Verification

403 Forbidden - Invalid OTP

{
  "message": "Invalid OTP",
  "data": {
    "frontendCallbackURL": "https://app.akedly.io/verify/result?transactionID=abc123&status=Failed"
  }
}

Cause: Provided OTP doesn't match the correct code
Solution: User should re-enter the correct OTP

403 Forbidden - Already Verified

{
  "message": "Transaction already verified"
}

Cause: Transaction has already been successfully verified
Solution: Redirect user to success page - authentication is complete

404 Not Found - Wrong ID Used

{
  "message": "Transaction Request not found"
}

Cause: Using transactionID instead of transactionReqID for verification
Solution: Use the correct ID from Step 2 response

Common Integration Mistakes

1. Wrong ID Usage for Verification

❌ Common Mistake:

// Using transactionID instead of transactionReqID
const response = await fetch(`/verify/${transactionID}`)

✅ Correct Implementation:

// Extract correct ID from Step 2 response
let verificationId
if (response.method === 'whatsapp_optin') {
  verificationId = response.data.transactionReqID
} else if (response.fallbackUsed) {
  verificationId = response.data._id
}

const response = await fetch(`/verify/${verificationId}`)

2. Not Handling Both Response Types

❌ Common Mistake:

// Only handling WhatsApp opt-in flow
if (data.whatsappLink) {
  window.open(data.whatsappLink)
}

✅ Correct Implementation:

if (data.method === 'whatsapp_optin') {
  showWhatsAppButton(data.data.whatsappLink)
  showOTPInput(data.data.transactionReqID)
} else if (data.fallbackUsed) {
  showMessage('OTP sent via SMS/Email')
  showOTPInput(data.data._id)
}

3. Poor Error Handling

❌ Common Mistake:

if (response.status === 429) {
  alert('Too many requests')
}

✅ Correct Implementation:

if (response.rateLimited) {
  showRateLimitMessage(`Please wait ${response.timeRemaining} seconds`)
  disableResendButton()
  startCountdown(response.timeRemaining, () => {
    enableResendButton()
  })
}

Security Considerations

• Phone number validation: System automatically validates sender matches transaction
• Time-limited transactions: 3-minute window for opt-in activation
• Pattern matching: Strict message format validation
• Standard OTP security: Same verification standards as traditional SMS flow

Migration from Standard Authentication

Easy Integration

The opt-in method integrates seamlessly with existing implementations:

1. Replace Step 2: Use /optin-link/ endpoint instead of /activate/
2. Handle both responses: Add logic for WhatsApp vs. SMS fallback responses
3. Same verification: Step 4 remains identical to existing flow
4. Backward compatible: Existing transactions continue to work normally

Gradual Rollout Strategy

• A/B testing: Route percentage of users to opt-in method
• User preference: Let users choose between standard and opt-in flows
• Fallback ready: Automatic SMS ensures no authentication failures
• Analytics tracking: Monitor success rates and user preferences

This innovative opt-in WhatsApp authentication method represents the future of cost-effective, user-friendly authentication while maintaining the highest security standards. Perfect for Egyptian startups looking to optimize costs and provide superior user experiences.