Tunisia Phone Numbers: Format, Area Code & Validation Guide

Introduction

Are you developing an application that interacts with Tunisian phone numbers? Understanding the nuances of Tunisia's telecommunications system is crucial for seamless integration. This guide provides a deep dive into Tunisian phone number formats, validation techniques, best practices, and potential pitfalls to consider during implementation. We'll equip you with the knowledge to confidently handle Tunisian phone numbers in your projects.

Background on Tunisia's Telecommunications Landscape

Before diving into the technical details, let's take a quick look at the current state of Tunisia's telecommunications sector. This context will help you understand the "why" behind some of the formatting and validation rules. Tunisia boasts a high mobile penetration rate, exceeding 149.7% as of 2022, with over 15.9 million mobile lines. This vibrant market is served by four major operators: Tunisie Telecom, Ooredoo, Orange Tunisia, and Lycamobile. This competitive landscape, combined with the government's push for digitalization, has led to a modern and standardized numbering system. You'll find this standardization reflected in the predictable structure of Tunisian phone numbers.

Number Formats in Tunisia

Tunisia uses an 8-digit National Significant Number (NSN) preceded by the country code +216. This consistent structure simplifies parsing and validation. Let's break down the different number types you'll encounter.

Geographic Numbers (Landlines)

Geographic numbers identify landlines within specific regions of Tunisia. You can determine the region by looking at the first two digits of the NSN.

Regional Prefixes:

• 71: Greater Tunis Region (Capital)
• 72: Northern Tunisia (Including Bizerte, B??ja)
• 73: Central Tunisia (Including Sousse, Monastir)
• 74: Southern Tunisia (Including Sfax, Gab??s)
• 75-78: Other regions

Format: XX XXX XXX
Example: 71 234 567

^(3[0-2]|7[0-9])\d{6}$

Best Practice: When working with geographic numbers, validate both the prefix (71-78) and the overall 8-digit NSN structure. This ensures accuracy and helps you avoid common input errors.

Mobile Numbers

Mobile numbers are identified by operator prefixes, allowing for easy provider identification. This is particularly useful when integrating with carrier-specific APIs or services.

Operator Prefixes:

• 20-29: Tunisie Telecom (Historical operator)
• 50-59: Ooredoo (Previously Tunisiana)
• 90-99: Orange Tunisia

Format: XX XXX XXX
Example: 20 123 456

^(2[0-9]|5[0-9]|9[0-9])\d{6}$

Consider this: While these prefixes generally identify the operator, Mobile Number Portability (MNP) can introduce exceptions. We'll discuss MNP in more detail later.

Emergency Service Numbers

Tunisia uses a standardized set of emergency numbers accessible from any phone, even without a SIM card. Your application should handle these numbers correctly, ensuring they are never blocked or incorrectly formatted.

Warning: Ensure your application allows calls to emergency numbers even when offline or without a SIM card. This is a critical safety requirement.

Special Service Numbers

Special service numbers follow distinct patterns for toll-free, premium rate, and shared cost services. You should be aware of these patterns when validating user input or routing calls.

• Toll-Free: 80 XXX XXX (Example: 80 100 123)
• Premium Rate: 88 XXX XXX (Example: 88 123 456)
• Shared Cost: 81 XXX XXX (Example: 81 234 567)

Best Practice: Clearly identify and handle special service numbers differently in your application, especially regarding billing or routing logic.

Implementation Guide for Developers

Now that you understand the different number formats, let's explore how to implement them in your code.

Validation and Formatting in JavaScript

Here's how you can validate and format Tunisian phone numbers using JavaScript:

1. Basic Validation:

// Regular expression for Tunisian mobile numbers
const mobileRegex = /^(2[0-9]|5[0-9]|9[0-9])\d{6}$/;

// Regular expression for landline numbers
const landlineRegex = /^(3[0-2]|7[0-9])\d{6}$/;

// Example usage
if (mobileRegex.test("20123456")) {
  console.log("Valid mobile number");
}

if (landlineRegex.test("71234567")) {
  console.log("Valid landline number");
}

These regular expressions provide a basic level of validation. However, for more robust validation, consider using a dedicated library or service.

2. Number Formatting:

function formatTunisianNumber(number, international = false) {
  // Remove all non-digit characters
  const cleaned = number.replace(/\D/g, '');

  // Format for international display
  if (international) {
    return `+216 ${cleaned.slice(0, 2)} ${cleaned.slice(2, 5)} ${cleaned.slice(5)}`;
  }

  // Format for local display
  return `${cleaned.slice(0, 2)} ${cleaned.slice(2, 5)} ${cleaned.slice(5)}`;
}

// Example usage
console.log(formatTunisianNumber("20123456", true)); // Output: +216 20 123 456
console.log(formatTunisianNumber("71234567")); // Output: 71 234 567

This function formats numbers for both local and international display, improving user experience.

Advanced Implementation with TypeScript

For more complex applications, consider using TypeScript to define clear data structures:

interface TunisianPhoneNumber {
  countryCode: '+216';
  numberType: 'geographic' | 'mobile' | 'special';
  areaCode?: string; // For geographic numbers
  subscriberNumber: string;
}

This interface helps you maintain data integrity and improve code readability.

Geographic Number Validation with Area Code Check

You can enhance geographic number validation by explicitly checking the area code:

function validateGeographicNumber(number) {
  const cleanNumber = number.replace(/\s+/g, '');
  const areaCode = cleanNumber.substring(0, 2);
  const isValidArea = ['71', '72', '73', '74','75','76','77','78'].includes(areaCode); // Updated to include all area codes
  const matchesPattern = /^(3[0-2]|7[0-9])\d{6}$/.test(cleanNumber);

  return isValidArea && matchesPattern;
}

This function provides a more precise validation check, ensuring the area code is valid.

Handling Mobile Number Portability (MNP)

Tunisia, like many countries, has implemented Mobile Number Portability (MNP). This allows users to switch operators while keeping their existing number. This can complicate validation and routing, as operator prefixes are no longer guaranteed to be accurate. You should be aware of this when designing your system. As noted by the Tunisian telecom authority INT (Instance Nationale des Telecommunications), major operators including Tunisie Telecom, Ooredoo, Orange, and Lycamobile Tunisia have signed a Service Level Agreement (SLA) for MNP. This agreement aims to standardize the process and improve quality. However, you should still implement robust error handling and fallback mechanisms.

Best Practice: Use a real-time number lookup service to determine the current operator for a given number. Cache these lookups to improve performance, but ensure your cache is updated regularly.

async function checkOperatorForNumber(number) {
  try {
    const response = await mnpLookupService.query(number);
    return response.currentOperator;
  } catch (error) {
    // Fallback to prefix-based lookup
    return determineOperatorByPrefix(number);
  }
}

This example demonstrates a best-practice approach, using a lookup service with a prefix-based fallback.

Conclusion

You now have a comprehensive understanding of Tunisian phone number formats, validation techniques, and best practices for implementation. By following the guidance in this guide, you can ensure your application handles Tunisian phone numbers accurately and efficiently. Remember to consider MNP and implement appropriate error handling to create a robust and reliable system. With Tunisia's growing telecommunications market and the government's focus on digitalization (as highlighted by the "Digital Tunisia 2020" program), understanding these details is more critical than ever for developers.