View Categories

Phone Validation in Java

6 min read

Ensuring the accuracy of user-provided phone numbers is a critical part of data collection. While Java offers a basic form of this validation, it falls short in many real-world validation metrics. Phone Validation API goes beyond a simple formatting check, offering a robust and reliable solution.

The Regex Approach in Java #

A common method for validating phone numbers in Java is to use a regular expression. This approach checks if the input string conforms to a predefined pattern for a phone number.

The following Java implementation validates a U.S. or Canadian phone number and includes a main method to demonstrate how to check both valid and invalid numbers:

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class PhoneValidator {
    // Regex to match a 10 or 11-digit number, with an optional Leading '1' or '+1'
    private static final String PHONE_REGEX = "^(\\+?1)?[2-9]\\d{2}[2-9]\\d{2}\\d{4}$";
    private static final Pattern PHONE_PATTERN = Pattern.compile(PHONE_REGEX); //

    public static boolean isValidPhoneNumber(String phoneNumber) {
        if (phoneNumber == null) {
            return false;
        }
        // Remove common formatting characters
        String cleanedNumber = phoneNumber.replaceAll("[\\s\\-()]", "");
        return PHONE_PATTERN.matcher(cleanedNumber).matches();
    }

    public static void main(String[] args) {
        String number = "1(206) 973-5100";

        // Check the valid number
        if (isValidPhoneNumber(number)) {
            System.out.println("Regex: The phone number '" + number + "' is valid.");
        } else {
            System.out.println("Regex: The phone number '" + number + "' is invalid.");
        }
    }
}

This code defines a regex pattern and a method to check if a given phone number string matches it after removing common formatting.

Rigid Formatting: The regex implementation above will only work correctly for U.S. and Canadian numbers. If you want to allow numbers outside of the United States or Canada, you will have to update this regex as follows:

    private static final String PHONE_REGEX = "^\\+?[1-9]\\d{6,14}$";

This updated implementation is more flexible but still has limitations. It can’t verify if a number is valid for a specific country. It also can’t verify what country a number is coming from without a large list of constants to parse.

If you want to allow maybe a couple of countries only, then something like this will work better:

private static final String PHONE_REGEX = "^((1)?[2-9]\\d{2}[2-9]\\d{2}\\d{4}|52\\d{10})$";

The above checks US, CA, and MX numbers. As you can see, the string is already getting fairly verbose with only three countries.

The Limitations of Regex #

While quick to implement, regex-based validation has significant drawbacks:

  • Format, Not Function: It can only verify that the number’s format is correct. It cannot determine if the number is actually in service assigned to a carrier and/or a subscriber.
  • No Real-World Data: Regex doesn’t provide valuable context like whether the number is a mobile, landline, or VoIP line.
  • Limited Scope: It can’t tell you if a number is active or has been recently disconnected.
  • No Vanity Number Support: It can’t take in numbers like 1-800-DIALME

A More Robust Solution: Trestle’s Phone Validation API #

Phone Validation API, on the other hand, offers a comprehensive and reliable validation process. By making a simple API call, you can get detailed, real-time information about a phone number.

Here’s how you can validate a phone number using Trestle’s API in Java. This example has been enhanced to parse key attributes from the JSON response and apply conditional logic:

import java.net.URI;
import java.net.URLEncoder;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


public class TrestlePhoneValidator {
    private static final String API_KEY = "YOUR_API_KEY_HERE";
    private static final String BASE_URL = "https://api.trestleiq.com/3.0/phone_intel"; 

    public static void validatePhone(String phoneNumber) {
        HttpClient client = HttpClient.newHttpClient();
        try {
            // Properly encode the phone number
            String encodedPhone = URLEncoder.encode(phoneNumber, StandardCharsets.UTF_8);
            String fullUrl = BASE_URL + "?phone=" + encodedPhone;

            HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(fullUrl))
                .header("x-api-key", API_KEY)
                .build();

            HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
            String responseBody = response.body();
            System.out.println("Response: " + responseBody);

            // Process the JSON response to check for validity and other details
            Boolean isValid = getJsonValue(responseBody, "is_valid", Boolean.class);
            Integer activityScore = getJsonValue(responseBody, "activity_score", Integer.class);

            if (isValid != null && !isValid) {
                 System.out.println("Result: This number is not valid.");
            } else if (activityScore != null && activityScore <= 30) {
                System.out.println("Result: This phone number is likely disconnected or inactive.");
            } else if (isValid != null && isValid) {
                 System.out.println("Result: Phone number is valid and active.");
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // A simple helper method to extract values from JSON string using regex.
    private static <T> T getJsonValue(String json, String key, Class<T> type) {
        Matcher matcher = Pattern.compile("\"" + key + "\":\\s*([^,}]+)").matcher(json);
        if (matcher.find()) {
            String valueStr = matcher.group(1).replace("\"", "");
            if (type == Boolean.class) {
                return type.cast(Boolean.valueOf(valueStr));
            }
            if (type == Integer.class) {
                return type.cast(Integer.valueOf(valueStr));
            }
        }
        return null;
    }
     public static void main(String[] args) {
        // Example with a potentially inactive number
        validatePhone("18005550199");
    }
}

This example uses Java’s built-in HttpClient to send a request to the Trestle API and retrieve validation results.

Comparison: #

FeatureJava RegexTrestle’s Phone Validation API
Basic Format ValidationYesYes
Verifies if Number is in ServiceNoYes
Identifies Line TypeNoYes
Provides Carrier InformationNoYes
Prepaid StatusNoYes
Activity ScoreNoYes
Real-time DataNoYes
Litigator ChecksNo Yes (add on)

The Trestle Advantage #

By integrating Phone Validation API, you gain a significant advantage over basic regex checks. The API not only confirms that a phone number is correctly formatted but also verifies its validity and provides valuable metadata. This includes the line type, carrier, and an activity score to gauge if the number is currently in use. This deeper level of insight allows businesses to reduce wasted outreach efforts and improve the quality of their contact data.