Configuración de proxy en Selenium: guía con ejemplos de código

```html

Selenium WebDriver es una de las herramientas más populares para la automatización del navegador y el raspado de datos. Al trabajar con grandes volúmenes de solicitudes o al necesitar eludir restricciones geográficas, es crítico configurar correctamente el proxy. En esta guía, exploraremos todas las formas de integrar proxies en Selenium para diferentes navegadores y lenguajes de programación, así como resolver problemas comunes que enfrentan los desarrolladores.

¿Por qué se necesitan proxies en Selenium?

Al automatizar el raspado web o las pruebas a través de Selenium, surgen varias tareas que no se pueden resolver sin proxies:

Eludir limitaciones de tasa — muchos sitios limitan la cantidad de solicitudes desde una sola dirección IP. Sin un proxy, tu script será bloqueado rápidamente después de 50-100 solicitudes.
Restricciones geográficas — si necesitas raspar contenido disponible solo desde un país específico, un proxy con IP de la geolocalización necesaria resuelve esta tarea.
Distribución de carga — al raspar datos masivamente, la rotación de direcciones IP a través de proxies permite distribuir las solicitudes y evitar la detección de bots.
Pruebas de localización — para verificar cómo se muestra un sitio a usuarios de diferentes países, se necesitan proxies de las regiones correspondientes.
Eludir sistemas anti-bots — las protecciones modernas (Cloudflare, DataDome) analizan la reputación de la IP. Proxies de calidad ayudan a parecer un usuario normal.

Sin una configuración adecuada de proxies, tu script de Selenium funcionará de manera inestable: recibirá captchas, baneos temporales o un bloqueo total de acceso. Esto es especialmente crítico al raspar plataformas de comercio electrónico, redes sociales o sitios con protección agresiva contra bots.

Qué tipos de proxies utilizar

La elección del tipo de proxy depende de la tarea. Para la automatización de Selenium, se utilizan tres tipos principales de proxies, cada uno con sus ventajas:

Tipo de proxy	Velocidad	Anonimato	Mejores escenarios
Proxies de centros de datos	Muy alta (100+ Mbps)	Media	Raspado de datos públicos, pruebas de rendimiento, verificaciones masivas
Proxies residenciales	Media (10-50 Mbps)	Muy alta	Eludir sistemas anti-bots, raspado de redes sociales, comercio electrónico, sitios con protección estricta
Proxies móviles	Media (5-30 Mbps)	Máxima	Trabajo con versiones móviles de sitios, redes sociales, aplicaciones con verificación de IP móviles

Recomendaciones para la elección:

Para raspar sitios de noticias, API abiertas, catálogos simples — son adecuados los proxies de centros de datos. Son más baratos y rápidos.
Para trabajar con Amazon, eBay, Google, redes sociales — solo proxies residenciales. Estas plataformas bloquean activamente las IP de centros de datos.
Para emular usuarios móviles o trabajar con Instagram, TikTok — los proxies móviles son indispensables.
Para pruebas de geolocalización — elige proxies con la opción de seleccionar un país y ciudad específicos.

Configuración de proxy para Chrome en Selenium

Chrome WebDriver es la opción más popular para la automatización de Selenium. La configuración del proxy se realiza a través del objeto ChromeOptions. Veamos algunas formas.

Método 1: Proxy HTTP/HTTPS sin autenticación (Python)

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

# Configuración del proxy
PROXY = "123.45.67.89:8080"  # Reemplaza con tu servidor proxy

chrome_options = Options()
chrome_options.add_argument(f'--proxy-server=http://{PROXY}')

# Opciones adicionales para estabilidad
chrome_options.add_argument('--no-sandbox')
chrome_options.add_argument('--disable-dev-shm-usage')

# Iniciar el controlador
driver = webdriver.Chrome(options=chrome_options)

# Verificar IP
driver.get('https://httpbin.org/ip')
print(driver.page_source)

driver.quit()

Método 2: Proxy SOCKS5 (Python)

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

PROXY = "123.45.67.89:1080"

chrome_options = Options()
# Para SOCKS5, especificamos el protocolo explícitamente
chrome_options.add_argument(f'--proxy-server=socks5://{PROXY}')

driver = webdriver.Chrome(options=chrome_options)
driver.get('https://httpbin.org/ip')
print(driver.page_source)
driver.quit()

Importante: Chrome admite proxies HTTP, HTTPS y SOCKS5. Para SOCKS4 se requieren configuraciones adicionales o el uso de extensiones.

Configuración de proxy para Chrome en Java

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.chrome.ChromeOptions;
import org.openqa.selenium.Proxy;

public class ChromeProxyExample {
    public static void main(String[] args) {
        // Configuración del proxy
        Proxy proxy = new Proxy();
        proxy.setHttpProxy("123.45.67.89:8080");
        proxy.setSslProxy("123.45.67.89:8080");
        
        ChromeOptions options = new ChromeOptions();
        options.setProxy(proxy);
        options.addArguments("--no-sandbox");
        
        WebDriver driver = new ChromeDriver(options);
        driver.get("https://httpbin.org/ip");
        
        System.out.println(driver.getPageSource());
        driver.quit();
    }
}

Configuración de proxy para Firefox en Selenium

Firefox WebDriver utiliza un enfoque diferente para configurar proxies a través del perfil del navegador. Esto ofrece más flexibilidad, pero requiere entender los parámetros de configuración.

Proxy HTTP/HTTPS para Firefox (Python)

from selenium import webdriver
from selenium.webdriver.firefox.options import Options

PROXY_HOST = "123.45.67.89"
PROXY_PORT = 8080

firefox_options = Options()

# Configuración del proxy a través de preferencias
firefox_options.set_preference("network.proxy.type", 1)
firefox_options.set_preference("network.proxy.http", PROXY_HOST)
firefox_options.set_preference("network.proxy.http_port", PROXY_PORT)
firefox_options.set_preference("network.proxy.ssl", PROXY_HOST)
firefox_options.set_preference("network.proxy.ssl_port", PROXY_PORT)

# Desactivar el proxy para direcciones locales
firefox_options.set_preference("network.proxy.no_proxies_on", "localhost,127.0.0.1")

driver = webdriver.Firefox(options=firefox_options)
driver.get('https://httpbin.org/ip')
print(driver.page_source)
driver.quit()

Proxy SOCKS5 para Firefox (Python)

from selenium import webdriver
from selenium.webdriver.firefox.options import Options

PROXY_HOST = "123.45.67.89"
PROXY_PORT = 1080

firefox_options = Options()

firefox_options.set_preference("network.proxy.type", 1)
firefox_options.set_preference("network.proxy.socks", PROXY_HOST)
firefox_options.set_preference("network.proxy.socks_port", PROXY_PORT)
firefox_options.set_preference("network.proxy.socks_version", 5)

# Para SOCKS5 con DNS a través del proxy
firefox_options.set_preference("network.proxy.socks_remote_dns", True)

driver = webdriver.Firefox(options=firefox_options)
driver.get('https://httpbin.org/ip')
print(driver.page_source)
driver.quit()

Ventaja de Firefox: el parámetro network.proxy.socks_remote_dns permite realizar consultas DNS a través del proxy, lo que aumenta el anonimato y ayuda a eludir bloqueos a nivel de DNS.

Trabajando con proxies que requieren autenticación

La mayoría de los servicios de proxy de calidad utilizan autenticación por nombre de usuario y contraseña. Selenium no admite la transmisión de credenciales directamente en la URL del proxy para Chrome, por lo que se requieren soluciones alternativas.

Método 1: Extensión de Chrome para autenticación (recomendado)

Creamos una extensión temporal de Chrome que inserta automáticamente el nombre de usuario y la contraseña al conectarse al proxy:

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

PROXY_HOST = "123.45.67.89"
PROXY_PORT = 8080
PROXY_USER = "username"
PROXY_PASS = "password"

# Creación del manifiesto de la extensión
manifest_json = """
{
    "version": "1.0.0",
    "manifest_version": 2,
    "name": "Chrome Proxy",
    "permissions": [
        "proxy",
        "tabs",
        "unlimitedStorage",
        "storage",
        "webRequest",
        "webRequestBlocking"
    ],
    "background": {
        "scripts": ["background.js"]
    }
}
"""

# Script para autenticación
background_js = """
var config = {
    mode: "fixed_servers",
    rules: {
        singleProxy: {
            scheme: "http",
            host: "%s",
            port: parseInt(%s)
        },
        bypassList: ["localhost"]
    }
};

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

function callbackFn(details) {
    return {
        authCredentials: {
            username: "%s",
            password: "%s"
        }
    };
}

chrome.webRequest.onAuthRequired.addListener(
    callbackFn,
    {urls: [""]},
    ['blocking']
);
""" % (PROXY_HOST, PROXY_PORT, PROXY_USER, PROXY_PASS)

# Creación de la extensión
plugin_path = 'proxy_auth_plugin.zip'
with zipfile.ZipFile(plugin_path, 'w') as zp:
    zp.writestr("manifest.json", manifest_json)
    zp.writestr("background.js", background_js)

# Iniciar Chrome con la extensión
chrome_options = Options()
chrome_options.add_extension(plugin_path)

driver = webdriver.Chrome(options=chrome_options)
driver.get('https://httpbin.org/ip')
print(driver.page_source)

driver.quit()
os.remove(plugin_path)  # Eliminación del archivo temporal

Método 2: Firefox con autenticación (más fácil)

Firefox permite transmitir credenciales a través de la configuración del perfil:

from selenium import webdriver
from selenium.webdriver.firefox.options import Options

PROXY_HOST = "123.45.67.89"
PROXY_PORT = 8080
PROXY_USER = "username"
PROXY_PASS = "password"

firefox_options = Options()

firefox_options.set_preference("network.proxy.type", 1)
firefox_options.set_preference("network.proxy.http", PROXY_HOST)
firefox_options.set_preference("network.proxy.http_port", PROXY_PORT)
firefox_options.set_preference("network.proxy.ssl", PROXY_HOST)
firefox_options.set_preference("network.proxy.ssl_port", PROXY_PORT)

# Autenticación (no siempre funciona, depende de la versión de Firefox)
firefox_options.set_preference("network.proxy.username", PROXY_USER)
firefox_options.set_preference("network.proxy.password", PROXY_PASS)

# Desactivar la solicitud de autenticación
firefox_options.set_preference("network.automatic-ntlm-auth.trusted-uris", PROXY_HOST)

driver = webdriver.Firefox(options=firefox_options)
driver.get('https://httpbin.org/ip')
print(driver.page_source)
driver.quit()

Nota: Si tu proveedor de proxy admite listas blancas de IP, es más fácil agregar la IP de tu servidor a la lista blanca y usar el proxy sin autenticación.

Rotación de proxies en Selenium

Al raspar grandes volúmenes de datos, es crítico cambiar de proxy para evitar bloqueos. Existen dos enfoques: rotación a nivel de código y uso de proxies rotativos.

Rotación a nivel de código (creación de un nuevo controlador)

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

# Lista de proxies
PROXY_LIST = [
    "123.45.67.89:8080",
    "98.76.54.32:8080",
    "11.22.33.44:8080",
]

def create_driver_with_proxy(proxy):
    """Crear un controlador con el proxy especificado"""
    chrome_options = Options()
    chrome_options.add_argument(f'--proxy-server=http://{proxy}')
    chrome_options.add_argument('--no-sandbox')
    return webdriver.Chrome(options=chrome_options)

# Raspado con rotación
urls_to_parse = [
    'https://example.com/page1',
    'https://example.com/page2',
    'https://example.com/page3',
]

for url in urls_to_parse:
    # Elegir un proxy aleatorio
    current_proxy = random.choice(PROXY_LIST)
    
    # Crear un nuevo controlador con el proxy
    driver = create_driver_with_proxy(current_proxy)
    
    try:
        driver.get(url)
        # Tu lógica de raspado
        print(f"Raspado {url} a través de {current_proxy}")
        print(driver.title)
    except Exception as e:
        print(f"Error con {current_proxy}: {e}")
    finally:
        driver.quit()  # Importante cerrar el controlador

Uso de proxies rotativos (más fácil)

Muchos proveedores de proxies ofrecen un endpoint rotativo: una URL que cambia automáticamente la IP en cada solicitud o a intervalos específicos. Esto simplifica el código:

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

# Endpoint de proxy rotativo (la IP cambia automáticamente)
ROTATING_PROXY = "rotating.proxycove.com:8080"

chrome_options = Options()
chrome_options.add_argument(f'--proxy-server=http://{ROTATING_PROXY}')

driver = webdriver.Chrome(options=chrome_options)

# Cada solicitud será con una nueva IP
urls = ['https://httpbin.org/ip'] * 5

for url in urls:
    driver.get(url)
    print(driver.find_element("tag name", "body").text)
    # Cada salida mostrará una IP diferente

driver.quit()

Recomendación: Para proyectos grandes, utiliza proxies rotativos: ahorra recursos (no es necesario recrear el controlador) y simplifica el código. Los proxies residenciales suelen admitir rotación de forma nativa.

Errores comunes y su solución

Error: "ERR_PROXY_CONNECTION_FAILED"

Causa: Selenium no puede conectarse al servidor proxy.

Solución:

Verifica la dirección IP y el puerto del proxy
Asegúrate de que el proxy esté activo (verifica a través de curl: curl -x http://123.45.67.89:8080 https://httpbin.org/ip)
Verifica el firewall — es posible que las conexiones salientes al proxy estén bloqueadas
Si usas autenticación, verifica la exactitud del nombre de usuario/contraseña

Error: "ERR_TUNNEL_CONNECTION_FAILED"

Causa: Problema con la conexión HTTPS a través del proxy.

Solución:

Asegúrate de que el proxy admita HTTPS (método CONNECT)
Para sitios HTTPS, utiliza proxies HTTPS o SOCKS5
Agrega la opción para ignorar errores SSL: chrome_options.add_argument('--ignore-certificate-errors')

Error: El proxy funciona, pero el sitio detecta el bot

Causa: El sitio utiliza métodos avanzados de detección (huellas digitales, análisis de comportamiento).

Solución:

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

chrome_options = Options()
chrome_options.add_argument(f'--proxy-server=http://{PROXY}')

# Desactivar la bandera del webdriver (principal indicador de automatización)
chrome_options.add_experimental_option("excludeSwitches", ["enable-automation"])
chrome_options.add_experimental_option('useAutomationExtension', False)

driver = webdriver.Chrome(options=chrome_options)

# Eliminar navigator.webdriver
driver.execute_cdp_cmd('Page.addScriptToEvaluateOnNewDocument', {
    'source': '''
        Object.defineProperty(navigator, 'webdriver', {
            get: () => undefined
        })
    '''
})

driver.get('https://bot.sannysoft.com/')  # Sitio para verificar detección

Además, se recomienda utilizar la biblioteca undetected-chromedriver, que aplica automáticamente muchas técnicas anti-detección.

Problema: Carga lenta de páginas a través del proxy

Causa: El proxy está sobrecargado o se encuentra geográficamente lejos.

Solución:

Elige proxies más cercanos al servidor objetivo (por ejemplo, para raspar sitios de EE. UU., utiliza proxies de EE. UU.)
Utiliza proxies de centros de datos para tareas donde la velocidad es más importante que el anonimato
Configura los tiempos de espera en Selenium para evitar bloqueos:

from selenium.webdriver.support.ui import WebDriverWait

driver.set_page_load_timeout(30)  # Máximo 30 segundos para cargar
driver.implicitly_wait(10)  # Espera implícita para elementos

Mejores prácticas al trabajar con proxies

1. Utiliza grupos de proxies
No confíes en un solo servidor proxy. Crea un grupo de 10-50 proxies y rótalos. Si un proxy es bloqueado, el raspado continuará con otro.

2. Agrega retrasos aleatorios
Incluso con proxies, solicitudes demasiado rápidas parecen sospechosas. Agrega retrasos aleatorios de 2-5 segundos entre solicitudes:

import time
import random

for url in urls:
    driver.get(url)
    # Raspado...
    time.sleep(random.uniform(2, 5))  # Retraso aleatorio de 2-5 seg

3. Monitorea la calidad de los proxies
Verifica los proxies antes de usarlos. Excluye del grupo aquellos que no responden o devuelven errores:

import requests

def check_proxy(proxy):
    """Verificar la funcionalidad del proxy"""
    try:
        response = requests.get(
            'https://httpbin.org/ip',
            proxies={'http': f'http://{proxy}', 'https': f'http://{proxy}'},
            timeout=10
        )
        return response.status_code == 200
    except:
        return False

# Filtrar proxies funcionales
working_proxies = [p for p in PROXY_LIST if check_proxy(p)]
print(f"Proxies funcionales: {len(working_proxies)}/{len(PROXY_LIST)}")

4. Usa el modo headless con precaución
Los navegadores headless son más fáciles de detectar. Para sitios complejos, ejecuta el navegador en modo normal o usa --window-size en lugar de --headless.

5. Registra todas las solicitudes
Guarda información sobre qué proxy se utilizó para cada solicitud. Esto ayudará a identificar proxies problemáticos y depurar errores.

6. Respeta robots.txt y límites de tasa
Incluso con proxies, respeta las reglas del sitio. El raspado agresivo puede llevar al bloqueo de subredes completas de proxies, lo que perjudica a otros usuarios.

Conclusión

La configuración adecuada de proxies en Selenium WebDriver es fundamental para un raspado y automatización estables. Hemos revisado todas las formas principales de integrar proxies para Chrome y Firefox, trabajar con autenticación, rotación de direcciones IP y resolver problemas comunes. Lo más importante es elegir el tipo de proxy adecuado para tu tarea: para un raspado simple, son suficientes los proxies de centros de datos, mientras que para trabajar con plataformas protegidas se necesitan proxies residenciales o móviles.

Recuerda las mejores prácticas: utiliza grupos de proxies, agrega retrasos aleatorios, monitorea la calidad de las conexiones y aplica técnicas anti-detección. Esto aumentará la estabilidad de tus scripts y reducirá el riesgo de bloqueos en decenas de veces.

Si planeas automatizar el raspado con altos requisitos de anonimato y eludir sistemas anti-bots, te recomendamos probar proxies residenciales — proporcionan la máxima estabilidad al trabajar con cualquier sitio, incluidas redes sociales, plataformas de comercio electrónico y servicios con protección avanzada. Para tareas donde la velocidad de procesamiento de grandes volúmenes de datos es crítica, los proxies de centros de datos serán la opción óptima en términos de relación calidad-precio.

```

Configuración de proxy en Selenium WebDriver: guía completa con ejemplos de código para Python y Java

¿Por qué se necesitan proxies en Selenium?

Qué tipos de proxies utilizar

Configuración de proxy para Chrome en Selenium

Método 1: Proxy HTTP/HTTPS sin autenticación (Python)

Método 2: Proxy SOCKS5 (Python)

Configuración de proxy para Chrome en Java

Configuración de proxy para Firefox en Selenium

Proxy HTTP/HTTPS para Firefox (Python)

Proxy SOCKS5 para Firefox (Python)

Trabajando con proxies que requieren autenticación

Método 1: Extensión de Chrome para autenticación (recomendado)

Método 2: Firefox con autenticación (más fácil)

Rotación de proxies en Selenium

Rotación a nivel de código (creación de un nuevo controlador)

Uso de proxies rotativos (más fácil)

Errores comunes y su solución

Error: "ERR_PROXY_CONNECTION_FAILED"

Error: "ERR_TUNNEL_CONNECTION_FAILED"

Error: El proxy funciona, pero el sitio detecta el bot

Problema: Carga lenta de páginas a través del proxy

Mejores prácticas al trabajar con proxies

Conclusión