Использование прокси в Python (Requests + ProxyHat SDK)

Зачем использовать прокси в Python?

Python занимает лидирующие позиции в области извлечения данных. Библиотеки Requests, httpx и Scrapy делают HTTP-запросы тривиальными, но без прокси ваши скрипты попадают под IP-баны за считанные минуты. Использование прокси в Python позволяет ротировать IP-адреса, обходить географические ограничения и надёжно масштабировать операции парсинга.

В этом руководстве вы узнаете, как интегрировать прокси в Python с помощью ProxyHat Python SDK и стандартной библиотеки requests. Каждый раздел содержит готовый к копированию код, который можно запустить сразу.

Независимо от того, строите ли вы пайплайн веб-скрапинга, отслеживаете результаты поисковой выдачи или собираете данные о ценах — это руководство охватывает аутентификацию, ротацию прокси, геотаргетинг, обработку ошибок и масштабирование в продакшене.

Установка и настройка

Установка ProxyHat SDK и Requests

Установите ProxyHat Python SDK и библиотеку requests с помощью pip:

pip install proxyhat requests

Для асинхронных сценариев также установите httpx и aiohttp:

pip install httpx aiohttp

Получение API-ключей

Зарегистрируйтесь на ProxyHat и получите API-ключ в личном кабинете. Вам понадобятся имя пользователя и пароль (или API-ключ) для аутентификации на прокси. Подробная информация об аутентификации доступна в документации ProxyHat API.

Аутентификация и базовая настройка

Использование ProxyHat SDK

SDK берёт на себя аутентификацию, ротацию и управление соединениями:

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

Прямое подключение через Requests

Если вы предпочитаете использовать requests напрямую, настройте URL прокси:

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-запрос через прокси

Вот полный пример отправки GET-запроса через резидентный прокси 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}")

Или с помощью стандартной библиотеки requests:

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

Выбор типа прокси

ProxyHat предлагает три типа прокси. Выбирайте в зависимости от задачи. Для подробного сравнения прочитайте наше руководство резидентные, датацентр и мобильные прокси.

Тип	Лучше всего для	Скорость	Риск обнаружения	Стоимость
Резидентные	Веб-скрапинг, мониторинг SERP	Средняя	Очень низкий	За ГБ
Датацентр	Большие объёмы, задачи с высокой скоростью	Высокая	Повышенный	За IP/месяц
Мобильные	Соцсети, тестирование приложений	Средняя	Минимальный	За ГБ

Переключение типов прокси в коде

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

Ротация и липкие сессии

Ротационные прокси назначают новый IP для каждого запроса — идеальный вариант для масштабного парсинга, где нужна максимальная анонимность. Липкие сессии сохраняют один и тот же IP на заданный период, что необходимо для многошаговых процессов: авторизация, постраничная навигация, работа с корзиной.

Ротационные прокси (новый IP на каждый запрос)

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

Липкие сессии (один IP на заданный период)

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

Геотаргетинг запросов

Нужны данные из определённой страны? ProxyHat поддерживает геотаргетинг по 195+ локациям. Это критически важно для локализованного парсинга SERP, мониторинга цен и проверки контента.

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

Обработка ошибок и повторные попытки

Сетевые запросы падают. Прокси уходят в тайм-аут. Целевые сайты блокируют вас. Грамотная обработка ошибок отличает продакшен-скрапер от учебного скрипта.

Базовая логика повторных попыток

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)

Встроенные повторные попытки в 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)

Параллельный парсинг с потоками

Последовательные запросы — это медленно. Для продакшен-нагрузок используйте модуль concurrent.futures из Python для параллельной отправки запросов через прокси.

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

Асинхронный парсинг с asyncio и 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")

Интеграция с популярными библиотеками Python

Работа с Requests (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())

Работа с 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())

Работа с 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())

Работа со Scrapy

Добавьте ProxyHat в паука Scrapy через конфигурацию 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(),
            }

Советы для продакшена

Пул соединений и тайм-ауты

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)

Логирование и мониторинг

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

Переменные окружения для учётных данных

Никогда не хардкодьте учётные данные. Используйте переменные окружения:

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

Полный список тарифных планов и опций трафика смотрите на странице цен. Для продвинутых сценариев и справки по эндпоинтам обратитесь к документации API. Также рекомендуем наше руководство лучшие прокси для веб-скрапинга в 2026 году для сравнения провайдеров.

Ключевые выводы

• Установка одной командой: pip install proxyhat requests — и вы готовы к работе.
• Используйте SDK для простоты: ProxyHat Python SDK автоматически обрабатывает аутентификацию, повторные попытки и ротацию.
• Выбирайте правильный тип прокси: резидентные для парсинга, датацентр для скорости, мобильные для соцсетей.
• Ротация или липкие сессии: ротационные прокси для массового парсинга, липкие сессии для многошаговых процессов.
• Геотаргетинг по необходимости: указывайте страну и город для локализованного сбора данных.
• Обрабатывайте ошибки правильно: экспоненциальный откат и логика повторных попыток для надёжности в продакшене.
• Масштабируйте через параллелизм: используйте ThreadPoolExecutor или asyncio для параллельных запросов.
• Не хардкодьте учётные данные: храните API-ключи в переменных окружения.

Часто задаваемые вопросы

Как настроить прокси в Python Requests?

Передайте словарь proxies в любой метод requests: requests.get(url, proxies={"http": "http://user:pass@host:port", "https": "http://user:pass@host:port"}). ProxyHat SDK упрощает этот процесс, автоматически управляя конфигурацией прокси.

В чём разница между ротационными и липкими прокси в Python?

Ротационные прокси назначают новый IP-адрес для каждого запроса, что идеально для масштабного парсинга. Липкие прокси сохраняют один и тот же IP на заданный период (например, 10–30 минут), что необходимо для сессий авторизации, работы с корзиной или постраничной навигации, где важна стабильность IP.

Можно ли использовать прокси ProxyHat с asyncio и aiohttp?

Да. Прокси ProxyHat работают с любым HTTP-клиентом, поддерживающим настройку прокси, включая aiohttp, httpx (асинхронный режим) и фреймворки на базе asyncio. Передайте URL прокси в параметр proxy вашего асинхронного клиента.

Как обрабатывать ошибки прокси и тайм-ауты в Python?

Оберните запросы в блоки try/except, перехватывающие ProxyError, Timeout и ConnectionError. Реализуйте экспоненциальный откат (удвоение времени ожидания между попытками) и установите максимальное количество повторов. ProxyHat SDK включает встроенную логику повторных попыток с настраиваемыми параметрами.

Какая библиотека Python лучше всего подходит для веб-скрапинга с прокси?

Для простых задач requests с ProxyHat SDK — самый простой вариант. Для высоконагруженного асинхронного парсинга используйте httpx или aiohttp. Для сложного краулинга с переходом по ссылкам и извлечением данных Scrapy с middleware для прокси — наиболее мощный выбор. Все эти библиотеки безупречно работают с прокси ProxyHat.