How to Send SMS in Lebanon: Compliance, Carriers & API Integration

Lebanon SMS Market Overview

Sending SMS in Lebanon requires understanding the country's unique telecom landscape. Lebanon has two main mobile operators – Alfa and touch (formerly MTC Touch) – both state-run providers that share the market nearly equally with approximately 4.7 million combined subscribers. While OTT messaging apps like WhatsApp have gained popularity, SMS remains a critical channel for business communications. Both operators provide comprehensive 2G/3G/4G coverage across urban and rural areas. Industry forecasts project Lebanon's telecom services market to grow at approximately 5.2% CAGR through 2031, driven by smartphone adoption and emerging services. Android holds a larger market share than iOS due to its wider range of affordable devices.

Lebanon SMS Features and Capabilities

Lebanon supports basic SMS functionality with limitations on advanced features. You can use one-way messaging with concatenated messages and alphanumeric sender IDs for your SMS campaigns.

Two-Way SMS Support

Two-way SMS is not supported in Lebanon through standard A2P (Application-to-Person) channels. Use alternative communication channels like email or web forms to receive customer responses.

Concatenated Messages (Segmented SMS)

Support: Yes, concatenation is supported, though availability may vary by sender ID type.

Message length rules:

• GSM-7 encoding: 160 characters per segment
• UCS-2 encoding (Arabic and special characters): 70 characters per segment

Cost implications: Concatenated messages count as multiple segments. A 300-character message using GSM-7 encoding will be billed as 2 segments (160 + 140 characters), while a 150-character Arabic message using UCS-2 will be billed as 3 segments (70 + 70 + 10 characters).

Example: Sending "Thank you for your order. Your tracking number is 123456789. Visit our website for updates." uses 91 characters (1 segment). Adding Arabic text like "شكراً لطلبك" increases the character count and triggers UCS-2 encoding, reducing each segment to 70 characters.

MMS Support

MMS messages are not directly supported in Lebanon. Carriers automatically convert MMS content to SMS with an embedded URL link where recipients can view the multimedia content. This ensures compatibility while maintaining the ability to share rich media.

Recipient Phone Number Compatibility

Number Portability

Number portability is not available in Lebanon. Mobile numbers remain tied to their original carrier, simplifying message routing and delivery for your SMS gateway.

Sending SMS to Landlines

You cannot send SMS to landline numbers in Lebanon. Attempts to send messages to landlines will result in a 400 response error (code 21614), and the message will not be delivered or logged.

SMS Compliance Requirements: Lebanon TRA Regulations

The Telecommunications Regulatory Authority (TRA) regulates SMS communications in Lebanon. While specific SMS marketing laws are still evolving, you must adhere to general telecommunications regulations and international best practices for message consent and privacy when sending bulk SMS campaigns.

Consent and Opt-In Requirements

Explicit Consent Requirements:

• Obtain clear, documented opt-in consent before sending any marketing messages
• Maintain detailed records of when and how you obtained consent
• Include clear terms of service and privacy policy information during opt-in
• Specify the type and frequency of messages users can expect

Documentation Best Practices:

• Store consent records with timestamp and source
• Maintain audit trails of opt-in methods
• Regularly update and verify consent status
• Implement double opt-in for marketing campaigns

HELP/STOP and Other Commands

Support these standard opt-out keywords in both English and Arabic:

• STOP/إيقاف
• CANCEL/إلغاء
• HELP/مساعدة

Send response messages to these commands in both English and Arabic. Send opt-out confirmations immediately upon receiving a STOP command.

Example automated responses:

• STOP command received: "You have been unsubscribed from our messages. Reply START to opt back in."
• HELP command received: "Reply STOP to unsubscribe or visit example.com/help for support."

Opt-out processing flow:

1. User sends STOP command
2. System immediately adds number to suppression list
3. Automated confirmation sent within 5 seconds
4. Database updated with opt-out timestamp
5. No further marketing messages sent to that number

Do Not Call / Do Not Disturb Registries

Lebanon does not maintain an official Do Not Call registry. However, you should:

• Maintain your own suppression lists
• Honor opt-out requests within 24 hours
• Regularly clean contact lists to remove unsubscribed numbers
• Implement automated systems to prevent messaging to opted-out numbers

Time Zone Sensitivity

Lebanon observes Eastern European Time (EET/UTC+2 in winter, EEST/UTC+3 during daylight saving time). Follow these best practices:

• Send messages between 9:00 AM and 8:00 PM local time
• Account for seasonal time changes when scheduling campaigns
• Avoid sending during religious holidays and Friday prayers
• Consider Ramadan timing adjustments when applicable
• Send emergency messages outside these hours only if necessary

Sender ID Options for Lebanon SMS

Alphanumeric Sender ID

Operator network capability: Fully supported by Alfa and touch carriers

Registration requirements: No pre-registration required – dynamic usage supported

Sender ID preservation: Yes, sender IDs are preserved as specified

Character restrictions:

• Maximum 11 characters
• Letters (A-Z), numbers (0-9), and spaces allowed
• Must contain at least one letter
• Case-sensitive (appears as sent)

Best practices:

• ✓ Good: "MyBrand", "Acme Store", "BankAlert"
• ✗ Poor: "12345" (all numbers), "VeryLongCompanyName" (exceeds 11 chars), "!!URGENT!!" (special characters)

Long Codes

Domestic vs. International:

• Domestic long codes: Not supported
• International long codes: Supported but with limitations

Sender ID preservation: No – carriers typically overwrite international numeric sender IDs

Provisioning time: N/A

Use cases: Not recommended for marketing campaigns; better suited for transactional messages

Short Codes

Support: Not currently supported in Lebanon

Provisioning time: N/A

Use cases: N/A

Restricted SMS Content, Industries, and Use Cases

Restricted Content Types:

• Gambling and betting services
• Adult content or explicit material
• Political messaging without proper authorization
• Cryptocurrency and unauthorized financial services
• Religious content without proper permits

Regulated Industries:

• Financial services require additional disclaimers
• Healthcare messages must comply with privacy regulations
• Insurance services need specific regulatory approvals

Content Filtering

Known Carrier Filters:

• URLs from unknown domains may be blocked
• Messages containing specific keywords related to restricted content
• Multiple exclamation marks or all-caps messages

Best Practices:

• Avoid URL shorteners in your messages
• Use clear, professional language
• Include your company name in each message
• Avoid excessive punctuation and special characters

Testing strategies:

1. Send test messages to both Alfa and touch numbers
2. Test with various message lengths and content types
3. Include URLs and special characters in test scenarios
4. Monitor delivery reports for filtering patterns
5. Adjust content based on delivery success rates

Lebanon SMS Best Practices

Messaging Strategy

• Keep messages under 160 characters when possible
• Include a clear call-to-action
• Use personalization tokens thoughtfully
• Maintain a consistent brand voice

Sending Frequency and Timing

• Limit to 2–4 messages per month per user
• Respect religious and cultural observances
• Avoid sending during major holidays
• Space out messages appropriately

Arabic SMS and Localization for Lebanon

Support both Arabic and English in your SMS campaigns targeting Lebanon. Use proper Arabic character encoding (UCS-2) and ensure proper right-to-left text display for Arabic content. For guidance on international messaging formats, review our international SMS best practices.

Bilingual message example (English/Arabic):

Your order #12345 has shipped. Track: example.com/track
تم شحن طلبك #12345. التتبع: example.com/track

Encoding implementation:

// Detect if message contains Arabic characters
function requiresUCS2Encoding(message: string): boolean {
  // Arabic Unicode range: U+0600 to U+06FF
  return /[\u0600-\u06FF]/.test(message);
}

// Calculate segment count
function calculateSegments(message: string): number {
  const encoding = requiresUCS2Encoding(message) ? 'UCS2' : 'GSM7';
  const segmentLength = encoding === 'UCS2' ? 70 : 160;
  const headerLength = message.length > segmentLength ? (encoding === 'UCS2' ? 3 : 7) : 0;

  return Math.ceil(message.length / (segmentLength - headerLength));
}

Opt-Out Management

• Process opt-outs in real-time
• Send opt-out confirmation immediately
• Maintain a centralized opt-out database
• Regularly audit opt-out compliance

Testing and Monitoring

Test messages across both Alfa and touch carriers before launching campaigns. Monitor delivery rates by carrier, track engagement metrics, and regularly test opt-out functionality. Consider implementing two-factor authentication for transactional messages.

Key metrics to track:

• Delivery rate (target: >95%)
• Message latency (time from send to delivery)
• Opt-out rate (industry average: 1–3%)
• Bounce rate by carrier
• Cost per message

Monitoring dashboard elements:

interface SMSMetrics {
  totalSent: number;
  delivered: number;
  failed: number;
  pending: number;
  deliveryRate: number;
  averageLatency: number; // in seconds
  carrierBreakdown: {
    alfa: { sent: number; delivered: number };
    touch: { sent: number; delivered: number };
  };
}

SMS API Integration for Lebanon

Twilio SMS API for Lebanon

Twilio provides robust SMS API support for Lebanon. You need an account SID and auth token for authentication.

Key Parameters:

• accountSid: Your Twilio account identifier
• authToken: Your authentication token
• from: Alphanumeric sender ID (up to 11 characters)
• to: Recipient number in E.164 format (+961)
• body: Message content (supports Unicode)

import { Twilio } from 'twilio';

// Initialize Twilio client
const client = new Twilio(process.env.TWILIO_ACCOUNT_SID, process.env.TWILIO_AUTH_TOKEN);

// Function to send SMS to Lebanon
async function sendSMSToLebanon(
  to: string,
  message: string,
  senderId: string
): Promise<void> {
  try {
    // Validate Lebanon phone number format
    if (!to.startsWith('+961')) {
      throw new Error('Invalid Lebanon phone number format');
    }

    const response = await client.messages.create({
      body: message,
      from: senderId,  // Alphanumeric sender ID
      to: to,
      // Optional parameters for delivery tracking
      statusCallback: 'https://your-webhook.com/status'
    });

    console.log(`Message sent successfully! SID: ${response.sid}`);
  } catch (error) {
    console.error('Error sending message:', error);
    throw error;
  }
}

For comprehensive compliance guidance, review our SMS compliance requirements documentation.

Sinch SMS API for Lebanon

Sinch offers a straightforward REST API for sending SMS to Lebanon. You need an API token and service plan ID.

Key Parameters:

• serviceplanId: Your Sinch service plan identifier
• apiToken: Bearer token for authentication
• from: Sender ID
• to: Array of recipient numbers
• body: Message content

import axios from 'axios';

class SinchSMSService {
  private readonly baseUrl: string;
  private readonly headers: Record<string_ string>;

  constructor(serviceplanId: string, apiToken: string) {
    this.baseUrl = `https://sms.api.sinch.com/xms/v1/${serviceplanId}/batches`;
    this.headers = {
      'Authorization': `Bearer ${apiToken}`,
      'Content-Type': 'application/json'
    };
  }

  async sendSMS(to: string, message: string, senderId: string): Promise<void> {
    try {
      const response = await axios.post(
        this.baseUrl,
        {
          from: senderId,
          to: [to],
          body: message,
          // Enable delivery reports
          delivery_report: 'summary'
        },
        { headers: this.headers }
      );

      console.log('Message sent:', response.data.id);
    } catch (error) {
      console.error('Sinch SMS error:', error.response?.data || error);
      throw error;
    }
  }
}

MessageBird SMS API for Lebanon

MessageBird (now branded as "Bird") provides a feature-rich API for Lebanon SMS messaging.

Key Parameters:

• apiKey: Your MessageBird API key
• originator: Sender ID (alphanumeric or phone number)
• recipients: Array of recipient numbers
• body: Message content

import { MessageBirdClient, MessageParameters } from 'messagebird';

class MessageBirdService {
  private client: MessageBirdClient;

  constructor(apiKey: string) {
    this.client = new MessageBirdClient(apiKey);
  }

  async sendSMS(
    to: string,
    message: string,
    senderId: string
  ): Promise<void> {
    const params: MessageParameters = {
      originator: senderId,
      recipients: [to],
      body: message,
      // Optional parameters
      reportUrl: 'https://your-webhook.com/delivery-reports'
    };

    return new Promise((resolve, reject) => {
      this.client.messages.create(params, (err, response) => {
        if (err) {
          console.error('MessageBird error:', err);
          reject(err);
        } else {
          console.log('Message sent:', response.id);
          resolve();
        }
      });
    });
  }
}

API Rate Limits and Throughput

Rate Limits for Lebanon:

• Standard rate limit: 30 messages per second
• Burst limit: 50 messages per second for short durations
• Daily quota varies by provider and plan

Throughput Management Strategies:

• Implement exponential backoff for retry logic
• Use queuing systems (Redis, RabbitMQ) for high-volume campaigns
• Batch messages when possible (up to 100 per request)
• Monitor delivery rates and adjust sending patterns accordingly

Rate limiting implementation with retry logic:

import { setTimeout } from 'timers/promises';

class RateLimiter {
  private queue: Array<() => Promise<void>> = [];
  private processing = false;
  private messagesPerSecond: number;
  private retryConfig = {
    maxRetries: 3,
    baseDelay: 1000, // 1 second
    maxDelay: 32000  // 32 seconds
  };

  constructor(messagesPerSecond: number = 30) {
    this.messagesPerSecond = messagesPerSecond;
  }

  async enqueue(task: () =&gt; Promise<void&gt;): Promise<void&gt; {
    return new Promise((resolve, reject) =&gt; {
      this.queue.push(async () =&gt; {
        try {
          await this.executeWithRetry(task);
          resolve();
        } catch (error) {
          reject(error);
        }
      });

      if (!this.processing) {
        this.processQueue();
      }
    });
  }

  private async executeWithRetry(
    task: () =&gt; Promise<void&gt;,
    attempt: number = 0
  ): Promise<void&gt; {
    try {
      await task();
    } catch (error: any) {
      if (
        attempt &lt; this.retryConfig.maxRetries &&
        (error.code === 'RATE_LIMIT' || error.code === 'TIMEOUT')
      ) {
        const delay = Math.min(
          this.retryConfig.baseDelay * Math.pow(2_ attempt)_
          this.retryConfig.maxDelay
        );
        console.log(`Retry attempt ${attempt + 1} after ${delay}ms`);
        await setTimeout(delay);
        return this.executeWithRetry(task_ attempt + 1);
      }
      throw error;
    }
  }

  private async processQueue(): Promise<void&gt; {
    this.processing = true;
    const delayBetweenMessages = 1000 / this.messagesPerSecond;

    while (this.queue.length &gt; 0) {
      const task = this.queue.shift();
      if (task) {
        await task();
        await setTimeout(delayBetweenMessages);
      }
    }

    this.processing = false;
  }
}

Error Handling and Reporting

Common Error Scenarios:

• Invalid phone number format – verify the number starts with +961
• Network timeouts – implement retry logic with exponential backoff
• Rate limit exceeded – reduce sending rate or implement queuing
• Invalid sender ID format – ensure alphanumeric IDs are 11 characters or fewer

Logging Best Practices:

interface SMSLogEntry {
  messageId: string;
  timestamp: Date;
  recipient: string;
  status: string;
  errorCode?: string;
  errorMessage?: string;
}

// Example logging implementation
function logSMSActivity(entry: SMSLogEntry): void {
  console.log(JSON.stringify({
    ...entry,
    service: 'sms',
    country: 'Lebanon',
    timestamp: new Date().toISOString()
  }));
}

Error resolution decision tree:

1. Invalid number format → Validate E.164 format (+961XXXXXXXX)
2. Rate limit error → Implement exponential backoff, max 3 retries
3. Authentication failure → Verify API credentials, rotate if needed
4. Timeout (>30s) → Retry once after 5 seconds
5. Carrier rejection → Check content filters, modify message
6. Invalid sender ID → Verify alphanumeric format and length

FAQ: Sending SMS in Lebanon

What carriers operate SMS services in Lebanon?

Lebanon has two main mobile carriers: Alfa and touch (formerly MTC Touch). Both are state-run providers that share the market nearly equally and support SMS messaging with alphanumeric sender IDs.

Do I need to register my sender ID in Lebanon?

No, Lebanon does not require pre-registration for alphanumeric sender IDs. You can use dynamic sender IDs (up to 11 characters) without prior approval from carriers.

What is the SMS character limit in Lebanon?

Standard SMS messages in Lebanon support 160 characters using GSM-7 encoding. For Arabic text using UCS-2 encoding, the limit is 70 characters per segment. Messages exceeding these limits are automatically concatenated.

Is two-way SMS supported in Lebanon?

No, two-way SMS is not supported through standard A2P channels in Lebanon. Use alternative methods like email or web forms to receive customer responses.

What are the compliance requirements for SMS in Lebanon?

The TRA (Telecommunications Regulatory Authority) regulates SMS in Lebanon. You must obtain explicit consent before sending marketing messages, support bilingual opt-out commands (STOP/إيقاف), and send messages between 9:00 AM and 8:00 PM local time.

Can I use Unicode characters for Arabic SMS in Lebanon?

Yes, you can send Arabic SMS using UCS-2 encoding. Each segment supports 70 characters when using Arabic or other Unicode characters, compared to 160 characters for standard GSM-7 encoding.

Recap and Additional Resources

Key Takeaways

1. Compliance Priorities

   • Obtain explicit consent before sending marketing messages
   • Respect time zone restrictions (9:00 AM – 8:00 PM EET/EEST)
   • Support bilingual opt-out commands (English and Arabic)

2. Technical Considerations

   • Use proper character encoding (GSM-7 or UCS-2 for Arabic)
   • Implement retry logic with exponential backoff
   • Monitor delivery rates across Alfa and touch carriers

3. Best Practices

   • Test thoroughly across both carriers before launching campaigns
   • Maintain clean contact lists with real-time opt-out processing
   • Document all consent records with timestamps

Next Steps

1. Review the TRA Lebanon Guidelines for regulatory compliance
2. Implement proper error handling and logging in your application
3. Set up delivery reporting webhooks to track message status
4. Test message delivery across Alfa and touch carriers

Additional Resources

• Lebanon Telecommunications Regulatory Authority
• SMS Marketing Guidelines
• Technical Implementation Standards
• Consumer Protection Laws