Validating Indian phone numbers with regex is a common but tricky task for developers. We'll explore five ways to implement this validation, complete with working code snippets. We will also examine the pitfalls of these traditional regex methods and show how Abstract API helps address these shortcomings.
How to Implement Indian Phone Number Validation in Regex
Here are four regular expressions to validate Indian phone numbers. Each method addresses a different format, from strict 10-digit mobile numbers to more lenient, user-friendly patterns.
Strict 10-Digit Mobile Series Only
This regex validates only 10-digit mobile numbers that start with a digit from 6 to 9. The anchors "^" and "$" ensure the string contains exactly ten digits. The first digit check conforms to the current GSM allocation. The "\d" character matches digits from various scripts, so you can use "[0-9]" for ASCII-only numerals. This regex for Indian mobile numbers is quite strict.
re.fullmatch(r'^[6-9]\d{9}$', s) is not None.
Optional National or International Prefix
This pattern accepts numbers with an optional "0" or "+91" prefix, like “9123456789” or “+919123456789”. A non-capturing group, "(?:...)", contains the prefix options without an effect on the main match index. This approach is a good fit when you need to tolerate different dial styles but reject separators. This method helps validate Indian phone numbers with optional prefixes.
/^(?:0|\+91)?[6-9]\d{9}$/u.test(s).
E.164-Conformant Representation Only
This regex enforces the international E.164 standard. It requires the "+" sign and the "91" country code, and it does not permit spaces, a trunk "0", or any separators. The total length of a valid number is always 13 characters. This consistency simplifies downstream data normalization and is suitable for storage layers or APIs that require the canonical format.
Pattern.matches("^\\+91[6-9]\\d{9}$", s).
Lenient Consumer-Input Pattern
This regex offers flexibility for user-submitted numbers. It handles various common formats and is useful at the UI boundary where you want to accept almost anything and canonicalize it later.
- It accepts prefixes like "+91-", "0091 ", and "0 ".
- It allows optional spaces or hyphens within the number.
- It includes a fallback path that simply counts ten digits, even if split into a 5-5 pattern like "98834-43344".
Regex.IsMatch(s, @"^(?:(?:\+|0{0,2})91(\s*[-]\s*)?|0)?[6-9]\d{9}|(\d[ -]?){10}\d$").
Challenges of Indian Phone Number Validation in Regex
While regex offers a quick solution, it struggles with the complexities of India's numbering plan. These patterns often introduce significant validation gaps and maintenance burdens for developers.
- Landline area codes vary from two to eight digits. This variable length makes it difficult for a single regex pattern, like the strict 10-digit mobile method, to correctly validate all fixed-line numbers without over-acceptance or complex permutations.
- Mobile number portability and new digit series mean prefixes no longer guarantee a number is mobile or fixed. This makes prefix-based rules, like the strict 10-digit or E.164-conformant methods, unreliable and prone to become outdated quickly.
- A single number appears in multiple formats, such as with a +91 or 0 prefix. Lenient patterns accommodate this, but strict methods like the E.164-conformant regex will incorrectly reject valid, locally dialed numbers without the international prefix.
- India's numbering plan constantly evolves as TRAI allocates new ranges and considers changes like 11-digit numbers. A static regex, even a lenient one, requires constant updates to avoid the rejection of newly valid phone numbers in the future.
Validate Indian Phone Numbers with Abstract API
Start validating Indian phone numbers to build a clean and reliable user contact database.
Get started for free
How Abstract API Handles Indian Phone Number Validation
Abstract API addresses the core weaknesses of traditional methods through a single API call that replaces brittle regex patterns.
- It confirms a number is active and assigned, which moves beyond simple format checks to prevent false positives from unallocated lines.
- The API automatically reflects changes to India’s numbering plan. This means client code requires no manual updates when new number series appear.
- It returns pre-normalized local and international formats. This removes the need for developers to write separate code to handle prefixes like +91 or 0.
- A single call provides operational data like carrier, line type, and region. This information supports workflows like risk scores and SMS routing.
How to Bring Abstract API to Your Dev Environment
Once you're familiar with Abstract’s capabilities, you can add its Indian phone number validation API to your project with ease. The process requires just a few steps to get your environment ready.
- Sign in at Abstract API, enable Phone Validation, and copy your API key.
- Add an HTTP client like curl, requests, or axios to your project.
- Store the key as an environment variable to avoid hard-code placement in your code.
- Construct a request to the API endpoint with your key, the phone number, and the country code "IN".
- Parse the JSON response and check the "valid" field before you use the data.
- Wrap the call in a utility function for reuse and to manage throughput needs.
import os, requests
url = "https://phonevalidation.abstractapi.com/v1/"
params = {
"api_key": os.environ["ABSTRACT_API_KEY"],
"phone": "918888555555",
"country": "IN"
}
data = requests.get(url, params=params).json()
print(data)
Sample Indian Phone Number Validation Implementation with Abstract API
The Python code above sends a GET request to the validation endpoint. It passes an API key, the phone number to check, and the country code "IN" for India. The API returns a detailed JSON object with key information about the number.
The "valid" field confirms the number is active, not just correctly formatted. The "format" object provides both international and local versions, which removes the need for manual normalization. Additional fields like "location", "type", and "carrier" offer operational data that simple regex cannot provide, useful for tasks like fraud analysis or message routing.
{
"phone": "918888555555",
"valid": true,
"format": {
"international": "+918888555555",
"local": "8888555555"
},
"country": {
"code": "IN",
"name": "India",
"prefix": "+91"
},
"location": "Maharashtra",
"type": "mobile",
"carrier": "Bharti Airtel"
}
Final Thoughts
Traditional regex methods only check a number's format, not its real-world status. This leads to errors from unallocated lines and requires constant updates for new number series. Abstract API solves these problems with a single call that confirms a number is active and provides rich data. To reliably validate phone numbers, create a free account with Abstract API.
Validate Indian Phone Numbers with Abstract API
Stop bad data at the source. Implement a reliable Indian phone number validation system today.
Get started for free
