Configuração de proxy no Selenium: guia com exemplos de código

```html

Selenium WebDriver é uma das ferramentas mais populares para automação de navegador e raspagem de dados. Ao trabalhar com grandes volumes de solicitações ou ao precisar contornar restrições geográficas, é criticamente importante configurar o proxy corretamente. Neste guia, abordaremos todas as maneiras de integrar proxy no Selenium para diferentes navegadores e linguagens de programação, além de resolver problemas comuns enfrentados pelos desenvolvedores.

Por que usar proxies no Selenium

Ao automatizar a raspagem da web ou testes através do Selenium, surgem várias tarefas que não podem ser resolvidas sem proxies:

Contornar limitações de taxa — muitos sites limitam o número de solicitações de um único endereço IP. Sem proxies, seu script rapidamente será bloqueado após 50-100 solicitações.
Restrições geográficas — se você precisa raspar conteúdo disponível apenas de um determinado país, proxies com IP da geolocalização necessária resolvem essa tarefa.
Distribuição de carga — ao realizar raspagem em massa de dados, a rotação de endereços IP através de proxies permite distribuir as solicitações e evitar a detecção de bots.
Teste de localização — para verificar como o site é exibido para usuários de diferentes países, são necessários proxies das regiões correspondentes.
Contornar sistemas anti-bot — as proteções modernas (Cloudflare, DataDome) analisam a reputação do IP. Proxies de qualidade ajudam a parecer um usuário comum.

Sem a configuração correta do proxy, seu script Selenium funcionará de forma instável: receberá CAPTCHAs, banimentos temporários ou bloqueio total de acesso. Isso é especialmente crítico ao raspar plataformas de e-commerce, redes sociais ou sites com proteção agressiva contra bots.

Quais tipos de proxy usar

A escolha do tipo de proxy depende da tarefa. Para automação com Selenium, são utilizados três tipos principais de proxies, cada um com suas vantagens:

Tipo de proxy	Velocidade	Anonimato	Melhores cenários
Proxies de data center	Muito alta (100+ Mbps)	Média	Raspagem de dados públicos, teste de desempenho, verificações em massa
Proxies residenciais	Média (10-50 Mbps)	Muito alta	Contornar sistemas anti-bot, raspagem de redes sociais, e-commerce, sites com proteção rigorosa
Proxies móveis	Média (5-30 Mbps)	Máxima	Trabalho com versões móveis de sites, redes sociais, aplicativos com verificação de IPs móveis

Recomendações para escolha:

Para raspagem de sites de notícias, APIs abertas, catálogos simples — proxies de data center são adequados. Eles são mais baratos e mais rápidos.
Para trabalhar com Amazon, eBay, Google, redes sociais — apenas proxies residenciais. Essas plataformas bloqueiam ativamente IPs de data centers.
Para emular usuários móveis ou trabalhar com Instagram, TikTok — proxies móveis são indispensáveis.
Para testar geolocalização — escolha proxies com a capacidade de selecionar um país e cidade específicos.

Configuração de proxy para Chrome no Selenium

Chrome WebDriver é a escolha mais popular para automação com Selenium. A configuração do proxy é feita através do objeto ChromeOptions. Vamos considerar algumas maneiras.

Método 1: Proxy HTTP/HTTPS sem autenticação (Python)

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

# Configuração do proxy
PROXY = "123.45.67.89:8080"  # Substitua pelo seu servidor proxy

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

# Opções adicionais para estabilidade
chrome_options.add_argument('--no-sandbox')
chrome_options.add_argument('--disable-dev-shm-usage')

# Iniciar o driver
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, especifique o protocolo explicitamente
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: O Chrome suporta proxies HTTP, HTTPS e SOCKS5. Para SOCKS4, serão necessárias configurações adicionais ou o uso de extensões.

Configuração de proxy para Chrome em 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) {
        // Configuração do 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();
    }
}

Configuração de proxy para Firefox no Selenium

O Firefox WebDriver utiliza uma abordagem diferente para configurar proxies através do perfil do navegador. Isso oferece mais flexibilidade, mas requer compreensão das opções de configuração.

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()

# Configuração do proxy através de preferências
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)

# Desativar proxy para endereços locais
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 com DNS através do 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()

Vantagem do Firefox: a opção network.proxy.socks_remote_dns permite realizar consultas DNS através do proxy, aumentando a anonimidade e ajudando a contornar bloqueios a nível de DNS.

Trabalhando com proxies que requerem autenticação

A maioria dos serviços de proxy de qualidade utiliza autenticação por login e senha. O Selenium não suporta a passagem de credenciais diretamente na URL do proxy para o Chrome, portanto, são necessárias soluções alternativas.

Método 1: Extensão do Chrome para autenticação (recomendado)

Criamos uma extensão temporária do Chrome que insere automaticamente o login e a senha ao conectar-se ao 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"

# Criação do manifesto da extensão
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 autenticação
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)

# Criação da extensão
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 o Chrome com a extensão
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)  # Remover arquivo temporário

Método 2: Firefox com autenticação (mais simples)

O Firefox permite passar credenciais através das configurações do 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)

# Autenticação (não funciona sempre, depende da versão do Firefox)
firefox_options.set_preference("network.proxy.username", PROXY_USER)
firefox_options.set_preference("network.proxy.password", PROXY_PASS)

# Desativar solicitação de autenticação
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: Se o seu provedor de proxy suporta whitelist de IP, é mais fácil adicionar o IP do seu servidor à lista de permissões e usar o proxy sem autenticação.

Rotação de proxies no Selenium

Ao raspar grandes volumes de dados, é criticamente importante mudar de proxy para evitar bloqueios. Existem duas abordagens: rotação a nível de código e uso de proxies rotativos.

Rotação a nível de código (criação de um novo driver)

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):
    """Criação de um driver com o 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)

# Raspagem com rotação
urls_to_parse = [
    'https://example.com/page1',
    'https://example.com/page2',
    'https://example.com/page3',
]

for url in urls_to_parse:
    # Escolher um proxy aleatório
    current_proxy = random.choice(PROXY_LIST)
    
    # Criar um novo driver com o proxy
    driver = create_driver_with_proxy(current_proxy)
    
    try:
        driver.get(url)
        # Sua lógica de raspagem
        print(f"Raspado {url} via {current_proxy}")
        print(driver.title)
    except Exception as e:
        print(f"Erro com {current_proxy}: {e}")
    finally:
        driver.quit()  # Importante fechar o driver

Uso de proxies rotativos (mais simples)

Muitos provedores de proxy oferecem um endpoint rotativo — uma URL que muda automaticamente o IP a cada solicitação ou em intervalos definidos. Isso simplifica o código:

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

# Endpoint de proxy rotativo (IP muda automaticamente)
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 solicitação será com um novo IP
urls = ['https://httpbin.org/ip'] * 5

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

driver.quit()

Recomendação: Para grandes projetos, use proxies rotativos — isso economiza recursos (não é necessário recriar o driver) e simplifica o código. Proxies residenciais geralmente suportam rotação por padrão.

Erros comuns e suas soluções

Erro: "ERR_PROXY_CONNECTION_FAILED"

Causa: O Selenium não consegue se conectar ao servidor proxy.

Solução:

Verifique a correção do IP e da porta do proxy
Certifique-se de que o proxy está ativo (verifique com curl: curl -x http://123.45.67.89:8080 https://httpbin.org/ip)
Verifique o firewall — pode ser que as conexões de saída para o proxy estejam bloqueadas
Se você estiver usando autenticação, verifique a correção do login/senha

Erro: "ERR_TUNNEL_CONNECTION_FAILED"

Causa: Problema com a conexão HTTPS através do proxy.

Solução:

Certifique-se de que o proxy suporta HTTPS (método CONNECT)
Para sites HTTPS, use proxies HTTPS ou SOCKS5
Adicione a opção para ignorar erros SSL: chrome_options.add_argument('--ignore-certificate-errors')

Erro: O proxy funciona, mas o site detecta o bot

Causa: O site utiliza métodos avançados de detecção (fingerprinting, análise de comportamento).

Solução:

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

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

# Desativar a flag do webdriver (principal sinal de automação)
chrome_options.add_experimental_option("excludeSwitches", ["enable-automation"])
chrome_options.add_experimental_option('useAutomationExtension', False)

driver = webdriver.Chrome(options=chrome_options)

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

driver.get('https://bot.sannysoft.com/')  # Site para verificar a detecção

Além disso, é recomendável usar a biblioteca undetected-chromedriver, que aplica automaticamente várias técnicas anti-detecção.

Problema: Carregamento lento de páginas através do proxy

Causa: O proxy está sobrecarregado ou está geograficamente distante.

Solução:

Escolha proxies mais próximos do servidor de destino (por exemplo, para raspagem de sites dos EUA, use proxies dos EUA)
Use proxies de data center para tarefas onde a velocidade é mais importante que a anonimidade
Configure os timeouts no Selenium para evitar travamentos:

from selenium.webdriver.support.ui import WebDriverWait

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

Melhores práticas ao trabalhar com proxies

1. Use pools de proxies
Não confie em um único servidor proxy. Crie um pool de 10-50 proxies e rotacione-os. Se um proxy for banido, a raspagem continuará com outro.

2. Adicione atrasos aleatórios
Mesmo com proxies, solicitações muito rápidas parecem suspeitas. Adicione atrasos aleatórios de 2-5 segundos entre as solicitações:

import time
import random

for url in urls:
    driver.get(url)
    # Raspagem...
    time.sleep(random.uniform(2, 5))  # Atraso aleatório de 2-5 seg

3. Monitore a qualidade dos proxies
Verifique os proxies antes de usá-los. Exclua do pool aqueles que não respondem ou retornam erros:

import requests

def check_proxy(proxy):
    """Verificação da funcionalidade do 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

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

4. Use o modo headless com cautela
Navegadores headless são mais fáceis de detectar. Para sites complexos, inicie o navegador no modo normal ou use --window-size em vez de --headless.

5. Registre todas as solicitações
Salve informações sobre qual proxy foi usado para cada solicitação. Isso ajudará a identificar proxies problemáticos e depurar erros.

6. Respeite o robots.txt e as limitações de taxa
Mesmo com proxies, respeite as regras do site. A raspagem agressiva pode levar ao bloqueio de sub-redes inteiras de proxies, prejudicando outros usuários.

Conclusão

A configuração correta de proxies no Selenium WebDriver é a base para uma raspagem e automação estáveis. Abordamos todas as principais maneiras de integrar proxies para Chrome e Firefox, o trabalho com autenticação, a rotação de endereços IP e a solução de problemas comuns. O principal é escolher o tipo de proxy adequado para sua tarefa: para raspagem simples, proxies de data center são suficientes, enquanto para trabalhar com plataformas protegidas, são necessários proxies residenciais ou móveis.

Lembre-se das melhores práticas: use pools de proxies, adicione atrasos aleatórios, monitore a qualidade das conexões e aplique técnicas anti-detecção. Isso aumentará a estabilidade de seus scripts e reduzirá o risco de bloqueios em dezenas de vezes.

Se você planeja automatizar a raspagem com altas exigências de anonimato e contorno de sistemas anti-bot, recomendamos experimentar proxies residenciais — eles garantem a máxima estabilidade ao trabalhar com qualquer site, incluindo redes sociais, plataformas de e-commerce e serviços com proteção avançada. Para tarefas onde a velocidade de processamento de grandes volumes de dados é crítica, proxies de data center serão a escolha ideal em termos de custo-benefício.

```

Configuração de Proxy no Selenium WebDriver: guia completo com exemplos de código para Python e Java

Por que usar proxies no Selenium

Quais tipos de proxy usar

Configuração de proxy para Chrome no Selenium

Método 1: Proxy HTTP/HTTPS sem autenticação (Python)

Método 2: Proxy SOCKS5 (Python)

Configuração de proxy para Chrome em Java

Configuração de proxy para Firefox no Selenium

Proxy HTTP/HTTPS para Firefox (Python)

Proxy SOCKS5 para Firefox (Python)

Trabalhando com proxies que requerem autenticação

Método 1: Extensão do Chrome para autenticação (recomendado)

Método 2: Firefox com autenticação (mais simples)

Rotação de proxies no Selenium

Rotação a nível de código (criação de um novo driver)

Uso de proxies rotativos (mais simples)

Erros comuns e suas soluções

Erro: "ERR_PROXY_CONNECTION_FAILED"

Erro: "ERR_TUNNEL_CONNECTION_FAILED"

Erro: O proxy funciona, mas o site detecta o bot

Problema: Carregamento lento de páginas através do proxy

Melhores práticas ao trabalhar com proxies

Conclusão