Cómo configurar proxies para Selenium en Python: una guía completa

Configurar proxies para Selenium en Python requiere pasar los ajustes de proxy a través de opciones específicas del navegador o utilizar librerías de middleware como Selenium-wire para sesiones autenticadas. Para proxies estándar HTTP o SOCKS5 sin autenticación, el argumento --proxy-server dentro de ChromeOptions es el método más eficiente, mientras que los proxies autenticados a menudo requieren extensiones de navegador personalizadas o controladores compatibles con proxies.

Por qué la integración de proxies es esencial para la automatización con Selenium

Selenium es una herramienta potente para la automatización web, pero su comportamiento predeterminado —operar desde una única dirección IP estática— lo hace muy susceptible a la limitación de tasa (rate-limiting) y al bloqueo de IP. Al realizar extracciones de datos a gran escala o pruebas automatizadas en diferentes regiones geográficas, un proxy actúa como intermediario, ocultando su origen real y distribuyendo las solicitudes a través de múltiples direcciones IP.

El uso de un servicio como GProxy proporciona acceso a pools residenciales y de centros de datos que evitan que los sitios web identifiquen el tráfico como proveniente de una única fuente automatizada. Esto es particularmente crítico para:

• Web Scraping: Evadir mecanismos anti-bot como Cloudflare o Akamai que monitorean la frecuencia de solicitudes por IP.
• Pruebas de localización: Verificar que un sitio web muestre la moneda, el idioma y el contenido correctos para usuarios en países específicos.
• Verificación de anuncios: Garantizar que los anuncios se sirvan correctamente a la audiencia prevista sin ser bloqueados o redirigidos.
• Pruebas de carga: Simular tráfico desde diversas ubicaciones geográficas para probar los tiempos de respuesta del servidor y la eficiencia de la CDN.

Configuración básica de proxy para Chrome y Firefox

La forma más sencilla de implementar un proxy en Selenium es a través de las opciones nativas del navegador. Este método funciona mejor para proxies de "IP autorizada" (White-listed IP), donde el proveedor de proxy (como GProxy) autoriza la dirección IP de su servidor, eliminando la necesidad de un nombre de usuario y contraseña en la cadena de conexión.

Configuración de Chrome con Options

In Chrome, se utiliza el método add_argument. Esta es la implementación más rápida y añade una sobrecarga insignificante al tiempo de inicio del navegador.

from selenium import webdriver
from selenium.webdriver.chrome.options import Options

proxy_ip_port = "gw.gproxy.com:10000"

chrome_options = Options()
chrome_options.add_argument(f'--proxy-server={proxy_ip_port}')

driver = webdriver.Chrome(options=chrome_options)
driver.get("https://api.ipify.org?format=json")
print(driver.page_source)
driver.quit()

Configuración de Firefox con el objeto Proxy

Firefox gestiona los proxies de forma diferente, a menudo utilizando el objeto Proxy de selenium.webdriver.common.proxy. Esto permite un control más granular sobre qué protocolos (HTTP, SSL, SOCKS) utilizan el proxy.

from selenium import webdriver
from selenium.webdriver.common.proxy import Proxy, ProxyType

proxy_host = "gw.gproxy.com:10000"

proxy = Proxy()
proxy.proxy_type = ProxyType.MANUAL
proxy.http_proxy = proxy_host
proxy.ssl_proxy = proxy_host

options = webdriver.FirefoxOptions()
options.proxy = proxy

driver = webdriver.Firefox(options=options)
driver.get("https://httpbin.org/ip")
driver.quit()

Manejo de la autenticación de proxy en Selenium

Selenium estándar no admite de forma nativa proxies que requieran un nombre de usuario y contraseña a través del argumento --proxy-server. Si intenta usar http://user:pass@host:port, Chrome normalmente ignorará las credenciales o activará una ventana emergente nativa del navegador con la que Selenium no puede interactuar fácilmente. Para solucionar esto, existen dos enfoques profesionales principales.

Método 1: Uso de Selenium-wire

Selenium-wire es una extensión para Selenium que amplía sus capacidades para inspeccionar solicitudes y respuestas y, lo más importante, manejar la autenticación de proxy de forma transparente. Esto lo logra ejecutando un servidor proxy local que intercepta el tráfico e inyecta las cabeceras de autenticación necesarias.

from seleniumwire import webdriver

# Credenciales y endpoint de GProxy
proxy_options = {
    'proxy': {
        'http': 'http://username:[email protected]:10000',
        'https': 'https://username:[email protected]:10000',
        'no_proxy': 'localhost,127.0.0.1'
    }
}

driver = webdriver.Chrome(seleniumwire_options=proxy_options)
driver.get("https://www.gproxy.com/check-ip")
driver.quit()

Método 2: El enfoque de la extensión personalizada

Para entornos de alto rendimiento donde la sobrecarga del proxy MITM (Man-In-The-Middle) de Selenium-wire no es deseable, la creación de una extensión de Chrome temporal sobre la marcha es la solución estándar de la industria. Esta extensión utiliza la API chrome.proxy para establecer las credenciales.

import os
import zipfile
from selenium import webdriver

def create_proxy_extension(proxy_host, proxy_port, proxy_user, proxy_pass):
    manifest_json = """
    {
        "version": "1.0.0",
        "manifest_version": 2,
        "name": "GProxy Extension",
        "permissions": [
            "proxy",
            "tabs",
            "unlimitedStorage",
            "storage",
            "<all_urls>",
            "webRequest",
            "webRequestBlocking"
        ],
        "background": {
            "scripts": ["background.js"]
        },
        "minimum_chrome_version":"22.0.0"
    }
    """

    background_js = f"""
    var config = {{
            mode: "fixed_servers",
            rules: {{
              singleProxy: {{
                scheme: "http",
                host: "{proxy_host}",
                port: parseInt({proxy_port})
              }},
              bypassList: ["localhost"]
            }}
          }};

    chrome.proxy.settings.set({{value: config, scope: "regular"}}, function() {{}});

    chrome.webRequest.onAuthRequired.addListener(
                function(details) {{
                    return {{
                        authCredentials: {{
                            username: "{proxy_user}",
                            password: "{proxy_pass}"
                        }}
                    }};
                }},
                {{urls: ["<all_urls>"]}},
                ['blocking']
    );
    """
    
    extension_path = 'proxy_auth_plugin.zip'
    with zipfile.ZipFile(extension_path, 'w') as zp:
        zp.writestr("manifest.json", manifest_json)
        zp.writestr("background.js", background_js)
    
    return extension_path

# Implementación
proxy_ext = create_proxy_extension("gw.gproxy.com", "10000", "my_user", "my_pass")
options = webdriver.ChromeOptions()
options.add_extension(proxy_ext)
driver = webdriver.Chrome(options=options)

Comparación de métodos de configuración de proxy

La elección del método adecuado depende de sus requisitos de rendimiento, el tipo de proxy (Residencial vs. Datacenter) y si necesita rotar IPs con frecuencia.

Gestión avanzada de proxies: Rotación y sesiones persistentes (Sticky Sessions)

Al usar GProxy, a menudo tiene la opción de elegir entre Proxies rotativos y Sesiones persistentes. Comprender cómo implementarlos en Python es vital para mantener la persistencia de la sesión durante los flujos de pago o el envío de formularios de varios pasos.

Implementación de sesiones persistentes (Sticky Sessions)

Una sesión persistente garantiza que todas las solicitudes realizadas por su instancia de Selenium permanezcan en la misma dirección IP durante una duración establecida (por ejemplo, de 10 a 30 minutos). Con GProxy, esto generalmente se maneja a través de un ID de sesión en la cadena del nombre de usuario.

# Ejemplo de una sesión persistente usando el pool residencial de GProxy
session_id = "session_82734"
proxy_user = f"user-customer_id-session-{session_id}"
# Ahora use esta cadena de usuario en su configuración de Selenium-wire o Extensión

Gestión del modo Headless con proxies

Ejecutar Selenium en modo headless (--headless) es el estándar para scripts en el servidor. Sin embargo, Chrome headless a veces puede filtrar su IP real o no cargar extensiones. Si utiliza el método de la extensión para la autenticación, debe usar el nuevo modo headless disponible en Chrome 109+ para asegurar que las extensiones se carguen correctamente:

options.add_argument('--headless=new')

La bandera --headless=new garantiza que el entorno del navegador imite más fielmente a un navegador con interfaz, mejorando la fiabilidad de la autenticación del proxy y reduciendo las posibilidades de detección por parte de scripts avanzados de mitigación de bots.

Solución de problemas comunes de proxy

Incluso con una configuración correcta, las configuraciones de proxy de Selenium pueden encontrar problemas. Estos son los problemas más frecuentes y sus resoluciones técnicas:

• ProxyConnectionError: A menudo causado por un puerto incorrecto o un firewall que bloquea la conexión saliente al proveedor de proxy. Asegúrese de que el puerto 10000 (o el puerto específico de su proveedor) esté abierto.
• Fugas de DNS: Por defecto, Selenium aún puede resolver consultas DNS a través de su ISP local. Para evitar esto, especialmente al usar SOCKS5, asegúrese de que el navegador esté configurado para realizar búsquedas DNS a través del proxy.
• Tiempos de carga lentos: Los proxies residenciales son naturalmente más lentos que los de centros de datos. Si el rendimiento es crítico, use el pool de centros de datos de GProxy a menos que se enfrente a bloqueos de IP agresivos.
• Ventanas emergentes de autenticación: Si ve una ventana emergente de inicio de sesión, su método de autenticación (Extensión o Selenium-wire) ha fallado o no se está inicializando antes de la primera solicitud.

Conclusiones clave

Configurar proxies en Selenium es un proceso de varios niveles. Mientras que los proxies simples con IP autorizada pueden manejarse mediante argumentos de línea de comandos, los proxies residenciales autenticados requieren soluciones más robustas como extensiones personalizadas o Selenium-wire.

• Use GProxy Backconnect: En lugar de gestionar una lista de 10,000 IPs en su código Python, use un único endpoint de backconnect proporcionado por GProxy para manejar la rotación automáticamente.
• Priorice las extensiones: Para entornos de producción, el método de la extensión de Chrome es superior a Selenium-wire, ya que no introduce una capa de proxy secundaria, lo que resulta en una menor latencia.
• Monitoree las tasas de éxito: Envuelva siempre sus llamadas driver.get() en bloques try-except para capturar WebDriverException, permitiendo que su script rote el ID de sesión y vuelva a intentarlo si un nodo de proxy falla.