Guides Développeurs 12 min de lecture

Utiliser des proxies en Python (Requests + SDK ProxyHat)

Découvrez comment utiliser les proxies dans Python avec la bibliothèque Requests et ProxyHat SDK. Couvre l'authentification, la rotation, le géo-ciblage, la manipulation des erreurs et le grattage de l'async.

ProxyHat Team
Utiliser des proxies en Python (Requests + SDK ProxyHat)

Pourquoi utiliser Proxies dans Python ?

Python domine le paysage de l'extraction des données. Bibliothèques comme Demandes, http://europa.eu.intet Scrapy faire des appels HTTP triviales, mais sans proxies, vos scripts ont frappé des interdictions IP en quelques minutes. Utilisation proxies en Python vous permet de tourner les adresses IP, de contourner les géorestrictions et d'évaluer vos opérations de démolition de manière fiable.

Dans ce guide, vous apprendrez comment intégrer les proxies dans Python en utilisant le ProxyHat Python SDK et la norme requests bibliothèque. Chaque section inclut un code prêt à copier et à coller que vous pouvez exécuter immédiatement.

Que vous construisiez une pipeline de démolition de réseau, surveillance Résultats du SERP, ou la collecte de données de tarification, ce guide couvre l'authentification, la rotation par procuration, le géo-ciblage, le traitement des erreurs et l'échelle de production.

Installation et configuration

Installation du SDK ProxyHat et des requêtes

Installez le SDK ProxyHat Python et le requests bibliothèque utilisant pip:

pip install proxyhat requests

Pour les workflows async, installez aussi httpx et aiohttp:

pip install httpx aiohttp

Obtenir vos identifiants d'API

Inscrivez-vous à ProxyHat et récupérer votre clé API dans le tableau de bord. Vous aurez besoin de votre Nom d'utilisateur et mot de passe (ou clé API) pour l'authentification par proxy. Tous les détails d'authentification sont disponibles dans la Documentation de l'API ProxyHat.

Authentification et configuration de base

Utilisation du SDK ProxyHat

Le SDK gère l'authentification, la rotation et la gestion des connexions pour vous :

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")

Utilisation des pouvoirs Raw Proxy avec les demandes

Si vous préférez utiliser requests directement, configurer l'URL 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"}

Simple GET Demande avec un mandataire

Voici un exemple complet qui envoie une demande GET par l'intermédiaire d'un mandataire résidentiel 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 avec la norme requests bibliothèque:

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])

Choisir le bon type de procuration

ProxyHat offre trois types de proxy. Choisissez en fonction de votre cas d'utilisation. Pour une comparaison plus approfondie, lisez notre guide sur proxies résidentiels vs datacenter vs mobiles.

Choisir le bon type de procuration
TypeMeilleur pourVitesseRisque de détectionCoût
RésidentielDégraissage du Web, suivi du SERPMoyenneTrès faiblePar GB
Centre de donnéesTâches importantes et critiques en matière de vitesseRapidePlus hautPar IP/mois
MobileMédias sociaux, tests d'applicationsMoyennePlus basPar GB

Changer de type mandataire dans le code

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"
)

Sessions rotatives et séances collantes

Proxies tournantes assignez une nouvelle IP pour chaque demande, idéale pour le grattage à grande échelle où vous avez besoin d'une anonymat maximale. Séances collantes conserver la même IP pour une durée définie, essentielle pour les workflows multi-étapes comme les séquences de connexion ou la navigation paginée.

Proxies tournantes (nouvelle IP chaque demande)

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

Sessions collantes (même IP pour la durée)

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

Demandes géographiées

Besoin de données d'un pays donné? Prise en charge de proxyHat géo-ciblage sur plus de 195 sites. Ceci est essentiel pour la mise au rebut localisée du SERP, la surveillance des prix et la vérification du contenu.

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}")

Gestion des erreurs et retraits

Les demandes réseau échouent. C'est un temps mort. Les cibles vous bloquent. La manipulation d'erreur robuste sépare les racleurs de production des scripts de jouets.

Logique de base de réessayer

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)

Utilisation de la réessayer intégrée du 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)

Scraping simultané avec filetage

Les demandes séquentielles sont lentes. Pour les charges de production, utilisez Python concurrent.futures de paralléliser les demandes par des procurations.

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 Scraping avec asyncio et 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")

Intégration avec les bibliothèques populaires de Python

Utilisation avec les demandes (session)

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())

Utilisation avec 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())

Utilisation avec 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())

Utilisation avec Scrapy

Ajouter ProxyHat à votre araignée Scrapy en configurant le 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(),
            }

Conseils de production

Connexions et délais

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)

Exploitation forestière et surveillance

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

Variables d'environnement pour les pouvoirs

Jamais de code dur. Utiliser les variables d'environnement:

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"
)

Pour une liste complète des plans proxy disponibles et des options de trafic, visitez notre page de prix. Pour les cas d'utilisation avancée et la référence du paramètre, voir Documentation API. Vous pouvez également explorer notre guide les meilleurs proxies pour le grattage de toile en 2026 pour les comparaisons avec les fournisseurs.

A emporter des clés

  • Installer dans une commande : pip install proxyhat requests commence immédiatement.
  • Utilisez le SDK pour la simplicité : Le SDK ProxyHat Python gère automatiquement l'authentification, les relevés et la rotation.
  • Choisissez le bon type de proxy : Résidentiel pour la démolition, datacenter pour la vitesse, mobile pour les plateformes sociales.
  • Rotation vs bâton: Utilisez des proxies tournantes pour le grattage en vrac, des sessions collantes pour les workflows en plusieurs étapes.
  • Géo-cible au besoin: Préciser le pays et la ville pour la collecte de données localisées.
  • Gérer correctement les erreurs : Mettre en œuvre une logique exponentielle de recul et de réessayer pour la fiabilité de la production.
  • Échelle avec concordance : Utilisation ThreadPoolExecutor ou asyncio Paralléliser les demandes.
  • Jamais d'identification de code dur : Stocker les clés API dans les variables d'environnement.

Foire aux questions

Comment configurer un proxy dans les requêtes Python ?

Passer une proxies dictionnaire à n'importe quel requests méthode: requests.get(url, proxies={"http": "http://user:pass@host:port", "https": "http://user:pass@host:port"}). Le SDK ProxyHat simplifie encore cette tâche en manipulant la configuration proxy en interne.

Quelle est la différence entre les proxies rotatives et collantes en Python ?

Les mandataires rotatifs attribuent une nouvelle adresse IP pour chaque demande, ce qui est idéal pour le grattage à grande échelle. Les proxies collants maintiennent la même IP pour une durée définie (par exemple, 10-30 minutes), qui est nécessaire pour les sessions de connexion, les paniers d'achat ou la navigation paginée où la cohérence IP compte.

Puis-je utiliser ProxyHat avec asyncio et aiohttp?

Oui. ProxyHat proxies fonctionne avec tout client HTTP qui prend en charge la configuration de proxy, y compris aiohttp, httpx (mode async), et asyncio- des cadres basés. Passez l'URL du proxy comme proxy paramètre dans votre client async.

Comment gérer les erreurs proxy et les timeouts en Python ?

Enveloppez vos demandes en essayant/sauf les blocs de capture ProxyError, Timeoutet ConnectionError. Mettre en place un contre-temps exponentiel (doubler le temps d'attente entre les relevés) et fixer un nombre maximal de réessayer. Le SDK ProxyHat comprend une logique de réessayer intégrée avec des paramètres configurables.

Quelle bibliothèque Python est la meilleure pour le grattage web avec des proxies ?

Pour des tâches simples, requests avec le SDK ProxyHat est l'option la plus facile. Pour le grattage d'async à haute monnaie, utiliser httpx ou aiohttp. Pour ramper complexe avec le lien suivant et l'extraction de données, Scrapy avec le middleware proxy est le choix le plus puissant. Tout fonctionne parfaitement avec ProxyHat proxies.

Prêt à commencer ?

Accédez à plus de 50M d'IPs résidentielles dans plus de 148 pays avec filtrage IA.

Voir les tarifsProxies résidentiels
← Retour au Blog