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 HTTPS CONNECT on

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 sentOf which proxiedDirect baselineExpected refusals
1: 2026-10-30, 06:23 to 07:061,1061,041605
2: 2026-10-30, 14:00 to 14:421,1061,041605
3: 2026-10-30, 22:00 to 22:421,1061,041605
4: 2026-11-10 23:42 to 2026-11-11 00:241,1061,041605
All four4,4244,16424020

Each window ran the same fixed plan, in the same order, with the same client code:

PhaseWhatPer window
DirectNo proxy, client to target, 30 HTTP + 30 HTTPS60
New tunnelHTTPS, a new CONNECT tunnel per request, no targeting300
Tunnel reuseHTTPS, 20 tunnels x 10 requests200
HTTP keep-alivePlain HTTP, 10 kept-alive client connections x 10 requests100
HTTP new connectionPlain HTTP, a new client connection per request50
SOCKS5A new SOCKS5 connection per request, plain HTTP inside100
Country-country-us, -country-it, -country-es 30 each; -country-de 595
Sticky7 sessions probed for 40 minutes, alongside the phases above201

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:

WindowRequestsUnique exitsRepeated pairsMost uses of one exitSame exit twice in a rowDistinct /24s
130029552039
230029552039
3300291103039
430029462039
Expected under a uniform draw (inference)300295.54.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)UnitsRequestsResult
HTTPS, one tunnel reused for 10 requests80 tunnels80080 of 80 tunnels kept a single exit
Plain HTTP, one kept-alive client connection for 10 requests40 connections4000 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)SessionsChecksLast check on first exitFirst check on new exitExit changes
Sparse, HTTPS122281,770 s1,815 s1 each
Active, HTTPS124921,800 s1,860 s1 each
SOCKS54841,799.6 to 1,800 s1,919.5 to 1,920 s1 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)RequestsExit in requested countryRepeated pairs by windowExpected repeats by chance (inference)
-country-us1201201 (0, 0, 1, 0)about 0.05 per window
-country-it1201204 (2, 1, 0, 1)about 0.9 per window
-country-es1201205 (1, 1, 3, 0)about 0.9 per window
-country-de (no exits)20refused 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.

PathW1 total p50W2 total p50W3 total p50W1-3: total p50W1-3: total p90W1-3: n
Direct HTTPS, no proxy22622822822723590
HTTPS, new tunnel, US exit290286352293488814
HTTPS, new tunnel, Italy/Spain exit9389561,0069651,13586
HTTPS, request on an open tunnel72738974188540
Direct HTTP, no proxy15014015115015690
Plain HTTP, new connection, US exit147148176150259134
Plain HTTP, kept-alive, US exit7678897895249
SOCKS5, new connection, US exit351352428362499270

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:

WindowUS new tunnelsPredicted missesHandshake p50, predicted hit (ms)Handshake p50, predicted miss (ms)Slow handshakesOf which predicted misses
127651721595250
226841711564441
327053851696250
4267405.7894238

"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 timeout0
Proxy refused (407, 5xx)0
TLS error0
Target timeout or closed0
Wrong or missing response body, nonce mismatch0
Retries sent0
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.

with dated amendments (including the one on chronology).

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.

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.

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 3 regenerates 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.