Korzystanie z Proxies w Python (Requests + ProxyHat SDK)

Dlaczego używać Proxies w Pythonie?

Python dominuje nad krajobrazem ekstrakcji danych. Biblioteki takie jak Wnioski, httpxoraz Scrapy zrobić HTTP połączeń trywialnych, ale bez proxy, skrypty trafiają zakazy IP w ciągu kilku minut. Stosowanie proxy w Pythonie pozwala obracać adresy IP, omijać ograniczenia geologiczne i skalować operacje skrobania niezawodnie.

W tym przewodniku dowiesz się, jak zintegrować proxy z Python za pomocą ProxyHat Python SDK oraz standard requests Biblioteka. Każda sekcja zawiera kod copy- paste- gotowy można uruchomić natychmiast.

Czy budujesz rurociąg do rozdrabniania sieci, monitoring Wyniki SERPlub gromadzenie danych dotyczących cen, niniejszy przewodnik obejmuje uwierzytelnianie, rotację zastępczą, ukierunkowanie geologiczne, obsługę błędów i skalowanie produkcji.

Instalacja i konfiguracja

Instalacja ProxyHat SDK i zapytania

Zainstaluj ProxyHat Python SDK i requests biblioteka przy użyciu pip:

pip install proxyhat requests

Dla Async Workflow, również zainstalować httpx oraz aiohttp:

pip install httpx aiohttp

Uzyskanie API

Zarejestruj się na ProxyHat i odzyskać klucz API z deski rozdzielczej. Będziesz potrzebował swojego nazwa użytkownika oraz hasło (lub klucz API) do uwierzytelniania proxy. Pełne szczegóły uwierzytelniania są dostępne w Dokumentacja API ProxyHat.

Uwierzytelnianie i konfiguracja podstawowa

Korzystanie z ProxyHat SDK

SDK obsługuje uwierzytelnianie, rotację i zarządzanie połączeniami dla Ciebie:

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

Korzystanie z Surowych Proxy Kredytów z wnioskami

Jeśli wolisz używać requests bezpośrednio skonfigurować adres pośredniczący:

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

Prosty GET Prośba o proxy

Oto kompletny przykład, który wysyła wniosek GET za pośrednictwem proxy ProxyHat mieszkalnego:

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

Lub ze standardem requests biblioteka:

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

Wybór odpowiedniego typu proxy

ProxyHat oferuje trzy typy proxy. Wybierz na podstawie przypadku użycia. Dla głębszego porównania, przeczytaj nasz przewodnik na mieszkaniowe vs datacenter vs mobilne proxy.

Przełączanie typów proxy w kodzie

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

Obracanie vs Sticky Sessions

Proxy obrotowe przydziela nowy adres IP dla każdej prośby, idealny do drapania na dużą skalę, gdzie potrzebujesz maksymalnej anonimowości. Przyklejone sesje zachować ten sam IP przez określony czas, niezbędny dla wielostopniowych przepływów roboczych, takich jak sekwencje logowania lub nawigacja paginana.

Rotating Proxies (Nowe IP Każdy wniosek)

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

Sticky Sessions (Ten sam OD dla czasu trwania)

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

Wnioski o udzielenie pozwolenia na dopuszczenie do obrotu

Potrzebujesz danych z określonego kraju? Podpory ProxyHat geocelowanie w 195 + lokalizacjachMa to kluczowe znaczenie dla zlokalizowanego skanowania SERP, monitorowania cen i weryfikacji treści.

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

Błąd obsługi i zatrzymywania

Żądania sieci zawiodły. Czas zgonu. Cele cię blokują. Solidna obsługa błędów oddziela skraplacze od skryptów zabawek.

Podstawowa logika retry

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)

Korzystanie z 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)

Równoczesne rozdrabnianie z gwintem

Sekwencyjne prośby są powolne. Do produkcji ładunków roboczych, użyj Pythona concurrent.futures równoległe żądania poprzez 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 with asyncio and 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")

Integracja z popularnymi bibliotekami Pythona

Korzystanie z zapytań (sesja)

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

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

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

Stosowanie z produktem Scrapy

Dodaj ProxyHat do swojego scrapy pająka konfigurując 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(),
            }

Wskazówki dotyczące produkcji

Połączenie Pooling and 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)

Logowanie i monitorowanie

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

Zmienne środowiskowe dla kredytów

Nigdy nie koduj. Użyj zmiennych środowiskowych:

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

Aby uzyskać pełną listę dostępnych planów proxy i opcji ruchu, odwiedź nasze Strona cenowaW przypadku przypadków zaawansowanego stosowania i punktu końcowego, patrz Dokumentacja API. Można również zbadać nasz przewodnik na najlepsze proxy do skrobania stron internetowych w 2026 dla porównania dostawców.

Key Takeaways

• Zainstaluj w jednym poleceniu: pip install proxyhat requests Od razu zaczynasz.
• Użyj SDK dla prostoty: ProxyHat Python SDK obsługuje uwierzytelnianie, ponowne próby i rotację automatycznie.
• Wybierz odpowiedni typ proxy: Mieszkalne do skrobania, dane do prędkości, mobilne do platform społecznościowych.
• Obróć względem kija: Używać rotacyjnych proxy do masowych skrobania, lepkie sesje dla wielostopniowych przepływów pracy.
• Cel geologiczny w razie potrzeby: Określić kraj i miasto dla lokalnego gromadzenia danych.
• Prawidłowe obsługiwanie błędów: Wdrożenie wykładniczego backupu i powtórzenie logiki dla niezawodności produkcji.
• Skala ze współrzędnymi: Stosowanie ThreadPoolExecutor lub asyncio równoległe żądania.
• Nigdy nie należy stosować kodów twardych: Zapisz klucze API w zmiennych środowiskowych.

Często zadawane pytania

Jak ustawić proxy w Python Requests?

Podanie proxies słownik do dowolnego requests Metoda: requests.get(url, proxies={"http": "http://user:pass@host:port", "https": "http://user:pass@host:port"})ProxyHat SDK upraszcza to jeszcze bardziej poprzez obsługę wewnętrznej konfiguracji proxy.

Jaka jest różnica między obrotowymi i lepkimi proxy w Pythonie?

Rotacyjne proxy przyporządkowują nowy adres IP dla każdego żądania, który jest idealny do drapania na dużą skalę. Sticky proxy utrzymują ten sam IP przez określony czas (np. 10- 30 minut), co jest niezbędne do sesji logowania, wózków sklepowych lub przeglądania stron, gdzie ma znaczenie spójność IP.

Czy mogę używać ProxyHat proxy z asyncio i aiohttp?

Tak. ProxyHat Proxy współpracuje z dowolnym klientem HTTP, który obsługuje konfigurację proxy, w tym aiohttp, httpx (tryb async), oraz asyncio- W oparciu o ramy. Podaj proxy URL jako proxy parametr w kliencie async.

Jak radzić sobie z błędami proxy i timeout w Pythonie?

Zawiń swoje żądania w próbie / z wyjątkiem bloków połowu ProxyError, Timeoutoraz ConnectionError. Wdrożenie kopii zapasowej wykładniczej (podwojenie czasu oczekiwania pomiędzy powtórzeniami) i ustawić maksymalną liczbę powtórzeń. ProxyHat SDK zawiera wbudowaną logikę retry z konfigurowalnymi parametrami.

Która biblioteka Pythona jest najlepsza do skrobania stron z proxy?

Dla prostych zadań, requests ProxyHat SDK jest najprostszą opcją. Dla wysokiej konkubiny async scrating, używać httpx lub aiohttp. Dla kompleksu pełzającego z linkiem po i ekstrakcji danych, Scrapy z proxy middleware jest najpotężniejszym wyborem. Wszystkie pracują bezproblemowo z ProxyHat proxy.