Proxy para Python

Python — a linguagem nº 1 para raspagem de dados e automação. Mas qualquer script, cedo ou tarde, acaba sendo bloqueado por IP. Para evitar isso, é necessário integrar proxies de forma inteligente.

Neste guia, vamos analisar como conectar um proxy nos quatro cenários mais populares: de simples requisições ao controle do navegador.

📌 Método 1. Biblioteca requests (A mais popular)

Se você está escrevendo um raspador simples ou trabalhando com uma API, você usa requests. Aqui, os proxies são passados através de um dicionário (dict) comum.

Código:

import requests

# Formato: login:password@ip:port
# No CyberYozh App usamos a porta 5959 para HTTP
proxy = "http://user:pass@51.77.190.247:5959"

proxies = {
    "http": proxy,
    "https": proxy
}

try:
    # Sempre especifique um timeout!
    response = requests.get("https://httpbin.org/ip", proxies=proxies, timeout=10)
    print(f"Seu IP: {response.json()['origin']}")
except Exception as e:
    print(f"Erro: {e}")

Dica: Não escreva os proxies diretamente no código (hardcoding). É melhor extraí-los de variáveis de ambiente (os.getenv).

Se você quiser usar SOCKS5 no Python, você precisa:

1. Instalar uma biblioteca adicional: O requests por si só não suporta SOCKS. Você precisa instalar uma extensão:

pip install requests[socks]
# ou
pip install pysocks

 

2. Alterar o esquema no código: Aqui a porta e a sintaxe mudam para 9595 e socks5h://.

import requests

# Usamos socks5h para proteger contra vazamento de DNS (Remote DNS resolution)
socks_proxy = "socks5h://user:pass@51.77.190.247:9595"

proxies = {
    "http": socks_proxy,
    "https": socks_proxy
}

try:
    response = requests.get("https://httpbin.org/ip", proxies=proxies, timeout=10)
    print(f"Seu IP via SOCKS5: {response.json()['origin']}")
except Exception as e:
    print(f"Erro: {e}")

 

🤖 Método 2. Biblioteca Selenium (Emulação de navegador)

Se o site usa JavaScript complexo (React, Vue), Single Page Application (SPA) ou proteção Cloudflare, o requests comum não dará conta — ele simplesmente não sabe executar código JS. Você precisa do Selenium, que abre e controla um navegador real (Chrome/Firefox).

⚠️ O problema principal: Autenticação

O Chrome padrão tem uma característica desagradável: ele não suporta o envio de login e senha do proxy via argumentos de inicialização. Se você tentar passar http://user:pass@ip:port, o navegador simplesmente ignorará a autenticação e mostrará uma janela pop-up pedindo a senha, o que interrompe a automação.

✅ Solução: Biblioteca selenium-wire

Esta é uma extensão para o Selenium comum que consegue interceptar requisições e inserir automaticamente o login e a senha do proxy.

Instalação:

pip install selenium-wire

 

Código (Configuração correta com autenticação):

# Atenção: importamos webdriver do seleniumwire, e não do selenium
from seleniumwire import webdriver 

# Seus dados de proxy do CyberYozh App
PROXY_HOST = "51.77.190.247"
PROXY_PORT = "5959" # Porta para HTTP
PROXY_USER = "seu_login"
PROXY_PASS = "sua_senha"

# Formamos o dicionário de configurações
proxy_options = {
    'proxy': {
        'http': f'http://{PROXY_USER}:{PROXY_PASS}@{PROXY_HOST}:{PROXY_PORT}',
        'https': f'http://{PROXY_USER}:{PROXY_PASS}@{PROXY_HOST}:{PROXY_PORT}',
        'no_proxy': 'localhost,127.0.0.1' # Não usar proxy para endereços locais
    }
}

# Inicializamos o navegador com a opção seleniumwire_options
driver = webdriver.Chrome(seleniumwire_options=proxy_options)

print("Navegador iniciado, verificando IP...")
driver.get("https://httpbin.org/ip")

# Exibimos o conteúdo da página (deve aparecer o IP do seu proxy)
print(driver.find_element("tag name", "body").text)

driver.quit()

 

Por que isso funciona: O selenium-wire cria um servidor intermediário local que assume a comunicação com o seu proxy. O navegador pensa que está trabalhando sem senha, enquanto a própria biblioteca "cola" os cabeçalhos de autorização necessários. Este é o método mais confiável para Python.

Selenium e SOCKS5:

Da mesma forma que para o requests, para que o selenium-wire funcione com proxies SOCKS, você deve instalar a biblioteca pysocks (se ainda não a tiver):

pip install pysocks

 

Código para SOCKS5 (Selenium Wire)

A lógica permanece a mesma: as chaves do dicionário ('http', 'https') indicam à biblioteca qual tráfego interceptar, e os valores (socks5://...) indicam para onde enviá-lo.

from seleniumwire import webdriver  # Importação especificamente do seleniumwire!

# Seus dados de proxy SOCKS5
PROXY_HOST = "51.77.190.247"
PROXY_PORT = "9595"  # Certifique-se de que é a porta para SOCKS5 (geralmente diferente de HTTP)
PROXY_USER = "seu_login"
PROXY_PASS = "sua_senha"

# Configurações
proxy_options = {
    'proxy': {
        # O esquema muda para socks5://
        'http': f'socks5://{PROXY_USER}:{PROXY_PASS}@{PROXY_HOST}:{PROXY_PORT}',
        'https': f'socks5://{PROXY_USER}:{PROXY_PASS}@{PROXY_HOST}:{PROXY_PORT}',
        'no_proxy': 'localhost,127.0.0.1'
    }
}

# Inicialização do navegador
# Podem ser adicionadas opções comuns do Chrome (headless, etc.) via chrome_options=...
driver = webdriver.Chrome(seleniumwire_options=proxy_options)

try:
    print("Navegador iniciado, verificando IP...")
    driver.get("https://httpbin.org/ip")

    # Exibimos o IP
    print(driver.find_element("tag name", "body").text)

    # Recomendo verificar o tipo de proxy em um verificador mais detalhado
    # driver.get("https://browserleaks.com/ip")

except Exception as e:
    print(f"Erro: {e}")
finally:
    driver.quit()

 

Qual a diferença?

No dicionário proxy_options, mudamos o esquema de http:// para socks5://.

Atenção às chaves do dicionário: Nós NÃO mudamos as chaves 'http' e 'https' para 'socks'.

  • A chave 'https' significa: "Quando o navegador solicitar sites HTTPS..."

  • O valor socks5://... significa: "...envie-os através deste túnel SOCKS5".

E quanto ao DNS (socks5h)?

No selenium-wire, a resolução DNS é de responsabilidade da lógica interna da biblioteca. Geralmente, ela lida com o redirecionamento de consultas DNS através do proxy automaticamente se o esquema socks5 for usado, já que o selenium-wire funciona como um Man-in-the-Middle (intermediário) entre o navegador e a internet.

Se por acaso você notar um vazamento de DNS (seu provedor real é visível), tente indicar socks5h:// na string de conexão — o selenium-wire suporta este formato graças à biblioteca requests por baixo do pano.

🚀 Método 3. Biblioteca aiohttp (Asincronicidade)

Quando você precisa raspar 10.000 páginas por minuto, usa-se a abordagem assíncrona (async/await). Aqui, o requests comum não serve, você precisa do aiohttp.

Código:

import aiohttp
import asyncio

async def fetch_ip():
    proxy_auth = aiohttp.BasicAuth('user', 'pass') # Login e senha separadamente
    proxy_url = "http://51.77.190.247:5959"

    async with aiohttp.ClientSession() as session:
        async with session.get("https://httpbin.org/ip", 
                               proxy=proxy_url, 
                               proxy_auth=proxy_auth) as resp:
            print(await resp.json())

asyncio.run(fetch_ip())

 

SOCKS5 para aiohttp

Para o aiohttp, a situação é um pouco mais complexa do que para o requests. A biblioteca aiohttp por si só não suporta proxies SOCKS nativamente. Ela só sabe trabalhar com proxies HTTP.

Para "ensiná-la" a trabalhar com SOCKS5, é necessário usar um conector especial.

1. Instalação

Você precisará da biblioteca ponte aiohttp-socks:

pip install aiohttp-socks

 

2. Código (abordagem correta via Connector)

Diferente do exemplo HTTP onde passávamos o proxy em cada requisição (session.get(..., proxy=...)), para o SOCKS5 configuramos o proxy uma única vez na criação da sessão.

Isso é até melhor para o desempenho (conexão Keep-Alive).

import aiohttp
import asyncio
from aiohttp_socks import ProxyConnector # Importamos o conector

async def fetch_ip():
    # Formamos a string de conexão.
    # Note: embutimos login e senha direto na string da URL.
    socks_url = "socks5://user:pass@51.77.190.247:9595"

    # Criamos o conector
    # rdns=True — é o análogo ao socks5h (proteção contra vazamento de DNS).
    # Isso é OBRIGATÓRIO para o anonimato.
    connector = ProxyConnector.from_url(socks_url, rdns=True)

    # Passamos o conector para ClientSession
    # Agora toda esta sessão funcionará através do SOCKS5
    async with aiohttp.ClientSession(connector=connector) as session:
        try:
            # ATENÇÃO: Dentro de .get() NÃO É MAIS necessário escrever proxy=...
            # O proxy já está "embutido" na session via connector.
            async with session.get("https://httpbin.org/ip") as resp:
                print(await resp.json())
        except Exception as e:
            print(f"Erro: {e}")

if __name__ == '__main__':
    # Inicialização correta para Windows/Linux
    asyncio.run(fetch_ip())

 

🔍 Quais as principais diferenças da variante HTTP?

  1. Biblioteca: Adicionamos from aiohttp_socks import ProxyConnector.

  2. Local de configuração:

    • Antes: session.get(..., proxy=...) (configuração em cada requisição).

    • Depois: aiohttp.ClientSession(connector=...) (configuração da sessão inteira).

  3. DNS (rdns=True): O parâmetro rdns=True faz o mesmo que o socks5h — força a resolução de domínios no lado do proxy, escondendo do provedor para onde você está navegando.

Este código é ideal para raspar 10.000 páginas, já que o connector gerencia de forma eficiente o pool de conexões através do túnel SOCKS.

🔧 Método 4. Uso de variáveis de ambiente (Best Practice)

Desenvolvedores profissionais não escrevem proxies dentro do código. Isso é inseguro (se você subir o código no GitHub, seus proxies serão roubados). O Python sabe detectar proxies automaticamente do sistema.

No terminal (Linux/Mac):

export HTTP_PROXY="http://user:pass@51.77.190.247:5959"

 

No código:

import requests
# Não é necessário passar nenhum argumento proxies=...!
# A biblioteca encontrará as configurações no sistema por conta própria.
requests.get("https://httpbin.org/ip")

 

💡 Qual proxy escolher para um script em Python?

O código é apenas metade do trabalho. O fundamental é a qualidade do proxy e o método de gestão da rotação. Dependendo da tarefa, a arquitetura do seu script mudará.

1. Datacenter (IPv4, IPv6)

Ideal para: Requisições simples de API, download de arquivos, trabalho com sites sem proteções rígidas.

  • Lógica no Python: Se um IP for banido, simplesmente mude-o no script para o próximo da sua lista de proxies.

  • Vantagem: Alta velocidade (até 1 Gbps) e preço baixo.

2. Residenciais Rotativos

Ideal para: Raspagem agressiva (Amazon, eBay), evasão de Cloudflare e coleta de grandes volumes de dados.

  • Como funciona a rotação: Você não precisa escrever um código complexo de rotação. No CyberYozh App usamos o «Gerador inteligente de credenciais». Você altera o comportamento do proxy apenas mudando o login:

    • login-res-any: O script recebe um novo IP a cada requisição (requests.get).

    • login-res-any-sid-12345678: O IP é fixado a este conjunto de dígitos (sid) por até 1 minuto.

    • login-resfix: O script fixa o IP para si (Sticky Session) para autenticação.

  • Vantagem para o Python: Você usa apenas uma string de conexão e ganha acesso a milhões de IPs.

👉 Saiba mais sobre a rotação de proxies residenciais aqui.

3. Proxies Móveis (Mobile 4G/LTE)

Ideal para: Registro de contas, trabalho com redes sociais (Instagram, TikTok) e emulação de usuários reais via Selenium/Appium. Nível de confiança (trust) mais elevado.

Existem dois cenários de gestão no código aqui:

  • 🅰️ Privados (Private): Rotação via link Você aluga o modem inteiro. Para mudar o IP, seu script em Python deve "chamar" um link de API especial.

    • Exemplo de lógica:

      # 1. Executa um ciclo de ações
do_registration()
# 2. Reinicia o modem via API
requests.get("https://app.cyberyozh.com/api/v1/...") 
time.sleep(15) # Aguarda o modem restabelecer a conexão
# 3. Começa um novo ciclo

  • 🅱️ Compartilhados (Shared): Auto-rotação O IP muda sozinho conforme o temporizador do serviço (ex: a cada 5 ou 30 minutos).

    • Lógica no Python: Você precisa lidar com quedas de conexão. Se o modem estiver reiniciando durante uma requisição, o script deve capturar o erro ConnectionError, aguardar alguns segundos e repetir a requisição (Retry).

👉 Saiba mais sobre proxies móveis aqui.

Conclusão

Integrar um proxy no Python leva apenas de 3 a 5 linhas de código. O segredo é escolher o tipo certo de proxy para o objetivo e a biblioteca correspondente.

👉 Pronto para começar a codar? No catálogo do CyberYozh App você encontrará todos os tipos de proxies mencionados. Basta escolher o plano adequado para suas tarefas (raspagem, registros ou navegação), copiar os acessos e integrá-los ao seu projeto em poucos minutos.