Como configurar proxies para Selenium em Python: guia completo

Configurar proxies para Selenium em Python exige passar as configurações de proxy pelas opções específicas do navegador ou usar bibliotecas de middleware como o Selenium-wire para sessões autenticadas. Para proxies HTTP ou SOCKS5 padrão sem autenticação, o argumento --proxy-server dentro de ChromeOptions é o método mais eficiente, enquanto proxies autenticados costumam exigir extensões de navegador personalizadas ou drivers com suporte a proxy.

Por que a integração de proxy é essencial na automação com Selenium

O Selenium é uma ferramenta poderosa de automação web, mas seu comportamento padrão — operar a partir de um único endereço IP estático — o torna altamente suscetível a rate limiting e a bloqueios de IP. Ao executar extração de dados em larga escala ou testes automatizados em diferentes regiões geográficas, o proxy atua como intermediário, mascarando sua origem real e distribuindo as requisições por vários endereços IP.

Usar um serviço como o GProxy dá acesso a pools residenciais e de datacenter que impedem os sites de identificar o tráfego como vindo de uma única fonte automatizada. Isso é especialmente crítico para:

• Web scraping: contornar mecanismos anti-bot como Cloudflare ou Akamai, que monitoram a frequência de requisições por IP.
• Testes de localização: verificar se o site exibe a moeda, o idioma e o conteúdo corretos para usuários de países específicos.
• Verificação de anúncios: garantir que os anúncios estejam sendo entregues corretamente ao público pretendido, sem bloqueios ou redirecionamentos.
• Testes de carga: simular tráfego de diversas localizações geográficas para testar o tempo de resposta do servidor e a eficiência da CDN.

Configuração básica de proxy para Chrome e Firefox

A forma mais direta de implementar um proxy no Selenium é pelas opções nativas do navegador. Esse método funciona melhor para proxies com "IP na whitelist", em que o provedor de proxy (como a GProxy) autoriza o endereço IP do seu servidor, dispensando usuário e senha na string de conexão.

Configurando o Chrome com Options

No Chrome, você usa o método add_argument. É a implementação mais rápida e acrescenta uma sobrecarga desprezível ao tempo de inicialização do 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()

Configurando o Firefox com o objeto Proxy

O Firefox lida com proxies de outra forma, geralmente usando o objeto Proxy de selenium.webdriver.common.proxy. Isso permite um controle mais granular sobre quais protocolos (HTTP, SSL, SOCKS) usam o 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()

Lidando com autenticação de proxy no Selenium

O Selenium padrão não oferece suporte nativo a proxies que exigem usuário e senha via argumento --proxy-server. Se você tentar usar http://user:pass@host:port, o Chrome normalmente ignora as credenciais ou dispara um pop-up nativo do navegador com o qual o Selenium não consegue interagir facilmente. Para resolver isso, existem duas abordagens profissionais principais.

Método 1: usando o Selenium-wire

O Selenium-wire é um wrapper do Selenium que amplia suas capacidades para inspecionar requisições e respostas e, principalmente, tratar a autenticação de proxy de forma transparente. Ele faz isso executando um servidor proxy local que intercepta o tráfego e injeta os cabeçalhos de autenticação necessários.

from seleniumwire import webdriver

# Credenciais e endpoint da 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: a abordagem da extensão personalizada

Em ambientes de alto desempenho, nos quais a sobrecarga do proxy MITM (Man-In-The-Middle) do Selenium-wire é indesejável, criar uma extensão temporária do Chrome em tempo de execução é a solução padrão do mercado. Essa extensão usa a API chrome.proxy para definir as credenciais.

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

# Implementação
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)

Comparação dos métodos de configuração de proxy

A escolha do método certo depende dos seus requisitos de desempenho, do tipo de proxy (residencial ou datacenter) e da necessidade de rotacionar IPs com frequência.

Gerenciamento avançado de proxy: rotação e sessões sticky

Ao usar a GProxy, você geralmente escolhe entre proxies rotativos e sessões sticky. Entender como implementá-los em Python é essencial para manter a persistência da sessão durante fluxos de checkout ou envios de formulários em várias etapas.

Implementando sessões sticky

Uma sessão sticky garante que todas as requisições feitas pela sua instância do driver do Selenium permaneçam no mesmo endereço IP por um período definido (por exemplo, de 10 a 30 minutos). Na GProxy, isso normalmente é feito por meio de um ID de sessão na string de usuário.

# Exemplo de sessão sticky usando o pool residencial da GProxy
session_id = "session_82734"
proxy_user = f"user-customer_id-session-{session_id}"
# Agora use essa string de usuário na sua configuração do Selenium-wire ou da extensão

Gerenciando o modo headless com proxies

Rodar o Selenium em modo headless (--headless) é padrão em scripts do lado do servidor. No entanto, o Chrome headless às vezes pode vazar seu IP real ou falhar ao carregar extensões. Se você estiver usando o método da extensão para autenticação, precisa usar o novo modo headless disponível no Chrome 109+ para garantir que as extensões sejam carregadas corretamente:

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

A flag --headless=new faz com que o ambiente do navegador imite mais de perto um navegador com interface gráfica, melhorando a confiabilidade da autenticação de proxy e reduzindo as chances de detecção por scripts avançados de mitigação de bots.

Solução de problemas comuns de proxy

Mesmo com a configuração correta, setups de proxy no Selenium podem apresentar problemas. Veja os mais frequentes e suas resoluções técnicas:

• ProxyConnectionError: geralmente causado por porta incorreta ou por um firewall bloqueando a conexão de saída até o provedor de proxy. Garanta que a porta 10000 (ou a porta específica do seu provedor) esteja aberta.
• Vazamentos de DNS: por padrão, o Selenium pode continuar resolvendo consultas DNS pelo seu ISP local. Para evitar isso, especialmente ao usar SOCKS5, garanta que o navegador esteja configurado para fazer as buscas DNS através do proxy.
• Carregamento lento: proxies residenciais são naturalmente mais lentos que os de datacenter. Se o desempenho for crítico, use o pool de datacenter da GProxy, a menos que você esteja enfrentando bloqueio agressivo de IP.
• Pop-ups de autenticação: se aparecer um pop-up de login, seu método de autenticação (extensão ou Selenium-wire) falhou ou não está sendo inicializado antes da primeira requisição.

Principais conclusões

Configurar proxies no Selenium é um processo em várias camadas. Enquanto proxies simples com IP na whitelist podem ser tratados por argumentos de linha de comando, proxies residenciais autenticados exigem soluções mais robustas, como extensões personalizadas ou o Selenium-wire.

• Use o GProxy Backconnect: em vez de gerenciar uma lista de 10.000 IPs no seu código Python, use um único endpoint backconnect fornecido pela GProxy para tratar a rotação automaticamente.
• Priorize extensões: em ambientes de produção, o método da extensão do Chrome é superior ao Selenium-wire, pois não introduz uma segunda camada de proxy, resultando em menor latência.
• Monitore as taxas de sucesso: sempre envolva suas chamadas driver.get() em blocos try-except para capturar WebDriverException, permitindo que seu script rotacione o ID de sessão e tente novamente caso um nó de proxy falhe.