Rotating vs. Sticky Proxies: Choose the Right Session Strategy
Learn when to rotate IPs and when to preserve a sticky session, with request timelines, an exit-IP diagnostic and workflow-based selection criteria.

A rotating proxy changes the exit route according to a rotation policy. A sticky proxy session asks the provider to keep a route for a bounded period. The useful question is not which sounds more powerful: it is where your application can safely start a new network context. A collection of unrelated pages and a three-step storefront test can need different policies, even when they use the same residential network.
1. Separate the three meanings of session
Proxy session describes the provider's routing policy: how requests are associated with an exit and when that association expires or changes. Rotating and sticky are operating modes, not separate IP ownership categories. A residential product may offer both; a static ISP product emphasizes an assigned address. Read the actual endpoint contract rather than assuming the product name defines every behavior.
Application session describes state held by the website and client: cookies, login tokens, cart contents or a pagination cursor. RFC 6265 defines HTTP cookie state management. Keeping an IP does not preserve an expired cookie, and changing an IP does not automatically clear cookies. Whether the application associates a session with network signals is application-specific.
Connection reuse concerns transport. A client can reuse an established connection to avoid repeated setup. Python's Requests Session documentation describes cookie persistence and connection pooling; it does not promise a fixed proxy exit. A Session object therefore cannot turn a rotating endpoint into a sticky one.
This distinction changes debugging. Missing cookies require client-state checks. An unexpected exit requires provider-routing checks. A slow connection needs timing and transport investigation. Changing all three at once makes the next successful request difficult to explain.
2. Read two request timelines before choosing a mode
Timeline A — independent observations
Imagine three approved public product checks. Each URL stands alone, uses the same intended market and does not require a token from the previous response. Rotation between these jobs is a reasonable starting point. Keep the market settings constant: an IP change should not accidentally turn a US-price sample into a different storefront.
Job 1 /product/alpha → exit A → record 1
Job 2 /product/beta → exit B → record 2
Job 3 /product/gamma → exit C → record 3
Boundary: each independent job may choose a route.
A, B and C are illustrative labels, not a promise of three unique addresses. A rotating pool can select an address already seen, and some products rotate per connection or on a timer. Verify the documented trigger and observe the actual exit before concluding that rotation is broken.
Timeline B — one stateful sequence
Now consider an authorized storefront test: select a region, open a catalog and follow a cursor to the next page. If the application needs a consistent context, use one sticky route and one isolated cookie jar for that sequence. Record the market and cursor together so a retry does not silently combine different views.
Workflow 7 / same cookie jar / intended market US
select region → exit A → region cookie
catalog page 1 → exit A → cursor K
catalog page 2 → exit A → validated result
finish → release this workflow's context
Boundary: rotate after the sequence, not between its dependent steps.
Not every paginated site binds its cursor to an IP. This is an engineering choice to test, not a universal requirement. Arcvenza's residential route guidance likewise distinguishes independent requests from multi-step sequences.
3. Choose the rotation boundary and a realistic lifetime
Define the lifetime from the whole sequence, including navigation, waiting and allowed retries. An illustrative job with 40 requests averaging 0.8 seconds, 20 seconds of pacing and a 15-second retry budget needs about 67 seconds before any additional margin. This arithmetic is a planning example, not an Arcvenza performance measurement. Variable response times mean a pilot's duration distribution is more useful than one average.
Check both maximum session duration and idle timeout. A route may expire while a worker waits on another task, and the underlying residential peer may disconnect sooner. Specify what happens next: receive an error, accept a replacement route or restart from a checkpoint. Provider behavior differs: Oxylabs' session-control documentation illustrates the distinction between replacement-friendly sessions and strict single-IP binding. Those controls are vendor-specific, not Arcvenza parameters.
For parallel work, separate scheduling from routing. Ten workers sharing one sticky identity are still ten workers sending traffic through the same context. Use a destination-level request budget as well as workflow ownership; additional sessions do not automatically increase the rate a source permits.
4. Verify the exit with a small, observable experiment
Configure the desired mode in your provider's dashboard and copy the complete issued proxy URL. Supply it to the process as ARC_PROXY_URL through your local secret configuration; do not paste credentials into the article, source control or logs. Install Requests with python -m pip install requests. SOCKS endpoints additionally require the requests[socks] extra.
Set PROXY_MODE to sticky or rotating, save the following file and run python probe_sessions.py. PROXY_MODE only changes the diagnostic's expectation; it does not configure the provider. The program samples the ipify IP-echo API six times, one second apart, and stops on an unexpected response. It uses explicit proxies, keeps TLS verification enabled and performs no automatic retry.
"""Sample an endpoint's observed egress; this is not a performance benchmark."""
import ipaddress
import json
import os
import time
from urllib.parse import urlsplit
import requests
def main():
proxy = os.environ["ARC_PROXY_URL"]
mode = os.environ.get("PROXY_MODE", "sticky")
if mode not in {"sticky", "rotating"}:
raise SystemExit("PROXY_MODE must be sticky or rotating")
parsed = urlsplit(proxy)
if parsed.scheme not in {"http", "https", "socks5", "socks5h"} or not parsed.hostname:
raise SystemExit("Use the complete proxy URL issued by your provider")
seen, first_ip = set(), None
with requests.Session() as client:
client.trust_env = False
for sample in range(1, 7):
started = time.perf_counter()
try:
response = client.get(
"https://api.ipify.org?format=json",
proxies={"http": proxy, "https": proxy},
timeout=(5, 15),
allow_redirects=False,
)
except requests.RequestException as error:
raise SystemExit(f"Transport failure: {type(error).__name__}") from None
if response.status_code == 429:
wait = response.headers.get("Retry-After", "not supplied")
raise SystemExit(f"Rate limited; Retry-After: {wait}. Stop and review.")
if response.status_code != 200:
raise SystemExit(f"HTTP {response.status_code}; stop and inspect")
try:
observed = str(ipaddress.ip_address(response.json()["ip"]))
except (ValueError, KeyError, TypeError):
raise SystemExit("Invalid IP response; stop and inspect") from None
seen.add(observed)
print(json.dumps({
"sample": sample, "egress_ip": observed,
"elapsed_ms": round((time.perf_counter() - started) * 1000),
}))
if mode == "sticky" and first_ip is not None and observed != first_ip:
raise SystemExit("Egress changed inside this sticky probe")
first_ip = first_ip or observed
if sample < 6:
time.sleep(1)
print(json.dumps({"samples": 6, "unique_egress_ips": len(seen)}))
if __name__ == "__main__":
main()
A sticky sample returning A, A, A, A, A, A is consistent with continuity during this short observation. It does not establish an uptime guarantee, dedicated ownership or a full session lifetime. A rotating sample returning A, B, A, C, B, C demonstrates observed variation; repetition alone is not a failure. If all exits match, inspect the configured trigger, endpoint syntax and connection behavior before changing anything.
The elapsed time covers this client's complete request to the echo service. It is not isolated proxy latency, target-site performance or a statistically meaningful benchmark. The connect/read timeout tuple also is not a hard total execution deadline. For a longer test, repeat at permitted intervals across the intended lifetime and idle gaps, with an external job deadline. Store IP observations only in access-controlled diagnostic logs.
5. Diagnose a broken workflow before rotating again
Preserve a small evidence bundle: workflow ID, step, timestamp, configured mode, response status, elapsed time and validated output fields. Keep credentials and session tokens out of it. Where exit observations are available, remember an echo request is a separate request: on a rotating service, it does not prove which IP a subsequent target request used.
| Signal | Likely area to inspect | Next step |
|---|---|---|
| Exit changes during a sticky sequence | Session identifier, lifetime, idle timeout or peer loss | Pause dependent steps; verify state and restart from a safe checkpoint if required. |
| Exit is stable but the session disappears | Cookie jar, token expiry or application state | Inspect client state and the application's response before changing the route. |
| HTTP 407 | Proxy authentication or allocation | Check issued credentials, endpoint and allowlist; do not loop through exits. |
| HTTP 429 | Rate limiting by a server or intermediary | Honor applicable Retry-After guidance and reduce the affected request rate. |
| HTTP 200 with the wrong currency or region | Market configuration, cookies or content parsing | Reject the record until its business fields match the intended observation. |
| Timeout or 502 | Client, proxy or upstream availability | Locate the failing hop and bound any safe retry; inspect provider diagnostics. |
RFC 6585 defines 429 and allows a Retry-After header; it does not make rate limits exclusively IP-based. Treating every rate-limit response as a request for a fresh exit misses the server's actual instruction.
Retry design also depends on the operation. A failed read and an uncertain purchase or form submission have different consequences. HTTP Semantics, RFC 9110 explains idempotency and cautions against automatically retrying non-idempotent requests without knowing they are safe. Rotation is not a recovery plan for an operation that may already have completed.
6. Evaluate completed workflows, then choose the product
Compare policies using the same approved target set, market, client, concurrency and collection window. Repeat the comparison across representative periods. Change one meaningful variable at a time, and distinguish proxy-route failure from parser failure and application rejection. A short IP-echo test is a configuration check; the final decision belongs to the real workflow.
A scorecard that rewards useful output
- Workflow completion rate = workflows that reach a validated final state ÷ workflows started. Count a three-step sequence once, rather than treating its first two successful steps as a successful job.
- Continuity failures = workflows with an unexpected route change before their intended boundary. Measure only where you have reliable route evidence; do not infer this solely from HTTP errors.
- Cost per 1,000 accepted records = attributed collection cost ÷ accepted records × 1,000. State whether the numerator includes proxy traffic, compute, retries and operational work. If no records pass validation, report no usable yield rather than a misleading unit cost.
- Track p50/p95 workflow duration alongside valid-output coverage. A fast response with the wrong market or missing fields is not a useful win.
Choose Residential Proxies when geographic flexibility and selectable session behavior fit the job. Evaluate ISP Proxies when assigned endpoints and repeatable long-running identity matter more. For a broader network-type comparison, see Residential vs. ISP Proxies. Obtain exact session settings from the current dashboard or documentation; this article does not invent a gateway username format or promise a fixed sticky duration.
Can a sticky session still change IP?
Yes, depending on expiry, peer availability and the provider's failure policy. A label such as sticky is not enough to establish whether the connection fails or receives a replacement. Verify that behavior before a sequence depends on it.
Should every scraping request rotate?
No. Select the smallest independent unit of work that can safely acquire a new route. For some jobs that is one request; for others it is a whole sequence. Read the residential scraping guide for related collection design.
Will either mode guarantee access?
No. Destination rules, account permissions, request behavior and application controls still apply. Work with permitted sources and supported regions, and stop to review explicit access denials. The operational goal is a reproducible result with an explainable session policy.
Official Standards & Technical Documentation
Arcvenza — Residential location and session controls
Arcvenza — ISP endpoints and persistent sessions
Python Requests — Sessions, proxies and timeouts
IETF — HTTP State Management Mechanism (RFC 6265)
IETF — HTTP Semantics and idempotency (RFC 9110)
IETF — HTTP 429 and rate limiting (RFC 6585)

