Avoiding TCP port exhaustion

On large scrapes and proxy-checker runs, a client can start throwing intermittent connection failed or address already in use errors even though CPU, RAM, and bandwidth are nowhere near saturated. That is almost never a ColdProxy limit; it is the operating system running out of local ephemeral (source) TCP ports because closed sockets accumulate in TIME_WAIT faster than they drain. This page shows how to widen the ephemeral port range and shorten TIME_WAIT on Windows and Linux, plus the ColdProxy-side levers that cut the connection churn at its source.

#Symptom

Under heavy concurrency, requests fail intermittently while the machine looks idle:

• Errors like connection failed, address already in use, WSAEADDRINUSE (Windows), or EADDRNOTAVAIL (Linux), appearing in bursts rather than constantly.
• Spare CPU, RAM, and network headroom: the box is not overloaded.
• Failures scale with concurrency: a few hundred workers are fine, a few thousand start failing.
• The same proxy string works perfectly in a single-threaded test, so the credentials and ports are not the problem.

#Cause

Every outbound TCP connection consumes one ephemeral source port on the client. When the connection closes, that port sits in the TIME_WAIT state before it can be reused, a deliberate TCP safeguard against stray late packets from the old connection landing on a new one.

Two OS defaults make this a bottleneck at scale:

• A small ephemeral port range. Windows defaults to roughly 16,000 dynamic ports (49152–65535). At a few thousand new connections per second, that pool empties fast.
• A long TIME_WAIT. Windows holds closed connections in TIME_WAIT for about 120 seconds. Ports tied up for two minutes drain far slower than a busy scraper allocates them.

Range divided by TIME_WAIT sets a hard ceiling on new connections per second. With ~16,000 ports and a 120-second hold, sustained churn exhausts the pool and new connections fail until ports recycle, regardless of how many proxy ports your plan provisions.

#Windows fix

Run an elevated (Administrator) terminal; these settings change OS networking and require admin rights. They persist across reboots.

#Widen the ephemeral port range

Expand the dynamic (ephemeral) TCP port pool. A conservative range that avoids the well-known and registered low ports:

netsh int ipv4 set dynamicport tcp start=10000 num=55000

#Shorten TIME_WAIT

Reduce how long closed connections linger in TIME_WAIT. The registry value is the reliable form across Windows builds:

reg add "HKLM\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters" /v TcpTimedWaitDelay /t REG_DWORD /d 30 /f

#Verify

Confirm the new range took effect:

netsh int ipv4 show dynamicport tcp

The output should report the start port and number of ports you set. The TcpTimedWaitDelay change applies to new connections after the setting is written (a reboot guarantees it everywhere).

#Linux equivalent

On Linux, set the same two levers (and enable safe TIME_WAIT socket reuse) in /etc/sysctl.conf, then reload. This requires root.

# /etc/sysctl.conf
net.ipv4.ip_local_port_range = 10000 65535
net.ipv4.tcp_fin_timeout = 30
net.ipv4.tcp_tw_reuse = 1

sysctl -p

ip_local_port_range widens the ephemeral pool, tcp_fin_timeout shortens how long sockets sit in FIN-WAIT, and tcp_tw_reuse lets the kernel safely reuse a TIME_WAIT socket for a new outbound connection when it is safe to do so.

#Before / after comparison

The tuned values raise the per-second connection ceiling by both enlarging the port pool and recycling each port sooner:

#ColdProxy-side levers

OS tuning raises the ceiling, but the most effective fix is to open fewer connections in the first place. Reducing connection churn helps far more than widening the port range alone:

• Reuse connections. Use HTTP keep-alive and a pooled client (a requests.Session, an httpx client, a Node agent with keepAlive: true) instead of opening a fresh socket per request. One reused socket consumes one ephemeral port across many requests.
• Use sticky sessions where the workflow allows. Holding one exit IP for a multi-step flow lets the underlying connection stay open instead of re-dialing per request. See Sticky vs rotating sessions for when to pin an IP versus rotate.
• Cap concurrency to what the workload needs. A bounded worker pool with sensible request pacing collects public data just as fast while generating a fraction of the socket churn, and is gentler on the target site.

import requests

# One pooled session reuses sockets instead of one socket per request
session = requests.Session()
proxy = "http://USERNAME:PASSWORD@gw-2312.coldproxy.com:30000"
session.proxies = {"http": proxy, "https": proxy}

for _ in range(1000):
    session.get("https://api.vipv6proxy.com/api/checker/my-ip", timeout=30)