How many concurrent connections can a rotating proxy handle?

Rotating proxy concurrent connections depend on plan limits, open sockets and target rules. Set worker caps, test capacity and measure useful throughput.

A rotating proxy handles concurrent connections up to the provider's enforced limit, but rotation alone does not establish that limit or promise usable throughput. Your practical ceiling also depends on how connections are counted, how long requests occupy them, and what the destination permits. This guide explains how to size workers, test capacity, and separate a proxy connection limit from a scraping bottleneck.

TL;DR

  • Rotating proxy concurrent connections are a connection limit, not an exit-IP count or a promised requests-per-second figure.
  • Python workers need explicit connection caps; adding tasks alone does not establish usable capacity.
  • Measure completed, valid responses alongside latency, timeouts, and destination rate limits.
  • Sticky sessions preserve exit identity temporarily; they do not reserve extra connection capacity.

As many as the plan's connection limit allows, if the workload can use them

A rotating proxy can handle only the simultaneous connections its service permits and your workload can sustain. There is no universal connection count attached to the word “rotating.” Get the limit and its scope before sizing your client.

A connection allowance is not necessarily a worker allowance. A browser worker can open several connections, while an asynchronous task can spend time waiting without holding a network connection. Protocol behavior and connection reuse also affect the relationship.

Before comparing plans, establish these definitions:

QuantityWhat it measuresBest forLimitation
Concurrent connectionsConnections open at the same timeEnforcing a network resource ceilingDoes not establish completed requests per second
In-flight requestsRequests started but not finishedControlling application workloadDoes not always equal open connections
Worker countTasks or processes allowed to work simultaneouslyScheduling jobsOne worker can create several connections
Request rateRequests started or completed per time intervalControlling destination loadDoes not describe connection occupancy
Exit-IP countDistinct addresses used as exitsMeasuring address distributionDoes not establish concurrency capacity

Use the aiohttp high-concurrency scraping workflow when implementing application-level controls. Keep the provider's connection accounting separate from your task scheduler.

A connection limit is not a usable-work measurement

A connection limit tells you how much simultaneous network activity the service permits. It does not tell you whether the resulting responses contain usable data. A busy scraper can consume its allowance while completing little useful work.

Treat capacity planning as an end-to-end measurement problem. The proxy gateway, your client, and the destination each impose constraints. Raising a setting in one place does not remove a constraint elsewhere.

The useful target is completed, validated work within the destination's permitted access rules, not the largest possible task count. Keep authentication failures, transport failures, rate-limit responses, and parsing failures separate. Each points to a different corrective action.

What does a connection allowance actually include?

Ask whether the provider counts connections per account, credential, gateway, or another scope. Then establish whether open idle connections count. Those details determine whether separate jobs compete for the same allowance.

For HTTPS over an HTTP proxy, a client commonly creates a CONNECT tunnel before exchanging encrypted traffic with the destination. That tunnel occupies a proxy connection while it remains open. Finishing a response does not necessarily close it if the client retains the connection for reuse.

This creates a practical distinction: your application can report no active requests while still retaining open pooled connections. Conversely, scheduled tasks can wait for a client-side connection slot without creating additional proxy traffic.

Before deployment, get explicit answers to these questions:

  • What event starts and ends a counted connection?
  • Does the allowance apply across all credentials and projects?
  • Do idle keep-alive connections consume the allowance?
  • What happens when the limit is reached: queuing, rejection, or disconnection?
  • Is request rate controlled separately from concurrent connections?

Do not infer these answers from a dashboard label. Translate the documented rules into client settings and verify the behavior with a controlled workload.

Why usable concurrency varies

The same connection allowance can produce different throughput across workloads. The difference comes from what occupies each connection and what happens after the destination responds.

  • Response duration: Slow responses occupy request slots longer. Increasing concurrency does not make an individual response finish sooner.
  • Payload size: Large responses keep connections busy while bytes transfer. Measure completed downloads rather than response headers alone.
  • Connection reuse: Retaining connections reduces repeated setup work, but retained connections also need to fit the service's accounting rules.
  • Destination restrictions: Rate limits and access controls can reject traffic even when the proxy still has connection capacity.
  • Client resources: Socket limits, CPU work, memory pressure, and blocking code can stop the client from using its configured allowance.
  • Retries and timeouts: Overlapping retries add load. Long timeouts retain occupied slots during failures.

Change one factor at a time during testing. If concurrency and retry behavior change together, you lose the ability to identify what caused the result.

How do you test the practical connection ceiling?

Use a destination you control or have permission to test. A load test against an unrelated public website is not a valid substitute for an authorized capacity test.

For a capacity review, keep the request mix, response validation, timeout policy, and test destination consistent. A different page size or authentication flow changes the workload, even when the worker count stays the same.

  1. Validate connectivity. Confirm that a request passes through the intended proxy and returns the expected response. Fix authentication and routing errors before increasing load.
  2. Set explicit caps. Limit both application workers and client connections. Keep the caps within the provider's documented allowance.
  3. Record a baseline. Measure completed responses, valid results, latency, timeout counts, and status codes at the initial setting.
  4. Increase gradually. Raise the cap in controlled steps without changing payloads or retry rules. Record each configuration with its results.
  5. Identify saturation. Look for throughput flattening while latency, failures, or queued work increase. Separate provider rejections from destination responses.
  6. Choose the operating point. Use a setting that meets the job's requirements without depending on the most aggressive test result. Retest when the workload changes.

The highest configured concurrency is not the highest useful concurrency. Select the operating point from validated completions, not from a task counter.

How do you cap Python requests explicitly?

The following example uses aiohttp with a fixed worker queue and an explicit connector limit. It makes no throughput promise. Supply a proxy endpoint and an authorized test destination through environment variables.

Install the dependency in your Python environment:

python -m pip install aiohttp

Save this as capacity_check.py:

import asyncio
import os
from collections import Counter
from time import perf_counter

import aiohttp

PROXY = os.environ['PROXY_URL']
TARGET = os.environ['TEST_URL']
WORKERS = int(os.environ['WORKERS'])
REQUESTS = int(os.environ['REQUESTS'])
TIMEOUT_SECONDS = float(os.environ['TIMEOUT_SECONDS'])

async def main():
    if WORKERS < 1 or REQUESTS < 1 or TIMEOUT_SECONDS <= 0:
        raise ValueError('Use positive configuration values')

    queue = asyncio.Queue()
    for _ in range(REQUESTS):
        queue.put_nowait(TARGET)

    results = Counter()
    connector = aiohttp.TCPConnector(limit=WORKERS)
    timeout = aiohttp.ClientTimeout(total=TIMEOUT_SECONDS)
    started = perf_counter()

    async with aiohttp.ClientSession(
        connector=connector, timeout=timeout
    ) as session:
        async def worker():
            while True:
                try:
                    url = queue.get_nowait()
                except asyncio.QueueEmpty:
                    return
                try:
                    async with session.get(
                        url, proxy=PROXY, allow_redirects=False
                    ) as response:
                        await response.read()
                        results[f'http_{response.status}'] += 1
                except asyncio.TimeoutError:
                    results['timeout'] += 1
                except aiohttp.ClientError:
                    results['client_error'] += 1
                finally:
                    queue.task_done()

        await asyncio.gather(
            *(worker() for _ in range(min(WORKERS, REQUESTS)))
        )

    elapsed = perf_counter() - started
    print(dict(results))
    print(f'elapsed_seconds={elapsed:.3f}')

asyncio.run(main())

Set PROXY_URL, TEST_URL, WORKERS, REQUESTS, and TIMEOUT_SECONDS in your environment, then run:

python capacity_check.py

Use the HTTP proxy form of your endpoint for this example. SOCKS requires a compatible connector and different setup; changing the URL scheme alone is not enough for this implementation.

The script reads each response body before releasing its request slot. It disables redirects so a redirect response is visible instead of silently becoming another request. It also omits automatic retries, which keeps the initial connection test easier to interpret.

The status counts are transport observations, not proof of usable data. Add content validation for your workload, such as an expected field or page marker. A successful HTTP status can still accompany an unexpected page.

For a production test, also collect per-request durations and your provider's connection telemetry. The connector cap controls this client's pool, not every process using the same account. Keep proxy credentials out of logs and source control.

Does rotation give you more concurrent connections?

Rotation changes exit selection according to the service's rules. It does not, by itself, increase the connection allowance. Sending traffic through different exit addresses is different from opening more simultaneous connections.

A distinct-IP count is therefore the wrong denominator for sizing workers. Establish the permitted connection count first, then measure how the exits behave under the intended workload. Do not assume each new request receives a unique address.

For procurement, ask for connection scope and rotation behavior as separate specifications. You need both, but they answer different questions.

Do sticky sessions reduce available concurrency?

Sticky sessions keep requests associated with an exit identity according to the provider's session rules. They do not inherently establish a new connection allowance. A session identifier and a network connection are different objects.

A client can make several requests under the same session identity, but whether those requests share or open connections depends on the client, protocol, and service. Keep session routing separate from your connection limiter.

Node4 Rotating Unmetered is best for teams that want a rotating proxy product sold by concurrent connections rather than gigabytes. Its connection units are literal: 250 connections means neither 250 GB nor 250 IPs. Sticky sessions on Node4's rotating gateway hold one exit for up to 30 minutes from first assignment, not from the latest request; that ceiling is a constraint to account for in longer workflows.

Those product rules do not establish the request rate your destination will accept. Test the workload and confirm the applicable connection allowance before scheduling production jobs.

What should you change when more workers stop helping?

Start with the failure category, not another increase in concurrency. A proxy authentication error calls for a credential check. A destination rate-limit response calls for lower request pressure and compliance with the destination's retry instructions.

If latency rises while completed work stays flat, inspect connection queues and client resource usage. If downloads occupy slots for longer, inspect payload size and transfer duration. If responses arrive quickly but fail validation, investigate content and access behavior rather than celebrating the request rate.

Retries need their own limit. Schedule retry attempts through the same concurrency controls as initial requests, with bounded attempts and an explicit backoff policy. Otherwise a failure burst becomes extra traffic precisely when the system is already struggling.

For agencies and data teams sharing an account, coordinate limits across projects. Independent per-process caps do not create an account-wide cap. Use a shared dispatcher or another centrally enforced budget when jobs draw from the same allowance.

FAQ

How many rotating proxy concurrent connections do I need?

You need enough concurrent connections to meet your validated throughput target without exceeding the provider's allowance or destination rules. Measure your actual request duration, connection occupancy, and successful output before choosing the cap.

Does a rotating proxy give every request a different IP?

A rotating proxy does not guarantee a different IP for every request unless the service explicitly provides that behavior. Rotation policy and sticky-session settings determine exit selection.

Are concurrent connections the same as requests per second?

Concurrent connections are not requests per second. Concurrency describes simultaneous connections, while request rate describes activity over a time interval.

Can one browser worker use multiple proxy connections?

One browser worker can use multiple proxy connections when it loads page resources or maintains parallel network activity. Count observed connections rather than assuming one worker equals one connection.

Does an unmetered connection plan mean uncapped concurrent connections?

An unmetered bandwidth allowance does not establish an uncapped connection limit. Confirm the connection cap, its scope, and any separate usage restrictions before setting worker counts.

Should I increase concurrency when requests time out?

Do not increase concurrency simply because requests time out. Identify whether the delay comes from client queuing, the proxy, or the destination, then change the relevant control.

Can several scraping projects share a connection allowance?

Several projects share a connection allowance when the provider applies that allowance at their common account or credential scope. Coordinate their combined usage rather than setting each project to the full cap.

Close the client and verify the pool actually drained

An empty application queue does not prove that every proxy connection has closed. Connection pools can retain idle connections for reuse, which matters when the provider counts those connections against your allowance.

Before signing off a capacity test, close the client cleanly and verify that connection usage returns to its expected resting state. That final check distinguishes a repeatable workload from a test that leaves capacity occupied after the work ends.