IP Address Format Converter
About This Tool
IPv4 Address Representations
An IPv4 address is fundamentally a 32-bit binary number. The familiar dotted decimal notation (192.168.1.1) is just one way to express this value. Depending on your context, you may encounter IP addresses in binary, hexadecimal, octal, or integer form. Each representation is mathematically equivalent — they all describe the same 32-bit value, just written in different bases or groupings.
This tool converts any IPv4 address representation to all other formats instantly. Whether you are reading a packet capture, debugging network code, interpreting a system log, or studying for a networking certification, understanding how to move between these formats is an essential skill.
Dotted Decimal Notation
Dotted decimal is the standard human-readable format for IPv4 addresses, defined in RFC 791. The 32-bit address is divided into four 8-bit groups (octets), each converted to a decimal number between 0 and 255 and separated by dots. For example, the binary value 11000000 10101000 00000001 00000001 becomes 192.168.1.1 in dotted decimal.
This is the format used in almost every end-user configuration: router admin pages, DHCP leases, DNS records, firewall rules, and operating system network settings. Its readability makes it the preferred format for human communication, even though computers work with the raw binary or integer representation internally.
Binary Representation
The binary representation shows the full 32-bit structure of an IP address. Each octet is converted to an 8-bit binary string. In the grouped format, dots separate the four octets for readability: 11000000.10101000.00000001.00000001. In the ungrouped format, all 32 bits appear as a continuous string: 11000000101010000000000100000001.
Binary is the most important format for understanding how subnetting works. The subnet mask and the AND operation that produces a network address are both clearest when viewed in binary. Networking courses and certification exams frequently require students to work directly with binary IP addresses to understand concepts like CIDR, VLSM, and ACL matching.
Hexadecimal Representation
Hexadecimal (base 16) represents each octet as two hex digits (00-FF). The address 192.168.1.1 becomes C0A80101 in hex, or 0xC0A80101 with the conventional 0x prefix. A dotted hex format C0.A8.01.01 is also available, where dots separate the octets as in dotted decimal but each group uses hex digits.
Hexadecimal IP addresses appear in Wireshark packet captures, Windows registry entries, /proc/net/tcp and similar Linux pseudo-files, C and C++ network programming, and hardware documentation. In C, you can write uint32_t addr = 0xC0A80101 to represent 192.168.1.1 directly in code without any conversion function.
Octal Notation
Octal (base 8) represents each octet as a three-digit octal number with a leading zero prefix. The address 192.168.1.1 becomes 0300.0250.0001.0001 in dotted octal notation. In C and Unix environments, a numeric literal with a leading zero is interpreted as octal, so 0300 equals 192 in decimal.
Octal IP addresses were more common in early Unix systems and are still encountered in some embedded networking code. A notable security concern is that some older applications and parsers interpret an IP octet with a leading zero as octal rather than decimal. This means that an address like 010.0.0.1 might be parsed as 8.0.0.1 rather than 10.0.0.1, potentially bypassing IP-based access controls.
32-bit Integer Representation
Every IPv4 address can be expressed as a single unsigned 32-bit integer between 0 and 4,294,967,295. The conversion treats the four octets as a big-endian 32-bit number: the first octet occupies the most significant byte. For 192.168.1.1: (192 × 16,777,216) + (168 × 65,536) + (1 × 256) + 1 = 3,232,235,777.
The integer form is how operating systems store IP addresses in memory and how they are transmitted in many protocols. Functions like inet_addr() in C, inet_aton() in Python, and ip2long() in PHP all return the integer form. Databases often store IP addresses as integers for efficient indexing and range queries. The integer form also makes IP address arithmetic straightforward: adding 1 increments to the next address, and you can test whether an address is in a subnet with a simple integer comparison.
Auto-Detection of Input Format
This tool automatically detects which format you entered. A value with four decimal octets separated by dots is recognized as dotted decimal. A value starting with 0x followed by hex digits is recognized as hexadecimal. A value of exactly 32 characters containing only 0 and 1 is recognized as binary. Four octal groups each starting with a leading zero are recognized as octal. A large integer value is recognized as a 32-bit integer.
The detected format is highlighted in the results table with an input badge so you can confirm the tool understood your entry correctly before using the converted values in production configurations.
Practical Use Cases
Network engineers use this tool when reading Wireshark captures that show hex addresses and need to confirm which host is communicating. Developers use it when working with socket programming in C, Go, or Rust where network addresses are manipulated as integers. Security analysts use it when inspecting firewall logs that record IP addresses in binary or hex. Students use it when practicing subnetting and need to verify their binary conversions.
Database administrators use integer-form IP addresses for efficient range queries. Instead of string comparisons on dotted decimal addresses, an integer comparison covers an entire subnet range with a single BETWEEN clause. Understanding the integer representation is therefore useful whenever IP addresses are stored or queried in a database.
Frequently Asked Questions
Yes, IP Address Format Converter is totally free :)
Yes, you can install the webapp as PWA.
Yes, any data related to IP Address Format Converter only stored in your browser (if storage required). You can simply clear browser cache to clear all the stored data. We do not store any data on server.
IPv4 addresses can be represented in several formats: dotted decimal (192.168.1.1), binary with octets separated by dots (11000000.10101000.00000001.00000001), hexadecimal (0xC0A80101 or C0A80101), octal with each octet in octal notation (0300.0250.0001.0001), and as a 32-bit unsigned integer (3232235777). Each format is useful in different contexts such as networking, programming, or low-level system administration.
An IPv4 address is converted to a 32-bit unsigned integer by treating each octet as a group of 8 bits. The formula is: Integer = (octet1 × 256³) + (octet2 × 256²) + (octet3 × 256) + octet4. For 192.168.1.1: (192 × 16777216) + (168 × 65536) + (1 × 256) + 1 = 3232235777. This integer form is how IP addresses are stored internally in most operating systems.
Hexadecimal IP addresses appear in packet captures, system logs, ARP tables, memory dumps, and low-level protocol debugging. Each octet converts to two hex digits (00-FF). For example, 192.168.1.1 becomes C0.A8.01.01 in dotted hex, or C0A80101 as a single value. In C and many other languages, the hex form 0xC0A80101 can be assigned directly to a network address variable.
Octal IP addresses appear occasionally in older Unix-style configurations and some embedded systems. Each octet is represented in base 8 with a leading zero prefix (e.g., 0300 for 192). Some older network libraries and shell scripts may accept or produce octal-formatted addresses. Being able to recognize and convert octal notation prevents security misconfigurations where an octal address like 010.0.0.1 is misread as decimal 10.0.0.1 but actually means 8.0.0.1.
Yes. This tool supports automatic format detection. If you enter a numeric value like 3232235777, it is recognized as a 32-bit integer and converted to 192.168.1.1 in dotted decimal along with all other formats. The valid integer range for IPv4 is 0 to 4294967295 (2^32 - 1).
The tool attempts to identify the format of your input automatically. A value with dots and only decimal digits is treated as dotted decimal. A value containing only hexadecimal characters (with or without 0x prefix) is treated as hex. A large number (greater than 255) is treated as a 32-bit integer. You can also override the detection by selecting the input format explicitly.