Configuração de proxy com Selenium Wire: um guia completo em Python

Um proxy com Selenium Wire é o caminho mais curto para rodar automação de navegador autenticada em Python, porque o Selenium Wire aceita diretamente uma URL de proxy com login:password em uma única opção, em vez de forçar o contorno da extensão que o Selenium puro exige. Ele também expõe cada requisição e resposta HTTP que o navegador faz, e é por isso que equipes de scraping e de QA recorrem a ele.

Este guia é um passo a passo completo. Ele cobre instalar e fixar a biblioteca com segurança, configurar um proxy autenticado, verificar o IP de saída, inspecionar e aguardar requisições, editar cabeçalhos, rotacionar IPs, rodar em modo headless, reduzir o uso de memória, lidar com o certificado HTTPS com honestidade, combiná-lo com o undetected-chromedriver e onde as alternativas modernas se encaixam.

A DataImpulse é um provedor ético de proxies que oferece mais de 90 milhões de endereços IP residenciais, móveis e de datacenter em 195 países. Usa um modelo de pagamento por uso a partir de 1 dólar por GB com tráfego que não expira, e é usada para web scraping, verificação de anúncios, monitoramento de preços, pesquisa de mercado e gestão de múltiplas contas.

O que é o Selenium Wire e ele ainda tem manutenção?

O Selenium Wire é uma biblioteca Python que estende o Selenium para que seu script possa inspecionar, aguardar e modificar as requisições e respostas HTTP do navegador, e adiciona suporte a proxy autenticado de primeira classe. Ele funciona rodando um proxy local do tipo man-in-the-middle para o qual o navegador é apontado, e então encaminha o tráfego para o seu proxy upstream real.

A ressalva honesta é que o projeto original está arquivado e não recebe mais manutenção ativa. Ele ainda funciona bem em produção, mas você deve fixar suas versões e testar de forma isolada qualquer atualização de Selenium, Chrome ou dependências antes de colocá-la em produção. Existem forks da comunidade que carregam as correções de compatibilidade adiante, e mais adiante neste guia a tabela comparativa mostra quando uma ferramenta com manutenção como o Playwright é o melhor lar a longo prazo.

O motivo pelo qual as equipes ainda o escolhem é a conveniência. Se você já tem uma suíte de testes ou um scraper em Selenium, adicionar o Selenium Wire é uma mudança de import de uma linha mais uma opção de proxy, e você ganha imediatamente tanto o suporte a proxy autenticado quanto a capacidade de ler cada requisição que a página faz. Reconstruir essa visibilidade no nível de requisição no Selenium puro dá trabalho de verdade, então para bases de código existentes a troca costuma valer a pena apesar do status arquivado. Se você está começando a usar navegadores reais para coleta de dados, nosso guia sobre como fazer scraping de páginas web dinâmicas cobre o panorama mais amplo da renderização e quando um navegador é de fato necessário.

Como instalar o Selenium Wire e fixar versões para evitar quebras?

Instale o selenium-wire junto do selenium e fixe o blinker abaixo de 1.8, porque essa versão removeu um nome interno que o Selenium Wire importa ao iniciar. Como o projeto está arquivado, dependências sem fixação são o motivo mais comum de uma configuração que funcionava falhar de repente.

A falha clássica é um ImportError em WeakNamespace depois que o blinker se atualiza sozinho. Fixar as versões evita isso:

# Selenium Wire is archived. Pin known-good versions so an upstream release
# does not break your build overnight.
#
# blinker >= 1.8 removed blinker._saferef / WeakNamespace, which Selenium Wire
# imports at startup. On blinker 1.8+ you get:
#   ImportError: cannot import name 'WeakNamespace' from 'blinker'
# The fix is to hold blinker below 1.8.
pip install "selenium-wire==5.1.0" "selenium==4.9.1" "blinker==1.7.0"

# Selenium Wire also depends on brotli and can trip on very new Selenium.
# If you must run current Selenium, test in a throwaway virtualenv first, or
# move to a maintained fork such as selenium-wire-2 that tracks these fixes.

Mantenha essas versões fixadas em um arquivo de requisitos para que a integração contínua e seus colegas obtenham a mesma combinação testada. Quando você quiser migrar para o Selenium atual, trate isso como uma atualização deliberada com sua própria rodada de testes, em vez de deixar o pip resolver o mais recente de tudo.

Como configurar um proxy autenticado no Selenium Wire?

Passe um dicionário de proxy dentro de seleniumwire_options ao criar o driver, com o usuário e a senha embutidos na URL e o localhost excluído via no_proxy. Esse é o único recurso que faz valer a pena usar o Selenium Wire em vez do Selenium puro para trabalhar com proxies.

Importe o webdriver do seleniumwire, não do selenium, e então passe as opções para ele. As credenciais, o host e a porta vêm do painel do seu provedor. Com a DataImpulse o host é gw.dataimpulse.com e a porta é 823:

from seleniumwire import webdriver  # import from seleniumwire, not selenium

proxy_url = "http://login:[email protected]:823"

seleniumwire_options = {
    "proxy": {
        "http": proxy_url,
        "https": proxy_url,
        "no_proxy": "localhost,127.0.0.1",
    }
}

driver = webdriver.Chrome(seleniumwire_options=seleniumwire_options)
driver.get("https://example.com")
print(driver.title)
driver.quit()

A entrada no_proxy mantém os endereços locais fora do proxy para que o driver possa falar diretamente com o ChromeDriver. Se a autenticação estiver errada, você normalmente verá uma resposta 407; nossa nota sobre o erro 407 Proxy Authentication Required explica como diagnosticá-lo. Para entender de modo geral como funcionam os proxies com credenciais, veja os proxies residenciais.

Como verificar se o IP de saída do proxy está funcionando?

Aponte o driver para um endpoint que devolve o IP, como api.ipify.org, e confirme que o endereço retornado pertence ao proxy e não à sua própria máquina. Nunca presuma que o proxy está ativo só porque a página carregou.

import json
from seleniumwire import webdriver

proxy_url = "http://login:[email protected]:823"
seleniumwire_options = {
    "proxy": {"http": proxy_url, "https": proxy_url,
              "no_proxy": "localhost,127.0.0.1"}
}

driver = webdriver.Chrome(seleniumwire_options=seleniumwire_options)
driver.get("https://api.ipify.org/?format=json")

body = driver.find_element("tag name", "body").text
exit_ip = json.loads(body)["ip"]
print("Exit IP:", exit_ip)  # should be the proxy, not your own address

driver.quit()

Se a resposta mostrar o seu IP real, vale a pena checar três coisas: que o no_proxy não esteja coincidindo por acidente com o seu alvo, que as credenciais estejam corretas e que você tenha importado o webdriver do seleniumwire. Rode essa verificação como o primeiro passo de qualquer trabalho novo, e repita-a depois de mudar as configurações de proxy.

Como inspecionar e aguardar requisições específicas?

Leia driver.requests para percorrer cada requisição e resposta que o navegador fez, e use driver.wait_for_request para bloquear até que uma chamada correspondente apareça. Essa é a capacidade que separa o Selenium Wire de um WebDriver comum, e é inestimável para encontrar a API JSON por trás de uma página.

from seleniumwire import webdriver

driver = webdriver.Chrome(seleniumwire_options=seleniumwire_options)
driver.get("https://example.com/products")

# Block until a request whose URL matches the regex is captured.
request = driver.wait_for_request(r"/api/v2/products", timeout=15)
print(request.method, request.url)
print("Status:", request.response.status_code)
print("Type:", request.response.headers["Content-Type"])

# Walk every captured request/response pair the browser made.
for r in driver.requests:
    if r.response:
        print(r.response.status_code, r.url)

driver.quit()

A chamada wait_for_request recebe uma expressão regular comparada com a URL e retorna assim que a requisição é capturada, então você evita os frágeis sleeps fixos. Uma vez que você sabe qual chamada em segundo plano carrega os dados, muitas vezes pode pular a renderização por completo e acessar esse endpoint diretamente, o que é bem mais barato. Essa técnica é central nas melhores práticas de web scraping.

Como modificar os cabeçalhos das requisições com um interceptor?

Atribua uma função a driver.request_interceptor e ela roda antes de cada requisição deixar o navegador, permitindo sobrescrever cabeçalhos, injetar tokens ou descartar parâmetros. Definir um User-Agent e um idioma realistas é um motivo comum para recorrer a isso.

from seleniumwire import webdriver

driver = webdriver.Chrome(seleniumwire_options=seleniumwire_options)

def interceptor(request):
    # Delete first, then set, so you replace the header instead of duplicating it.
    del request.headers["User-Agent"]
    request.headers["User-Agent"] = "Mozilla/5.0 (Windows NT 10.0; Win64; x64)"
    request.headers["Accept-Language"] = "en-US,en;q=0.9"

driver.request_interceptor = interceptor
driver.get("https://httpbin.org/headers")
print(driver.find_element("tag name", "body").text)
driver.quit()

Apague o cabeçalho existente antes de definir um novo valor, caso contrário o Selenium Wire pode enviar tanto o original quanto o seu substituto. Um response_interceptor correspondente permite ler ou reescrever respostas. Mantenha os interceptores leves, já que eles rodam em cada requisição, incluindo imagens e scripts. Cabeçalhos consistentes e com aparência humana são um dos sinais mais discretos dentro das melhores práticas de web scraping.

Como rotacionar proxies por requisição no Selenium Wire?

Você tem dois padrões: reatribuir driver.proxy em tempo de execução para trocar a configuração no mesmo navegador, ou recriar o driver quando você também quer um perfil e um repositório de cookies limpos. Um gateway rotativo como a DataImpulse já entrega uma saída residencial nova a cada nova conexão, então a maioria dos trabalhos só precisa trocar a configuração para usar outro país.

from seleniumwire import webdriver

base = "http://login:[email protected]:823"
opts = {"proxy": {"http": base, "https": base,
                  "no_proxy": "localhost,127.0.0.1"}}
driver = webdriver.Chrome(seleniumwire_options=opts)

# Option A: reassign driver.proxy at runtime to switch config (for example a
# different country gateway) without rebuilding the browser. Cheap and fast.
uk = "http://login:[email protected]:823"
driver.proxy = {"http": uk, "https": uk, "no_proxy": "localhost,127.0.0.1"}
driver.get("https://api.ipify.org")
print(driver.find_element("tag name", "body").text)
driver.quit()

# Option B: recreate the driver per job when you need a guaranteed clean
# browser profile and cookie jar as well as a fresh exit IP.
def fresh_driver():
    return webdriver.Chrome(seleniumwire_options=opts)

for _ in range(3):
    d = fresh_driver()
    d.get("https://api.ipify.org")
    print(d.find_element("tag name", "body").text)
    d.quit()

Reatribuir driver.proxy é barato e mantém o navegador aquecido, o que combina com laços de alto volume onde o custo de inicialização domina. Recriar o driver é mais pesado, mas garante o isolamento entre trabalhos, o que importa quando um alvo amarra as sessões a cookies e armazenamento local além do IP. Escolha com base em se você precisa de uma identidade limpa ou apenas de um novo endereço. Uma regra prática é reatribuir o proxy enquanto coleta páginas públicas anônimas, e recriar o driver sempre que cruzar uma fronteira de conta ou de login, para que um cookie vazado de uma execução não possa segui-lo até a próxima. Alvos móveis que aplicam fingerprinting agressivo muitas vezes justificam os proxies móveis para os casos mais difíceis, enquanto páginas mais leves podem ficar em saídas mais baratas.

Como rodar o Selenium Wire em modo headless e manter o uso de memória baixo?

Adicione opções do Chrome para o modo headless e a estabilidade, e então restrinja o que o Selenium Wire captura para que o buffer de requisições não cresça sem limite. Em servidores, headless mais uma captura delimitada é a diferença entre um trabalho que roda por horas e outro que esgota a RAM.

Comece com um conjunto sólido de flags do Chrome para um contêiner headless ou um ambiente de CI:

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

chrome_options = Options()
chrome_options.add_argument("--headless=new")     # modern headless mode
chrome_options.add_argument("--no-sandbox")
chrome_options.add_argument("--disable-dev-shm-usage")
chrome_options.add_argument("--disable-gpu")
chrome_options.add_argument("--window-size=1920,1080")

proxy_url = "http://login:[email protected]:823"
seleniumwire_options = {
    "proxy": {"http": proxy_url, "https": proxy_url,
              "no_proxy": "localhost,127.0.0.1"}
}

driver = webdriver.Chrome(options=chrome_options,
                          seleniumwire_options=seleniumwire_options)
driver.get("https://api.ipify.org")
print(driver.find_element("tag name", "body").text)
driver.quit()

Por padrão, o Selenium Wire captura e mantém em buffer cada requisição e resposta, que é justamente o que consome memória em execuções longas. Restrinja a captura com driver.scopes, mantenha o armazenamento em memória e limpe o buffer entre as páginas:

from seleniumwire import webdriver

seleniumwire_options = {
    "proxy": {"http": proxy_url, "https": proxy_url,
              "no_proxy": "localhost,127.0.0.1"},
    "request_storage": "memory",   # keep the buffer in RAM, not on disk
}

driver = webdriver.Chrome(seleniumwire_options=seleniumwire_options)

# Only capture the API traffic you care about. Images, fonts, analytics, and
# tracking pixels are ignored, which keeps the capture buffer small.
driver.scopes = [r".*/api/.*"]

driver.get("https://example.com/products")
for request in driver.requests:
    print(request.url)

del driver.requests   # clear the buffer between pages on long-running jobs
driver.quit()

A lista scopes é um conjunto de expressões regulares de URL; tudo que ficar fora delas passa, mas não é armazenado. Em um scraper que só precisa das respostas da API, isso pode reduzir drasticamente o buffer residente. Reduzir o que você baixa também diminui o custo do proxy, já que o tráfego da DataImpulse é cobrado por gigabyte.

Como o Selenium Wire lida com o HTTPS e seu certificado?

Para ler os corpos criptografados de requisições e respostas, o Selenium Wire descriptografa o HTTPS como man-in-the-middle usando seu próprio certificado raiz, que ele injeta automaticamente no perfil do navegador para Chrome e Firefox. Isso é poderoso, mas tem limites honestos que você deve entender antes de depender disso.

from seleniumwire import webdriver

proxy_url = "http://login:[email protected]:823"
seleniumwire_options = {
    "proxy": {"http": proxy_url, "https": proxy_url,
              "no_proxy": "localhost,127.0.0.1"},
    # Selenium Wire is a man-in-the-middle proxy: to read HTTPS bodies it
    # decrypts traffic using its own root certificate, which it injects into
    # the browser profile automatically. These two options relax verification
    # on the upstream leg so a mismatched or self-signed cert does not abort.
    "verify_ssl": False,
    "suppress_connection_errors": True,
}

driver = webdriver.Chrome(seleniumwire_options=seleniumwire_options)
driver.get("https://example.com")
driver.quit()

Do design man-in-the-middle decorrem duas coisas. Primeiro, um site que usa certificate pinning vai recusar o certificado injetado, e a interceptação desse tráfego vai falhar; nesse caso desative a captura para o host afetado ou abra mão de inspecionar os corpos dele. Segundo, se você iniciar o Chrome com um perfil personalizado ou não padrão, pode ser preciso garantir que a CA do Selenium Wire seja confiável ali. As opções verify_ssl e suppress_connection_errors relaxam o trecho upstream para que um certificado estranho não aborte a execução, mas elas não derrotam o pinning.

Dá para combinar com o undetected-chromedriver, e quais são as alternativas?

Sim. O Selenium Wire traz uma integração com o undetected-chromedriver que você importa como seleniumwire.undetected_chromedriver, dando a você inspeção de requisições e proxies autenticados enquanto o undetected-chromedriver reduz as impressões digitais de automação. É a combinação de referência para alvos bem defendidos.

# Selenium Wire ships its own undetected-chromedriver integration.
import seleniumwire.undetected_chromedriver as uc

proxy_url = "http://login:[email protected]:823"
seleniumwire_options = {
    "proxy": {"http": proxy_url, "https": proxy_url,
              "no_proxy": "localhost,127.0.0.1"}
}

options = uc.ChromeOptions()
options.add_argument("--headless=new")

driver = uc.Chrome(seleniumwire_options=seleniumwire_options, options=options)
driver.get("https://api.ipify.org")
print(driver.find_element("tag name", "body").text)
driver.quit()

Quando o próprio Selenium Wire não é a escolha certa, duas alternativas cobrem a maioria das necessidades. O Selenium 4 puro pode usar um proxy autenticado por meio de uma pequena extensão gerada, que uma biblioteca auxiliar automatiza:

from selenium import webdriver
# Plain Selenium cannot send proxy credentials on its own. A small helper builds
# a throwaway Chrome extension that answers the proxy auth challenge for you.
from selenium_authenticated_proxy import SeleniumAuthenticatedProxy

proxy = SeleniumAuthenticatedProxy(
    proxy_url="http://login:[email protected]:823"
)
options = webdriver.ChromeOptions()
proxy.enrich_options(options)

driver = webdriver.Chrome(options=options)
driver.get("https://api.ipify.org")
print(driver.find_element("tag name", "body").text)
driver.quit()

O Playwright lida com proxies autenticados de forma nativa e recebe manutenção ativa, o que o torna a melhor base para projetos novos:

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(
        headless=True,
        proxy={
            "server": "http://gw.dataimpulse.com:823",
            "username": "login",
            "password": "password",
        },
    )
    page = browser.new_page()
    page.goto("https://api.ipify.org")
    print(page.inner_text("body"))
    browser.close()

Veja como os três se comparam especificamente para o trabalho com proxies autenticados:

Conselho de migração: se você só precisa de proxies com credenciais e nenhuma captura de requisições, o Selenium puro com uma extensão de autenticação é o movimento mais leve e permanece em código com manutenção. Se você depende de inspecionar ou reescrever tráfego e está começando do zero, o Playwright oferece isso de forma nativa sem o fardo de fixar versões. Mantenha o Selenium Wire quando você tiver uma base de código Selenium existente cujo controle no nível de requisição seria caro de reconstruir. Para escolher IPs com qualquer uma dessas ferramentas, compare os proxies residenciais, os proxies de datacenter e os proxies móveis frente às defesas do seu alvo.

Perguntas frequentes

Guias relacionados

• Scraping de páginas web dinâmicas
• O que é autenticação de proxy
• Melhores práticas de web scraping

Rode o Selenium Wire através de proxies confiáveis

Um proxy com Selenium Wire vale tanto quanto os IPs por trás dele. Você pode rotear sua automação de navegador através de IPs residenciais, móveis ou de datacenter de origem ética com tráfego de pagamento por uso a partir de 1 dólar por GB. Crie uma conta na DataImpulse e comece com sessões rotativas ou fixas.