Rotación de Direcciones IP: Cómo y Por Qué Cambiar tus Proxys

Solicitud 1 → Proxy A (185.45.12.34) → El sitio ve 185.45.12.34
Solicitud 2 → Proxy B (92.118.45.78) → El sitio ve 92.118.45.78
Solicitud 3 → Proxy C (178.62.91.22) → El sitio ve 178.62.91.22
Solicitud 4 → Proxy A (185.45.12.34) → El sitio ve 185.45.12.34

1. Evitar el Rate Limiting (límites de solicitudes)

La mayoría de los sitios limitan el número de solicitudes por IP en una unidad de tiempo. Por ejemplo, una API puede permitir solo 100 solicitudes por hora por IP. Al usar una rotación de 10 direcciones IP, puede enviar 1,000 solicitudes por hora, distribuyendo la carga.

2. Evitar baneos de IP al hacer scraping

Al recopilar grandes volúmenes de datos (web scraping de e-commerce, monitoreo de precios, recopilación de contactos), las solicitudes frecuentes desde una sola IP conducen rápidamente al bloqueo. La rotación permite distribuir las solicitudes para que cada IP realice solo unas pocas solicitudes por hora, como un usuario normal.

3. Evitar bloqueos geográficos

Muchos servicios muestran contenido o precios diferentes según la geolocalización. La rotación de proxies desde diferentes países permite recopilar datos de todas las regiones sin necesidad de estar físicamente allí.

4. Enmascarar la automatización

Los sistemas de protección (Cloudflare, Akamai, PerimeterX) analizan patrones de comportamiento. Si cientos de solicitudes provienen de una sola IP en poco tiempo, es una clara señal de bot. La rotación ayuda a crear la ilusión de múltiples usuarios independientes.

5. Inteligencia competitiva

El seguimiento de precios de la competencia, el monitoreo de campañas publicitarias, el análisis de posiciones SEO requieren verificaciones frecuentes. La rotación de IP permite recopilar estos datos sin ser detectado, sin llamar la atención de los competidores.

6. Pruebas y monitoreo

Verificar la disponibilidad del sitio desde diferentes regiones, probar experimentos A/B, monitorear posiciones SEO en diferentes países, todo esto requiere el uso de direcciones IP de diferentes ubicaciones.

1. Rate Limiting (análisis de frecuencia de solicitudes)

Los sitios rastrean el número de solicitudes desde una IP específica en un período de tiempo determinado. Los umbrales típicos son:

• Sitios conservadores: 10-30 solicitudes por minuto
• Sitios promedio: 50-100 solicitudes por minuto
• Servicios API: 100-1000 solicitudes por hora (a menudo especificado en la documentación)

2. Análisis de Reputación de IP

Existen bases de datos extensas que clasifican las direcciones IP por tipo:

• IP Residencial — Proveedores de Internet domésticos (alta reputación)
• IP de Centro de Datos — Servidores de empresas de hosting (sospechosos)
• IP Móvil — Operadores móviles (alta reputación)
• IP de Proxy Conocido — Servidores proxy conocidos (a menudo bloqueados)

3. Huella Digital del Navegador (Browser Fingerprinting)

Incluso al cambiar la IP, los sistemas de protección pueden vincular las solicitudes mediante una "huella digital" única del navegador: resolución de pantalla, fuentes instaladas, complementos, huella digital de WebGL, huella digital de Canvas, huella digital de Audio Context.

4. Análisis de Comportamiento

Los sistemas anti-bot modernos analizan el comportamiento:

• Velocidad de desplazamiento de la página
• Movimientos del ratón
• Patrones de clics
• Tiempo entre acciones
• Secuencia de visitas a páginas

5. Huella Digital TLS

Durante una conexión HTTPS, el servidor puede determinar la versión TLS, las suites de cifrado utilizadas, las extensiones; estos datos forman una huella digital única que puede usarse para el seguimiento incluso con el cambio de IP.

Intervalos de rotación típicos:

• Cada 5 minutos — para scraping intensivo con alta frecuencia de solicitudes
• Cada 10-15 minutos — modo estándar para la mayoría de las tareas
• Cada 30-60 minutos — para tareas con baja frecuencia de solicitudes
• Cada 2-24 horas — para sesiones persistentes (sticky sessions)

✅ Ventajas:

• Previsibilidad — sabe exactamente cuándo ocurrirá el cambio de IP
• Fácil implementación — fácil de configurar con temporizadores
• Adecuado para sesiones persistentes — puede mantener la sesión durante un tiempo determinado
• Distribución uniforme — la carga se distribuye uniformemente a lo largo del tiempo
• Fácil de escalar — puede ejecutar varias sesiones en paralelo con diferentes temporizadores

❌ Desventajas:

• Ineficiencia con carga variable — si hay pocas solicitudes, la IP cambia sin necesidad
• Riesgo de exceder límites — si se envían demasiadas solicitudes en un corto intervalo
• Patrón predecible — los sistemas de protección avanzados pueden detectar la regularidad
• Pérdida de sesión — el cambio de IP puede causar pérdida de autorización o contexto

🎯 Mejor adecuado para:

• Tareas con carga predecible
• Sesiones a largo plazo (autorización, trabajo con cuentas)
• Monitoreo con intervalos fijos
• Situaciones donde la estabilidad de la IP durante un tiempo determinado es importante

10:00 - Proxy A → Verificación de precios (50 productos)
10:30 - Proxy B → Verificación de precios (50 productos)
11:00 - Proxy C → Verificación de precios (50 productos)
11:30 - Proxy D → Verificación de precios (50 productos)
12:00 - Proxy A → Verificación de precios (50 productos)

Variantes de implementación:

1. Rotación por solicitud (Per-request rotation): nueva IP para cada solicitud (la estrategia más agresiva)
2. Rotación por ráfaga (Burst rotation): cambio de IP después de N solicitudes (ej. cada 10 solicitudes)
3. Rotación adaptativa (Adaptive rotation): cambio de IP al recibir códigos HTTP específicos (429, 403, 503)
4. Basada en sesión (Session-based): cambio de IP al iniciar una nueva sesión lógica

✅ Ventajas:

• Máxima protección contra rate limiting: cada IP realiza un mínimo de solicitudes
• Adaptabilidad: la rotación ocurre solo cuando es necesario
• Uso eficiente del pool: las IP cambian solo cuando es necesario
• Reacción rápida a bloqueos: puede cambiar la IP instantáneamente ante un error
• Ideal para scraping: cada página se solicita con una nueva IP

❌ Desventajas:

• Imposibilidad de mantener la sesión: el cambio constante de IP rompe la autorización
• Más difícil de depurar: es más difícil reproducir un problema con una IP específica
• Agotamiento rápido del pool: con un trabajo intensivo, puede agotar rápidamente todas las IP
• Más costoso: requiere un pool más grande de proxies para un trabajo eficiente
• Sobrecarga por cambio: cada cambio de IP consume fracciones de segundo

🎯 Mejor adecuado para:

• Scraping intensivo de grandes volúmenes de datos
• Evitar límites de tasa estrictos
• Solicitudes únicas sin necesidad de mantener el estado
• Scraping de páginas públicas sin autorización
• Tareas donde cada solicitud es independiente de la anterior

Tipo de sitio	Cantidad recomendada de solicitudes	Intervalo
Sitios altamente protegidos (bancos, redes sociales)	1-3 solicitudes	5-10 seg entre solicitudes
E-commerce (marketplaces)	5-10 solicitudes	2-5 seg entre solicitudes
Portales de noticias	10-20 solicitudes	1-3 seg entre solicitudes
APIs públicas	Depende de los límites	Según la documentación
Sitios estáticos	20-50 solicitudes	0.5-2 seg entre solicitudes

Variantes de rotación aleatoria:

• Intervalos de tiempo aleatorios: cambio de IP en intervalos aleatorios (ej. entre 3 y 15 minutos)
• Número aleatorio de solicitudes: cambio después de un número aleatorio de solicitudes (ej. entre 5 y 20)
• Selección aleatoria de IP: la selección de la siguiente IP del pool es aleatoria, no secuencial
• Rotación ponderada (Weighted random): las IP con mejor reputación se utilizan con más frecuencia
• Rotación con jitter: adición de un retraso aleatorio a los intervalos fijos

✅ Ventajas:

• Imprevisibilidad: es más difícil para los sistemas de protección detectar un patrón
• Imitación de usuarios reales: las personas no actúan con regularidad perfecta
• Flexibilidad: se puede combinar con otras estrategias
• Patrón de tráfico natural: se parece más al tráfico orgánico
• Más difícil de detectar: incluso al analizar grandes volúmenes de datos

❌ Desventajas:

• Más difícil de pronosticar: es difícil estimar la velocidad de finalización de la tarea
• Puede ser ineficiente: con una aleatoriedad desafortunada, la IP puede cambiar con demasiada frecuencia
• Depuración más compleja: reproducir un problema es más difícil debido a la aleatoriedad
• Requiere un pool más grande: para asegurar una carga uniforme
• Implementación más compleja: requiere un buen algoritmo de generación de aleatoriedad

🎯 Mejor adecuado para:

• Eludir sistemas de protección avanzados (Cloudflare, Akamai)
• Proyectos a largo plazo con altos requisitos de sigilo
• Inteligencia competitiva
• Scraping de sitios con análisis de comportamiento
• Tareas donde se requiere la máxima imitación del comportamiento humano

Criterio	Basada en Tiempo	Basada en Solicitud	Aleatoria
Complejidad de implementación	⭐ Fácil	⭐⭐ Media	⭐⭐⭐ Difícil
Previsibilidad	✅ Alta	⚠️ Media	❌ Baja
Protección contra rate limit	⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐
Sigilo (Stealth)	⭐⭐	⭐⭐⭐	⭐⭐⭐⭐⭐
Soporte de sesiones	✅ Sí	❌ No	⚠️ Parcialmente
Eficiencia de uso del pool	⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐
Velocidad de scraping	⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐
Tamaño de pool requerido	Pequeño-Mediano	Grande	Mediano-Grande
Facilidad de depuración	✅ Fácil	⚠️ Media	❌ Difícil
Costo	💰 Bajo	💰💰💰 Alto	💰💰 Medio

1. Gestión de redes sociales

Al trabajar con múltiples cuentas de Instagram, Facebook, Twitter, es necesario mantener una sola IP durante la sesión. Un cambio frecuente de IP al iniciar sesión es una vía directa al bloqueo.

Recomendación: Sticky session de 1-2 horas, una IP única para cada cuenta.

2. E-commerce y carritos de compra

Añadir productos al carrito, realizar el pedido, el proceso de pago, todo requiere mantener la sesión. Un cambio de IP resultará en la pérdida del carrito y la necesidad de empezar de nuevo.

Recomendación: Sticky session de 30-60 minutos para el ciclo completo de compra.

3. Rellenar formularios y registro

Formularios de varios pasos, registro en sitios web, verificación de correo electrónico; todos estos procesos requieren constancia de IP. Un cambio de IP entre pasos puede generar sospechas o errores de validación.

Recomendación: Sticky session de 10-30 minutos para completar el proceso.

4. Pruebas de aplicaciones web

Pruebas E2E, automatización con Selenium/Puppeteer, verificación de escenarios de usuario; todo esto requiere mantener la IP para imitar la experiencia de un usuario real.

Recomendación: Sticky session durante toda la duración de la prueba (5-60 minutos).

5. Trabajo con APIs que requieren autenticación

Muchas APIs emiten un token de acceso vinculado a la dirección IP. Cambiar la IP invalidará el token y requerirá una nueva autenticación.

Recomendación: Sticky session durante la vida útil del token (generalmente 1-24 horas).

import requests
from itertools import cycle

# Lista de 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'
]

# Creamos un iterador infinito
proxy_pool = cycle(proxies_list)

# Función para enviar una solicitud
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

# Uso
urls = ['https://example.com/page1', 'https://example.com/page2']
for url in urls:
    make_request(url)
    # Cada solicitud utiliza el siguiente proxy de la lista

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):
        """Obtener un proxy aleatorio que funcione"""
        available = [p for p in self.proxies if p not in self.failed_proxies]
        if not available:
            # Si todos los proxies fallaron, reiniciamos la lista
            self.failed_proxies.clear()
            available = self.proxies
        return random.choice(available)

    def make_request(self, url, max_retries=3):
        """Enviar solicitud con rotación automática en caso de error"""
        session = requests.Session()

        # Configuración de la estrategia de reintento
        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)

                # Verificación de 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}")

# Uso
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: tiempo en segundos (600 = 10 minutos)
        """
        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):
        """Obtener el proxy actual o rotar si el tiempo ha expirado"""
        now = datetime.now()

        # Primer inicio o tiempo expirado
        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

# Uso: La IP cambiará cada 10 minutos
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 segundos entre solicitudes

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;
    }
  }
}

// Uso
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();

    // Parseo de la URL del proxy
    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();

      // Autenticación del proxy si existe
      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;
    }
  }
}

// Uso
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);
    // Cada página se abre con un nuevo proxy
  }
}

scrapeMultiplePages();

Cómo funciona:

1. Se conecta a un único endpoint (ej. rotate.proxycove.com:8000)
2. Con cada solicitud, la puerta de enlace selecciona automáticamente una IP aleatoria del pool
3. No necesita gestionar la lista de proxies ni escribir lógica de rotación
4. Se puede configurar sticky sessions a través de parámetros (session_id en el nombre de usuario)

# Ejemplo en Python con rotating gateway
import requests

# Para rotación: cada solicitud = nueva IP
proxies = {
    'http': 'http://username:password@rotate.proxycove.com:8000',
    'https': 'http://username:password@rotate.proxycove.com:8000'
}

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

# Rotación: cada solicitud con una nueva IP
for i in range(10):
    r = requests.get('https://api.ipify.org', proxies=proxies)
    print(f"Request {i}: IP = {r.text}")  # IP diferente cada vez

# Sticky: todas las solicitudes con la misma IP
for i in range(10):
    r = requests.get('https://api.ipify.org', proxies=sticky_proxies)
    print(f"Request {i}: IP = {r.text}")  # Siempre la misma IP

1. ProxyBroker

Biblioteca para buscar, verificar y utilizar proxies con rotación automática.

2. rotating-proxies (Scrapy middleware)

Middleware para Scrapy con soporte para rotación automática y gestión de lista negra.

3. requests-ip-rotator

Extensión para la biblioteca requests con soporte para AWS API Gateway para rotación de IP.

1. proxy-chain

Biblioteca para crear un servidor proxy HTTP con rotación y tunneling.

2. puppeteer-extra-plugin-proxy-rotation

Plugin para Puppeteer con rotación automática de proxy para cada página.

1. Rotación ponderada (Weighted Rotation)

Las proxies con mejor reputación y velocidad se utilizan con más frecuencia. Por ejemplo, las IP residenciales reciben un peso de 0.6 y las de centro de datos un 0.4.

2. Rotación Geo-dirigida

Selección automática de proxy de un país/ciudad específico según la URL de destino. Por ejemplo, para un dominio .de se utilizan proxies alemanes.

3. Verificación de Salud y Eliminación Automática (Health Check & Auto-removal)

Verificación periódica de la salud del proxy y exclusión automática de los que no funcionan del pool. Recuperación después de un período de "cooldown".

4. Rotación Adaptativa a la Tasa de Solicitudes

La frecuencia de rotación se adapta automáticamente en función de los códigos HTTP recibidos. Si se recibe 429 (Too Many Requests), la rotación se acelera.

Configuraciones típicas de sesiones persistentes:

• 1-5 minutos — sesiones cortas para operaciones rápidas
• 10-30 minutos — modo estándar para la mayoría de las tareas
• 1-2 horas — para trabajar con cuentas y autorizaciones
• 12-24 horas — duración máxima para operaciones a largo plazo
• Infinito (hasta desconexión) — la IP se mantiene hasta que finaliza la sesión

✅ Ventajas de las Sesiones Persistentes:

• Mantenimiento de la autorización — puede iniciar sesión y operar en nombre de una cuenta
• Soporte de cookies — el sitio "recuerda" al usuario entre solicitudes
• Comportamiento natural — un usuario normal usa una sola IP durante una sesión
• Menos CAPTCHA — una IP constante genera menos sospechas
• Consistencia de acciones — permite realizar operaciones de varios pasos
• Más fácil de depurar — más fácil reproducir un problema con una IP específica

❌ Desventajas de las Sesiones Persistentes:

• Vulnerabilidad al rate limiting — todas las solicitudes provienen de la misma IP
• Riesgo de baneo de toda la sesión — si la IP es bloqueada, pierde todo el progreso
• Menor escalabilidad — limitado por la velocidad de una sola IP
• Duración finita — la sesión eventualmente expirará y la IP cambiará

✅ Ventajas de los Proxies Rotativos:

• Máxima protección contra rate limiting — cada IP realiza un mínimo de solicitudes
• Alta velocidad de scraping — puede enviar miles de solicitudes paralelas
• Mínimo riesgo de baneo — si se bloquea una IP, no afecta el trabajo
• Escalabilidad — fácil aumentar el volumen de trabajo
• Sigilo — parece provenir de muchos usuarios independientes

❌ Desventajas de los Proxies Rotativos:

• Imposibilidad de autorización — el cambio constante de IP rompe la sesión
• Las cookies no funcionan — cada solicitud parece ser de un usuario nuevo
• No se pueden realizar operaciones multi-paso — el carrito, formularios, checkout no funcionan
• Más CAPTCHA — el cambio frecuente de IP puede generar sospechas
• Más costoso — requiere un gran pool de proxies

Criterio	Sesiones Persistentes	Proxies Rotativos
Autorización	✅ Sí	❌ No
Cookies	✅ Funcionan	❌ No funcionan
Evasión de rate limit	⚠️ Limitada	✅ Excelente
Velocidad de scraping	⭐⭐⭐	⭐⭐⭐⭐⭐
Riesgo de baneo	⚠️ Medio	✅ Bajo
Costo	💰 Menor	💰💰 Mayor
Complejidad	⭐ Simple	⭐⭐ Media

1. Gestión de redes sociales

Al trabajar con múltiples cuentas de Instagram, Facebook, Twitter, es necesario mantener una sola IP durante la sesión. Un cambio frecuente de IP al iniciar sesión es una vía directa al bloqueo.

Recomendación: Sticky session de 1-2 horas, una IP única para cada cuenta.

2. E-commerce y carritos de compra

Añadir productos al carrito, realizar el pedido, el proceso de pago, todo requiere mantener la sesión. Un cambio de IP resultará en la pérdida del carrito y la necesidad de empezar de nuevo.

Recomendación: Sticky session de 30-60 minutos para el ciclo completo de compra.

3. Rellenar formularios y registro

Formularios de varios pasos, registro en sitios web, verificación de correo electrónico; todos estos procesos requieren constancia de IP. Un cambio de IP entre pasos puede generar sospechas o errores de validación.

Recomendación: Sticky session de 10-30 minutos para completar el proceso.

4. Pruebas de aplicaciones web

Pruebas E2E, automatización con Selenium/Puppeteer, verificación de escenarios de usuario; todo esto requiere mantener la IP para imitar la experiencia de un usuario real.

Recomendación: Sticky session durante toda la duración de la prueba (5-60 minutos).

5. Trabajo con APIs que requieren autenticación

Muchas APIs emiten un token de acceso vinculado a la dirección IP. Cambiar la IP invalidará el token y requerirá una nueva autenticación.

Recomendación: Sticky session durante la vida útil del token (generalmente 1-24 horas).

import requests
from itertools import cycle

# Lista de 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'
]

# Creamos un iterador infinito
proxy_pool = cycle(proxies_list)

# Función para enviar una solicitud
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

# Uso
urls = ['https://example.com/page1', 'https://example.com/page2']
for url in urls:
    make_request(url)
    # Cada solicitud utiliza el siguiente proxy de la lista

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):
        """Obtener un proxy aleatorio que funcione"""
        available = [p for p in self.proxies if p not in self.failed_proxies]
        if not available:
            # Si todos los proxies fallaron, reiniciamos la lista
            self.failed_proxies.clear()
            available = self.proxies
        return random.choice(available)

    def make_request(self, url, max_retries=3):
        """Enviar solicitud con rotación automática en caso de error"""
        session = requests.Session()

        # Configuración de la estrategia de reintento
        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)

                # Verificación de 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}")

# Uso
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: tiempo en segundos (600 = 10 minutos)
        """
        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):
        """Obtener el proxy actual o rotar si el tiempo ha expirado"""
        now = datetime.now()

        # Primer inicio o tiempo expirado
        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

# Uso: La IP cambiará cada 10 minutos
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 segundos entre solicitudes

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;
    }
  }
}

// Uso
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();

    // Parseo de la URL del proxy
    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();

      // Autenticación del proxy si existe
      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;
    }
  }
}

// Uso
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);
    // Cada página se abre con un nuevo proxy
  }
}

scrapeMultiplePages();

Cómo funciona:

1. Se conecta a un único endpoint (ej. rotate.proxycove.com:8000)
2. Con cada solicitud, la puerta de enlace selecciona automáticamente una IP aleatoria del pool
3. No necesita gestionar la lista de proxies ni escribir lógica de rotación
4. Se puede configurar sticky sessions a través de parámetros (session_id en el nombre de usuario)

# Ejemplo en Python con rotating gateway
import requests

# Para rotación: cada solicitud = nueva IP
proxies = {
    'http': 'http://username:password@rotate.proxycove.com:8000',
    'https': 'http://username:password@rotate.proxycove.com:8000'
}

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

# Rotación: cada solicitud con una nueva IP
for i in range(10):
    r = requests.get('https://api.ipify.org', proxies=proxies)
    print(f"Request {i}: IP = {r.text}")  # IP diferente cada vez

# Sticky: todas las solicitudes con la misma IP
for i in range(10):
    r = requests.get('https://api.ipify.org', proxies=sticky_proxies)
    print(f"Request {i}: IP = {r.text}")  # Siempre la misma IP

1. ProxyBroker

Biblioteca para buscar, verificar y utilizar proxies con rotación automática.

2. rotating-proxies (Scrapy middleware)

Middleware para Scrapy con soporte para rotación automática y gestión de lista negra.

3. requests-ip-rotator

Extensión para la biblioteca requests con soporte para AWS API Gateway para rotación de IP.

1. proxy-chain

Biblioteca para crear un servidor proxy HTTP con rotación y tunneling.

2. puppeteer-extra-plugin-proxy-rotation

Plugin para Puppeteer con rotación automática de proxy para cada página.

1. Rotación ponderada (Weighted Rotation)

Las proxies con mejor reputación y velocidad se utilizan con más frecuencia. Por ejemplo, las IP residenciales reciben un peso de 0.6 y las de centro de datos un 0.4.

2. Rotación Geo-dirigida

Selección automática de proxy de un país/ciudad específico según la URL de destino. Por ejemplo, para un dominio .de se utilizan proxies alemanes.

3. Verificación de Salud y Eliminación Automática (Health Check & Auto-removal)

Verificación periódica de la salud del proxy y exclusión automática de los que no funcionan del pool. Recuperación después de un período de "cooldown".

4. Rotación Adaptativa a la Tasa de Solicitudes

La frecuencia de rotación se adapta automáticamente en función de los códigos HTTP recibidos. Si se recibe 429 (Too Many Requests), la rotación se acelera.

1. Tipo de sitio web de destino

• Sitios altamente protegidos (bancos, redes sociales): Rotación cada 3-5 solicitudes o cada 10-15 minutos
• E-commerce (Amazon, Walmart): Rotación cada 5-10 solicitudes o cada 5-10 minutos
• Sitios de noticias: Rotación cada 10-20 solicitudes o cada 15-30 minutos
• APIs públicas: Según la documentación (a menudo 100-1000 req/hora por IP)
• Sitios estáticos: Rotación cada 20-50 solicitudes o cada 30-60 minutos

2. Volumen de datos a recopilar

• Volumen pequeño (hasta 1,000 páginas): Basada en tiempo, rotación cada 15-30 minutos
• Volumen medio (1,000-10,000 páginas): Basada en solicitud, rotación cada 10-15 solicitudes
• Volumen grande (10,000+ páginas): Rotación por solicitud (per-request) con un pool grande de proxies

3. Tamaño del pool de proxies

• Pool pequeño (10-50 IP): Rotación basada en tiempo de 30-60 minutos para que cada IP se "enfríe"
• Pool mediano (50-200 IP): Rotación basada en solicitud de 10-20 solicitudes por IP
• Pool grande (200+ IP): Rotación por solicitud, máxima velocidad

4. Requisitos de sesión

• Sin autorización: Rotación agresiva, cada 1-5 solicitudes
• Con autorización: Sticky session durante toda la operación (1-24 horas)
• Modo híbrido: Sticky para autorización, rotating para recolección de datos

Escenario de uso	Frecuencia de rotación	Tamaño del pool	Retraso entre solicitudes
Scraping de búsqueda en Google	Cada 3-5 solicitudes	200-500 IP	5-10 seg
Monitoreo de precios en Amazon	Cada 5-10 solicitudes	100-300 IP	3-7 seg
Automatización de Instagram	Sticky 1-2 horas	1 IP por cuenta	30-60 seg
Agregador de noticias	Cada 15-30 minutos	50-100 IP	1-3 seg
Scraping de bienes raíces	Cada 10-20 solicitudes	50-200 IP	2-5 seg
Monitoreo de API	Según límites de API	Según límites	Según documentación
Seguimiento de posiciones SEO	Cada 20-30 solicitudes	100-300 IP	3-8 seg
Scraping de Avito/Yula	Cada 7-15 solicitudes	100-200 IP	3-6 seg

1. Round-Robin (cíclico)

Los proxies se seleccionan secuencialmente de la lista. Después del último, se vuelve al primero. Es el método más simple, asegura una distribución uniforme.

2. Aleatorio (Random)

Cada vez se elige un proxy aleatorio del pool. Un patrón menos predecible, más difícil de detectar.

3. Menos Conexiones (Least Connections)

Se elige el proxy con la menor cantidad de conexiones activas. Ideal para solicitudes paralelas.

4. Round-Robin Ponderado

Los proxies con mejor rendimiento obtienen un peso mayor y se utilizan con más frecuencia. Las IP residenciales pueden tener un peso de 3, y las de centro de datos un peso de 1.

5. Hash de IP

El proxy se selecciona en función del hash de la URL o el dominio. Garantiza que las solicitudes a un mismo dominio siempre pasen por la misma IP.

Períodos de enfriamiento recomendados:

• Pool pequeño (10-50 IP): 30-60 minutos entre usos de la misma IP
• Pool mediano (50-200 IP): 15-30 minutos entre usos
• Pool grande (200+ IP): 5-15 minutos o sin cooldown con rotación por solicitud

1. Modo Agresivo (Speed-First)

• Rotación por solicitud: nueva IP para cada solicitud
• Retrasos mínimos (0.5-1 seg entre solicitudes)
• Pool grande de proxies (500+ IP)
• Procesamiento paralelo (5-15 hilos)

⚠️ Riesgos: Alta probabilidad de bloqueos, ciclo de vida corto de la IP, puede activar el rate limiting incluso con rotación.

📊 Adecuado para: Tareas únicas, recopilación de datos públicos, sitios tolerantes.

2. Modo Equilibrado (Balanced)

• Rotación basada en solicitud: cada 10-20 solicitudes
• Retrasos medios (2-5 seg entre solicitudes)
• Pool medio de proxies (100-300 IP)
• Paralelismo moderado (5-15 hilos)

✅ Ventajas: Buen equilibrio entre velocidad y estabilidad, adecuado para la mayoría de las tareas.

📊 Adecuado para: Monitoreo de e-commerce, scraping regular, proyectos a largo plazo.

3. Modo Cauteloso (Stealth-First)

• Rotación basada en tiempo: cada 15-30 minutos
• Retrasos grandes (5-15 seg entre solicitudes)
• Pool pequeño de proxies de alta calidad (50-100 IP residenciales)
• Paralelismo mínimo (1-3 hilos)
• Simulación de comportamiento humano (retrasos aleatorios, acciones del usuario)

✅ Ventajas: Mínimo riesgo de bloqueo, estabilidad a largo plazo, parece usuarios reales.

📊 Adecuado para: Redes sociales, sitios altamente protegidos, trabajo con cuentas, inteligencia competitiva.

❌ Problema 1: Recibo 429 (Too Many Requests) incluso con rotación

Posibles causas:

• Rotación demasiado frecuente hacia el mismo dominio
• Todos los proxies son de la misma subred (detectado por ASN)
• No se rotan los User-Agent y otros encabezados
• Período de cooldown demasiado corto

✅ Soluciones:

• Aumentar los retrasos entre solicitudes a 5-10 segundos
• Usar proxies residenciales en lugar de los de centro de datos
• Añadir rotación de User-Agent, encabezados, huella digital TLS
• Aumentar el tamaño del pool de proxies 2-3 veces
• Añadir jitter (desviación aleatoria) a los retrasos

❌ Problema 2: CAPTCHAs constantes al cambiar de IP

Posibles causas:

• Proxies de centro de datos con mala reputación
• La rotación demasiado agresiva genera sospechas
• Uso de proxies públicos (gratuitos)
• La huella digital del navegador (fingerprint) no cambia al cambiar de IP

✅ Soluciones:

• Cambiar a proxies residenciales o móviles
• Usar sesiones persistentes en lugar de rotación constante
• Integrar servicios de resolución de CAPTCHA (2Captcha, AntiCaptcha)
• Usar navegadores sin cabeza con anti-detección (Playwright, puppeteer-extra-plugin-stealth)
• "Calentar" los proxies antes del trabajo principal (algunas solicitudes simples)

❌ Problema 3: Pérdida de sesión al autorizar

Posibles causas:

• La rotación de IP rompe la sesión
• Las cookies no se guardan entre solicitudes
• La sesión persistente ha expirado

✅ Soluciones:

• Usar sesiones persistentes con session_id para solicitudes autorizadas
• Aumentar la duración de la sesión persistente (1-24 horas)
• Guardar y reutilizar cookies/tokens entre sesiones
• Enfoque híbrido: sticky para autorización, rotating para recolección de datos

❌ Problema 4: Agotamiento rápido del pool de proxies

Posibles causas:

• Rotación por solicitud demasiado agresiva
• Pool pequeño para un gran volumen de trabajo
• El período de cooldown no se tiene en cuenta

✅ Soluciones:

• Cambiar a rotación por ráfaga (cambio cada N solicitudes en lugar de cada una)
• Aumentar el pool de proxies proporcionalmente a la carga
• Implementar una cola con seguimiento de cooldown
• Usar la puerta de enlace de proxy rotativo del proveedor

❌ Problema 5: Baja velocidad de scraping

Posibles causas:

• Proxies lentos (alto ping)
• Procesamiento secuencial en lugar de paralelo
• Grandes retrasos entre solicitudes
• Sobrecarga de conexión al rotar frecuentemente

✅ Soluciones:

• Usar agrupación de conexiones (connection pooling) y keep-alive
• Procesamiento paralelo de solicitudes (threading/asyncio)
• Elegir proxies con bajo ping (filtrar por latencia)
• Reducir la frecuencia de rotación (ráfaga en lugar de por solicitud)
• Usar proxies más rápidos (ISP en lugar de residenciales)

Métrica	Normal	Problema si
Tasa de Éxito (Success Rate)	> 95%	< 85%
Tasa de Error 429	< 2%	> 10%
Tasa de Error 403/503	< 3%	> 15%
Tasa de CAPTCHA	< 1%	> 5%
Tiempo Promedio de Respuesta	< 3 seg	> 10 seg
Tasa de Tiempo de Espera (Timeout)	< 1%	> 5%
IP Únicas Usadas	> 80% del pool	< 50% del pool

✅ 1. Siempre combine la rotación de IP con otras técnicas

La rotación de IP es solo un componente. También rote User-Agent, use navegadores reales (Puppeteer/Playwright), simule comportamiento humano, rote encabezados y cookies.

✅ 2. Use proxies residenciales/móviles para tareas críticas

Los proxies de centro de datos son más baratos, pero tienen mala reputación. Para redes sociales, e-commerce y sitios altamente protegidos, use solo IP residenciales o móviles.

✅ 3. Implemente degradación elegante (graceful degradation)

Ante el aumento de errores, reduzca automáticamente la velocidad de las solicitudes, aumente los retrasos, cambie a proxies de mayor calidad. La adaptabilidad es mejor que una configuración rígida.

✅ 4. Pruebe con una muestra pequeña antes de escalar

Antes de iniciar un scraping grande, pruebe la estrategia con 100-1000 solicitudes. Asegúrese de que la tasa de éxito sea > 95%, que no haya bloqueos masivos y que la velocidad sea aceptable.

✅ 5. Respete robots.txt y los Términos de Servicio

El scraping ético es clave para el éxito a largo plazo. Cumpla con robots.txt, no sobrecargue los servidores, no recopile datos personales sin consentimiento. En Rusia, esto está regulado por la ley de datos personales.

✅ 6. Invierta en proxies de calidad

Los proxies gratuitos y baratos resultan más caros a largo plazo: baja velocidad, bloqueos frecuentes, pérdida de datos, riesgos de seguridad. Utilice proveedores probados como ProxyCove con garantía de tiempo de actividad.

Conclusiones clave:

1. No hay solución universal: la elección de la estrategia depende del tipo de sitio, el volumen de datos, el presupuesto y los requisitos de velocidad
2. Tres tipos principales de rotación: basada en tiempo (estabilidad), basada en solicitud (velocidad), aleatoria (sigilo) — use combinaciones
3. Las sesiones persistentes son críticas para trabajar con autorización, carritos y procesos multi-paso. Los proxies rotativos son para scraping masivo
4. La calidad es más importante que la cantidad: 50 IP residenciales son mejores que 500 de centro de datos para la mayoría de las tareas en 2025
5. El monitoreo es obligatorio: rastree la tasa de éxito, los códigos de error, el tiempo de respuesta para optimizar a tiempo
6. Equilibre velocidad y sigilo: el scraping agresivo da resultados a corto plazo, el cauteloso da estabilidad a largo plazo
7. Automatización a través del proveedor: use puertas de enlace rotativas en lugar de soluciones autodesarrolladas para ahorrar tiempo
8. La adaptabilidad es superior a la estaticidad: los sistemas de protección evolucionan, su estrategia debe adaptarse

📋 Lista de verificación antes de iniciar el scraping:

💼 Para negocios:

Si su negocio depende del web scraping (monitoreo de precios, inteligencia competitiva, generación de leads), no escatime en la infraestructura de proxies. El costo del tiempo de inactividad o el bloqueo supera con creces los gastos en proxies de calidad y una rotación adecuada.

🎓 Para desarrolladores:

Invierta tiempo en escribir un sistema de rotación robusto una vez, en lugar de resolver problemas de bloqueo constantemente. Utilice bibliotecas listas, registre métricas, pruebe diferentes estrategias. La automatización se amortizará muchas veces.