How Node4 Rotating Datacenter Rotates: 4,424 Requests
Four test windows against our own echo server: when the exit changes, how long a sticky session holds, and what the gateway hop adds.
Measured on 2026-10-30 in three windows and repeated on 2026-11-10. Product: Node4 Rotating Datacenter. Target: an echo server we ran.
Short answer: on Node4 Rotating Datacenter the exit is chosen when a connection opens. Every new HTTPS CONNECT tunnel or SOCKS5 connection got its own exit, and every request down an open tunnel kept it. Plain HTTP through the proxy changed exit on every request, even on one kept-alive connection. A sticky session id held one exit until the 30-minute mark and then moved once, whether it was used every minute or barely at all.
We measured this on our own gateway with a script you can run yourself, across four windows on two days, and we kept every attempt. This is a behavior study of one product against one target we control. It does not tell you how any third-party website will treat these addresses.
What we tested, and what we did not
- Product: Rotating Datacenter, through
gw-rotating_datacenter.node4.io(HTTP proxy and HTTPSCONNECTon
port 8083, SOCKS5 on 1083), with an ordinary username and password credential on an internal test account.
- Target: a small echo server reachable only from the proxy exits and our client. It reports the source
address and port it saw, so the exit is measured, not inferred.
- Locations: in windows 1 to 3 the client ran on a cloud server in San Francisco and the target on a separate
cloud server in New York. In window 4 the client and the target ran on one server in New York, about 2 ms from the gateway.
- Not tested: whether any website accepts these exits, CAPTCHAs or blocking, throughput, high concurrency,
residential, Rotating Unmetered, static proxies, and other providers. This is not a provider comparison.
- Load: one or two connections at a time, at most two new connections per second. These are behavior
measurements, not a load test.
Windows and denominators
| Window (UTC) | Requests sent | Of which proxied | Direct baseline | Expected refusals |
|---|---|---|---|---|
| 1: 2026-10-30, 06:23 to 07:06 | 1,106 | 1,041 | 60 | 5 |
| 2: 2026-10-30, 14:00 to 14:42 | 1,106 | 1,041 | 60 | 5 |
| 3: 2026-10-30, 22:00 to 22:42 | 1,106 | 1,041 | 60 | 5 |
| 4: 2026-11-10 23:42 to 2026-11-11 00:24 | 1,106 | 1,041 | 60 | 5 |
| All four | 4,424 | 4,164 | 240 | 20 |
Each window ran the same fixed plan, in the same order, with the same client code:
| Phase | What | Per window |
|---|---|---|
| Direct | No proxy, client to target, 30 HTTP + 30 HTTPS | 60 |
| New tunnel | HTTPS, a new CONNECT tunnel per request, no targeting | 300 |
| Tunnel reuse | HTTPS, 20 tunnels x 10 requests | 200 |
| HTTP keep-alive | Plain HTTP, 10 kept-alive client connections x 10 requests | 100 |
| HTTP new connection | Plain HTTP, a new client connection per request | 50 |
| SOCKS5 | A new SOCKS5 connection per request, plain HTTP inside | 100 |
| Country | -country-us, -country-it, -country-es 30 each; -country-de 5 | 95 |
| Sticky | 7 sessions probed for 40 minutes, alongside the phases above | 201 |
Window 4 was a confirmation run: the unchanged plan, eleven days later, from a different client location. Its behavior results are reported with the other three below. Its latency is not comparable with windows 1 to 3, because client and target sat next to the gateway, so the latency section uses windows 1 to 3 only.
The method (sample sizes, success definitions, retry rule and stop conditions) is encoded in the test runner, which predates the data. The written plan was finalized during the first window, so this study was not preregistered. A few checks were added after seeing window 1 and are labeled as exploratory below; windows 2 to 4 then tested them with the same definitions.
Success has two levels. Transport success means the TCP connection to the gateway, the proxy handshake (CONNECT 200, or SOCKS5 reply 0), TLS where used, and a complete HTTP response all succeeded. Application success adds HTTP 200 from the echo, valid JSON, and the random nonce we sent echoed back unchanged. A failed attempt was to be retried once after 12 seconds, recorded separately, and never mixed into first-attempt figures.
Findings
1. Every new connection gets an independently chosen exit
Each window sent 300 HTTPS requests, each on its own new CONNECT tunnel:
| Window | Requests | Unique exits | Repeated pairs | Most uses of one exit | Same exit twice in a row | Distinct /24s |
|---|---|---|---|---|---|---|
| 1 | 300 | 295 | 5 | 2 | 0 | 39 |
| 2 | 300 | 295 | 5 | 2 | 0 | 39 |
| 3 | 300 | 291 | 10 | 3 | 0 | 39 |
| 4 | 300 | 294 | 6 | 2 | 0 | 39 |
| Expected under a uniform draw (inference) | 300 | 295.5 | 4.6 |
The comparison row is an inference. The gateway's pool held 9,857 eligible addresses when we snapshotted our inventory before window 1, and the same 9,857 before window 4; 300 independent uniform draws from that many are expected to give about 295.5 unique addresses and about 4.6 repeated pairs. Windows 1, 2 and 4 match that closely. Window 3 had 10 repeated pairs, more than chance predicts for one window (about a 2% chance under that model, about 7% that one of four windows would look like this). We did not re-snapshot the pool for window 3, so a smaller effective pool that evening is one possible reason; the data cannot separate that from chance. Across all four windows the repeat count within a window was 26 against about 18.2 expected.
The spread across the ten exit servers and three countries matched each server's share of the pool (chi-square goodness of fit on 1,200 new-tunnel requests: p = 0.99 by server, p = 0.56 by country; exploratory, see limitations). Across all 2,200 untargeted requests (HTTPS, plain HTTP and SOCKS5), 1,990 exits were in the United States, 117 in Italy and 93 in Spain, by our own address inventory.
What this means for you: a client that opens a new connection per request will see a different address almost every time, with an occasional repeat. With any random pool a repeat is a matter of probability.
2. A reused HTTPS tunnel keeps its exit; plain HTTP changes exit on every request
| Pattern (all four windows) | Units | Requests | Result |
|---|---|---|---|
| HTTPS, one tunnel reused for 10 requests | 80 tunnels | 800 | 80 of 80 tunnels kept a single exit |
| Plain HTTP, one kept-alive client connection for 10 requests | 40 connections | 400 | 0 of 360 back-to-back pairs shared an exit |
The echo server also saw each reused HTTPS tunnel as a single TCP connection. On plain HTTP the gateway picks an exit per request, so keeping your client connection to the gateway open does not pin the address.
Most HTTP libraries reuse connections by default, so an HTTPS scraper that "should be rotating" can send many requests through one exit. If you need a new address per HTTPS request, open a new connection per request (disable keep-alive or the connection pool for the proxied client). If you need one address for a short exchange, reusing one tunnel is the cheapest way to get it. The IP rotation guide covers the settings for common clients.
3. Sticky sessions held until the 30-minute mark, and use did not extend them
Each window opened seven sticky sessions by adding -session-<id> to the username, then checked the exit for 40 minutes, each check on a brand-new connection:
- three sparse sessions, checked at 0, 0.5, 1, 2, 5, 10, 15, 20, 25, 27, 28, 29 and 29.5 minutes, then at
30.25, 30.75, 31.5, 33, 35 and 40;
- three active sessions, checked every 60 seconds, to see whether continuous use stretches the window;
- one SOCKS5 session, checked every 2 minutes.
| Session type (x4 windows) | Sessions | Checks | Last check on first exit | First check on new exit | Exit changes |
|---|---|---|---|---|---|
| Sparse, HTTPS | 12 | 228 | 1,770 s | 1,815 s | 1 each |
| Active, HTTPS | 12 | 492 | 1,800 s | 1,860 s | 1 each |
| SOCKS5 | 4 | 84 | 1,799.6 to 1,800 s | 1,919.5 to 1,920 s | 1 each |
All 804 checks succeeded. In all 28 sessions the exit stayed the same through the last check before 30 minutes and changed exactly once afterwards; the new exit then held to the end of the 40 minutes. Window 4 matched the first three to the probe second. The active sessions, used every minute, changed on the same schedule as the sparse ones, so activity did not extend the window. The checks bound the change between 1,770 and 1,815 seconds for sparse sessions; they cannot show the exact second.
Over HTTPS the gateway reports what it did in an X-Node4-Sticky header on the CONNECT reply: opened when it assigns a new exit to the session, held when it reuses the pinned one. In every HTTPS session we saw opened on the first check and on the first check after the change, and held on every other check.
What this means for you: the sticky window on Rotating Datacenter is 30 minutes from first assignment. A login or checkout flow that finishes inside it keeps one address. For longer work, start a new session id before the window ends. Sticky vs rotating sessions explains the session syntax, and how long a rotating proxy keeps the same IP covers the wider question.
4. Country targeting kept to the requested country, and refused one it could not serve
| Requested (x4 windows) | Requests | Exit in requested country | Repeated pairs by window | Expected repeats by chance (inference) |
|---|---|---|---|---|
-country-us | 120 | 120 | 1 (0, 0, 1, 0) | about 0.05 per window |
-country-it | 120 | 120 | 4 (2, 1, 0, 1) | about 0.9 per window |
-country-es | 120 | 120 | 5 (1, 1, 3, 0) | about 0.9 per window |
-country-de (no exits) | 20 | refused with 502, 20 of 20 |
Exit country here is the country in our own address inventory, not a third-party geolocation database. Italy and Spain each draw from about 500 addresses, so short-run repeats are more likely there than in the US. -country-de was refused with a 502 and a message naming the problem rather than served from another country.
5. Latency: what the gateway hop costs
Windows 1 to 3 only. Medians in milliseconds, successful requests only. The client was in San Francisco and the target in New York, so roughly 70 ms of each step is the distance; the direct rows are the same requests with no proxy.
| Path | W1 total p50 | W2 total p50 | W3 total p50 | W1-3: total p50 | W1-3: total p90 | W1-3: n |
|---|---|---|---|---|---|---|
| Direct HTTPS, no proxy | 226 | 228 | 228 | 227 | 235 | 90 |
| HTTPS, new tunnel, US exit | 290 | 286 | 352 | 293 | 488 | 814 |
| HTTPS, new tunnel, Italy/Spain exit | 938 | 956 | 1,006 | 965 | 1,135 | 86 |
| HTTPS, request on an open tunnel | 72 | 73 | 89 | 74 | 188 | 540 |
| Direct HTTP, no proxy | 150 | 140 | 151 | 150 | 156 | 90 |
| Plain HTTP, new connection, US exit | 147 | 148 | 176 | 150 | 259 | 134 |
| Plain HTTP, kept-alive, US exit | 76 | 78 | 89 | 78 | 95 | 249 |
| SOCKS5, new connection, US exit | 351 | 352 | 428 | 362 | 499 | 270 |
Step by step, for a new HTTPS tunnel to a US exit (windows 1 to 3, medians): TCP to the gateway 68 ms, the CONNECT handshake 73 ms, TLS with the target through the tunnel 73 ms, first byte 72 ms. Over going direct, that is about one extra round trip for the CONNECT. A request on an already-open tunnel costs about the same as a request on a direct connection, which is the other reason connection reuse matters. European exits add a transatlantic round trip to every step here, because client and target were both in the US; a US-to-US job should use -country-us if latency matters. The open-tunnel p90 (188 ms) is pulled up mostly by the tunnels that happened to land on a European exit (36 of the 540 requests), and in window 3 by slower US requests.
Window 4 is not in this table because its client and target were both in New York, about 2 ms from the gateway, which removes the cross-country distance from every step. Its medians, for reference: direct HTTPS 2.5 ms, new HTTPS tunnel to a US exit 21 ms (of which the CONNECT handshake 5.9 ms), a request on an open tunnel 6.6 ms, SOCKS5 to a US exit 17.5 ms, and a new tunnel to an Italian or Spanish exit 643 ms.
Window 3 was slower on the client-to-gateway leg. TCP connect to all eight gateway entry points rose from a median of about 67 ms in windows 1 and 2 to about 81 ms in window 3, while the direct connection from the same client to the target stayed at 75 ms. Because that leg sits inside every proxied round trip, every proxied figure in window 3 moved up by roughly the same amount per round trip. In window 3, 32 of 771 proxied connections also took about 1.08 to 1.14 seconds to connect, spread across all eight entry points; none did in windows 1 or 2. A delay of just over one second fits one lost connection packet and a standard retransmit (inference). We cannot tell from this data where on the path that happened.
6. Why about one in five handshakes took an extra round trip
In windows 1 to 3, about one in five US-exit CONNECT handshakes took roughly one extra round trip (158 of 814 over 120 ms, spread across all eight gateway entry points and all eight US exit servers). We traced it to how the gateway checks a login.
What happens. Each gateway server keeps its own short-lived cache of successful logins. An entry lives 30 seconds from the moment it is filled, and using it does not extend it. The first request a server sees for your credential after its entry has expired waits for a login check before an exit is picked, which adds about 80 to 90 ms. Requests that find a live entry skip the check. The cache is per server, so with eight entry points behind the gateway hostname a client builds up to eight entries, one per server it reaches.
At the study's pace (one new connection about every 1.3 seconds, spread by DNS over eight servers) each server saw the credential every 6 to 10 seconds, so roughly one request in five arrived after an expiry. Replaying every request through that rule (exploratory: the model was built after windows 1 to 3) labels each one a predicted cache hit or miss before looking at its timing:
| Window | US new tunnels | Predicted misses | Handshake p50, predicted hit (ms) | Handshake p50, predicted miss (ms) | Slow handshakes | Of which predicted misses |
|---|---|---|---|---|---|---|
| 1 | 276 | 51 | 72 | 159 | 52 | 50 |
| 2 | 268 | 41 | 71 | 156 | 44 | 41 |
| 3 | 270 | 53 | 85 | 169 | 62 | 50 |
| 4 | 267 | 40 | 5.7 | 89 | 42 | 38 |
"Slow" here is more than 40 ms above that window's predicted-hit median. Window 4 was not used to build the rule, and it confirmed it: with the client next to the gateway a cache hit took 5.7 ms and a miss 89 ms, so the extra login check stood out cleanly.
A controlled test. After window 4 we pinned each of the eight gateway entry points in turn and sent new CONNECT tunnels on a fixed schedule: a first request (predicted miss), one 28 seconds later (predicted hit), one 32 seconds after the first (past the 30-second life, predicted miss) and one 35 seconds after the first (predicted hit). The prediction was written into each record before it was sent. Of 96 tunnels, 91 went to US exits: the 45 predicted hits took 4.5 to 19.6 ms (median 5.6) and the 46 predicted misses 82.0 to 125.6 ms (median 89). The two groups did not overlap. Moving the same request from 28 to 32 seconds after the fill turned a 5.5 ms handshake into an 87 ms one (US exits, medians).
The extra time is the same size on every protocol, because the check happens before the protocol matters: across all four windows the predicted-miss median was 86 ms slower than the predicted-hit median for HTTPS CONNECT, 85 ms for plain HTTP, 88 ms for SOCKS5 and 85 ms for sticky checks.
About 2% of US handshakes (21 of 1,081) were slow while predicted to hit the cache. Most of those in windows 1 to 3 were 320 to 670 ms, a different and rarer event, and in window 3 they coincide with the client-leg slowdown described above. We have not explained that remainder.
What this means for you: the login check is paid at most once per gateway server per 30 seconds for a credential in use, not once per request. A busy client mostly hits the cache: one opening ten new connections a second over eight servers would pay the extra round trip on roughly 8 of every 300 connections (inference from the rule above). A client that opens a connection only now and then pays it more often, because its entries expire between requests. Reusing a tunnel avoids the check entirely after the first request, as section 2 shows.
Version note, 2026-11-11. After these measurements we changed how the gateway refreshes a cached login: since 01:08 UTC on 2026-11-11, a credential in steady use is re-checked in the background shortly before its entry expires, so a request no longer waits for that check. Everything in this section describes the gateway as measured on 2026-10-30 and 2026-11-10, before the change. We have not measured the new behavior yet; a dated follow-up will be added here when we have, with the raw data alongside the original.
7. Reliability on this target
All 4,164 proxied requests (HTTPS, plain HTTP, SOCKS5, country-targeted and sticky) succeeded on the first attempt, at both the transport and the application level. No retries were triggered, and no stale kept-alive connection had to be reopened. The echo server's own logs independently recorded all 4,404 client-side successes (the 4,164 proxied plus 240 direct), each from the same source address the client reported.
| Failure category (all four windows) | Count |
|---|---|
| Gateway connect error or timeout | 0 |
| Proxy refused (407, 5xx) | 0 |
| TLS error | 0 |
| Target timeout or closed | 0 |
| Wrong or missing response body, nonce mismatch | 0 |
| Retries sent | 0 |
Expected refusal: -country-de (502) | 20 of 20 |
With 4,164 attempts and no failures, the 95% confidence interval for the share that succeed on this target is 99.9% to 100%: a failure level of about one in 1,400 could still have produced zero failures here. The figure describes our gateway reaching a cooperative echo server at low load on two days. It says nothing about how often a real website will accept these exits, which depends on the site.
8. Data used
Client-side proxied traffic was about 2.04 MB per window in windows 1 to 3 (TLS and proxy handshakes included), about 1,960 bytes per successful request. In window 4 it was 2.38 MB, about 2,284 bytes per request, because that window's test certificate was larger. Rotating Datacenter is metered per GB. For windows 1, 2 and 4 the account's metered usage came to 87 to 90% of what the client counted; we did not break down the difference. Real pages are far larger than this echo response, so data per useful page depends almost entirely on page size, not on the proxy hop. The Rotating Datacenter pricing page has the current per-GB rate.
Limitations
- Two days, four windows. 06:23, 14:00 and 22:00 UTC on 2026-10-30, and 23:42 UTC on 2026-11-10. That shows
the behavior repeated at four times of day, not that it holds every day or under heavy load.
- Two client set-ups, one target per set-up. San Francisco to New York in windows 1 to 3, New York to New York
in window 4. Your latency will differ with your location and your target's.
- An echo server is not a website. These results say nothing about blocking, CAPTCHAs or how any site treats
datacenter addresses. See whether datacenter proxies get blocked.
- Exit country is our own inventory record, not a third-party geolocation database. Commercial databases can
disagree with it for a given address.
- The uniform-draw and chi-square comparisons are inferences against pool snapshots taken before windows 1
and 4. The gateway deliberately weights away from servers whose uplinks are busy, so uneven spread in another window would not by itself mean anything is wrong.
- Pacing was gentle by design. At most two concurrent connections. Concurrency limits and throughput were not
measured.
- Not preregistered. The plan was finalized during window 1. The exploratory checks (chi-square, the region
split, the slow-handshake count) were added after seeing window 1, and the login-cache rule after windows 1 to 3; window 4 and the controlled test then checked the rule on data it had not seen.
Reproduce it
Everything is in the rotating-datacenter-gateway study folder of our examples repository on GitHub.
- Method: the study plan,
with dated amendments (including the one on chronology).
- Client: n4study_client.py,
Python standard library only. It opens raw sockets so each step (TCP, CONNECT or SOCKS5, TLS, first byte) is timed separately and the X-Node4-Sticky header is visible. The login-cache test is n4study_cacheprobe.py.
- Echo target: n4study_echo.py,
run on a server you control with its two ports opened only to the proxy exits and your client. The client pins the target certificate's SHA-256 fingerprint instead of using a certificate authority.
- Credential: any Rotating Datacenter username and password, in a JSON file with
username,password,
host, port and socks5_port.
- Raw data: every attempt as JSON lines,
failures and retries included (there were none), plus the target's own logs. Exit addresses and their /24s are replaced by keyed hashes whose key was discarded, so repeats, /24 counts and countries can be checked without the addresses being listed.
- Tables:
python summarize.py --windows 1 --windows 2 --windows 3regenerates every table in this article
for windows 1 to 3; python summarize.py --windows 4 --inventory inventory-window4.json does the same for window 4, and summarize_cacheprobe.py reproduces the controlled test.
If you want the same behavior on your own jobs, start with a Rotating Datacenter plan: open a new connection per request when you want a new address, and add -session-<id> when you want one address for up to 30 minutes.