How To Generate Random IPs for Web Scraping

In this guide, you will learn:

• The definition of an IP address and its uses
• Whether it is possible to programmatically generate random IP addresses
• How to build a random IP generator
• How to use random IP addresses to hide your identity

Let’s dive in!

What Is an IP Address?

An IP address is a string of numbers uniquely assigned to devices connected to a computer network communicating over the Internet Protocol. You can think of it as a digital address that helps identify a device on the Internet or a local network.

In short, IP addresses are essential for device identification, data routing, and even geolocation services. As of this writing, the most widely used version today is IPv4. An IPv4 address consists of four groups of numbers (called octets) separated by periods, as follows:

192.168.1.1

Each octet is a number that can range from 0 to 255, allowing for a space of 4.3 billion unique possible addresses.

A newer standard, IPv6, utilizes a different format and provides a much larger pool of addresses. However, this article focuses on IPv4. You can explore more in our IPv4 vs IPv6 guide.

The easiest way to discover your public IP address is to visit a site like “What is my IP address.” Alternatively, on Windows, you can find your IP by launching the following command in the terminal:

ipconfig

Great! Now, it is time to find out if you can build a random IP generator.

Is It Possible to Create a Random IP Address Generator?

TL;DR: Yes, creating a random IP address generator is entirely possible!

As mentioned before, IP addresses follow a well-defined structure with numbers within specific ranges. That makes generating valid random IPs not only possible but also relatively easy.
On the other hand, you need to understand how IPs are assigned and reserved to avoid generating addresses that are just meaningless sets of numbers.

IP addresses are managed by the IANA (Internet Assigned Numbers Authority) and distributed by RIRs (Regional Internet Registries). Adhering to IANA’s standards allows you to programmatically generate valid address formats.

When building an IP random generator tool, you also need to ignore certain IP ranges. That is because some IPs are reserved and not used for public Internet traffic.

You can find reserved IPv4 ranges in the following table:

See how to generate a random IP address using a simple Python script!

How to Generate a Random IP in Python

Follow this step-by-step tutorial to learn how to create a Python random IP generator function!

Step #1: Define a Function for Generating IPv4 Addresses

IPv4 addresses are nothing more than strings consisting of four octets, each ranging from 0 to 255. To generate those random numbers in the IP format, you can use the following logic:

def generate_random_ipv4():
    return f"{random.randint(0, 255)}.{random.randint(0, 255)}.{random.randint(0, 255)}.{random.randint(0, 255)}"

randint() from random generates a random number between 0 and 255. So, the generate_random_ipv4() function returns a string in the following format:

X.Y.Z.A 

Where X, Y, Z, and A are numbers from 0 to 255.

Do not forget to import random from the Python Standard Library:

import random

Step #2: Add the Filter Logic for Reserved IPs

The ipaddress library from the Python Standard Library provides an IPv4Address class. This exposes an is_reserved attribute to check whether an IP address is reserved.

First, import the ipaddress library:

import ipaddress

Next, use it to create a logic that repeatedly generates random IP addresses until it generates one that is not reserved:

while True:
    # Generate a random IP address
    ip = f"{random.randint(0, 255)}.{random.randint(0, 255)}.{random.randint(0, 255)}.{random.randint(0, 255)}"
    
    # Check if the generated IP is within the reserved blocks
    if not ipaddress.IPv4Address(ip).is_reserved:
        return ip

Wonderful! Your random IP address generator Python function is ready.

Step 3: Test the Function

This is what your random IP generation function would look like:

import random
import ipaddress


def generate_random_ipv4():
    while True:
        # Generate a random IP address
        ip = f"{random.randint(0, 255)}.{random.randint(0, 255)}.{random.randint(0, 255)}.{random.randint(0, 255)}"
        
        # Check if the generated IP is within the reserved blocks
        if not ipaddress.IPv4Address(ip).is_reserved:
            return ip

Call the IP random generator function and print the result:

ip = generate_random_ipv4()
print(ip)

The result will be something like:

61.18.2.4

Amazing! Mission complete.

Extra: Build an IPv6 Random Generator

Just like the IPv4 generator, here is how you can create an IPv6 generator:

import random
import ipaddress


def generate_random_ipv6():
    while True:
        # Generate a random IPv6 address
        ip = ":".join(f"{random.randint(0, 0xFFFF):04x}" for _ in range(8))
        
        # Check if the generated IP is within the reserved blocks
        if not ipaddress.IPv6Address(ip).is_reserved:
            return ip

Using Random IPs to Protect Your Identity

The real question is: Why would you need a random IP generator? Here are a few possible answers:

• Learning: Use it as a tool to understand how IP addresses are structured and managed.
• Testing: Utilize it in processes that require an IP address as input or involve using IPs for specific tasks, such as validating network configurations, firewalls, or other systems.

Now, remember that an IP address is a unique identifier. Wouldn’t it be magical if you could generate a random IP and use it to hide your identity? For example, during web scraping, this would help:

1. Prevent the target site from detecting automated requests.
2. Give you a virtually infinite pool of IPs to work with to avoid anti-scraping measures like rate limiting.

That would be fantastic! Yet, it is not possible to simply create a random IP generator and directly use it on your machine. What you can do instead is route your requests through a pool of proxy servers.

That mechanism helps you ensure that each request made by your machine appears to come from a different IP address. Learn more in our tutorial on how to rotate an IP address.

Using proxies is the closest you can get to leveraging a random IP generator for security and online anonymity. Many top-tier residential proxy providers offer massive pools of valid IPs—often in the millions. So, proxies are close to having access to random IPs.

Conclusion

In this guide, you will learn what an IP address is, what it consists of, and how to build a random IP address generator in Python. While generating random IPs is easy, they are not particularly useful by themselves. You cannot simply use them to override your machine’s identity.

This can be achieved through a different mechanism: proxy servers. A proxy server acts as a middleman, relaying requests from you to target servers and managing responses from the target back to you. In this way, the target server only sees the IP address of the proxy, not your real one.

The challenge lies in choosing a reliable proxy provider. Dozens of providers offer similar services, but not all are trustworthy or effective. You need a provider with reliable servers, a large pool of IPs, and strong privacy policies. Instead of wasting time testing them all, go straight to the best option on the market, Bright Data.

Bright Data controls the best proxy servers in the world, serving Fortune 500 companies and over 20,000 customers. Its worldwide proxy network involves:

• Datacenter proxies – Over 770,000 datacenter IPs.
• Residential proxies – Over 72M residential IPs in more than 195 countries.
• ISP proxies – Over 700,000 ISP IPs.
• Mobile proxies – Over 7M mobile IPs.

Overall, that is one of the largest and most reliable scraping-oriented proxy networks on the market.

Create a Bright Data account and test these scraping services with a free trial!