Softplorer Logo

Proxy Guide

Proxy Setup for Scaling

Scaling a proxy-based operation surfaces constraints that low-volume testing never reveals. The constraints are predictable — and addressing them before they become critical is cheaper than addressing them after.

In practice

  • Provider concurrency limits cap throughput before pool size becomes relevant ✗
  • Pool depletion: per-IP block rate rises as the clean pool is exhausted ✗
  • Target-side rate limiting activates at volume that low-concurrency tests never reached ✗
  • Multiple provider accounts distribute concurrency ceiling and reduce single-provider risk ✔
  • Provider API rate limits throttle rotation requests at high concurrency ✔

Scaling reveals the constraints. Testing at production concurrency before deployment reveals them earlier and cheaper.

Overview

A scraping operation that runs successfully at 10 concurrent connections may fail at 500 for reasons that have nothing to do with proxy quality or target detection changes. The concurrency ceiling of the proxy account is a fixed limit that fails new connection attempts silently or with connection errors — not with block responses from the target. The target's volume-based detection activates above a total request rate threshold that low-concurrency testing never approached. The pool depletes when the clean IP subset is exhausted by the higher concurrency's request rate.

These are scaling-specific constraints. They are foreseeable, measurable, and addressable — but only if they're tested for before production deployment rather than discovered during it.

How to think about it

Provider concurrency ceiling: the maximum simultaneous connections the proxy account supports. This is a hard limit — connections above it are rejected by the gateway, not routed through the pool. Most providers publish account-tier concurrency limits. The production workload's peak simultaneous connection count must fit within the account's concurrency limit with buffer for retry connections and connection overlap during request handoff. Exceeding the ceiling produces connection errors that look like proxy failures but are account configuration issues.

Pool depletion ceiling: the point at which the workload's request rate, combined with the target's IP scoring, exhausts the clean IP subset of the pool. Each IP from the pool receives requests, accumulates block signals from the target, and eventually crosses the threshold where the target blocks it. The rate at which this happens is a function of request rate per IP and the target's detection sensitivity. At high concurrency with per-request rotation, the pool cycles through IPs faster — which means the clean pool depletes faster unless the provider actively refreshes it.

Target volume ceiling: the point at which the target's detection activates on total request volume across all IPs, not per-IP volume. Some targets don't just rate-limit by IP — they monitor total traffic patterns from a source ASN or subnet and apply challenges or blocks when aggregate volume from a provider's pool exceeds a threshold. Distributing requests across more IPs doesn't help against this ceiling because the detection is operating above the IP level. The fix is reducing total request rate, distributing across multiple providers' IP blocks, or changing the behavioral pattern of requests.

How it works

Multiple provider accounts extend the concurrency ceiling beyond any single account's limit and reduce single-provider risk — if one provider's pool degrades on the target, traffic can be shifted to another provider without a pipeline outage. Load balancing across providers requires a proxy layer that treats multiple gateway endpoints as a pool: routes connections round-robin or weighted by observed success rate across endpoints, and fails over automatically when one endpoint's success rate drops below threshold.

Provider diversity also addresses the target volume ceiling in cases where detection is subnet-range-specific rather than total-volume-specific. Traffic from Provider A's residential pool exits through Provider A's enrolled device IP ranges. Traffic from Provider B exits through different residential IP ranges. The target observes aggregate volume from two distinct IP populations rather than one concentrated source. This doesn't help against detection that monitors total volume from a source ASN type, but it helps against detection that monitors subnet-level traffic concentration.

Provider API rate limits on gateway requests become a constraint at high concurrency. The gateway endpoint receives connection requests; if the provider rate-limits gateway connections, new connection requests above the limit are queued or rejected. At high concurrency with rapid connection turnover, gateway request rate can exceed provider-side limits without the account's concurrency limit being the binding constraint. Verify provider API rate limits at the concurrency levels required before scaling — this is a separate limit from the concurrency ceiling and is less commonly disclosed.

Where it breaks

The retry layer amplifies problems at scale. A retry rate that's acceptable at low volume — 10% of requests retried once — becomes a significant load amplifier at high concurrency. If 10,000 requests per minute result in 1,000 retries, the effective request volume is 11,000 per minute. If retries have a higher block rate than initial requests (because they often occur when the IP or session is already degraded), retry loops that don't resolve failures amplify load against degraded endpoints without improving yield.

Session management becomes complex at scale with sticky sessions. Each concurrent sticky session holds an IP from the pool unavailable for rotation — effectively reducing the rotating pool's available depth by the number of active sticky sessions. At high concurrent session counts, the available pool for new sessions shrinks. The session layer needs to enforce a maximum concurrent sticky session count that stays within the pool's depth capacity for the target.

Monitoring lag becomes operationally significant at scale. A 5-minute monitoring interval that's acceptable at low volume misses a degradation event that exhausts the pool in 3 minutes at high volume. High-volume operations require higher-frequency monitoring — 60-second intervals or per-100-request sampling — to catch degradation before it affects yield for an entire scraping run.

In context

The pre-scale test protocol: run the workload at the target production concurrency for the target production duration. Not 10% of concurrency for 10% of time — the full production concurrency for at least one complete scraping cycle. This surfaces the provider's concurrency ceiling, the pool depletion rate at production volume, the target's volume-triggered detection if it exists, and the retry amplification pattern under production load. These variables cannot be extrapolated from low-concurrency tests.

Load testing at scale also determines the correct plan tier and concurrency allocation before production deployment — which is cheaper than discovering the account limit during a time-critical production run and needing to upgrade and migrate urgently. Most proxy providers allow short-term plan upgrades for load testing; using this capability before deployment is operationally prudent.

Cost modeling at scale before commitment: high-volume operations have high per-GB consumption. Calculate the projected monthly bandwidth at production concurrency and volume against the provider's per-GB rate and any overage pricing. For residential proxies, the bandwidth at production volume may exceed the plan's included allocation significantly — and overage rates on bandwidth above the plan allocation are typically higher than the base rate. Size the plan on peak consumption, not average.

Choose your path

Before scaling from test volume to production volume, verify each constraint independently. Each constraint has a different fix; discovering all of them simultaneously in production is the most expensive way to find them.

  • Verify provider concurrency limit exceeds peak simultaneous connection count plus 20% buffer
  • Run pool depletion test: observe block rate over a full-length run at production concurrency
  • Identify whether target has volume-triggered detection: compare block rate at 10x vs 1x concurrency
  • Calculate retry amplification: estimate retry rate at production volume and its effect on effective request rate
  • Size the proxy plan on peak bandwidth, not average — model monthly cost at production volume before committing
Scraping pipeline architecture — the component model that supports scalingIP reputation degradation — the pool depletion pattern at high volumeProxy providers for scraping — evaluated by concurrency limits and pool depth