Utilizzando Proxies in Python (Richiesta + ProxyHat SDK)

Perché utilizzare i proxy in Python?

Python domina il paesaggio di estrazione dei dati. Biblioteche come Richieste♪ httpe Scrapy rendere le chiamate HTTP banali, ma senza proxy, i tuoi script hanno colpito i divieti IP in pochi minuti. Utilizzo proxy in Python consente di ruotare gli indirizzi IP, bypassare le restrizioni geografiche e scalare le operazioni di raschiamento in modo affidabile.

In questa guida, imparerai come integrare i proxy in Python utilizzando il ProxyHat Python SDK e lo standard requests biblioteca. Ogni sezione include il codice copy-paste-ready che è possibile eseguire immediatamente.

Se stai costruendo un web scraping pipeline, monitoraggio Risultati SERP, o la raccolta di dati sui prezzi, questa guida copre l'autenticazione, la rotazione dei proxy, la geo-targeting, la gestione degli errori e la scalabilità della produzione.

Installazione e configurazione

Installazione del ProxyHat SDK e Richieste

Installare il ProxyHat Python SDK e il requests biblioteca utilizzando pip:

pip install proxyhat requests

Per flussi di lavoro asincroni, installare anche httpx e aiohttp:

pip install httpx aiohttp

Ottenere le credenziali API

Registrati ProxyHat e recuperare la chiave API dal cruscotto. Avrai bisogno del tuo nome utente e password (o chiave API) per l'autenticazione proxy. I dettagli di autenticazione completi sono disponibili nel Documentazione API ProxyHat.

Autenticazione e configurazione di base

Utilizzo di ProxyHat SDK

SDK gestisce l'autenticazione, la rotazione e la gestione della connessione per voi:

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

Utilizzo di Credenziali di Proxy Raw con Richieste

Se preferisci usare requests direttamente, configurare l'URL del 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"}

GET semplice Richiesta con Proxy

Ecco un esempio completo che invia una richiesta GET tramite un proxy residenziale 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}")

O con lo standard 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])

Scegliere il tipo di proxy destro

ProxyHat offre tre tipi di proxy. Scegli in base al tuo caso di utilizzo. Per un confronto più profondo, leggi la nostra guida residenziale vs datacenter vs proxy mobili.

Interruttore tipi di proxy in codice

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

Rotating vs Sticky Sessions

Prossi rotanti assegnare un nuovo IP per ogni richiesta, ideale per la raschiatura su larga scala dove è necessario la massima anonimato. Sessioni appiccicose mantenere lo stesso IP per una durata impostata, essenziale per flussi di lavoro multi-step come sequenze di login o navigazione impaginata.

Processi rotanti (Nuovo IP ogni richiesta)

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

Sessioni appiccicose (stesso IP per durata)

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

Richieste Geo-Targeted

Hai bisogno di dati da un paese specifico? Supporti ProxyHat geo-targeting in 195+ sediQuesto è fondamentale per la demolizione SERP localizzata, il monitoraggio dei prezzi e la verifica dei contenuti.

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

Gestione degli errori e Retries

Le richieste di rete falliscono. Proxies timeout. Gli obiettivi ti bloccano. Robusta gestione degli errori separa i raschietti di produzione dagli script di giocattolo.

Logica di ricerca di base

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)

Utilizzando il SDK Built-in Retry

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 con corrente con filettatura

Le richieste sequenziali sono lente. Per i carichi di lavoro di produzione, utilizzare Python's concurrent.futures parallelizzare le richieste attraverso i proxy.

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

Integrazione con le biblioteche popolari di Python

Utilizzo di Richieste (Sessione)

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

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

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

Utilizzo di Scrapy

Aggiungi ProxyHat al tuo ragno Scrapy configurando 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(),
            }

Consigli di produzione

Connessione Piscina e Timeout

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)

Registrazione e monitoraggio

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

Ambiente Variabili per Credenziali

Mai le credenziali di codice. Utilizzare variabili di 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"
)

Per un elenco completo dei piani proxy disponibili e delle opzioni di traffico, visita il nostro pagina dei prezzi. Per casi di uso avanzato e riferimento endpoint, vedere il Documentazione API. Puoi anche esplorare la nostra guida sulla migliori proxy per la raschiatura web nel 2026 per i confronti dei fornitori.

Asporto chiave

• Installare in un unico comando: pip install proxyhat requests ti fa iniziare immediatamente.
• Utilizzare il SDK per semplicità: Il ProxyHat Python SDK gestisce automaticamente l'autenticazione, la ripetizione e la rotazione.
• Scegliere il tipo di proxy giusto: Residenziale per la demolizione, datacenter per la velocità, mobile per piattaforme sociali.
• Ruota contro bastone: Utilizzare i proxy rotanti per raschiatura di massa, sessioni appiccicose per flussi di lavoro multi-step.
• Geo-target quando necessario: Specifica paese e città per la raccolta dati localizzata.
• Maneggiare correttamente gli errori: Attuazione backoff esponenziale e riprova logica per affidabilità di produzione.
• Scala con convalutazione: Uso ThreadPoolExecutor o asyncio parallelizzare le richieste.
• Mai le credenziali di codice rigido: Conservare le chiavi API nelle variabili di ambiente.

Domande frequenti

Come configurare un proxy in Python Requests?

Passare proxies dizionario a qualsiasi requests metodo: requests.get(url, proxies={"http": "http://user:pass@host:port", "https": "http://user:pass@host:port"}). Il ProxyHat SDK semplifica ulteriormente la gestione della configurazione del proxy internamente.

Qual è la differenza tra i proxy rotanti e appiccicosi in Python?

I proxy rotanti assegnano un nuovo indirizzo IP per ogni richiesta, ideale per la raschiatura su larga scala. I proxy Sticky mantengono lo stesso IP per una durata impostata (ad esempio, 10-30 minuti), che è necessario per le sessioni di login, i carrelli per lo shopping, o la navigazione impaginata dove la consistenza IP conta.

Posso usare i proxy ProxyHat con asyncio e aiohttp?

Si'. Le proxy ProxyHat funzionano con qualsiasi client HTTP che supporta la configurazione del proxy, incluso aiohttp♪ httpx (modalità asincrona), e asyncio- framework basati. Passare l'URL del proxy come proxy parametro nel client asincastro.

Come faccio a gestire errori e timeout proxy in Python?

Avvolgi le tue richieste in prova/eccetto blocchi cattura ProxyError♪ Timeoute ConnectionError. Attuazione backoff esponenziale (doubling tempo di attesa tra i retries) e impostare un conteggio massimo di riprovazione. Il ProxyHat SDK include la logica di riprovazione integrata con parametri configurabili.

Quale libreria Python è meglio per la raschiatura web con i proxy?

Per compiti semplici, requests con il ProxyHat SDK è l'opzione più semplice. Per raschiamento asincastro ad alta frequenza, uso httpx o aiohttp. Per la scansione complessa con link seguente e l'estrazione dei dati, Scrapy con middleware proxy è la scelta più potente. Tutto il lavoro senza soluzione di continuità con proxy ProxyHat.