RetroSearch Browse

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.geeksforgeeks.org/how-to-validate-an-ip-address-using-regex/ below:

How to validate an IP address using ReGex

Last Updated : 15 Jul, 2025

Given an IP address, the task is to validate this IP address with the help of Regex (Regular Expression) in C++ as a valid IPv4 address or IPv6 address. If the IP address is not valid then print an invalid IP address.

Examples:

Input: str = "203.120.223.13"
Output: Valid IPv4

Input: str = "000.12.234.23.23"
Output: Invalid IP

Input: str = "2F33:12a0:3Ea0:0302"
Output: Invalid IP

Input: str = "I.Am.not.an.ip"
Output: Invalid IP

Approach:

Regex (Regular Expression) In C++ will be used to check the IP address.
Range Specifications
Specifying a range of characters or literals is one of the simplest criteria used in a regex.

i) [a-z]
ii) [A-Za-z0-9]

In the above expression ([]) square brackets are used to specify the range.
The first expression will match exactly one lowercase character.
The second expression specifies the range containing one single uppercase character, one lowercase character, and a digit from 0 to 9.
Now to include a '.' as part of an expression, we need to escape '.' and this can be done as :

[\\.0-9]

The above expression indicates an '.' and a digit in the range 0 to 9 as a regex.

regex_match() function is used to match the given pattern. This function returns true if the given expression matches the string. Otherwise, the function returns false.

Here is the implementation of the above approach.

C++


 // C++ program to validate
// IP address using Regex

#include <bits/stdc++.h>
using namespace std;

// Function for Validating IP
string Validate_It(string IP)
{

    // Regex expression for validating IPv4
    regex ipv4("(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])");

    // Regex expression for validating IPv6
    regex ipv6("((([0-9a-fA-F]){1,4})\\:){7}([0-9a-fA-F]){1,4}");

    // Checking if it is a valid IPv4 addresses
    if (regex_match(IP, ipv4))
        return "Valid IPv4";

    // Checking if it is a valid IPv6 addresses
    else if (regex_match(IP, ipv6))
        return "Valid IPv6";

    // Return Invalid
    return "Invalid IP";
}

// Driver Code
int main()
{
    // IP addresses to validate
    string IP = "257.120.223.13";
    cout << Validate_It(IP) << endl;

    IP = "fffe:3465:efab:23fe:2235:6565:aaab:0001";
    cout << Validate_It(IP) << endl;

    IP = "2F33:12a0:3Ea0:0302";
    cout << Validate_It(IP) << endl;

    return 0;
}

Java


 // Java program to validate
// IP address using Regex
import java.util.regex.*;

class GFG {

  // Function for Validating IP
  static String Validate_It(String IP)
  {

    // Regex expression for validating IPv4
    String regex="(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])";

    // Regex expression for validating IPv6
    String regex1="((([0-9a-fA-F]){1,4})\\:){7}([0-9a-fA-F]){1,4}";

    Pattern p = Pattern.compile(regex);
    Pattern p1 = Pattern.compile(regex1);

    // Checking if it is a valid IPv4 addresses
    if (p.matcher(IP).matches())
      return "Valid IPv4";

    // Checking if it is a valid IPv6 addresses
    else if (p1.matcher(IP).matches())
      return "Valid IPv6";

    // Return Invalid
    return "Invalid IP";
  }

  // Driver Code
  public static void main(String args[])
  {
    // IP addresses to validate
    String IP = "257.120.223.13";
    System.out.println(Validate_It(IP));

    IP = "fffe:3465:efab:23fe:2235:6565:aaab:0001";
    System.out.println(Validate_It(IP));

    IP = "2F33:12a0:3Ea0:0302";
    System.out.println(Validate_It(IP));

  }
}

// This code is contributed by Aman Kumar.

Python3


 # Python3 program to validate
# IP address using Regex
import re

# Function for Validating IP


def Validate_It(IP):

    # Regex expression for validating IPv4
    regex = "^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])$"

    # Regex expression for validating IPv6
    regex1 = "((([0-9a-fA-F]){1,4})\\:){7}"\
             "([0-9a-fA-F]){1,4}"

    p = re.compile(regex)
    p1 = re.compile(regex1)

    # Checking if it is a valid IPv4 addresses
    if (re.search(p, IP)):
        return "Valid IPv4"

    # Checking if it is a valid IPv6 addresses
    elif (re.search(p1, IP)):
        return "Valid IPv6"

    # Return Invalid
    return "Invalid IP"

# Driver Code


# IP addresses to validate
IP = "257.120.223.13"
print(Validate_It(IP))

IP = "fffe:3465:efab:23fe:2235:6565:aaab:0001"
print(Validate_It(IP))

IP = "2F33:12a0:3Ea0:0302"
print(Validate_It(IP))

# This code is contributed by avanitrachhadiya2155


 // C# program to validate
// IP address using Regex
using System;
using System.Text.RegularExpressions;

class GFG {

// Function for Validating IP
static string Validate_It(string IP)
{

    // Regex expression for validating IPv4
    string regex="(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])";

    // Regex expression for validating IPv6
    string regex1="((([0-9a-fA-F]){1,4})\\:){7}([0-9a-fA-F]){1,4}";

    Regex p = new Regex(regex);
    Regex p1 = new Regex(regex1);

    // Checking if it is a valid IPv4 addresses
    if (p.IsMatch(IP))
    return "Valid IPv4";

    // Checking if it is a valid IPv6 addresses
    else if (p1.IsMatch(IP))
    return "Valid IPv6";

    // Return Invalid
    return "Invalid IP";
}

// Driver Code
public static void Main()
{
    // IP addresses to validate
    string IP = "257.120.223.13";
    Console.WriteLine(Validate_It(IP));

    IP = "fffe:3465:efab:23fe:2235:6565:aaab:0001";
    Console.WriteLine(Validate_It(IP));

    IP = "2F33:12a0:3Ea0:0302";
    Console.WriteLine(Validate_It(IP));

}
}

// This code is contributed by Pushpesh Raj.

JavaScript


 // JavaScript program to validate
// IP address using Regex

// Function for Validating IP
function Validate_It(IP) {

    // Regex expression for validating IPv4
    let ipv4 = /(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])/;

    // Regex expression for validating IPv6
    let ipv6 = /((([0-9a-fA-F]){1,4})\:){7}([0-9a-fA-F]){1,4}/;

    // Checking if it is a valid IPv4 addresses
    if (IP.match(ipv4))
        return "Valid IPv4";

    // Checking if it is a valid IPv6 addresses
    else if (IP.match(ipv6))
        return "Valid IPv6";

    // Return Invalid
    return "Invalid IP";
}

// Driver Code
function main() {
    // IP addresses to validate
    let IP = "257.120.223.13";
    console.log(Validate_It(IP));

    IP = "fffe:3465:efab:23fe:2235:6565:aaab:0001";
    console.log(Validate_It(IP));

    IP = "2F33:12a0:3Ea0:0302";
    console.log(Validate_It(IP));
}

main();

// This code is contributed by akashish__

Output

Invalid IP
Valid IPv6
Invalid IP

Time Complexity: O (N)
Auxiliary Space: O (1)

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4