IP Rotation: Why and How to Change Your Proxies

Request 1 → Proxy A (185.45.12.34) → Site sees 185.45.12.34
Request 2 → Proxy B (92.118.45.78) → Site sees 92.118.45.78
Request 3 → Proxy C (178.62.91.22) → Site sees 178.62.91.22
Request 4 → Proxy A (185.45.12.34) → Site sees 185.45.12.34

1. Bypassing Rate Limiting

Most sites limit the number of requests from a single IP per unit of time. For example, an API might allow only 100 requests per hour per IP. By rotating through 10 IPs, you can send 1,000 requests per hour by distributing the load.

2. Avoiding IP Bans During Scraping

When collecting large volumes of data (e-commerce scraping, price monitoring, contact gathering), frequent requests from one IP quickly lead to a ban. Rotation allows distributing requests so that each IP makes only a few requests per hour—like a regular user.

3. Bypassing Geo-blocks

Many services display different content or prices based on geolocation. Rotating proxies from different countries allows collecting data from all regions without physically being there.

4. Masking Automation

Security systems (Cloudflare, Akamai, PerimeterX) analyze behavioral patterns. If hundreds of requests come from one IP in a short time, it's a clear sign of a bot. Rotation helps create the illusion of multiple independent users.

5. Competitive Intelligence

Tracking competitor pricing, monitoring ad campaigns, analyzing SEO positions require frequent checks. IP rotation allows collecting this data discreetly, without attracting competitor attention.

6. Testing and Monitoring

Checking site availability from different regions, testing A/B experiments, monitoring SEO positions in various countries—all require using IP addresses from different locations.

1. Rate Limiting (Request Frequency Analysis)

Sites track the number of requests from a specific IP over a period of time. Typical thresholds are:

• Conservative Sites: 10-30 requests per minute
• Average Sites: 50-100 requests per minute
• API Services: 100-1000 requests per hour (often specified in documentation)

2. IP Reputation Analysis

There are extensive databases classifying IP addresses by type:

• Residential IP — Home Internet Service Providers (high reputation)
• Datacenter IP — Hosting company servers (suspicious)
• Mobile IP — Mobile operators (high reputation)
• Known proxy IP — Known proxy servers (often blocked)

3. Browser Fingerprinting

Even with IP rotation, security systems can link requests via a unique browser "fingerprint": screen resolution, installed fonts, plugins, WebGL fingerprint, Canvas fingerprint, Audio context fingerprint.

4. Behavioral Analysis

Modern anti-bot systems analyze behavior:

• Scroll speed
• Mouse movements
• Click patterns
• Time between actions
• Page visit sequence

5. TLS Fingerprinting

During an HTTPS connection, the server can determine the TLS version, cipher suites used, and extensions—this data forms a unique fingerprint that can be used for tracking even when the IP changes.

Typical Rotation Intervals:

• Every 5 minutes — for intensive scraping with high request frequency
• Every 10-15 minutes — standard mode for most tasks
• Every 30-60 minutes — for low-frequency request tasks
• Every 2-24 hours — for sticky sessions (maintaining a session for a set time)

✅ Advantages:

• Predictability — You know exactly when the IP will change
• Ease of Implementation — Simple to set up using timers
• Suitable for Sticky Sessions — Can maintain a session for a specific duration
• Even Distribution — Load is distributed evenly over time
• Easy to Scale — Can run multiple parallel sessions with different timers

❌ Disadvantages:

• Inefficiency with variable load — IP changes even if few requests are made
• Risk of exceeding limits — If many requests are sent in a short interval
• Predictable pattern — Advanced security systems can detect regularity
• Session loss — Authorization or context might be lost upon IP change

🎯 Best Suited For:

• Tasks with predictable load
• Long-term sessions (authorization, account management)
• Monitoring with fixed intervals
• Situations where IP stability over a period is important

10:00 - Proxy A → Price check (50 products)
10:30 - Proxy B → Price check (50 products)
11:00 - Proxy C → Price check (50 products)
11:30 - Proxy D → Price check (50 products)
12:00 - Proxy A → Price check (50 products)

Implementation Options:

1. Per-request rotation — a new IP for every request (the most aggressive strategy)
2. Burst rotation — switching IP after N requests (e.g., every 10 requests)
3. Adaptive rotation — switching IP upon receiving specific HTTP codes (429, 403, 503)
4. Session-based — switching IP when starting a new logical session

✅ Advantages:

• Maximum protection against rate limiting — each IP makes minimal requests
• Adaptability — rotation only occurs when necessary
• Efficient pool usage — IPs change only when needed
• Fast response to bans — can instantly switch IP upon error
• Ideal for scraping — every page is requested with a new IP

❌ Disadvantages:

• Inability to maintain session — constant IP switching breaks authorization
• Harder to debug — difficult to reproduce an issue with a specific IP
• Rapid pool exhaustion — intensive work can quickly use up all IPs
• More expensive — requires a larger proxy pool for effective operation
• Switching overhead — every IP change takes a fraction of a second

🎯 Best Suited For:

• Intensive scraping of large data volumes
• Bypassing strict rate limits
• One-off requests without the need to maintain state
• Scraping public pages without authorization
• Tasks where each request is independent of the previous one

Site Type	Recommended Request Count	Interval
Highly Protected (Banks, Social Media)	1-3 requests	5-10 sec between requests
E-commerce (Marketplaces)	5-10 requests	2-5 sec between requests
News Portals	10-20 requests	1-3 sec between requests
Public APIs	Depends on limits	According to documentation
Static Websites	20-50 requests	0.5-2 sec between requests

Random Rotation Options:

• Random time intervals — switching IP after random periods (e.g., between 3 and 15 minutes)
• Random request count — switching after a random number of requests (e.g., between 5 and 20)
• Random IP selection — the next IP from the pool is chosen randomly, not sequentially
• Weighted random — IPs with better reputation are used more frequently
• Jittered rotation — adding random delay to fixed intervals

✅ Advantages:

• Unpredictability — harder for security systems to detect a pattern
• Mimics real users — humans do not act with perfect regularity
• Flexibility — can be combined with other strategies
• Natural traffic pattern — more closely resembles organic traffic
• Harder to detect — even when analyzing large volumes of data

❌ Disadvantages:

• Harder to predict — difficult to estimate task completion speed
• Can be inefficient — if randomness results in overly frequent switching
• Complicates debugging — reproducing issues is harder due to randomness
• Requires a larger pool — to ensure even load distribution
• More complex to implement — requires a good randomness generation algorithm

🎯 Best Suited For:

• Bypassing advanced security systems (Cloudflare, Akamai)
• Long-term projects with high stealth requirements
• Competitive intelligence
• Scraping sites with behavioral analysis
• Tasks where maximum imitation of human behavior is required

Criterion	Time-based	Request-based	Random
Implementation Complexity	⭐ Easy	⭐⭐ Medium	⭐⭐⭐ Hard
Predictability	✅ High	⚠️ Medium	❌ Low
Rate Limit Evasion	⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐
Stealthiness	⭐⭐	⭐⭐⭐	⭐⭐⭐⭐⭐
Session Support	✅ Yes	❌ No	⚠️ Partial
Pool Usage Efficiency	⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐
Scraping Speed	⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐
Required Pool Size	Small-Medium	Large	Medium-Large
Ease of Debugging	✅ Easy	⚠️ Medium	❌ Hard
Cost	💰 Low	💰💰💰 High	💰💰 Medium

1. Social Media Management

When managing multiple Instagram, Facebook, or Twitter accounts, maintaining one IP throughout the session is necessary. Frequent IP changes during an authenticated session are a direct path to a ban.

Recommendation: Sticky session of 1-2 hours, one unique IP per account.

2. E-commerce and Shopping Carts

Adding items to a cart, placing an order, checkout process—all require session persistence. An IP change will result in losing the cart and needing to start over.

Recommendation: Sticky session of 30-60 minutes for the entire purchase cycle.

3. Form Filling and Registration

Multi-step forms, site registration, email verification—these processes require IP consistency. Changing the IP between steps can trigger suspicion or validation errors.

Recommendation: Sticky session of 10-30 minutes to complete the process.

4. Web Application Testing

E2E testing, automation with Selenium/Puppeteer, checking user scenarios—all require IP persistence to mimic real user experience.

Recommendation: Sticky session for the entire test duration (5-60 minutes).

5. Working with Authenticated APIs

Many APIs issue access tokens tied to the IP address. Changing the IP will invalidate the token, requiring re-authentication.

Recommendation: Sticky session for the token's lifetime (usually 1-24 hours).

import requests
from itertools import cycle

# List of proxies
proxies_list = [
    'http://user:pass@185.45.12.34:8000',
    'http://user:pass@92.118.45.78:8000',
    'http://user:pass@178.62.91.22:8000',
    'http://user:pass@45.89.234.56:8000'
]

# Create an infinite iterator
proxy_pool = cycle(proxies_list)

# Function to make a request
def make_request(url):
    proxy = next(proxy_pool)
    proxies = {
        'http': proxy,
        'https': proxy
    }

    try:
        response = requests.get(url, proxies=proxies, timeout=10)
        print(f"Success with {proxy}: {response.status_code}")
        return response
    except Exception as e:
        print(f"Error with {proxy}: {e}")
        return None

# Usage
urls = ['https://example.com/page1', 'https://example.com/page2']
for url in urls:
    make_request(url)
    # Each request uses the next proxy in the list

import requests
import random
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

class ProxyRotator:
    def __init__(self, proxies_list):
        self.proxies = proxies_list
        self.failed_proxies = set()

    def get_random_proxy(self):
        """Get a random working proxy"""
        available = [p for p in self.proxies if p not in self.failed_proxies]
        if not available:
            # If all proxies failed, reset the list
            self.failed_proxies.clear()
            available = self.proxies
        return random.choice(available)

    def make_request(self, url, max_retries=3):
        """Send request with automatic rotation upon errors"""
        session = requests.Session()

        # Configure retry strategy
        retry = Retry(
            total=max_retries,
            backoff_factor=0.5,
            status_forcelist=[500, 502, 503, 504]
        )
        adapter = HTTPAdapter(max_retries=retry)
        session.mount('http://', adapter)
        session.mount('https://', adapter)

        for attempt in range(max_retries):
            proxy = self.get_random_proxy()
            proxies = {'http': proxy, 'https': proxy}

            try:
                response = session.get(url, proxies=proxies, timeout=15)

                # Check for rate limiting
                if response.status_code == 429:
                    print(f"Rate limited on {proxy}, rotating...")
                    self.failed_proxies.add(proxy)
                    continue

                print(f"✓ Success with {proxy}")
                return response

            except Exception as e:
                print(f"✗ Failed with {proxy}: {e}")
                self.failed_proxies.add(proxy)

        raise Exception(f"All retries failed for {url}")

# Usage
proxies = [
    'http://user:pass@proxy1.com:8000',
    'http://user:pass@proxy2.com:8000',
    'http://user:pass@proxy3.com:8000'
]

rotator = ProxyRotator(proxies)
response = rotator.make_request('https://example.com')

import requests
import time
from datetime import datetime, timedelta

class TimeBasedRotator:
    def __init__(self, proxies_list, rotation_interval=600):
        """
        rotation_interval: time in seconds (600 = 10 minutes)
        """
        self.proxies = proxies_list
        self.rotation_interval = rotation_interval
        self.current_proxy = None
        self.last_rotation = None
        self.current_index = 0

    def get_proxy(self):
        """Get current proxy or rotate if time has elapsed"""
        now = datetime.now()

        # First run or time has elapsed
        if (self.last_rotation is None or
            (now - self.last_rotation).seconds >= self.rotation_interval):

            self.current_proxy = self.proxies[self.current_index]
            self.current_index = (self.current_index + 1) % len(self.proxies)
            self.last_rotation = now
            print(f"🔄 Rotated to: {self.current_proxy}")

        return self.current_proxy

    def make_request(self, url):
        proxy = self.get_proxy()
        proxies = {'http': proxy, 'https': proxy}

        response = requests.get(url, proxies=proxies, timeout=10)
        return response

# Usage: IP will change every 10 minutes
proxies_list = [
    'http://user:pass@proxy1.com:8000',
    'http://user:pass@proxy2.com:8000',
    'http://user:pass@proxy3.com:8000'
]
rotator = TimeBasedRotator(proxies_list, rotation_interval=600)

for i in range(100):
    response = rotator.make_request('https://example.com')
    print(f"Request {i}: {response.status_code}")
    time.sleep(2)  # 2 seconds between requests

const axios = require('axios');
const HttpsProxyAgent = require('https-proxy-agent');

class ProxyRotator {
  constructor(proxies) {
    this.proxies = proxies;
    this.currentIndex = 0;
  }

  getNextProxy() {
    const proxy = this.proxies[this.currentIndex];
    this.currentIndex = (this.currentIndex + 1) % this.proxies.length;
    return proxy;
  }

  async makeRequest(url, options = {}) {
    const proxy = this.getNextProxy();
    const agent = new HttpsProxyAgent(proxy);

    try {
      const response = await axios.get(url, {
        ...options,
        httpAgent: agent,
        httpsAgent: agent,
        timeout: 10000
      });

      console.log(`✓ Success with ${proxy}: ${response.status}`);
      return response.data;

    } catch (error) {
      console.error(`✗ Failed with ${proxy}: ${error.message}`);
      throw error;
    }
  }
}

// Usage
const proxies = [
  'http://user:pass@proxy1.com:8000',
  'http://user:pass@proxy2.com:8000',
  'http://user:pass@proxy3.com:8000'
];

const rotator = new ProxyRotator(proxies);

async function scrape() {
  const urls = [
    'https://example.com/page1',
    'https://example.com/page2',
    'https://example.com/page3'
  ];

  for (const url of urls) {
    try {
      await rotator.makeRequest(url);
    } catch (error) {
      console.error(`Failed to scrape ${url}`);
    }
  }
}

scrape();

const puppeteer = require('puppeteer');

class PuppeteerProxyRotator {
  constructor(proxies) {
    this.proxies = proxies;
    this.currentIndex = 0;
  }

  getNextProxy() {
    const proxy = this.proxies[this.currentIndex];
    this.currentIndex = (this.currentIndex + 1) % this.proxies.length;
    return proxy;
  }

  async scrapeWithRotation(url) {
    const proxy = this.getNextProxy();

    // Parsing proxy URL
    const proxyUrl = new URL(proxy);

    const browser = await puppeteer.launch({
      headless: true,
      args: [
        `--proxy-server=${proxyUrl.protocol}//${proxyUrl.host}`,
        '--no-sandbox',
        '--disable-setuid-sandbox'
      ]
    });

    try {
      const page = await browser.newPage();

      // Proxy authentication if required
      if (proxyUrl.username && proxyUrl.password) {
        await page.authenticate({
          username: proxyUrl.username,
          password: proxyUrl.password
        });
      }

      await page.goto(url, { waitUntil: 'networkidle2', timeout: 30000 });

      const content = await page.content();
      console.log(`✓ Scraped ${url} with ${proxy}`);

      await browser.close();
      return content;

    } catch (error) {
      console.error(`✗ Error with ${proxy}: ${error.message}`);
      await browser.close();
      throw error;
    }
  }
}

// Usage
const proxies = [
  'http://user:pass@185.45.12.34:8000',
  'http://user:pass@92.118.45.78:8000'
];

const rotator = new PuppeteerProxyRotator(proxies);

async function scrapeMultiplePages() {
  const urls = ['https://example.com/1', 'https://example.com/2'];

  for (const url of urls) {
    await rotator.scrapeWithRotation(url);
    // Each page opens with a new proxy
  }
}

scrapeMultiplePages();

How it Works:

1. You connect to a single endpoint (e.g., rotate.proxycove.com:8000)
2. With every request, the gateway automatically selects a random IP from the pool
3. You don't need to manage the proxy list or write rotation logic
4. Sticky sessions can be configured via parameters (session_id in username)

# Python example with rotating gateway
import requests

# For rotating: every request = new IP
proxies = {
    'http': 'http://username:password@rotate.proxycove.com:8000',
    'https': 'http://username:password@rotate.proxycove.com:8000'
}

# For sticky session: add session_id
sticky_proxies = {
    'http': 'http://username-session-abc123:password@rotate.proxycove.com:8000',
    'https': 'http://username-session-abc123:password@rotate.proxycove.com:8000'
}

# Rotating: every request with a new IP
for i in range(10):
    r = requests.get('https://api.ipify.org', proxies=proxies)
    print(f"Request {i}: IP = {r.text}")  # Different IP every time

# Sticky: all requests with the same IP
for i in range(10):
    r = requests.get('https://api.ipify.org', proxies=sticky_proxies)
    print(f"Request {i}: IP = {r.text}")  # Always the same IP

1. ProxyBroker

A library for finding, checking, and using proxies with automatic rotation.

2. rotating-proxies (Scrapy middleware)

Middleware for Scrapy with support for automatic rotation and blacklist management.

3. requests-ip-rotator

Extension for the requests library with AWS API Gateway support for IP rotation.

1. proxy-chain

Library for creating an HTTP proxy server with rotation and tunneling.

2. puppeteer-extra-plugin-proxy-rotation

Plugin for Puppeteer with automatic proxy rotation for each page.

1. Weighted Rotation

Proxies with better reputation and speed are used more frequently. For example, residential IPs get a weight of 0.6, and datacenter IPs get a weight of 0.4.

2. Geo-targeted Rotation

Automatic selection of a proxy from the required country/city based on the target URL. For example, German proxies are used for .de domains.

3. Health Check & Auto-removal

Periodic checking of proxy health and automatic exclusion of non-working ones from the pool. Restoration after a "cooldown" period.

4. Request Rate Adaptive Rotation

The rotation frequency automatically adapts based on received HTTP codes. Upon 429 (Too Many Requests), rotation accelerates.

Typical Sticky Session Settings:

• 1-5 minutes — short sessions for quick operations
• 10-30 minutes — standard mode for most tasks
• 1-2 hours — for account management and authorization
• 12-24 hours — maximum duration for long-term operations
• Infinite (until disconnected) — IP is maintained until the session ends

✅ Advantages of Sticky Sessions:

• Authorization persistence — you can log into an account and operate under it
• Cookie support — the site "remembers" you between requests
• Natural behavior — a regular user uses one IP per session
• Fewer CAPTCHAs — a constant IP raises fewer suspicions
• Action consistency — allows performing multi-step operations
• Easier debugging — easier to reproduce an issue with a specific IP

❌ Disadvantages of Sticky Sessions:

• Vulnerability to rate limiting — all requests come from one IP
• Risk of session ban — if the IP is blocked, you lose all progress
• Less scalability — limited by the speed of a single IP
• Finite duration — the session will inevitably expire and the IP will change

✅ Advantages of Rotating Proxies:

• Maximum protection against rate limiting — each IP makes minimal requests
• High scraping speed — can send thousands of parallel requests
• Minimal ban risk — even if one IP is blocked, it won't affect overall operation
• Scalability — easy to increase the volume of work
• Stealthiness — appears as many independent users

❌ Disadvantages of Rotating Proxies:

• Inability to authorize — constant IP switching breaks the session
• Cookies don't work — every request appears from a new user
• Cannot perform multi-step operations — cart, forms, checkout won't work
• More CAPTCHAs — frequent IP changes can raise suspicion
• More expensive — requires a large proxy pool

Criterion	Sticky Sessions	Rotating Proxies
Authorization	✅ Yes	❌ No
Cookies	✅ Work	❌ Don't Work
Rate Limit Evasion	⚠️ Limited	✅ Excellent
Scraping Speed	⭐⭐⭐	⭐⭐⭐⭐⭐
Ban Risk	⚠️ Medium	✅ Low
Cost	💰 Lower	💰💰 Higher
Complexity	⭐ Simple	⭐⭐ Medium

1. Social Media Management

When managing multiple Instagram, Facebook, or Twitter accounts, maintaining one IP throughout the session is necessary. Frequent IP changes during an authenticated session are a direct path to a ban.

Recommendation: Sticky session of 1-2 hours, one unique IP per account.

2. E-commerce and Shopping Carts

Adding items to a cart, placing an order, checkout process—all require session persistence. An IP change will result in losing the cart and needing to start over.

Recommendation: Sticky session of 30-60 minutes for the entire purchase cycle.

3. Form Filling and Registration

Multi-step forms, site registration, email verification—these processes require IP consistency. Changing the IP between steps can trigger suspicion or validation errors.

Recommendation: Sticky session of 10-30 minutes to complete the process.

4. Web Application Testing

E2E testing, automation with Selenium/Puppeteer, checking user scenarios—all require IP persistence to mimic real user experience.

Recommendation: Sticky session for the entire test duration (5-60 minutes).

5. Working with Authenticated APIs

Many APIs issue access tokens tied to the IP address. Changing the IP will invalidate the token, requiring re-authentication.

Recommendation: Sticky session for the token's lifetime (usually 1-24 hours).

import requests
from itertools import cycle

# List of proxies
proxies_list = [
    'http://user:pass@185.45.12.34:8000',
    'http://user:pass@92.118.45.78:8000',
    'http://user:pass@178.62.91.22:8000',
    'http://user:pass@45.89.234.56:8000'
]

# Create an infinite iterator
proxy_pool = cycle(proxies_list)

# Function to make a request
def make_request(url):
    proxy = next(proxy_pool)
    proxies = {
        'http': proxy,
        'https': proxy
    }

    try:
        response = requests.get(url, proxies=proxies, timeout=10)
        print(f"Success with {proxy}: {response.status_code}")
        return response
    except Exception as e:
        print(f"Error with {proxy}: {e}")
        return None

# Usage
urls = ['https://example.com/page1', 'https://example.com/page2']
for url in urls:
    make_request(url)
    # Each request uses the next proxy in the list

import requests
import random
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

class ProxyRotator:
    def __init__(self, proxies_list):
        self.proxies = proxies_list
        self.failed_proxies = set()

    def get_random_proxy(self):
        """Get a random working proxy"""
        available = [p for p in self.proxies if p not in self.failed_proxies]
        if not available:
            # If all proxies failed, reset the list
            self.failed_proxies.clear()
            available = self.proxies
        return random.choice(available)

    def make_request(self, url, max_retries=3):
        """Send request with automatic rotation upon errors"""
        session = requests.Session()

        # Configure retry strategy
        retry = Retry(
            total=max_retries,
            backoff_factor=0.5,
            status_forcelist=[500, 502, 503, 504]
        )
        adapter = HTTPAdapter(max_retries=retry)
        session.mount('http://', adapter)
        session.mount('https://', adapter)

        for attempt in range(max_retries):
            proxy = self.get_random_proxy()
            proxies = {'http': proxy, 'https': proxy}

            try:
                response = session.get(url, proxies=proxies, timeout=15)

                # Check for rate limiting
                if response.status_code == 429:
                    print(f"Rate limited on {proxy}, rotating...")
                    self.failed_proxies.add(proxy)
                    continue

                print(f"✓ Success with {proxy}")
                return response

            except Exception as e:
                print(f"✗ Failed with {proxy}: {e}")
                self.failed_proxies.add(proxy)

        raise Exception(f"All retries failed for {url}")

# Usage
proxies = [
    'http://user:pass@proxy1.com:8000',
    'http://user:pass@proxy2.com:8000',
    'http://user:pass@proxy3.com:8000'
]

rotator = ProxyRotator(proxies)
response = rotator.make_request('https://example.com')

import requests
import time
from datetime import datetime, timedelta

class TimeBasedRotator:
    def __init__(self, proxies_list, rotation_interval=600):
        """
        rotation_interval: time in seconds (600 = 10 minutes)
        """
        self.proxies = proxies_list
        self.rotation_interval = rotation_interval
        self.current_proxy = None
        self.last_rotation = None
        self.current_index = 0

    def get_proxy(self):
        """Get current proxy or rotate if time has elapsed"""
        now = datetime.now()

        # First run or time has elapsed
        if (self.last_rotation is None or
            (now - self.last_rotation).seconds >= self.rotation_interval):

            self.current_proxy = self.proxies[self.current_index]
            self.current_index = (self.current_index + 1) % len(self.proxies)
            self.last_rotation = now
            print(f"🔄 Rotated to: {self.current_proxy}")

        return self.current_proxy

    def make_request(self, url):
        proxy = self.get_proxy()
        proxies = {'http': proxy, 'https': proxy}

        response = requests.get(url, proxies=proxies, timeout=10)
        return response

# Usage: IP will change every 10 minutes
proxies_list = [
    'http://user:pass@proxy1.com:8000',
    'http://user:pass@proxy2.com:8000',
    'http://user:pass@proxy3.com:8000'
]
rotator = TimeBasedRotator(proxies_list, rotation_interval=600)

for i in range(100):
    response = rotator.make_request('https://example.com')
    print(f"Request {i}: {response.status_code}")
    time.sleep(2)  # 2 seconds between requests

const axios = require('axios');
const HttpsProxyAgent = require('https-proxy-agent');

class ProxyRotator {
  constructor(proxies) {
    this.proxies = proxies;
    this.currentIndex = 0;
  }

  getNextProxy() {
    const proxy = this.proxies[this.currentIndex];
    this.currentIndex = (this.currentIndex + 1) % this.proxies.length;
    return proxy;
  }

  async makeRequest(url, options = {}) {
    const proxy = this.getNextProxy();
    const agent = new HttpsProxyAgent(proxy);

    try {
      const response = await axios.get(url, {
        ...options,
        httpAgent: agent,
        httpsAgent: agent,
        timeout: 10000
      });

      console.log(`✓ Success with ${proxy}: ${response.status}`);
      return response.data;

    } catch (error) {
      console.error(`✗ Failed with ${proxy}: ${error.message}`);
      throw error;
    }
  }
}

// Usage
const proxies = [
  'http://user:pass@proxy1.com:8000',
  'http://user:pass@proxy2.com:8000',
  'http://user:pass@proxy3.com:8000'
];

const rotator = new ProxyRotator(proxies);

async function scrape() {
  const urls = [
    'https://example.com/page1',
    'https://example.com/page2',
    'https://example.com/page3'
  ];

  for (const url of urls) {
    try {
      await rotator.makeRequest(url);
    } catch (error) {
      console.error(`Failed to scrape ${url}`);
    }
  }
}

scrape();

const puppeteer = require('puppeteer');

class PuppeteerProxyRotator {
  constructor(proxies) {
    this.proxies = proxies;
    this.currentIndex = 0;
  }

  getNextProxy() {
    const proxy = this.proxies[this.currentIndex];
    this.currentIndex = (this.currentIndex + 1) % this.proxies.length;
    return proxy;
  }

  async scrapeWithRotation(url) {
    const proxy = this.getNextProxy();

    // Parsing proxy URL
    const proxyUrl = new URL(proxy);

    const browser = await puppeteer.launch({
      headless: true,
      args: [
        `--proxy-server=${proxyUrl.protocol}//${proxyUrl.host}`,
        '--no-sandbox',
        '--disable-setuid-sandbox'
      ]
    });

    try {
      const page = await browser.newPage();

      // Proxy authentication if required
      if (proxyUrl.username && proxyUrl.password) {
        await page.authenticate({
          username: proxyUrl.username,
          password: proxyUrl.password
        });
      }

      await page.goto(url, { waitUntil: 'networkidle2', timeout: 30000 });

      const content = await page.content();
      console.log(`✓ Scraped ${url} with ${proxy}`);

      await browser.close();
      return content;

    } catch (error) {
      console.error(`✗ Error with ${proxy}: ${error.message}`);
      await browser.close();
      throw error;
    }
  }
}

// Usage
const proxies = [
  'http://user:pass@185.45.12.34:8000',
  'http://user:pass@92.118.45.78:8000'
];

const rotator = new PuppeteerProxyRotator(proxies);

async function scrapeMultiplePages() {
  const urls = ['https://example.com/1', 'https://example.com/2'];

  for (const url of urls) {
    await rotator.scrapeWithRotation(url);
    // Each page opens with a new proxy
  }
}

scrapeMultiplePages();

How it Works:

1. You connect to a single endpoint (e.g., rotate.proxycove.com:8000)
2. With every request, the gateway automatically selects a random IP from the pool
3. You don't need to manage the proxy list or write rotation logic
4. Sticky sessions can be configured via parameters (session_id in username)

# Python example with rotating gateway
import requests

# For rotating: every request = new IP
proxies = {
    'http': 'http://username:password@rotate.proxycove.com:8000',
    'https': 'http://username:password@rotate.proxycove.com:8000'
}

# For sticky session: add session_id
sticky_proxies = {
    'http': 'http://username-session-abc123:password@rotate.proxycove.com:8000',
    'https': 'http://username-session-abc123:password@rotate.proxycove.com:8000'
}

# Rotating: every request with a new IP
for i in range(10):
    r = requests.get('https://api.ipify.org', proxies=proxies)
    print(f"Request {i}: IP = {r.text}")  # Different IP every time

# Sticky: all requests with the same IP
for i in range(10):
    r = requests.get('https://api.ipify.org', proxies=sticky_proxies)
    print(f"Request {i}: IP = {r.text}")  # Always the same IP

1. ProxyBroker

A library for finding, checking, and using proxies with automatic rotation.

2. rotating-proxies (Scrapy middleware)

Middleware for Scrapy with support for automatic rotation and blacklist management.

3. requests-ip-rotator

Extension for the requests library with AWS API Gateway support for IP rotation.

1. proxy-chain

Library for creating an HTTP proxy server with rotation and tunneling.

2. puppeteer-extra-plugin-proxy-rotation

Plugin for Puppeteer with automatic proxy rotation for each page.

1. Weighted Rotation

Proxies with better reputation and speed are used more frequently. For example, residential IPs get a weight of 0.6, and datacenter IPs get a weight of 0.4.

2. Geo-targeted Rotation

Automatic selection of a proxy from the required country/city based on the target URL. For example, German proxies are used for .de domains.

3. Health Check & Auto-removal

Periodic checking of proxy health and automatic exclusion of non-working ones from the pool. Restoration after a "cooldown" period.

4. Request Rate Adaptive Rotation

The rotation frequency automatically adapts based on received HTTP codes. Upon 429 (Too Many Requests), rotation accelerates.

1. Target Site Type

• Highly Protected (Banks, Social Media): Rotation every 3-5 requests or 10-15 minutes
• E-commerce (Amazon, Walmart): Rotation every 5-10 requests or 5-10 minutes
• News Sites: Rotation every 10-20 requests or 15-30 minutes
• Public APIs: According to documentation (often 100-1000 req/hour per IP)
• Static Sites: Rotation every 20-50 requests or 30-60 minutes

2. Data Volume to Collect

• Small Volume (up to 1,000 pages): Time-based, rotation every 15-30 minutes
• Medium Volume (1,000-10,000 pages): Request-based, rotation every 10-15 requests
• Large Volume (10,000+ pages): Per-request rotation with a large proxy pool

3. Proxy Pool Size

• Small Pool (10-50 IPs): Time-based rotation of 30-60 minutes to allow each IP to "cool down"
• Medium Pool (50-200 IPs): Request-based rotation of 10-20 requests per IP
• Large Pool (200+ IPs): Per-request rotation, maximum speed

4. Session Requirements

• No authorization: Aggressive rotation, every 1-5 requests
• With authorization: Sticky session for the entire operation duration (1-24 hours)
• Hybrid mode: Sticky for auth, then rotating for data collection

Use Case	Rotation Frequency	Pool Size	Delay Between Requests
Google Search Scraping	Every 3-5 requests	200-500 IPs	5-10 sec
Amazon Price Monitoring	Every 5-10 requests	100-300 IPs	3-7 sec
Instagram Automation	Sticky 1-2 hours	1 IP per account	30-60 sec
News Aggregator	Every 15-30 minutes	50-100 IPs	1-3 sec
Real Estate Scraping	Every 10-20 requests	50-200 IPs	2-5 sec
API Monitoring	Per API limits	According to limits	According to documentation
SEO Position Tracking	Every 20-30 requests	100-300 IPs	3-8 sec
Avito/Yula Scraping	Every 7-15 requests	100-200 IPs	3-6 sec

1. Round-Robin (Cyclic)

Proxies are selected sequentially from the list. After the last one, it restarts from the first. The simplest method, ensuring even distribution.

2. Random

A random proxy is selected from the pool every time. A less predictable pattern, harder to detect.

3. Least Connections

The proxy with the fewest active connections is selected. Ideal for parallel requests.

4. Weighted Round-Robin

Proxies with better performance are used more often. Residential IPs might have a weight of 3, while datacenter IPs have a weight of 1.

5. IP Hash

The proxy is selected based on the hash of the URL or domain. Guarantees that requests to the same domain always go through the same IP.

Recommended Cooldown Periods:

• Small Pool (10-50 IPs): 30-60 minutes between uses of the same IP
• Medium Pool (50-200 IPs): 15-30 minutes between uses
• Large Pool (200+ IPs): 5-15 minutes or no cooldown with per-request rotation

1. Aggressive Mode (Speed-First)

• Per-request rotation—new IP for every request
• Minimal delays (0.5-1 sec between requests)
• Large proxy pool (500+ IPs)
• Parallel requests (10-50 threads)

⚠️ Risks: High probability of bans, short IP lifespan, can trigger rate limiting even with rotation.

📊 Suitable For: One-off tasks, collecting public data, working with tolerant sites.

2. Balanced Mode (Balanced)

• Request-based rotation—every 10-20 requests
• Medium delays (2-5 sec between requests)
• Medium proxy pool (100-300 IPs)
• Moderate parallelism (5-15 threads)

✅ Advantages: Good balance of speed and stability, suitable for most tasks.

📊 Suitable For: E-commerce monitoring, regular scraping, long-term projects.

3. Cautious Mode (Stealth-First)

• Time-based rotation—every 15-30 minutes
• Large delays (5-15 sec between requests)
• Smaller pool of high-quality proxies (50-100 residential IPs)
• Minimal parallelism (1-3 threads)
• Simulation of human behavior (random delays, user actions)

✅ Advantages: Minimal risk of bans, long-term stability, looks like real users.

📊 Suitable For: Social media, highly protected sites, account management, competitive intelligence.

❌ Problem 1: Receiving 429 (Too Many Requests) even with rotation

Possible Causes:

• Rotation too frequent for the same domain
• All proxies are from the same subnet (detectable by ASN)
• User-Agent and other headers are not being rotated
• Cooldown period is too short

✅ Solutions:

• Increase delays between requests to 5-10 seconds
• Use residential proxies instead of datacenter ones
• Rotate User-Agent, headers, and TLS fingerprint
• Increase the proxy pool size by 2-3 times
• Add jitter (random deviation) to delays

❌ Problem 2: Constant CAPTCHAs upon IP change

Possible Causes:

• Low-reputation datacenter proxies
• Aggressive rotation triggering suspicion
• Using public (free) proxies
• Browser fingerprint remains unchanged despite IP rotation

✅ Solutions:

• Switch to residential or mobile proxies
• Use sticky sessions instead of constant rotation
• Integrate CAPTCHA solving services (2Captcha, AntiCaptcha)
• Use headless browsers with anti-detection features (Playwright, puppeteer-extra-plugin-stealth)
• Warm-up proxies before the main work (a few simple requests)

❌ Problem 3: Session loss upon authorization

Possible Causes:

• IP rotation breaks the session
• Cookies are not preserved between requests
• Sticky session has expired

✅ Solutions:

• Use sticky sessions with session_id for authenticated requests
• Increase the duration of the sticky session (1-24 hours)
• Save and reuse cookies/tokens between sessions
• Hybrid approach: sticky for auth, rotating for data collection

❌ Problem 4: Rapid proxy pool exhaustion

Possible Causes:

• Overly aggressive per-request rotation
• Small pool for a large volume of work
• Cooldown period is not accounted for

✅ Solutions:

• Switch to burst rotation (switch every N requests instead of every one)
• Increase the proxy pool size proportionally to the load
• Implement a queue with cooldown tracking
• Use a rotating proxy gateway from the provider

❌ Problem 5: Slow scraping speed

Possible Causes:

• Slow proxies (high ping)
• Sequential processing instead of parallel processing
• Large delays between requests
• Overhead on connection establishment during frequent rotation

✅ Solutions:

• Use connection pooling and keep-alive
• Parallel processing of requests (threading/asyncio)
• Select proxies with low ping (filter by latency)
• Reduce rotation frequency (burst instead of per-request)
• Use faster proxies (ISP instead of residential)

Metric	Normal	Problem if
Success Rate	> 95%	< 85%
429 Error Rate	< 2%	> 10%
403/503 Error Rate	< 3%	> 15%
CAPTCHA Rate	< 1%	> 5%
Average Response Time	< 3 sec	> 10 sec
Timeout Rate	< 1%	> 5%
Unique IPs Used	> 80% of pool	< 50% of pool

✅ 1. Always combine IP rotation with other techniques

IP rotation is just one component. Also rotate User-Agents, use real browsers (Puppeteer/Playwright), simulate human behavior, and rotate headers and cookies.

✅ 2. Use residential/mobile proxies for critical tasks

Datacenter proxies are cheaper but have poor reputation. For social media, e-commerce, and highly protected sites, use only residential or mobile IPs.

✅ 3. Implement graceful degradation

If errors increase, automatically slow down requests, increase delays, or switch to higher-quality proxies. Adaptability is better than a rigid configuration.

✅ 4. Test on a small sample before scaling

Before launching a large scraping job, test your strategy on 100-1000 requests. Ensure success rate > 95%, no mass bans, and acceptable speed.

✅ 5. Respect robots.txt and Terms of Service

Ethical scraping is the key to long-term success. Follow robots.txt, do not overload servers, and do not collect personal data without consent. In Russia, this is regulated by data protection laws.

✅ 6. Invest in quality proxies

Free and cheap proxies cost more in the long run: low speed, frequent bans, data loss, security risks. Use trusted providers like ProxyCove with uptime guarantees.

Key Takeaways:

1. There is no universal solution — the choice of strategy depends on the site type, data volume, budget, and speed requirements.
2. Three main rotation types: time-based (stability), request-based (speed), random (stealth)—use combinations.
3. Sticky sessions are critical for working with authorization, carts, and multi-step processes. Rotating proxies are for mass scraping.
4. Quality over quantity — 50 residential IPs are better than 500 datacenter IPs for most tasks in 2025.
5. Monitoring is mandatory — track success rate, error codes, and response time for timely optimization.
6. Balance speed and stealth — aggressive scraping yields short-term results; cautious scraping ensures long-term stability.
7. Use provider automation — leverage rotating gateways instead of writing custom rotation code to save time.
8. Adaptability > Static configuration — security systems evolve; your strategy must adapt.

📋 Pre-Scraping Checklist:

💼 For Business:

If your business relies on web scraping (price monitoring, competitive intelligence, lead generation), do not skimp on proxy infrastructure. The cost of downtime or bans far outweighs the expense of quality proxies and proper rotation setup.

🎓 For Developers:

Invest time in writing a reliable IP rotation system once, rather than constantly solving ban issues. Use ready-made libraries, log metrics, and test different strategies. Automation will pay for itself many times over.