What is a random IP generator?
A random IP generator makes up IP addresses that are correctly formatted but picked at random. This one gives you up to 20 at a time, in one of six types: public IPv4, three private IPv4 ranges, loopback, or IPv6. Each address has its own Copy button, and Copy All puts the whole list on your clipboard, one address per line.
People need fake IP addresses for boring, useful reasons. A form field that validates IPs needs test input. A log parser needs sample lines. A firewall rule needs something to match against before it touches production. A screenshot for a bug report should not show a real customer's address. Typing 1.2.3.4 into every one of those gets old fast, and it never tests anything interesting.
Everything runs in your browser. Nothing is looked up, sent anywhere or saved. There's no signup and no limit on how many times you press the button.
How to generate random IP addresses
- Pick the type under IP Type. Public IPv4 is selected when the page loads.
- Drag the Count slider to choose how many addresses you want, from 1 to 20. It starts at 5.
- Press Generate IPs. The list appears below the button.
- Press Copy next to any single address, or Copy All for the whole list, one per line. Press Generate IPs again for a fresh batch.
Need more than 20? Generate, Copy All, paste, and repeat. Each batch is independent, so the same address can turn up twice across batches. It's rare, but if your test needs unique values, de-duplicate the combined list with the Remove Duplicate Lines tool.
What each IP type gives you
Here is exactly what each button produces. The examples follow each pattern; your output will be different every time.
| Type | Pattern the tool uses | Example |
|---|---|---|
| Public IPv4 | First number 1–254, skipping 10, 127, 169, 172 and 192. Middle numbers 0–255. Last number 1–254. | 83.142.7.219 |
| Private Class A (10.x) | 10. + 0–255 + 0–255 + 1–254 | 10.47.203.18 |
| Private Class B (172.16–31.x) | 172. + 16–31 + 0–255 + 1–254 | 172.24.9.131 |
| Private Class C (192.168.x) | 192.168. + 0–255 + 1–254 | 192.168.73.5 |
| Loopback (127.x) | 127.0.0. + 1–254 | 127.0.0.42 |
| IPv6 | Eight random groups of four hex digits, lowercase, leading zeros kept | 3f2a:09c1:b7e4:0000:5d10:e8a3:41f6:c07b |
The last number of an IPv4 address never comes out as 0 or 255. Those often mean "the network itself" and "everyone on the network," and they trip up tests that expect a normal host. The private types stay inside the three blocks that RFC 1918 sets aside for home and office networks, so they are safe to use in any internal config example.
Copy-paste IP addresses that are safe to publish
If you're writing documentation, a tutorial, a slide or a blog post, there's a better answer than any random address: the documentation ranges. RFC 5737 (2010) reserves three small IPv4 blocks for exactly this, and RFC 3849 does the same for IPv6. These addresses are never handed out to real machines, so they can't point at anyone.
| Name | Range | Copy-paste examples |
|---|---|---|
| TEST-NET-1 | 192.0.2.0/24 | 192.0.2.1, 192.0.2.44, 192.0.2.200 |
| TEST-NET-2 | 198.51.100.0/24 | 198.51.100.7, 198.51.100.85, 198.51.100.230 |
| TEST-NET-3 | 203.0.113.0/24 | 203.0.113.5, 203.0.113.77, 203.0.113.199 |
| IPv6 documentation | 2001:db8::/32 | 2001:db8::1, 2001:db8:85a3::8a2e:370:7334 |
Each /24 block holds 256 addresses, numbered .0 to .255. Use .1 to .254 if you want them to look like ordinary hosts. Want to see the start, end and size of any block? Paste it into the CIDR Calculator.
Rule of thumb. Use the generator when you need many varied addresses, such as test fixtures, seed data or load-test inputs. Use the documentation ranges when a human will read the address, such as docs, screenshots and examples. The generator does not draw from the documentation ranges, so for published material copy from the table above.
What "public" mode does and doesn't skip
Public IPv4 mode rejects any address whose first number is 0, 10, 127, 169, 172 or 192, then rolls again. That keeps out the private ranges, loopback and link-local addresses. It's a blunt filter: it drops the whole 169, 172 and 192 blocks, including plenty of real public space such as 172.217.x.x.
It doesn't filter every special range. Here's what can still come out:
| Range | What it's for | How often public mode lands there |
|---|---|---|
224.0.0.0/4 (224–239) | Multicast | About 1 in 16 addresses (6.4%) |
240.0.0.0/4 (240–254 here) | Reserved, the old "Class E" | About 1 in 17 (6.0%) |
100.64.0.0/10 | Carrier-grade NAT (RFC 6598) | About 1 in 1,000 (0.1%) |
198.18.0.0/15 | Network benchmarking (RFC 2544) | About 1 in 32,000 |
So roughly one address in eight starts with 224 or higher. If your code rejects multicast or reserved addresses, that's useful: it's free negative test data. If you need only ordinary unicast addresses, delete any line starting with 224 or above.
IPv6 mode is fully random across all 128 bits. Real internet addresses today sit in 2000::/3, which means they start with 2 or 3. Only about 1 in 8 random IPv6 addresses starts that way. The rest are valid in format but not in any range used on the public internet. That's fine for testing a parser or a database column. It's wrong if you need addresses that look like real traffic.
Is a fake IP address anonymous? (And the prank question)
No. A generated address changes nothing about your own connection. Your device keeps its real IP, websites still see it, and pasting a random number into a chat hides nothing. If you want to change the address websites see, that's a job for your network, not a text generator.
The prank version goes the other way: someone posts a "fake IP address" to pretend they know where a friend lives. A random public address, though, may belong to a real network somewhere, and an IP address alone doesn't give anyone a home address anyway. If a joke needs a number that clearly belongs to no one, use a documentation address like 203.0.113.42. It's the polite choice, and it's also the funnier one if your friend looks it up.
Common mistakes with test IP addresses
Rolling your own and assuming private ranges are rare. They are, but the real risk is the ranges you forgot. A fully random 32-bit number lands in 10.0.0.0/8 about 0.39% of the time, in 172.16.0.0/12 about 0.024%, and in 192.168.0.0/16 only 0.0015%. Multicast and reserved space, the top sixteenth each of the whole range, are far more likely to slip through than any private block.
Testing only the full IPv6 form. This tool prints all eight groups with leading zeros, like 2001:0db8:0000:0000:0000:0000:0000:0001. Real systems usually print the short form, 2001:db8::1. They're the same address. If your code stores or compares IPv6 strings, test both forms, plus uppercase hex.
Using real addresses in shared logs. Swapping a customer's IP for a random one before you share a log is fine for a demo. It is not anonymization for analytics: you lose the pattern you might need later. For that, truncate the address (for example to the /24) or hash it.
Forgetting validation edge cases. A good IP validator should reject 256.1.1.1 and 1.2.3, and decide on purpose what to do with leading zeros like 01.2.3.4, which some older software reads as octal. The generator only makes valid addresses, so write those bad cases by hand.
Building a full fake user record? Pair these addresses with names from the Random Name Generator, street addresses from the Fake Address Generator, hardware IDs from the MAC Address Generator and record keys from the UUID Generator. Each one does one job and runs in your browser.
Frequently asked questions
How many IP addresses can I generate at once?
Between 1 and 20 per batch, set with the Count slider. For a bigger list, generate several batches and paste them together. Batches are independent, so check for duplicates if your test needs unique values.
Are the generated public IP addresses real?
They're random numbers in a valid format. Some will fall inside blocks that belong to real networks, and roughly one in eight lands in multicast or reserved space. Don't send traffic to them. For examples people will read, use the RFC 5737 ranges instead.
What is TEST-NET-3 (203.0.113.0/24)?
It's one of three IPv4 blocks reserved by RFC 5737 for documentation and examples, alongside TEST-NET-1 (192.0.2.0/24) and TEST-NET-2 (198.51.100.0/24). Addresses in these blocks are never assigned to real devices. The IPv6 equivalent is 2001:db8::/32.
Can a fake IP address hide my real one?
No. Generating an address doesn't change your connection in any way. Websites still see your real IP. This tool is for test data and examples only.
What's the difference between private and public IP addresses?
Private addresses (10.x, 172.16–31.x, 192.168.x) work only inside a local network, like your home Wi-Fi. Public addresses are reachable across the internet. Your router usually translates between the two, which is why many devices at home share one public IP.
Does the IPv6 option give real-looking addresses?
The format is correct, but every bit is random. Only about 1 in 8 results starts with 2 or 3, the block used for public internet addresses today. For parsers and database fields that's fine. For realistic traffic samples, edit the first group to start with 2.