Cómo usar un proxy con Python Requests: 10 soluciones para mejorar el scraping web

import requests

proxies = {
    'http': 'http://tu_proxy_http:puerto',
    'https': 'http://tu_proxy_https:puerto',
}

try:
    response = requests.get('http://httpbin.org/ip', proxies=proxies, timeout=10)
    print(f"Tu IP: {response.json()['origin']}")
except requests.exceptions.RequestException as e:
    print(f"La solicitud falló: {e}")

import requests

proxies = {
    'http': 'http://tu_usuario:tu_contraseña@tu_proxy_http:puerto',
    'https': 'http://tu_usuario:tu_contraseña@tu_proxy_https:puerto',
}

try:
    response = requests.get('http://httpbin.org/ip', proxies=proxies, timeout=10)
    print(f"Tu IP: {response.json()['origin']}")
except requests.exceptions.RequestException as e:
    print(f"La solicitud falló: {e}")

import os
import requests

os.environ['HTTP_PROXY'] = 'http://tu_proxy_http:puerto'
os.environ['HTTPS_PROXY'] = 'http://tu_proxy_https:puerto'

try:
    response = requests.get('http://httpbin.org/ip', timeout=10)
    print(f"Tu IP: {response.json()['origin']}")
except requests.exceptions.RequestException as e:
    print(f"La solicitud falló: {e}")

# Limpiar variables de entorno (opcional)
del os.environ['HTTP_PROXY']
del os.environ['HTTPS_PROXY']

import requests

session = requests.Session()
session.proxies = {
    'http': 'http://tu_proxy_http:puerto',
    'https': 'http://tu_proxy_https:puerto',
}

try:
    response = session.get('http://httpbin.org/ip', timeout=10)
    print(f"Tu IP: {response.json()['origin']}")
    response = session.get('http://httpbin.org/headers', timeout=10)
    print(f"Encabezados: {response.json()['headers']}")
except requests.exceptions.RequestException as e:
    print(f"La solicitud falló: {e}")

import requests
import random

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

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

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

for _ in range(5): # Hacer 5 solicitudes con 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"Su IP: {response.json()['origin']}")
    except requests.exceptions.RequestException as e:
        print(f"La solicitud falló con el proxy {current_proxy['http']}: {e}")

pip install requests[socks]

import requests

proxies = {
    'http': 'socks5://your_socks_proxy:port',
    'https': 'socks5://your_socks_proxy:port',
}

try:
    response = requests.get('http://httpbin.org/ip', proxies=proxies, timeout=10)
    print(f"Su IP: {response.json()['origin']}")
except requests.exceptions.RequestException as e:
    print(f"La solicitud falló: {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 de selección de proxy personalizada
        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.example.com:8080',
    'proxy2.example.com:8080',
]

session = requests.Session()
# Montar el adaptador personalizado para todas las solicitudes 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"Su IP: {response.json()['origin']}")
except requests.exceptions.RequestException as e:
    print(f"La solicitud falló: {e}")

import requests

proxies_to_test = [
    {'http': 'http://good_proxy:8080', 'https': 'http://good_proxy:8080'},
    {'http': 'http://bad_proxy:8080', 'https': 'http://bad_proxy:8080'}, # Simular un proxy malo
]

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"El proxy {proxy['http']} está funcionando. IP: {response.json()['origin']}")
    working_proxies.append(proxy)
else:
    print(f"El proxy {proxy['http']} devolvió el código de estado {response.status_code}")
except requests.exceptions.RequestException as e:
    print(f"El proxy {proxy['http']} falló: {e}")

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

import requests

# Reemplace con su punto final de API Scrapeless real y clave API
SCRAPELESS_API_ENDPOINT = 'https://api.scrapeless.com/scrape'
SCRAPELESS_API_KEY = 'SU_CLAVE_API_SCRAPELESS'

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

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

payload = {
    'url': url_to_scrape,
    'proxy_type': 'residential',  # Especifique proxy residencial
    # Añada otros parámetros de Scrapeless según sea necesario, p.ej., geo-segmentación
}

try:
    response = requests.post(SCRAPELESS_API_ENDPOINT, headers=headers, json=payload, timeout=30)
    if response.status_code == 200:
        print("¡Raspado exitoso!")
        # Procese response.json() o response.text según sea necesario
        print(response.json())
    else:
        print(f"El raspado falló con el código de estado: {response.status_code}")
        print(response.text)
except requests.exceptions.RequestException as e:
    print(f"La solicitud a la API de Scrapeless falló: {e}")

# Este es un ejemplo conceptual. La implementación real con requests-toolbelt puede 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"Tu IP: {response.json()['origin']}")
# except requests.exceptions.RequestException as e:
#     print(f"La solicitud falló: {e}")

Un negocio de comercio electrónico necesita monitorear los precios de los competidores en varias tiendas en línea a nivel mundial. Esto requiere raspar páginas de productos de diferentes regiones geográficas, lo que a menudo implica restricciones geográficas. Al utilizar proxies residenciales con capacidades de geo-targeting, el negocio puede simular solicitudes de países específicos, asegurando la recopilación precisa de datos de precios. La rotación de proxies es crucial aquí para evitar la detección por parte de sistemas anti-bot que monitorean los patrones de solicitudes desde direcciones IP únicas. Una solución de proxy robusta como Scrapeless, con su extensa red de IPs residenciales, sería ideal para esta tarea, permitiendo al negocio reunir inteligencia competitiva sin interrupciones. Para un análisis más profundo de tareas específicas de raspado, aprender [cómo raspar datos de productos de Amazon](https://www.scrapeless.com/blog/how-to-scrape-amazon-product-data).

### Estudio de Caso 2: Análisis del Mercado Inmobiliario

Una empresa de análisis inmobiliario desea recopilar listados de propiedades de múltiples portales inmobiliarios locales. Estos portales a menudo tienen límites de tasa y pueden bloquear direcciones IP que envían demasiadas solicitudes desde la misma fuente. Implementar un grupo de proxies con rotación automática asegura que la firma pueda recopilar datos de manera continua sin ser bloqueada. Además, si ciertos portales tienen desafíos CAPTCHA, un servicio de proxy que integre capacidades de resolución de CAPTCHA (a menudo encontrado en APIs de proxy avanzadas) sería muy beneficioso, agilizando el proceso de recopilación de datos.

### Estudio de Caso 3: Recopilación de Datos de Redes Sociales para Análisis de Sentimientos

Investigadores que realizan análisis de sentimientos sobre publicaciones públicas en redes sociales necesitan recopilar grandes volúmenes de datos de plataformas que detectan y bloquean agresivamente el acceso automatizado. Usar proxies móviles es particularmente efectivo en este escenario, ya que las plataformas de redes sociales están altamente optimizadas para el tráfico móvil y tienden a confiar más en las IPs móviles. Combinar proxies móviles con la gestión de sesiones en Python Requests permite a los investigadores mantener estados de inicio de sesión y recopilar datos durante períodos prolongados sin activar alertas de seguridad.

## ¿Por qué elegir Scrapeless para sus necesidades de proxy?

Cuando se trata de soluciones de proxy confiables y eficientes para raspado web, Scrapeless se destaca, especialmente con su enfoque en proxies residenciales de alta calidad. Como se discutió, los proxies residenciales son fundamentales para tareas que requieren alta anonimidad y la capacidad de eludir medidas avanzadas anti-bot. Scrapeless proporciona acceso a una vasta red de direcciones IP residenciales reales, asegurando que sus actividades de raspado parezcan legítimas y sean menos propensas a ser detectadas o bloqueadas.

**Principales ventajas de Scrapeless:**

- **Extensa Pool de IPs Residenciales**: Acceso a millones de IPs residenciales genuinas a nivel mundial, permitiendo una geo-targeting precisa y alta anonimidad.
- **Rotación Automática de Proxies**: Scrapeless maneja las complejidades de la rotación y gestión de proxies, liberándolo para enfocarse en la extracción de datos en lugar de la infraestructura.
- **Altas Tasas de Éxito**: Diseñado para eludir incluso los sistemas anti-bot más avanzados, asegurando una mayor tasa de éxito para sus solicitudes de raspado.
- **Escalabilidad**: Escale fácilmente sus operaciones sin preocuparse por gestionar una gran infraestructura de proxies.
- **Costo-efectivo por Valor**: Si bien los proxies residenciales son una inversión, Scrapeless ofrece una ventaja competitiva al proporcionar proxies de alta calidad y confiables que le ahorran tiempo y recursos a largo plazo al minimizar bloqueos y reintentos.

Al integrar Scrapeless en su flujo de trabajo de Python Requests, puede mejorar significativamente la robustez y eficiencia de sus proyectos de raspado web, asegurando un acceso constante a los datos que necesita.

## Conclusión

Dominar el uso de proxies con Python Requests es una habilidad indispensable para cualquier persona involucrada en raspado web o extracción de datos. Desde configuraciones básicas de diccionario hasta gestión avanzada de sesiones y rotación de proxies, las soluciones descritas en esta guía proporcionan un conjunto de herramientas completo para navegar por las complejidades de la web. Al entender las sutilezas de diferentes tipos de proxies: residenciales, de datacenter y móviles; e implementar un manejo de errores robusto, puede mejorar significativamente la eficiencia, confiabilidad y sigilo de sus operaciones de raspado. Para aquellos que buscan una solución simplificada y altamente efectiva, aprovechar un servicio de proxies dedicado como Scrapeless, con su red premium de IPs residenciales, ofrece ventajas inigualables para eludir medidas anti-bot sofisticadas y asegurar un acceso consistente a datos valiosos. Adopte estas técnicas para transformar sus desafíos de raspado web en exitosos esfuerzos de adquisición de datos.
<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: ¿Cuál es el principal beneficio de usar proxies con Python Requests?

A1: El principal beneficio es evadir bloqueos de IP, acceder a contenido geográficamente restringido y mantener el anonimato durante el raspado web. Los proxies dirigen tus solicitudes a través de diferentes direcciones IP, lo que hace más difícil que los sitios web detecten y bloqueen tu actividad automatizada.

### Q2: ¿Cuál es la diferencia entre proxies residenciales y de centro de datos?

A2: Los proxies residenciales utilizan direcciones IP reales de Proveedores de Servicios de Internet (ISP) asignadas a usuarios domésticos, lo que los hace muy legítimos y menos propensos a detección. Los proxies de centro de datos son direcciones IP creadas artificialmente alojadas en centros de datos, que son más rápidas y económicas, pero más fácilmente detectables por sistemas anti-bot sofisticados.

### Q3: ¿Cómo puedo manejar la autenticación del proxy en Python Requests?

A3: Puedes manejar la autenticación del proxy incrustando tu nombre de usuario y contraseña directamente en la URL del proxy, como `http://username:password@host:port`, al definir tu diccionario de proxy en Python Requests.

### Q4: ¿Por qué es importante la rotación de proxies para el raspado web?

A4: La rotación de proxies es crucial para el raspado web a gran escala para evitar bloqueos de IP y límites de tasa. Al rotar a través de un grupo de diferentes direcciones IP, tus solicitudes parecen provenir de diversas fuentes, mimetizando el comportamiento humano y reduciendo la probabilidad de ser detectado y bloqueado.

### Q5: ¿Puedo usar proxies SOCKS con Python Requests?

A5: Sí, puedes usar proxies SOCKS con Python Requests, pero necesitas instalar primero la extensión `requests[socks]` (`pip install requests[socks]`). Después de la instalación, puedes especificar el protocolo SOCKS (por ejemplo, `socks5://`) en tu URL de proxy.

## Referencias

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

[2] <a href="https://www.zenrows.com/blog/python-requests-proxy" rel="nofollow">**ZenRows: Cómo Establecer un Proxy en Python Requests**</a>

[3] <a href="https://scrapfly.io/blog/posts/introduction-to-proxies-in-web-scraping" rel="nofollow">**Scrapfly: La Guía Completa Para Usar Proxies Para Raspado Web**</a>