What is a rotating proxy?
Definition
A proxy gateway that hands out a different exit address over time, per new connection or on a timer, while your client keeps one endpoint.
You point your client at one gateway hostname and port, and the provider decides which exit each connection leaves through. Nothing in your code changes when the address does. That is the appeal. It also hides the detail that trips people up: a gateway can only pick a new exit when it sees something new, and for HTTPS the only new thing it ever sees is a connection.
Rotation happens per tunnel, not per request
An HTTPS request through an HTTP proxy starts with a CONNECT. The proxy opens a TCP connection to the site and from then on relays encrypted bytes. Every request your client sends on that connection is inside TLS, unreadable to the gateway, and leaves through whichever exit was chosen when the tunnel opened. Many clients reuse a connection whenever they can: curl does within one command, and so does any library that keeps a connection pool. On a gateway that rotates per connection, “a new IP on every request” quietly becomes “a new IP on every new connection”.
We measured how often clients open a new tunnel, on 21 October 2026, with a small logging proxy on 127.0.0.1 that counts the CONNECT requests it receives. Each client fetched https://example.com/ three times, using curl 8.7.1 and Python 3.15.0.
| Client and pattern | HTTPS requests sent | CONNECT tunnels the proxy saw |
|---|---|---|
| curl, three separate runs | 3 | 3 |
| curl, three URLs in one command | 3 | 1 |
| Python urllib.request, three opener.open() calls | 3 | 3 |
| Python http.client, one connection, three requests | 3 | 1 |
curl reports the reuse itself. With -w "%{num_connects}", which the manual defines as the “Number of new connects made in the recent transfer”, the three URLs in one command printed 1, then 0, then 0:
curl -s -x http://127.0.0.1:8899 -o /dev/null -o /dev/null -o /dev/null \
-w "%{num_connects}\n" https://example.com/ https://example.com/ https://example.com/
The second and third requests rode the first tunnel, and on a per-connection gateway all three would share one exit address. The Python rows came from this script, standard library only, shown without its print lines:
import http.client, urllib.request
PROXY_HOST, PROXY_PORT = "127.0.0.1", 8899
# urllib: each call opens its own connection, so its own CONNECT
opener = urllib.request.build_opener(
urllib.request.ProxyHandler({"https": f"http://{PROXY_HOST}:{PROXY_PORT}"}))
for _ in range(3):
opener.open("https://example.com/").read()
# http.client: tunnel once, then three requests inside it
c = http.client.HTTPSConnection(PROXY_HOST, PROXY_PORT)
c.set_tunnel("example.com", 443)
for _ in range(3):
c.request("GET", "/")
c.getresponse().read()
c.close()
Two rules come out of it. If every request must leave from a different address, open a new connection for each one: a fresh process, a fresh session object, or keep-alive switched off in your HTTP library. If you need the opposite, one address across a multi-step flow, connection reuse is not a guarantee either, because clients open new connections when a pool drains or a server closes one. Ask for an explicit sticky session instead.
Plain http:// URLs behave differently. The client sends each request to the gateway in full, so the gateway can read it and could switch exits between requests even on one client connection. Whether it does is a provider setting, and worth testing rather than assuming.
The modes on offer
Gateways sold as rotating generally offer some mix of three behaviours. Per-connection rotation is the one measured above. Timed rotation keeps the same exit for a set number of minutes and then moves. On-demand rotation ties the exit to a session label you choose, and changing the label is how you ask for a new address. They are selected through the username or the port you connect to, and the syntax differs between providers, so your code keeps one gateway address and changes only the credentials. Behind the gateway is a proxy pool, and the arrangement as a whole is what the trade calls a backconnect proxy. Choosing between the modes, and the cost of getting it wrong, is the subject of Rotating vs sticky sessions.
What rotation does not fix
Rotation spreads volume across addresses. That helps against per-address rate limits and the 429 responses they produce. It does nothing about what stays constant across addresses: the TLS handshake, the header set, the cookie jar. An address that changes on every request while the same session cookie keeps arriving is itself an anomaly a site can see. And when a site classifies a whole network range rather than single addresses, rotating within that range changes nothing. The 403 vs 407 vs 429 guide shows how to tell which of those you are hitting from the responses alone, and the curl guide shows how to confirm the exit actually changed.