Range List → IP List

The Range List to IP List tool expands IP ranges, CIDR blocks, and mixed inputs into a complete list of individual IP addresses. Enter 192.168.1.0/28 and get back all 16 addresses from 192.168.1.0 through 192.168.1.15, or enter 10.0.0.100-10.0.0.105 and get the six individual IPs in that range. Use it when you need every address enumerated for scanning, scripting, or inventory workflows.

Understanding IP Range Expansion

Many network tools and workflows require individual IP addresses as input, even when the data you have is expressed as ranges or CIDR blocks. Nmap can accept CIDR notation directly, but a custom Python script that pings each host might expect one IP per line. A spreadsheet for asset tracking needs one row per device. An Ansible inventory file needs individual host entries. In all these cases, you need to expand a compact range notation into the full list of addresses it represents.

This expansion is the reverse of compression. Where the IP List to Ranges tool takes a thousand individual addresses and condenses them to a handful of ranges, this tool takes those ranges and expands them back out. The two tools form a complementary pair: compress for human review and storage efficiency, expand when a downstream system needs individual addresses.

The expansion seems trivial for small ranges -- a /28 is just 16 addresses -- but becomes significant at larger scales. A /16 contains 65,536 addresses. A /8 contains over 16 million. Even modest-looking IPv6 prefixes contain astronomically large numbers of addresses. The tool includes safety features to prevent browser crashes: a configurable output cap warns you before expanding ranges that would produce more addresses than your browser can comfortably handle, letting you adjust or reconsider before proceeding.

How to Expand IP Ranges to Individual Addresses

1. Enter your IP ranges in any supported format -- CIDR notation (192.168.1.0/24), start-end ranges (10.0.0.1-10.0.0.50), or individual IPs
2. Mix formats freely, one entry per line or comma-separated
3. Set the output cap if expanding large ranges (default: 10,000 IPs)
4. Click expand to generate the complete IP list
5. Copy the output or export in your preferred format (one per line, comma-separated, etc.)

Range Expansion Examples

Expanding a /28 CIDR block

Input: 192.168.1.0/28

Output:

192.168.1.0
192.168.1.1
192.168.1.2
...
192.168.1.14
192.168.1.15

Total: 16 addresses

Expanding a start-end range

Input: 10.0.0.100-10.0.0.105

Output:

10.0.0.100
10.0.0.101
10.0.0.102
10.0.0.103
10.0.0.104
10.0.0.105

Total: 6 addresses

Mixed input expansion

Input:

172.16.0.0/30
172.16.0.10-172.16.0.12
172.16.0.20

Output:

172.16.0.0
172.16.0.1
172.16.0.2
172.16.0.3
172.16.0.10
172.16.0.11
172.16.0.12
172.16.0.20

Total: 8 addresses

When to Use Range to IP List Expansion

• Network scanning -- generate target lists for Nmap, Masscan, or custom scanning scripts that require individual IP inputs
• Spreadsheet inventory -- create one-row-per-IP spreadsheets for asset tracking, CMDB imports, or compliance documentation
• Script input preparation -- feed individual IPs to bash loops, Python scripts, or Ansible playbooks that process one address at a time
• DHCP lease comparison -- expand a subnet to all addresses and cross-reference against active leases to find unused IPs
• Access log correlation -- generate a reference list of all IPs in a subnet to filter or join against log entries
• Penetration testing -- create target lists for security assessments where tools require explicit address enumeration

Understanding the Output Cap

IP ranges can contain enormous numbers of addresses. A /16 contains 65,536 addresses, a /8 contains 16,777,216, and even a small-looking IPv6 /112 contains 65,536 addresses. Expanding large ranges without limits can freeze your browser or consume excessive memory.

How the Cap Works

When the total address count exceeds the cap, the tool warns you before expanding and shows the actual count. You can increase the cap, proceed with truncation, or reconsider whether you truly need individual IPs for such a large range.

IPv6 Considerations

IPv6 ranges are almost always too large to enumerate individually. A /64 subnet contains 18,446,744,073,709,551,616 addresses. The tool warns about impractical IPv6 expansions and suggests using CIDR notation or range notation instead of individual addresses for IPv6 workflows.

How Range Expansion Works

CIDR Expansion

For CIDR input like 192.168.1.0/24, the tool calculates the network address and broadcast address, then enumerates every address in between. The network address is the CIDR with all host bits set to zero. The broadcast address has all host bits set to one. Every value between these two endpoints (inclusive) is an individual IP in the range.

Start-End Expansion

For range input like 10.0.0.5-10.0.0.20, both endpoints are converted to 32-bit integers, and every integer value in between is converted back to dotted-quad notation. 10.0.0.5 = 167772165, 10.0.0.20 = 167772180, yielding 16 addresses.

Deduplication

When multiple input entries produce overlapping addresses, duplicates are removed from the output. Expanding 192.168.1.0/24 and 192.168.1.0/28 together yields 256 unique addresses, not 272.

Practical Tips for Range Expansion

Before expanding a large range, always check the address count first. The tool displays the total number of addresses your input represents before performing the expansion, giving you a chance to reconsider. If you need to scan a /16 with Nmap, it is more efficient to pass the CIDR directly to Nmap rather than expanding 65,536 addresses to a file and feeding that file as input. Reserve expansion for tools that genuinely cannot handle range notation.

When expanding for comparison purposes -- for example, to find which IPs in a subnet have no corresponding DHCP lease -- consider whether a smarter approach exists. Instead of expanding the entire /24 and doing a line-by-line diff, you might expand only the usable host range (.1 through .254) and exclude known infrastructure addresses (gateway, DNS server, DHCP server). This produces a smaller, more meaningful output.

For scripting workflows, remember that the expanded output is sorted numerically by default. This makes it suitable for sequential processing but may not match the order of your input if you provided ranges in a specific sequence. If order matters for your use case, pre-sort your input ranges accordingly.

Frequently Asked Questions

Can I exclude specific addresses from the expansion?

The Range List to IP List tool expands everything in the input. To exclude specific addresses, first expand the range, then filter the output. Alternatively, use the CIDR Exclusion Tool to subtract sub-ranges before expanding.

What output formats are available?

Output can be formatted as one IP per line (most common for scripts), comma-separated (for CSV or spreadsheet paste), or space-separated. Some tools and firewalls accept each format natively.

Is the output sorted?

Yes. All output IPs are sorted in ascending numerical order, regardless of the order of input entries. Duplicate addresses across overlapping inputs appear only once.

What happens if I enter an invalid range like 10.0.0.50-10.0.0.10?

The tool detects reversed ranges where the end address is numerically lower than the start address. It either swaps the endpoints automatically or warns you about the invalid input, depending on the implementation.

Can I expand IPv6 ranges?

Technically yes, but practically only for very small ranges. A /126 (4 addresses) or /124 (16 addresses) can be expanded usefully. Anything larger than a /112 (65,536 addresses) will likely hit the output cap, and most IPv6 subnets are /64 or larger, making full enumeration impractical.

Related Tools

• IP List to Ranges - Compress individual IPs back into ranges
• CIDR to IP Range Converter - Convert CIDR notation to start-end range format
• CIDR Exclusion Tool - Subtract exception CIDRs from a parent block
• IP Range to CIDR Converter - Convert IP ranges to minimal CIDR blocks
• CIDR Deaggregator - Expand a CIDR block into smaller CIDR blocks