Building a Distributed IPv6 Proxy System: Master-Slave Architecture for Dynamic IP Rotation

After years of private use, I’m open-sourcing the IPv6 proxy infrastructure that handles millions of requests daily

The Problem

If you’ve worked with proxies, you know the pain. Commercial solutions cost $500+ monthly. Open-source options are either abandoned or impossibly complex. And nobody handles IPv6 properly.

I built this system years ago for my own use. Today, I’m making it public.

What Makes This Different

One line tells the whole story:

curl -x http://user:2a13:3380::5@proxy:8080 https://api.example.com

See that IPv6 address in the username field? That’s the magic. You choose exactly which IPv6 to use for each request. No configuration files. No complex routing rules. Just specify the IP you want.

Architecture in 30 Seconds

Two components:

Master Proxy — Accepts connections from your applications
Slave Connectors — Run on servers with IPv6 subnets

They talk over WebSocket. Master handles clients. Slaves handle routing. Dead simple.

Real Setup, Real Code

Here’s an actual setup from one of my servers.

First, configure your IPv6 subnets:

sudo ip -6 addr add 2a13:3380::2/29 dev eth0
sudo ip -6 addr add 2a0f:dfc0::2/29 dev eth0

Start the master proxy:

docker run -d - name proxy-master \
 -p 8080:8080 -p 3000:3000 \
 heysmmprovider/smm-panel-proxy-master

Connect the slave (on your IPv6 server):

docker run -d - name proxy-slave \
 - network host \
 -e PROXY_SERVER=ws://master-ip:3000 \
 heysmmprovider/smm-panel-ipv6-proxy

Done. You now have a distributed IPv6 proxy.

Using It

Python example:

python
import requests
proxies = {
 'http': 'http://user:2a13:3380::5@localhost:8080',
 'https': 'http://user:2a13:3380::5@localhost:8080'
}
response = requests.get('https://api.example.com', proxies=proxies)

Node.js example:

javascript
const HttpsProxyAgent = require('https-proxy-agent');
const agent = new HttpsProxyAgent('http://user:2a13:3380::5@localhost:8080');
const response = await fetch('https://api.example.com', { agent });

Each request can use a different IPv6. Just change the address in the proxy URL.

Performance Numbers

From production usage:

• Latency overhead: 5–10ms
• Concurrent connections: 1000+ per slave
• Memory: 100MB (master), 50MB (slave)
• Uptime: Weeks without restarts

These aren’t theoretical. This system has processed millions of requests.

The Code

Both components are on GitHub:

Master Proxy
https://github.com/heysmmprovider/smm-panel-proxy-master

Slave Connector
https://github.com/heysmmprovider/smm-panel-ipv6-proxy

MIT licensed. Docker ready. Production tested.

Technical Details

The interesting parts for developers:

WebSocket Control Plane

Master and slaves communicate over persistent WebSocket connections. Heartbeat every 30 seconds. Automatic reconnection on failure.

Correlation IDs

Every proxy connection gets a UUID. Prevents stream mixing. Enables proper cleanup.

Buffer Handling

javascript
socket.on('proxy:create-connection', ({ host, port, ipv6Address }) => {
   const connection = net.connect({
     host,
     port,
     family: 6,
     localAddress: ipv6Address // Bind to specific IPv6
   });
});

The localAddress parameter is key. It binds the outgoing connection to a specific IPv6 address.

Use Cases

Web Scraping
Different IP for each request. Bypass rate limits. Avoid blocks.

API Testing
Test geographic restrictions. Verify rate limiting. Load test from multiple IPs.

Social Media Automation
Separate IPs for different accounts. Avoid platform detection. Scale operations.

Privacy
Anonymize traffic origin. Distribute request patterns. Prevent tracking.

Current Limitations

Being honest about what it doesn’t do:

• IPv6 only (IPv4 not supported)
• Manual subnet configuration required
• Basic authentication only
• No built-in monitoring dashboard

These are by design or on the roadmap.

Why Open Source?

Simple. For making simple.

Providers charge insane prices for basic features. Open-source projects are abandoned. Documentation is non-existent.

This code works. It’s been tested in production for years. The community deserves better tools.

Getting Started

Clone the repos. Read the READMEs. Deploy with Docker or manually.

If you need help, open an issue. If you find it useful, star the repos.

For those who want managed solutions instead of self-hosting, I provide pre-configured setups with IPv6 subnets at HeySMMReseller.com.

What’s Next

Planning to add:

• Subnet auto-discovery
• Prometheus metrics
• Web UI dashboard
• Geographic routing
• Plugin system

Contributions welcome.

Final Thoughts

This isn’t a weekend hack. It’s production infrastructure solving real problems.

The code is simple enough to understand, robust enough for production. The master-slave design scales horizontally. The WebSocket control plane ensures reliability.

After years of private use, I’m curious to see what others build with it.

Master Proxy: https://github.com/heysmmprovider/smm-panel-proxy-master

Slave Connector: https://github.com/heysmmprovider/smm-panel-ipv6-proxy

Star if useful. Fork if inspired. Contribute if interested.

That’s it. Enjoy the code.

Powered By:

Smm Panel | HeySmmReseller

Smm Provider | HeySmmProvider