Build Your Own Rotating Residential Proxy Pool Using Devices You Already Own

Why Residential IPs Are Worth More Than Datacenter IPs

Not all IP addresses are treated equally by websites. When your request arrives at a web server, the server knows your IP address and looks it up in databases that classify IP ranges by origin and type. An IP address assigned by an ISP to a residential customer in Istanbul or Berlin looks fundamentally different from an IP address assigned to a server rack in an AWS or Google Cloud data center.

Websites with anti-scraping systems use this classification as a primary filter. Datacenter IP ranges are well-known, catalogued, and blocked preemptively. Residential IPs are harder to block because they come from the same ISP ranges used by ordinary human users browsing the same website. Blocking a residential IP risks blocking a real customer.

When you buy residential proxies from providers like Bright Data or Oxylabs, you are paying for access to their pool of devices running peer software that forwards your traffic through their home connections. Your request exits the internet from a real residential IP. The device owner gets a small payment or free service; you get an IP that websites do not block.

The critical insight: you already own devices with real residential IPs. Your home computer, your phone on mobile data, your family member's laptop at a different location, all of these are genuine residential IPs that any anti-scraping system will treat as real human traffic. The missing piece is infrastructure to route requests through them as a shared pool. That is exactly what Localtonet's rotating proxy feature provides.

The Cost Problem with Commercial Residential Proxies

Commercial residential proxy networks are expensive because acquiring, maintaining, and managing millions of real residential devices is operationally complex. The pricing reflects this overhead, not the fundamental cost of the bandwidth itself.

At these prices, the economics of data collection projects shift quickly. A scraping project that pulls 50GB per month costs $50 to $420 in proxy fees depending on the provider and plan. For teams running multiple concurrent scrapers, monthly proxy costs easily reach thousands of dollars before any other infrastructure expense.

The alternative is building a proxy pool from devices you already own. Your home ISP connection costs the same whether or not you route proxy traffic through it. The only additional cost is the Localtonet tunnel subscription that connects your devices into a shared pool, which is priced per tunnel rather than per gigabyte.

How a Rotating Proxy Pool Works: Technical Foundation

A rotating proxy pool has two core components: a backconnect gateway and a pool of exit nodes. The backconnect gateway is a single endpoint address that your scraper or browser sends requests to. Behind the gateway, the exit node pool is a collection of devices or servers whose IP addresses actually make the requests to target websites. The gateway handles IP selection from the pool, forwards your request through the selected exit node, and returns the response to you.

Building Your Pool with Localtonet: How It Works

Localtonet's Rotating Proxy feature is built on the same outbound tunnel architecture that makes its other services work behind NAT and CGNAT. Each device you want to include in your proxy pool installs the Localtonet client and connects outbound to Localtonet's infrastructure. Localtonet exposes a single shared proxy endpoint. Requests to that endpoint are distributed across all connected devices in the token group you configure.

# Linux / Raspberry Pi:
curl -fsSL https://localtonet.com/install.sh | sh
localtonet --authtoken DEVICE_TOKEN_HERE

# Windows: download installer from localtonet.com/documents
# Android: install from Google Play, enter token in app

Session IDs: Controlling Which Device Handles Your Requests

By default, every request goes to a randomly selected device in the pool. For use cases that require the same IP across multiple requests (logged-in sessions, account management, multi-step workflows), Localtonet supports session IDs embedded in the proxy username.

The format is: add -session-YOURVALUE- to the proxy username. All requests using the same session ID value are routed to the same device for the duration of that session.

# Normal rotation (different device every request):
# Username: your_username
# Password: your_password

# Sticky session - always routes to the same device:
# Username: your_username-session-12-
# Password: your_password

# Switch to a different device by changing the session ID:
# Username: your_username-session-13-
# Password: your_password

Changing the session ID number effectively switches to a different device in the pool without any configuration change. This makes managing multiple concurrent sticky sessions straightforward: each active session ID maps to one device.

Which Devices to Include in Your Pool

Any device with an internet connection and the ability to run the Localtonet client can join the pool. Different device types bring different IP characteristics:

HTTP vs SOCKS5: Which Protocol to Choose

For most web scraping and data collection use cases, HTTP proxy is the simpler choice and is natively supported by virtually every scraping library. Use SOCKS5 if your application type is not HTTP-based or if you need to proxy non-web protocols.

Using Your Proxy Pool: Code Examples

curl (command line)

# Random rotation (new device each request):
curl -x http://username:password@gateway.localto.net:PORT https://httpbin.org/ip

# Sticky session (always same device via session ID):
curl -x http://username-session-42-:password@gateway.localto.net:PORT https://httpbin.org/ip

# SOCKS5:
curl --socks5 username:password@gateway.localto.net:PORT https://httpbin.org/ip

Python with requests (random rotation)

import requests

PROXY_GATEWAY = "gateway.localto.net"
PROXY_PORT = "PORT"         # from Localtonet dashboard
USERNAME = "your_username"
PASSWORD = "your_password"

proxy_url = f"http://{USERNAME}:{PASSWORD}@{PROXY_GATEWAY}:{PROXY_PORT}"

proxies = {
    "http":  proxy_url,
    "https": proxy_url,
}

# Each call to requests.get() uses a different device from the pool:
for url in urls_to_scrape:
    response = requests.get(url, proxies=proxies, timeout=30)
    print(response.status_code, response.url)

Python with requests (sticky session)

import requests

PROXY_GATEWAY = "gateway.localto.net"
PROXY_PORT = "PORT"
PASSWORD = "your_password"

def get_session_proxy(session_id: int) -> dict:
    """Returns proxy config pinned to a specific device via session ID."""
    username = f"your_username-session-{session_id}-"
    proxy_url = f"http://{username}:{PASSWORD}@{PROXY_GATEWAY}:{PROXY_PORT}"
    return {"http": proxy_url, "https": proxy_url}

# Account A: all requests use device assigned to session 1
session = requests.Session()
session.proxies = get_session_proxy(1)
session.get("https://example.com/login", data={"user": "a", "pass": "x"})
session.get("https://example.com/dashboard")   # same IP as login

# Account B: different device via session 2
session2 = requests.Session()
session2.proxies = get_session_proxy(2)
session2.get("https://example.com/login", data={"user": "b", "pass": "y"})

Scrapy spider

# settings.py
ROTATING_PROXY_LIST = []  # not needed, gateway handles rotation

# Use a single proxy in settings; Localtonet gateway rotates internally:
DOWNLOADER_MIDDLEWARES = {
    'scrapy.downloadermiddlewares.httpproxy.HttpProxyMiddleware': 110,
}
HTTP_PROXY = 'http://username:password@gateway.localto.net:PORT'

# Or set per-request in the spider:
class MySpider(scrapy.Spider):
    def start_requests(self):
        for url in self.start_urls:
            yield scrapy.Request(
                url,
                meta={"proxy": "http://username:password@gateway.localto.net:PORT"}
            )

Playwright browser automation

import asyncio
from playwright.async_api import async_playwright

async def scrape_with_proxy():
    async with async_playwright() as p:
        browser = await p.chromium.launch(
            proxy={
                "server": "http://gateway.localto.net:PORT",
                "username": "your_username",
                "password": "your_password"
            }
        )
        page = await browser.new_page()
        await page.goto("https://example.com")
        content = await page.content()
        await browser.close()
        return content

asyncio.run(scrape_with_proxy())

Use Cases: What to Do with a Rotating Residential Proxy Pool

Client Management: Multiple Users on One Pool

If you want to give other users or team members access to your rotating proxy pool without sharing your main credentials, Localtonet's Clients feature lets you create separate usernames, passwords, and bandwidth limits for each client. Access the Clients management from the Clients button on the rotating proxy tunnel page in the dashboard.

Each client entry has:

• Username: The client's proxy username (can use session IDs in requests)
• Password: The client's proxy password
• Bandwidth limit: Maximum traffic this client can consume (prevents one client from consuming the entire pool's capacity)

This is useful for agencies managing proxy access across team members, or for individuals who want separate credentials for different projects (scraping project vs account management project) to keep usage logs separated.

Your Own Pool vs Commercial Residential Proxies

Frequently Asked Questions