Guias para Desenvolvedores 12 min de leitura

Usando Proxies em Python (Requests + ProxyHat SDK)

Saiba como usar proxies em Python com a biblioteca Requests e o ProxyHat SDK. Cobre autenticação, rotação, geo-alvo, manipulação de erros e raspagem assync.

ProxyHat Team
Usando Proxies em Python (Requests + ProxyHat SDK)

Por que usar Proxies em Python?

Python domina a paisagem de extração de dados. Bibliotecas como Pedidos, httpx, e Scrapy fazer chamadas HTTP triviais, mas sem proxies, seus scripts atingiram bans IP em poucos minutos. Utilização proxies em Python permite rodar endereços IP, contornar as geo-restrições e escalar suas operações de raspagem de forma confiável.

Neste guia, você aprenderá como integrar proxies em Python usando o ProxyHat Python SDK e a norma requests biblioteca. Cada seção inclui copy-paste-ready código que você pode executar imediatamente.

Se você está construindo um Oleoduto de raspagem da web, acompanhamento Resultados do SERP, ou coletando dados de preços, este guia abrange autenticação, rotação de proxy, geo-alvo, manipulação de erros e escala de produção.

Instalação e Configuração

Instalando o SDK ProxyHat e Solicitações

Instale o SDK do ProxyHat Python e o requests biblioteca usando pip:

pip install proxyhat requests

Para fluxos de trabalho async, também instale httpx e aiohttp:

pip install httpx aiohttp

Obtendo Suas Credenciais de API

Inscreva-se em ProxyHat e recuperar sua chave API do painel. Vais precisar da tua utilizador e senha (ou chave API) para autenticação de proxy. Os detalhes completos de autenticação estão disponíveis no Documentação da API do ProxyHat.

Autenticação e Configuração Básica

Usando o SDK do ProxyHat

O SDK lida com o gerenciamento de autenticação, rotação e conexão para você:

from proxyhat import ProxyHat
client = ProxyHat(
    api_key="your_api_key_here"
)
# Test the connection
info = client.get_account_info()
print(f"Traffic remaining: {info['traffic_remaining']} GB")

Usar Credenciais de Proxy RAW com Pedidos

Se preferir usar requests diretamente, configure o URL do proxy:

import requests
proxy_url = "http://username:password@gate.proxyhat.com:8080"
proxies = {
    "http": proxy_url,
    "https": proxy_url,
}
response = requests.get(
    "https://httpbin.org/ip",
    proxies=proxies,
    timeout=30
)
print(response.json())
# {"origin": "185.xxx.xxx.xxx"}

Simples GET Pedido com um Proxy

Aqui está um exemplo completo que envia uma solicitação GET através de um proxy residencial ProxyHat:

from proxyhat import ProxyHat
client = ProxyHat(api_key="your_api_key_here")
# Make a proxied GET request
response = client.get("https://httpbin.org/ip")
print(f"Status: {response.status_code}")
print(f"IP: {response.json()['origin']}")
print(f"Headers: {response.headers}")

Ou com o padrão requests biblioteca:

import requests
proxies = {
    "http": "http://user:pass@gate.proxyhat.com:8080",
    "https": "http://user:pass@gate.proxyhat.com:8080",
}
response = requests.get(
    "https://example.com/api/data",
    proxies=proxies,
    timeout=30,
    headers={"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)"}
)
print(response.status_code)
print(response.text[:500])

Escolher o tipo de proxy certo

O ProxyHat oferece três tipos de proxy. Escolha com base no seu caso de uso. Para uma comparação mais profunda, leia nosso guia sobre residencial vs datacenter vs proxies móveis.

Escolher o tipo de proxy certo
TipoMelhor paraVelocidadeRisco de detecçãoCusto
ResidencialRaspamento na Web, rastreamento SERPMédioMuito baixoPor GB
Centro de DadosTarefas de alto volume, críticas à velocidadeRápidoMais altoPor IP/mês
TelemóvelRedes sociais, testes de aplicaçõesMédioMenorPor GB

Alternando Tipos de Proxy em Código

from proxyhat import ProxyHat
client = ProxyHat(api_key="your_api_key_here")
# Residential proxy (default)
response = client.get(
    "https://example.com",
    proxy_type="residential"
)
# Datacenter proxy
response = client.get(
    "https://example.com",
    proxy_type="datacenter"
)
# Mobile proxy
response = client.get(
    "https://example.com",
    proxy_type="mobile"
)

Rodando vs Sessões Fixos

Proxies rotativas atribuir um novo IP para cada pedido, ideal para raspagem em grande escala onde você precisa de anonimato máximo. Sessões fixas manter o mesmo IP por uma duração definida, essencial para fluxos de trabalho em várias etapas, como sequências de login ou navegação paginada.

Proxies rotativas (Novo IP Cada Pedido)

from proxyhat import ProxyHat
client = ProxyHat(api_key="your_api_key_here")
urls = [
    "https://httpbin.org/ip",
    "https://httpbin.org/ip",
    "https://httpbin.org/ip",
]
for url in urls:
    response = client.get(url, session_type="rotating")
    print(f"IP: {response.json()['origin']}")
# Each request uses a different IP:
# IP: 185.xxx.xxx.1
# IP: 92.xxx.xxx.47
# IP: 78.xxx.xxx.203

Sessões pegajosas (mesmo IP para duração)

from proxyhat import ProxyHat
client = ProxyHat(api_key="your_api_key_here")
# Create a sticky session (maintains IP for up to 30 minutes)
session = client.create_session(duration_minutes=30)
# All requests in this session use the same IP
for page in range(1, 6):
    response = session.get(f"https://example.com/products?page={page}")
    print(f"Page {page}: IP {response.headers.get('X-Proxy-IP')}")
# Same IP across all pages:
# Page 1: IP 185.xxx.xxx.42
# Page 2: IP 185.xxx.xxx.42
# Page 3: IP 185.xxx.xxx.42

Pedidos Geo- Targeted

Precisa de dados de um país específico? Suportes do ProxyHat geo- direcionamento em 195+ locais. Isto é fundamental para a sucata localizada SERP, monitoramento de preços e verificação de conteúdo.

from proxyhat import ProxyHat
client = ProxyHat(api_key="your_api_key_here")
# Target a specific country
response = client.get(
    "https://www.google.com/search?q=best+restaurants",
    country="US"
)
# Target a specific city
response = client.get(
    "https://www.google.com/search?q=best+restaurants",
    country="US",
    city="New York"
)
# Using raw proxy URL with geo-targeting
# Format: username-country-US:password@gate.proxyhat.com:8080
import requests
proxies = {
    "http": "http://user-country-DE:pass@gate.proxyhat.com:8080",
    "https": "http://user-country-DE:pass@gate.proxyhat.com:8080",
}
response = requests.get("https://www.google.de", proxies=proxies, timeout=30)
print(f"Accessed from Germany: {response.status_code}")

Tratamento de Erros e Repetições

Os pedidos de rede falham. Intervalo de proxies. Os alvos bloqueiam-te. O manuseio robusto de erros separa raspadores de produção de scripts de brinquedo.

Lógica de repetição básica

import time
import requests
from requests.exceptions import ProxyError, Timeout, ConnectionError
def fetch_with_retry(url, proxies, max_retries=3, timeout=30):
    """Fetch a URL with automatic retry on failure."""
    for attempt in range(max_retries):
        try:
            response = requests.get(
                url,
                proxies=proxies,
                timeout=timeout,
                headers={"User-Agent": "Mozilla/5.0"}
            )
            response.raise_for_status()
            return response
        except (ProxyError, Timeout, ConnectionError) as e:
            wait = 2 ** attempt  # Exponential backoff
            print(f"Attempt {attempt + 1} failed: {e}. Retrying in {wait}s...")
            time.sleep(wait)
        except requests.exceptions.HTTPError as e:
            if e.response.status_code == 429:
                wait = 10 * (attempt + 1)
                print(f"Rate limited. Waiting {wait}s...")
                time.sleep(wait)
            elif e.response.status_code >= 500:
                time.sleep(2 ** attempt)
            else:
                raise
    raise Exception(f"Failed to fetch {url} after {max_retries} attempts")
# Usage
proxies = {
    "http": "http://user:pass@gate.proxyhat.com:8080",
    "https": "http://user:pass@gate.proxyhat.com:8080",
}
response = fetch_with_retry("https://example.com/data", proxies)

Usando a repetição incorporada do SDK

from proxyhat import ProxyHat
client = ProxyHat(
    api_key="your_api_key_here",
    max_retries=3,
    timeout=30,
    retry_on_status=[429, 500, 502, 503]
)
# The SDK handles retries automatically
response = client.get("https://example.com/data")
print(response.status_code)

Raspagem simultânea com rosca

Os pedidos sequenciais são lentos. Para cargas de trabalho de produção, use Python's concurrent.futures Paralelizar pedidos através de proxies.

from concurrent.futures import ThreadPoolExecutor, as_completed
from proxyhat import ProxyHat
client = ProxyHat(api_key="your_api_key_here")
urls = [
    "https://example.com/product/1",
    "https://example.com/product/2",
    "https://example.com/product/3",
    "https://example.com/product/4",
    "https://example.com/product/5",
]
def scrape(url):
    """Scrape a single URL through the proxy."""
    response = client.get(url, proxy_type="residential")
    return {"url": url, "status": response.status_code, "length": len(response.text)}
# Run 5 concurrent requests
results = []
with ThreadPoolExecutor(max_workers=5) as executor:
    futures = {executor.submit(scrape, url): url for url in urls}
    for future in as_completed(futures):
        try:
            result = future.result()
            results.append(result)
            print(f"OK: {result['url']} ({result['length']} bytes)")
        except Exception as e:
            print(f"Error: {futures[future]} - {e}")
print(f"\nCompleted: {len(results)}/{len(urls)}")

Async Raspando com assíncio e httpx

import asyncio
import httpx
async def scrape_urls(urls, proxy_url, max_concurrent=10):
    """Scrape multiple URLs concurrently using async proxies."""
    semaphore = asyncio.Semaphore(max_concurrent)
    async def fetch(client, url):
        async with semaphore:
            response = await client.get(url, timeout=30)
            return {"url": url, "status": response.status_code}
    async with httpx.AsyncClient(proxy=proxy_url) as client:
        tasks = [fetch(client, url) for url in urls]
        return await asyncio.gather(*tasks, return_exceptions=True)
# Usage
proxy_url = "http://user:pass@gate.proxyhat.com:8080"
urls = [f"https://example.com/page/{i}" for i in range(1, 51)]
results = asyncio.run(scrape_urls(urls, proxy_url))
successful = [r for r in results if not isinstance(r, Exception)]
print(f"Scraped {len(successful)}/{len(urls)} pages")

Integração com Bibliotecas Populares de Python

Utilização com Pedidos (Sessão)

import requests
session = requests.Session()
session.proxies = {
    "http": "http://user:pass@gate.proxyhat.com:8080",
    "https": "http://user:pass@gate.proxyhat.com:8080",
}
session.headers.update({
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)"
})
# All requests in this session use the proxy
response = session.get("https://example.com/api/products")
print(response.json())

Usando com httpx

import httpx
proxy_url = "http://user:pass@gate.proxyhat.com:8080"
# Synchronous
with httpx.Client(proxy=proxy_url) as client:
    response = client.get("https://httpbin.org/ip")
    print(response.json())
# Asynchronous
async with httpx.AsyncClient(proxy=proxy_url) as client:
    response = await client.get("https://httpbin.org/ip")
    print(response.json())

Usar com o aiohttp

import aiohttp
import asyncio
async def fetch_with_aiohttp():
    proxy_url = "http://user:pass@gate.proxyhat.com:8080"
    async with aiohttp.ClientSession() as session:
        async with session.get(
            "https://httpbin.org/ip",
            proxy=proxy_url,
            timeout=aiohttp.ClientTimeout(total=30)
        ) as response:
            data = await response.json()
            print(f"IP: {data['origin']}")
asyncio.run(fetch_with_aiohttp())

Usando com Scrapy

Adicione ProxyHat à sua aranha Scrapy configurando o settings.py:

# settings.py
DOWNLOADER_MIDDLEWARES = {
    "scrapy.downloadermiddlewares.httpproxy.HttpProxyMiddleware": 110,
}
HTTP_PROXY = "http://user:pass@gate.proxyhat.com:8080"
# Or set per-request in your spider:
import scrapy
class ProductSpider(scrapy.Spider):
    name = "products"
    start_urls = ["https://example.com/products"]
    def start_requests(self):
        for url in self.start_urls:
            yield scrapy.Request(
                url,
                meta={"proxy": "http://user:pass@gate.proxyhat.com:8080"},
                callback=self.parse
            )
    def parse(self, response):
        for product in response.css(".product-card"):
            yield {
                "name": product.css("h2::text").get(),
                "price": product.css(".price::text").get(),
            }

Dicas de produção

Pool de conexão e timeouts

import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry
session = requests.Session()
# Configure retry strategy
retry_strategy = Retry(
    total=3,
    backoff_factor=1,
    status_forcelist=[429, 500, 502, 503, 504],
)
adapter = HTTPAdapter(
    max_retries=retry_strategy,
    pool_connections=10,
    pool_maxsize=20
)
session.mount("http://", adapter)
session.mount("https://", adapter)
session.proxies = {
    "http": "http://user:pass@gate.proxyhat.com:8080",
    "https": "http://user:pass@gate.proxyhat.com:8080",
}
# Robust, production-ready request
response = session.get("https://example.com/data", timeout=(5, 30))
print(response.status_code)

Registo e monitorização

import logging
import time
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(message)s")
logger = logging.getLogger("scraper")
def monitored_request(session, url):
    """Log request timing and status for monitoring."""
    start = time.time()
    try:
        response = session.get(url, timeout=30)
        elapsed = time.time() - start
        logger.info(f"OK {response.status_code} {url} ({elapsed:.2f}s)")
        return response
    except Exception as e:
        elapsed = time.time() - start
        logger.error(f"FAIL {url} ({elapsed:.2f}s): {e}")
        raise

Variáveis de Ambiente para Credenciais

Nunca codifique credenciais. Usar variáveis de ambiente:

import os
from proxyhat import ProxyHat
client = ProxyHat(
    api_key=os.environ["PROXYHAT_API_KEY"]
)
# Or with raw proxy URL
proxy_url = os.environ.get(
    "PROXY_URL",
    "http://user:pass@gate.proxyhat.com:8080"
)

Para uma lista completa de planos de proxy disponíveis e opções de tráfego, visite nosso página de preços. Para casos de uso avançado e referência de endpoint, ver Documentação da API. Você também pode explorar nosso guia sobre o melhores proxies para raspagem web em 2026 Para comparações de fornecedores.

Tiras de Chaves

  • Instalar em um comando: pip install proxyhat requests Vai começar imediatamente.
  • Usar o SDK para simplificar: O ProxyHat Python SDK lida com autenticação, tentativas e rotação automaticamente.
  • Escolha o tipo de proxy certo: Residencial para raspagem, datacenter para velocidade, móvel para plataformas sociais.
  • Rodar vs vara: Use proxies rotativos para raspar a granel, sessões pegajosas para fluxos de trabalho em várias etapas.
  • Geo-alvo quando necessário: Especifique país e cidade para a coleta de dados localizada.
  • Lidar com erros corretamente: Implemente backoff exponencial e tente novamente a lógica para a confiabilidade da produção.
  • Escala com concordância: Utilização ThreadPoolExecutor ou asyncio Paralelizar os pedidos.
  • Nunca credenciais de código rígido: Armazenar chaves API em variáveis de ambiente.

Perguntas Frequentes

Como configuro um proxy nas Solicitações Python?

Passar a proxies dicionário para qualquer requests método: requests.get(url, proxies={"http": "http://user:pass@host:port", "https": "http://user:pass@host:port"}). O SDK ProxyHat simplifica isso ainda mais, manipulando a configuração do proxy internamente.

Qual é a diferença entre proxies giratórios e pegajosos em Python?

Proxies rotativos atribuem um novo endereço IP para cada solicitação, que é ideal para raspagem em grande escala. Proxies pegajosos mantêm o mesmo IP por uma duração definida (por exemplo, 10-30 minutos), que é necessário para sessões de login, carrinhos de compras, ou navegação paginada onde a consistência IP importa.

Posso usar proxies ProxyHat com assíncio e aiohttp?

Sim. ProxyHat proxies funcionam com qualquer cliente HTTP que suporta configuração proxy, incluindo aiohttp, httpx (modo de sincronização), e asyncio- quadros baseados. Passar o URL do proxy como o proxy parâmetro no seu cliente assync.

Como posso lidar com erros de proxy e timeouts em Python?

Enrole seus pedidos em tentar / exceto blocos captura ProxyError, Timeout, e ConnectionError. Implementar retrocesso exponencial (doubling wait time between retries) e definir uma contagem de repetição máxima. O SDK ProxyHat inclui lógica de repetição incorporada com parâmetros configuráveis.

Qual biblioteca Python é melhor para raspar web com proxies?

Para tarefas simples, requests com o SDK ProxyHat é a opção mais fácil. Para raspagem assincronizada de alta concorrência, utilizar httpx ou aiohttp. Para complexos que se arrastam com ligação e extração de dados, Scrapy com middleware proxy é a escolha mais poderosa. Todos trabalham perfeitamente com proxies ProxyHat.

Pronto para começar?

Acesse mais de 50M de IPs residenciais em mais de 148 países com filtragem por IA.

Ver preçosProxies residenciais
← Voltar ao Blog