Como Usar um Proxy com Python Requests: 10 Soluções para Aperfeiçoar a Captura de Dados na Web

import requests

proxies = {
    'http': 'http://seu_proxy_http:porta',
    'https': 'http://seu_proxy_https:porta',
}

try:
    response = requests.get('http://httpbin.org/ip', proxies=proxies, timeout=10)
    print(f"Seu IP: {response.json()['origin']}")
except requests.exceptions.RequestException as e:
    print(f"Falha na solicitação: {e}")

import requests

proxies = {
    'http': 'http://seu_usuario:sua_senha@seu_proxy_http:porta',
    'https': 'http://seu_usuario:sua_senha@seu_proxy_https:porta',
}

try:
    response = requests.get('http://httpbin.org/ip', proxies=proxies, timeout=10)
    print(f"Seu IP: {response.json()['origin']}")
except requests.exceptions.RequestException as e:
    print(f"Falha na solicitação: {e}")

import os
import requests

os.environ['HTTP_PROXY'] = 'http://seu_proxy_http:porta'
os.environ['HTTPS_PROXY'] = 'http://seu_proxy_https:porta'

try:
    response = requests.get('http://httpbin.org/ip', timeout=10)
    print(f"Seu IP: {response.json()['origin']}")
except requests.exceptions.RequestException as e:
    print(f"Falha na solicitação: {e}")

# Limpar variáveis de ambiente (opcional)
del os.environ['HTTP_PROXY']
del os.environ['HTTPS_PROXY']

import requests

session = requests.Session()
session.proxies = {
    'http': 'http://seu_proxy_http:porta',
    'https': 'http://seu_proxy_https:porta',
}

try:
    response = session.get('http://httpbin.org/ip', timeout=10)
    print(f"Seu IP: {response.json()['origin']}")
    response = session.get('http://httpbin.org/headers', timeout=10)
    print(f"Headers: {response.json()['headers']}")
except requests.exceptions.RequestException as e:
    print(f"Falha na solicitação: {e}")

import requests
import random

proxy_pool = [
    {'http': 'http://proxy1.exemplo.com:8080', 'https': 'http://proxy1.exemplo.com:8080'},
    {'http': 'http://proxy2.exemplo.com:8080', 'https': 'http://proxy2.exemplo.com:8080'},
    {'http': 'http://proxy3.exemplo.com:8080', 'https': 'http://proxy3.exemplo.com:8080'},
]

def get_random_proxy():
    return random.choice(proxy_pool)

url = 'http://httpbin.org/ip'

for _ in range(5):  # Faz 5 solicitações com proxies rotativos
    current_proxy = get_random_proxy()
    print(f"Usando proxy: {current_proxy['http']}")
    try:
        response = requests.get(url, proxies=current_proxy, timeout=10)
        print(f"Seu IP: {response.json()['origin']}")
    except requests.exceptions.RequestException as e:
        print(f"Solicitação falhou com proxy {current_proxy['http']}: {e}")

pip install requests[socks]

import requests

proxies = {
    'http': 'socks5://seu_proxy_socks:porta',
    'https': 'socks5://seu_proxy_socks:porta',
}

try:
    response = requests.get('http://httpbin.org/ip', proxies=proxies, timeout=10)
    print(f"Seu IP: {response.json()['origin']}")
except requests.exceptions.RequestException as e:
    print(f"Solicitação falhou: {e}")

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

class CustomProxyAdapter(HTTPAdapter):
    def __init__(self, proxy_list, *args, **kwargs):
        self.proxy_list = proxy_list
        super().__init__(*args, **kwargs)

    def send(self, request, **kwargs):
        proxy = random.choice(self.proxy_list)  # Lógica personalizada de seleção de proxy
        request.url = request.url.replace('http://', f'http://{proxy}/')
        request.url = request.url.replace('https://', f'https://{proxy}/')
        return super().send(request, **kwargs)

proxy_pool_for_adapter = [
    'proxy1.exemplo.com:8080',
    'proxy2.exemplo.com:8080',
]

session = requests.Session()
# Montar o adaptador personalizado para todas as solicitações HTTP/HTTPS
session.mount('http://', CustomProxyAdapter(proxy_pool_for_adapter))
session.mount('https://', CustomProxyAdapter(proxy_pool_for_adapter))

try:
    response = session.get('http://httpbin.org/ip', timeout=10)
    print(f"Seu IP: {response.json()['origin']}")
except requests.exceptions.RequestException as e:
    print(f"Solicitação falhou: {e}")

import requests

proxies_to_test = [
    {'http': 'http://proxy_bom:8080', 'https': 'http://proxy_bom:8080'},
    {'http': 'http://proxy_ruim:8080', 'https': 'http://proxy_ruim:8080'},  # Simular um proxy ruim
]

working_proxies = []

for proxy in proxies_to_test:
    try:

response = requests.get('http://httpbin.org/ip', proxies=proxy, timeout=5)
if response.status_code == 200:
    print(f"O proxy {proxy['http']} está funcionando. IP: {response.json()['origin']}")
    working_proxies.append(proxy)
else:
    print(f"O proxy {proxy['http']} retornou o código de status {response.status_code}")
except requests.exceptions.RequestException as e:
    print(f"O proxy {proxy['http']} falhou: {e}")

print(f"Proxies funcionais: {working_proxies}")

import requests

# Substitua pelo seu endpoint API Scrapeless real e chave API
SCRAPELESS_API_ENDPOINT = 'https://api.scrapeless.com/scrape'
SCRAPELESS_API_KEY = 'SUA_CHAVE_API_SCRAPELESS'

url_a_scrapar = 'https://www.example.com'

headers = {
    'X-Scrapeless-Api-Key': SCRAPELESS_API_KEY,
    'Content-Type': 'application/json'
}

payload = {
    'url': url_a_scrapar,
    'proxy_type': 'residential',  # Especifique proxy residencial
    # Adicione outros parâmetros do Scrapeless conforme necessário, por exemplo, geo-targeting
}

try:
    response = requests.post(SCRAPELESS_API_ENDPOINT, headers=headers, json=payload, timeout=30)
    if response.status_code == 200:
        print("Web scraping bem-sucedido!")
        # Processar response.json() ou response.text conforme necessário
        print(response.json())
    else:
        print(f"Web scraping falhou com código de status: {response.status_code}")
        print(response.text)
except requests.exceptions.RequestException as e:
    print(f"A solicitação para a API do Scrapeless falhou: {e}")

# Este é um exemplo conceitual. A implementação real com requests-toolbelt pode variar.
# from requests_toolbelt import sessions

# session = sessions.BaseUrlSession(base_url='http://httpbin.org/')
# session.proxies = {
#     'http': 'http://proxy1.example.com:8080',
#     'https': 'http://proxy2.example.com:8080',
# }

# try:
#     response = session.get('ip')
#     print(f"Seu IP: {response.json()['origin']}")
# except requests.exceptions.RequestException as e:
#     print(f"A solicitação falhou: {e}")

Um negócio de e-commerce precisa monitorar os preços dos concorrentes em várias lojas online globalmente. Isso requer a extração de páginas de produtos de diferentes regiões geográficas, o que frequentemente envolve restrições geográficas. Ao utilizar proxies residenciais com capacidades de geotargeting, o negócio pode simular solicitações de países específicos, garantindo a coleta precisa de dados de preços. A rotação de proxies é crucial aqui para evitar a detecção por sistemas anti-bot que monitoram padrões de solicitação a partir de endereços IP únicos. Uma solução de proxy robusta como a Scrapeless, com seu extenso pool de IPs residenciais, seria ideal para essa tarefa, permitindo que o negócio colete inteligência competitiva sem interrupções. Para um aprofundamento em tarefas específicas de scraping, aprenda [como extrair dados de produtos da Amazon](https://www.scrapeless.com/blog/how-to-scrape-amazon-product-data).

### Estudo de Caso 2: Análise do Mercado Imobiliário

Uma empresa de análises imobiliárias deseja coletar listagens de propriedades de múltiplos portais imobiliários locais. Esses portais frequentemente têm limites de taxa e podem bloquear IPs que enviam muitas solicitações da mesma origem. Implementar um pool de proxies com rotação automática garante que a empresa possa coletar dados continuamente sem ser bloqueada. Além disso, se certos portais tiverem desafios CAPTCHA, um serviço de proxy que integra capacidades de resolução de CAPTCHA (frequentemente encontrado em APIs de proxy avançadas) seria altamente benéfico, agilizando o processo de coleta de dados.

### Estudo de Caso 3: Coleta de Dados de Mídia Social para Análise de Sentimento

Pesquisadores que realizam análises de sentimento em postagens públicas de mídias sociais precisam coletar grandes volumes de dados de plataformas que detectam e bloqueiam agressivamente o acesso automatizado. Usar proxies móveis é particularmente eficaz nesse cenário, já que as plataformas de mídia social são altamente otimizadas para o tráfego móvel e tendem a confiar mais em IPs móveis. Combinar proxies móveis com gestão de sessão em Python Requests permite que os pesquisadores mantenham estados de login e coletem dados por períodos prolongados sem ativar alertas de segurança.

## Por Que Escolher a Scrapeless para Suas Necessidades de Proxy?

Quando se trata de soluções de proxy confiáveis e eficientes para web scraping, a Scrapeless se destaca, especialmente com seu foco em proxies residenciais de alta qualidade. Como discutido, proxies residenciais são fundamentais para tarefas que exigem alta anonimidade e a capacidade de contornar medidas anti-bot sofisticadas. A Scrapeless fornece acesso a uma vasta rede de endereços IP residenciais reais, garantindo que suas atividades de scraping pareçam legítimas e sejam menos propensas a serem detectadas ou bloqueadas.

**Principais vantagens da Scrapeless:**

- **Extenso Pool de IPs Residenciais**: Acesso a milhões de IPs residenciais genuínos globalmente, permitindo geotargeting preciso e alta anonimidade.
- **Rotação Automática de Proxies**: A Scrapeless lida com as complexidades da rotação e gestão de proxies, permitindo que você se concentre na extração de dados em vez da infraestrutura.
- **Altas Taxas de Sucesso**: Projetada para contornar até mesmo os sistemas anti-bot mais avançados, garantindo uma taxa de sucesso maior para suas solicitações de scraping.
- **Escalabilidade**: Escale suas operações facilmente sem se preocupar em gerenciar uma grande infraestrutura de proxies.
- **Custo-Efetivo para Valor**: Embora proxies residenciais sejam um investimento, a Scrapeless oferece uma vantagem competitiva ao fornecer proxies de alta qualidade e confiáveis que economizam tempo e recursos no longo prazo, minimizando bloqueios e retrabalhos.

Ao integrar a Scrapeless ao seu fluxo de trabalho do Python Requests, você pode aprimorar significativamente a robustez e a eficiência de seus projetos de web scraping, garantindo acesso consistente aos dados de que precisa.

## Conclusão

Dominar o uso de proxies com Python Requests é uma habilidade indispensável para quem está envolvido em web scraping ou extração de dados. Desde configurações básicas de dicionário até gestão avançada de sessões e rotação de proxies, as soluções descritas neste guia fornecem um kit de ferramentas abrangente para navegar pelas complexidades da web. Ao entender as nuances dos diferentes tipos de proxies — residenciais, de datacenter e móveis — e implementar um tratamento robusto de erros, você pode melhorar significativamente a eficiência, a confiabilidade e a discrição de suas operações de scraping. Para aqueles que buscam uma solução simplificada e altamente eficaz, aproveitar um serviço de proxy dedicado como a Scrapeless, com sua rede de IPs residenciais premium, oferece vantagens incomparáveis em contornar medidas anti-bot sofisticadas e garantir acesso consistente a dados valiosos. Adote essas técnicas para transformar seus desafios de web scraping em empreendimentos bem-sucedidos de aquisição de dados.
<div class="text-sm text-gray-500"> login_scrapeless.json </div>
          <div class="text-sm text-gray-500" style="margin-left: 6px">
            • 37 KB
          </div>
        </div>
      </div>
      <img src="https://app.scrapeless.com/assets/logo.svg" class="w-10 h-10" style="border: none; margin: 0"
        alt="Scrapeless" />
    </div>
  </a>

## FAQ

### Q1: Qual é o principal benefício de usar proxies com Python Requests?

A1: O principal benefício é contornar banimentos de IP, acessar conteúdo restrito geograficamente e manter a anonimidade durante a raspagem da web. Os proxies redirecionam suas solicitações através de diferentes endereços IP, tornando mais difícil para os sites detectar e bloquear sua atividade automatizada.

### Q2: Qual é a diferença entre proxies residenciais e de datacenter?

A2: Proxies residenciais usam endereços IP reais de Provedores de Serviços de Internet (ISPs) designados para usuários domésticos, tornando-os altamente legítimos e menos propensos à detecção. Proxies de datacenter são IPs criados artificialmente hospedados em datacenters, que são mais rápidos e baratos, mas mais facilmente detectáveis por sistemas anti-bot sofisticados.

### Q3: Como posso lidar com autenticação de proxy em Python Requests?

A3: Você pode lidar com autenticação de proxy incorporando seu nome de usuário e senha diretamente na URL do proxy, como `http://username:password@host:port`, ao definir seu dicionário de proxy no Python Requests.

### Q4: Por que a rotação de proxy é importante para a raspagem da web?

A4: A rotação de proxy é crucial para raspagem da web em larga escala para evitar banimentos de IP e limites de taxa. Ao alternar entre um pool de diferentes endereços IP, suas solicitações parecem vir de várias fontes, imitando o comportamento humano e reduzindo a probabilidade de serem detectadas e bloqueadas.

### Q5: Posso usar proxies SOCKS com Python Requests?

A5: Sim, você pode usar proxies SOCKS com Python Requests, mas precisa instalar a extensão `requests[socks]` primeiro (`pip install requests[socks]`). Após a instalação, você pode especificar o protocolo SOCKS (por exemplo, `socks5://`) na sua URL de proxy.

## Referências

[1] <a href="https://www.researchandmarkets.com/report/global-residential-proxy-server-market?srsltid=AfmBOop4yk7MwBnwaiY9TzPRLcv9AWqqqtxUowor5T5js4sMwLJnltsD" rel="nofollow">**ResearchAndMarkets: Mercado Global de Servidores Proxy Residenciais**</a>

[2] <a href="https://www.zenrows.com/blog/python-requests-proxy" rel="nofollow">**ZenRows: Como Definir um Proxy no Python Requests**</a>

[3] <a href="https://scrapfly.io/blog/posts/introduction-to-proxies-in-web-scraping" rel="nofollow">**Scrapfly: O Guia Completo para Usar Proxies na Raspagem da Web**</a>