Need a random IP? Try Browserling – get a browser with a random IP! I made it.

I often have to generate a sequence of IP addresses so I created this simple online utility that does it for me. It lets you generate however many sequential IPv4 addresses you need from the given range. It works in the browser and is powered by alien technology from the future.

IP Range and Count
Step and Separator

## Ip Addresses Generator Examples (click to try!)

In this example, we use the "Generate an IP Range" option to create a list of IPs from the range 0.0.0.0 to 255.255.255.255. This is the entire IP address space and there are 4,294,967,296 IPs in it. It would take an entire day to generate this many IP addresses so to quickly get usable data, we set the IP step value to 15.15.15.15. This way, we increase each octet by 15 and it takes just 18 iterations to get to the maximum possible IP address. We display the addresses in the decimal base (base-10) and also append their numerical values in parentheses.
```0.0.0.0 (0)
15.15.15.15 (252645135)
30.30.30.30 (505290270)
45.45.45.45 (757935405)
60.60.60.60 (1010580540)
75.75.75.75 (1263225675)
90.90.90.90 (1515870810)
105.105.105.105 (1768515945)
120.120.120.120 (2021161080)
135.135.135.135 (2273806215)
150.150.150.150 (2526451350)
165.165.165.165 (2779096485)
180.180.180.180 (3031741620)
195.195.195.195 (3284386755)
210.210.210.210 (3537031890)
225.225.225.225 (3789677025)
240.240.240.240 (4042322160)
255.255.255.255 (4294967295)```
Generate an IP Range
Start IP range value.
End IP range value.
IP step value.
Separate IPs with this symbol. (Newline by default.)
Separate IP octets with this symbol. (Dot by default.)
Print Numeric IP
Decimal Base
Fifty 10.0.0.0/8 IPs
In this example, we generate a sequence of the first fifty addresses from the private class A network. To do this, we select the "Generate an IP Count" mode, set the starting IP value to 10.0.0.0, and the IP step value to 0.0.0.1. In the output, we convert the IPs to a hexadecimal base (base-16), replace the dots with underscores, and print the addresses separated by spaces.
`0a_00_00_00 0a_00_00_01 0a_00_00_02 0a_00_00_03 0a_00_00_04 0a_00_00_05 0a_00_00_06 0a_00_00_07 0a_00_00_08 0a_00_00_09 0a_00_00_0a 0a_00_00_0b 0a_00_00_0c 0a_00_00_0d 0a_00_00_0e 0a_00_00_0f 0a_00_00_10 0a_00_00_11 0a_00_00_12 0a_00_00_13 0a_00_00_14 0a_00_00_15 0a_00_00_16 0a_00_00_17 0a_00_00_18 0a_00_00_19 0a_00_00_1a 0a_00_00_1b 0a_00_00_1c 0a_00_00_1d 0a_00_00_1e 0a_00_00_1f 0a_00_00_20 0a_00_00_21 0a_00_00_22 0a_00_00_23 0a_00_00_24 0a_00_00_25 0a_00_00_26 0a_00_00_27 0a_00_00_28 0a_00_00_29 0a_00_00_2a 0a_00_00_2b 0a_00_00_2c 0a_00_00_2d 0a_00_00_2e 0a_00_00_2f 0a_00_00_30 0a_00_00_31`
Generate an IP Count
Start IP value.
How many IPs to generate?
IP step value.
Separate IPs with this symbol. (Newline by default.)
Separate IP octets with this symbol. (Dot by default.)
Print Numeric IP
Duodecimal Base IPs
In this example, we generate every 5000th IP address from the private class B network in the duodecimal base (base-12). The private B network starts with the value 192.168.0.0 and ends with the value 192.168.255.255. To generate each 5000th address we set the step to 0.0.19.136 (this is calculated by the formula 19×256 + 136 = 5000). To get the duodecimal base, we select the custom base output mode and enter the radix 12 in the option.
```140.120.0.0
140.120.17.10b
140.120.33.46
140.120.4a.155
140.120.66.90
140.120.82.7
140.120.99.116
140.120.b5.51
140.120.110.160
140.120.128.97
140.120.144.12
140.120.15b.121
140.120.177.58
140.120.192.167```
Generate an IP Range
Start IP range value.
End IP range value.
IP step value.
Separate IPs with this symbol. (Newline by default.)
Separate IP octets with this symbol. (Dot by default.)
Print Numeric IP
Custom Base
If you selected a custom base, set its value here. Valid bases are from 2 to 64.

## How Does This Ip Addresses Generator Work?

This IP addresses list generator works entirely in your browser and is written in JavaScript. It can find all IPv4 addresses in the given range or generate a certain number of IPv4s starting from a specific address. When generating a range of IP addresses, the starting and ending address can be specified in the options as `rangeStart` and `rangeEnd` variables. There's also a `step` variable that controls the distance between consecutive IP addresses. To create an output array of IPs, the program runs a `for` loop with the initial expression `ip = rangeStart`, condition expression `ip <= endRange`, and increment expression `ip += step`, and `push`es the `ip` value to array `ipList` at each iteration step. When generating a specific count of IP addresses, the variables used are `startIp`, `count`, and `step`. In this case, the `ipList` array is also populated via a regular `for` loop with the counter `i` going from `1` to `count`. At each iteration step, the `startIp` value is `push`ed to the array and incremented by the `step` value. As IP addresses consist of four decimal numbers (called octets), each between 0 and 255 and separated by dots, it's not easy to increment them directly. To make it easier to work with IPs, they are transformed from the dotted form `a.b.c.d` to the single-integer form using the formula `intIp = aInt + bInt + cInt +dInt`, where `aInt = a×256×256×256`, `bInt = b×256×256`, `cInt = c×256`, and `dInt = d`. After running the loop and filling the output array `ipList` with IPs, they are converted back to the octet format through the reverse formula `(intIp>>24)&0xff + dot + (intIp>>16)&0xff + dot + (intIp>>8)&0xff + dot + intIp&0xff`. The `dot` variable can actually be any character and it can be changed in the octet separator option. The output IPs can also be converted to another base. In this case, the additional `BigNumber` library is loaded. With this library, it's easy to convert each octet to a different base. First, each octet is converted into a big number by calling `new BigNumber(octet)` and then it's converted to a string in the new base by calling `octet.toString(base)`. After all this, the IP addresses that were collected in the `ipList` array are converted to plain text format by calling `ipList.join(ipSeparator)` and are all printed to the output text box.

### Created by Browserling

This ip addresses generator was created by me and my team at Browserling. Behind the scenes, it's actually powered by our web developer tools that are used by millions of people every month. Browserling itself is an online cross-browser testing service powered by alien technology. Check it out!

Secret message: If you love my tools, then I love you, too! Use coupon code TOOLLING to get a discount at my company.