Melhor proxy para web scraping com Python 2026: código real

Pontos principais

• O que importa: rotação, retries, reuso de sessão e timeouts importam tanto quanto qual pool você compra.
• Como fazer benchmark: teste com o seu padrão real de requisições, não com uma amostra de páginas fáceis.
• Termos: respeite os termos de cada alvo; um scraper que funciona não é automaticamente um permitido.
• Precisa só de visitas: para visitas ao site em vez de dados, o Traffic Creator não exige nenhum código de proxy.

Encontrar o proxy certo para scraping com Python significa adequar o provedor ao nível de proteção do seu alvo — e saber configurá-lo corretamente no código. Um proxy que funciona perfeitamente para coletar preços de e-commerce falha imediatamente contra o LinkedIn.

Este guia cobre os melhores provedores de proxy para scraping com Python em 2026, com exemplos de código funcionais para as três bibliotecas de scraping mais comuns do Python: requests, Scrapy e Playwright.

Configuração de proxy em Python: o básico#

Toda biblioteca HTTP do Python aceita proxies em um formato semelhante. A estrutura da URL de proxy é:

http://username:password@proxy_host:port

Para proxies residenciais rotativos (em que cada requisição recebe um novo IP automaticamente), o host é o gateway rotativo do provedor. Você não gerencia IPs individuais — a infraestrutura do provedor os rotaciona a cada requisição.

Visão geral dos provedores por caso de uso em Python#

Exemplos de código por biblioteca#

1. Biblioteca requests do Python

requests é a biblioteca HTTP mais comum do Python. A configuração de proxy é um único dicionário passado a cada requisição.

Configuração básica de proxy rotativo (exemplo GeoNode)

import requests

# Proxy residencial rotativo GeoNode
# Substitua pelo seu usuário/senha reais do painel do GeoNode
PROXY_HOST = "rotating.geonode.com"
PROXY_PORT = "9000"
PROXY_USER = "YOUR_GEONODE_USERNAME"
PROXY_PASS = "YOUR_GEONODE_PASSWORD"

proxies = {
    "http": f"http://{PROXY_USER}:{PROXY_PASS}@{PROXY_HOST}:{PROXY_PORT}",
    "https": f"http://{PROXY_USER}:{PROXY_PASS}@{PROXY_HOST}:{PROXY_PORT}",
}

headers = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36"
}

response = requests.get(
    "https://httpbin.org/ip",
    proxies=proxies,
    headers=headers,
    timeout=30,
)
print(response.json())  # mostra o IP de saída usado

Rotacionando o User-Agent a cada requisição

User-Agents consistentes são uma impressão digital detectável mesmo com IPs residenciais. Rotacione-os:

import requests
import random

USER_AGENTS = [
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:125.0) Gecko/20100101 Firefox/125.0",
    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
]

def get_headers():
    return {"User-Agent": random.choice(USER_AGENTS)}

def scrape_url(url, proxies):
    try:
        response = requests.get(
            url,
            proxies=proxies,
            headers=get_headers(),
            timeout=30,
        )
        response.raise_for_status()
        return response.text
    except requests.RequestException as e:
        print(f"Requisição falhou: {e}")
        return None

Lógica de retry para requisições falhas

import requests
import time
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

def make_session_with_retry(proxies):
    session = requests.Session()
    session.proxies = proxies

    retry_strategy = Retry(
        total=3,
        backoff_factor=1,
        status_forcelist=[429, 500, 502, 503, 504],
    )
    adapter = HTTPAdapter(max_retries=retry_strategy)
    session.mount("http://", adapter)
    session.mount("https://", adapter)

    return session

# Uso
session = make_session_with_retry(proxies)
response = session.get("https://example.com", timeout=30)

2. Scrapy

Scrapy é o framework padrão para scraping em produção com Python. Ele lida com concorrência, retries e pipelines — mas a configuração de proxy exige um middleware.

Middleware de proxy do Scrapy (proxy rotativo)

Adicione ao seu settings.py:

# settings.py
DOWNLOADER_MIDDLEWARES = {
    "scrapy.downloadermiddlewares.retry.RetryMiddleware": 90,
    "myproject.middlewares.ProxyMiddleware": 100,
    "scrapy.downloadermiddlewares.httpproxy.HttpProxyMiddleware": 110,
}

RETRY_TIMES = 3
RETRY_HTTP_CODES = [500, 502, 503, 504, 429]

# Credenciais do GeoNode (configure via variáveis de ambiente em produção)
PROXY_HOST = "rotating.geonode.com:9000"
PROXY_USER = "YOUR_GEONODE_USERNAME"
PROXY_PASS = "YOUR_GEONODE_PASSWORD"

Crie o middlewares.py:

# middlewares.py
import base64
from scrapy import signals

class ProxyMiddleware:
    def __init__(self, proxy_host, proxy_user, proxy_pass):
        self.proxy = f"http://{proxy_host}"
        credentials = f"{proxy_user}:{proxy_pass}"
        self.proxy_auth = base64.b64encode(credentials.encode()).decode()

    @classmethod
    def from_crawler(cls, crawler):
        return cls(
            proxy_host=crawler.settings.get("PROXY_HOST"),
            proxy_user=crawler.settings.get("PROXY_USER"),
            proxy_pass=crawler.settings.get("PROXY_PASS"),
        )

    def process_request(self, request, spider):
        request.meta["proxy"] = self.proxy
        request.headers["Proxy-Authorization"] = f"Basic {self.proxy_auth}"

Spider do Scrapy com proxy

# spiders/product_spider.py
import scrapy

class ProductSpider(scrapy.Spider):
    name = "products"
    start_urls = ["https://example-shop.com/products"]

    custom_settings = {
        "DOWNLOAD_DELAY": 1,          # 1 segundo entre requisições
        "RANDOMIZE_DOWNLOAD_DELAY": True,  # atraso real: 0,5–1,5s
        "CONCURRENT_REQUESTS_PER_DOMAIN": 5,
    }

    def parse(self, response):
        for product in response.css(".product-card"):
            yield {
                "name": product.css(".product-name::text").get(),
                "price": product.css(".product-price::text").get(),
                "url": response.urljoin(product.css("a::attr(href)").get()),
            }

        next_page = response.css("a.next-page::attr(href)").get()
        if next_page:
            yield response.follow(next_page, self.parse)

3. Playwright (alvos que renderizam JavaScript)

Para alvos que usam renderização de JavaScript — aplicativos de página única, conteúdo com lazy loading, preços dinâmicos — você precisa de um navegador headless. O Playwright resolve isso em Python.

Playwright básico com proxy (GeoNode)

from playwright.sync_api import sync_playwright

PROXY_HOST = "rotating.geonode.com"
PROXY_PORT = "9000"
PROXY_USER = "YOUR_GEONODE_USERNAME"
PROXY_PASS = "YOUR_GEONODE_PASSWORD"

proxy_config = {
    "server": f"http://{PROXY_HOST}:{PROXY_PORT}",
    "username": PROXY_USER,
    "password": PROXY_PASS,
}

with sync_playwright() as p:
    browser = p.chromium.launch(
        headless=True,
        proxy=proxy_config,
    )
    context = browser.new_context(
        user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
        viewport={"width": 1920, "height": 1080},
    )
    page = context.new_page()

    page.goto("https://example.com", wait_until="networkidle")
    content = page.content()
    print(content[:500])

    browser.close()

Playwright para alvos Tier 3 com o Web Unlocker da Bright Data

Para alvos com proteção de nível corporativo, o Web Unlocker da Bright Data resolve CAPTCHAs e gerencia impressões digitais automaticamente. Você envia uma URL; a Bright Data devolve o HTML renderizado.

import requests

# Endpoint do Web Unlocker da Bright Data
# Obtenha suas credenciais em: https://get.brightdata.com/293896dumfgt
BRIGHTDATA_HOST = "brd.superproxy.io"
BRIGHTDATA_PORT = 22225
BRIGHTDATA_USER = "YOUR_BRIGHTDATA_USERNAME-zone-web_unlocker"
BRIGHTDATA_PASS = "YOUR_BRIGHTDATA_PASSWORD"

proxies = {
    "http": f"http://{BRIGHTDATA_USER}:{BRIGHTDATA_PASS}@{BRIGHTDATA_HOST}:{BRIGHTDATA_PORT}",
    "https": f"http://{BRIGHTDATA_USER}:{BRIGHTDATA_PASS}@{BRIGHTDATA_HOST}:{BRIGHTDATA_PORT}",
}

# A Bright Data cuida de toda a anti-detecção automaticamente
response = requests.get(
    "https://www.amazon.com/dp/B08N5WRWNW",
    proxies=proxies,
    verify=False,  # a Bright Data usa certificado próprio
    timeout=60,
)
print(response.status_code)  # 200 na Amazon com o Web Unlocker

Referência de configuração por provedor#

GeoNode (recomendado para Tier 2)

# Proxy residencial rotativo GeoNode
# Obtenha credenciais em: https://geonode.com/?ref=22282

PROXY_HOST = "rotating.geonode.com"
PROXY_PORT = "9000"   # HTTP rotativo
# PROXY_PORT = "9001" # SOCKS5 rotativo
# PROXY_PORT = "9002" # HTTP sticky (baseado em sessão)

# Segmentação por país (adicione ao nome de usuário):
# PROXY_USER = "username-country-US"  # apenas nós de saída dos EUA
# PROXY_USER = "username-country-DE"  # apenas nós de saída da Alemanha

proxies = {
    "http": f"http://{PROXY_USER}:{PROXY_PASS}@{PROXY_HOST}:{PROXY_PORT}",
    "https": f"http://{PROXY_USER}:{PROXY_PASS}@{PROXY_HOST}:{PROXY_PORT}",
}

Especificações do GeoNode para scraping com Python:

• Mais de 10.000.000 de IPs residenciais, mais de 195 países
• $3–$5/GB, sem compromisso mínimo
• Modos rotativo e sticky session
• Segmentação por país e por cidade

→ Começar com o plano gratuito do GeoNode — sem cartão de crédito.

IPRoyal (Tier 2 com foco na UE)

# Proxy residencial rotativo IPRoyal
# Obtenha credenciais em: https://iproyal.com/?r=Traffic-Creator

PROXY_HOST = "geo.iproyal.com"
PROXY_PORT = "12321"

# Segmentação por país:
# PROXY_USER = "username_country-DE"  # Alemanha
# PROXY_USER = "username_country-GB"  # Reino Unido

proxies = {
    "http": f"http://{PROXY_USER}:{PROXY_PASS}@{PROXY_HOST}:{PROXY_PORT}",
    "https": f"http://{PROXY_USER}:{PROXY_PASS}@{PROXY_HOST}:{PROXY_PORT}",
}

Especificações do IPRoyal: alta densidade de nós europeus — o melhor para alvos de scraping específicos da UE, a $7–$10/GB.

DataImpulse (Tier 1–2 econômico)

# Proxy residencial econômico DataImpulse
# Obtenha credenciais em: https://dataimpulse.com/?aff=312345

PROXY_HOST = "gw.dataimpulse.com"
PROXY_PORT = "823"

proxies = {
    "http": f"http://{PROXY_USER}:{PROXY_PASS}@{PROXY_HOST}:{PROXY_PORT}",
    "https": f"http://{PROXY_USER}:{PROXY_PASS}@{PROXY_HOST}:{PROXY_PORT}",
}

Especificações do DataImpulse: ~$0,70–$1,50/GB — a opção residencial mais barata para scraping de sites sem proteção até moderadamente protegidos.

Bright Data Web Unlocker (Tier 3)

# Bright Data Web Unlocker
# Obtenha acesso em: https://get.brightdata.com/293896dumfgt

proxies = {
    "http": "http://YOUR_USER-zone-web_unlocker:[email protected]:22225",
    "https": "http://YOUR_USER-zone-web_unlocker:[email protected]:22225",
}

# Para scraping de SERP com saída estruturada:
# Use a SERP API da própria Bright Data — retorna JSON estruturado
import json

serp_response = requests.get(
    "https://www.google.com/search?q=python+web+scraping",
    proxies=proxies,
    verify=False,
    timeout=60,
)

Escolhendo o provedor certo para o seu scraper Python#

Árvore de decisão

O que você está coletando?

Sites sem proteção (sem proteção contra bots)
  → DataImpulse (~$1/GB) ou ProxyScrape (~$2–4/GB)
  → requests ou Scrapy, com IPs rotativos

Proteção moderada (rate limiting, reputação de IP)
  → GeoNode (~$3–5/GB) para a maioria dos alvos
  → IPRoyal (~$7–10/GB) para alvos específicos da UE
  → requests/Scrapy com IPs residenciais rotativos

Fortemente protegido (Google, Amazon, LinkedIn)
  → Bright Data Web Unlocker (~$10,89/GB + $3/1.000 requisições)
  → requests com o endpoint de proxy da Bright Data, ou a SERP API deles
  → Para automação de navegador no Tier 3: Scraping Browser da Bright Data

Configurações de concorrência por provedor

Proxies residenciais lidam com concorrência de forma diferente dos datacenter. Concorrência agressiva demais queima banda sem melhorar o throughput.

Configurações recomendadas do Scrapy por provedor:

# GeoNode (residencial de mercado intermediário)
CONCURRENT_REQUESTS = 20
CONCURRENT_REQUESTS_PER_DOMAIN = 5
DOWNLOAD_DELAY = 0.5
RANDOMIZE_DOWNLOAD_DELAY = True

# DataImpulse (residencial econômico — concorrência menor)
CONCURRENT_REQUESTS = 10
CONCURRENT_REQUESTS_PER_DOMAIN = 3
DOWNLOAD_DELAY = 1
RANDOMIZE_DOWNLOAD_DELAY = True

# Bright Data Web Unlocker (anti-detecção gerenciado)
# Siga a concorrência recomendada pela Bright Data por zona
CONCURRENT_REQUESTS = 10
DOWNLOAD_DELAY = 0

Erros comuns de proxy em Python e correções#

ConnectionError: HTTPSConnectionPool

Causa: a conexão com o proxy falhou — host, porta ou credenciais errados.

Correção: teste com requests.get("https://httpbin.org/ip", proxies=proxies) antes de rodar o scraper. Confira host/porta/credenciais no painel do seu provedor.

407 Proxy Authentication Required

Causa: credenciais não passadas corretamente ou malformadas na URL do proxy.

Correção: verifique se o nome de usuário e a senha não contêm caracteres especiais que exigem codificação de URL. Codifique com urllib.parse.quote(password, safe='') se a senha tiver símbolos.

from urllib.parse import quote
encoded_pass = quote(PROXY_PASS, safe='')
proxy_url = f"http://{PROXY_USER}:{encoded_pass}@{PROXY_HOST}:{PROXY_PORT}"

503 Service Unavailable em alvos protegidos

Causa: o alvo detectou sua requisição como bot apesar do uso de IPs residenciais. Causas comuns: User-Agent consistente, ausência do header de referer, ausência do header accept-language, ritmo de requisições rápido demais.

Correção:

headers = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
    "Accept-Language": "en-US,en;q=0.5",
    "Accept-Encoding": "gzip, deflate, br",
    "Connection": "keep-alive",
    "Upgrade-Insecure-Requests": "1",
}

Se isso não resolver em alvos Tier 3, faça upgrade para o Bright Data Web Unlocker.

Requisições recebendo CAPTCHAs em vez de conteúdo

Causa: o site alvo está exibindo desafios de CAPTCHA para o seu IP. Acontece em alvos Tier 3 com IPs residenciais que não rotacionam rápido o suficiente.

Correção: ou rotacione mais rápido (novo IP por requisição via endpoint rotativo), ou use o Bright Data Web Unlocker, que resolve CAPTCHAs automaticamente.

Testando sua configuração de proxy#

Sempre valide antes de rodar uma coleta completa:

import requests

def test_proxy(proxies):
    # Teste 1: confira seu IP de saída
    try:
        r = requests.get("https://httpbin.org/ip", proxies=proxies, timeout=10)
        print(f"IP de saída: {r.json()['origin']}")
    except Exception as e:
        print(f"Falhou: {e}")
        return False

    # Teste 2: confirme que o IP é residencial (não datacenter)
    try:
        r = requests.get("https://ipinfo.io/json", proxies=proxies, timeout=10)
        data = r.json()
        print(f"Tipo de IP: {data.get('org', 'desconhecido')}")
        print(f"País: {data.get('country', 'desconhecido')}")
        print(f"Cidade: {data.get('city', 'desconhecida')}")
    except Exception as e:
        print(f"Falha na verificação do IPinfo: {e}")

    return True

test_proxy(proxies)

Um IP residencial mostra uma organização de ISP (ex.: "AS7922 Comcast Cable Communications"), não um ASN de data center (ex.: "AS14061 DigitalOcean").

Diretório de provedores#

Artigos relacionados#

• Webshare Review 2026: The Best Free Proxy Tier? Tested and Honest
• 10 Best Residential Proxies 2026: Tested and Ranked
• Best Proxy for Web Scraping in 2026: Ranked by Target Difficulty
• Bright Data Review 2026
• IPRoyal Review 2026
• Webshare Review 2026
• 10 Best Residential Proxies 2026
• Best Proxy for Web Scraping 2026 — Ranked by Target Difficulty
• GeoNode Review 2026: Tested at Production Scale
• Best Proxy Providers 2026 — Full Comparison Hub
• Cheapest Residential Proxies 2026

Perguntas frequentes#