Skip to main content

Python Integration

This guide covers using WeProxies with popular Python HTTP libraries.

Requests​

The most popular Python HTTP library.

Installation​

pip install requests

Basic Usage​

import requests

PROXY_USER = "wp_user123"
PROXY_PASS = "your-password"
PROXY_HOST = "proxy.weproxies.com"
PROXY_PORT = "1080"

proxies = {
    "http": f"http://{PROXY_USER}:{PROXY_PASS}@{PROXY_HOST}:{PROXY_PORT}",
    "https": f"http://{PROXY_USER}:{PROXY_PASS}@{PROXY_HOST}:{PROXY_PORT}"
}

response = requests.get("https://api.ipify.org?format=json", proxies=proxies)
print(response.json())

With Country Targeting​

def get_proxy(username, password, country=None, session=None):
    user = username
    if country:
        user += f"-country-{country}"
    if session:
        user += f"-session-{session}"

    return {
        "http": f"http://{user}:{password}@proxy.weproxies.com:1080",
        "https": f"http://{user}:{password}@proxy.weproxies.com:1080"
    }

# US IP
proxy = get_proxy("wp_user123", "password", country="US")
response = requests.get("https://api.ipify.org", proxies=proxy)

# UK IP with sticky session
proxy = get_proxy("wp_user123", "password", country="GB", session="uk-session-1")
response = requests.get("https://api.ipify.org", proxies=proxy)

Session with Retry Logic​

import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

def create_session(proxies, retries=3):
    session = requests.Session()
    session.proxies.update(proxies)

    retry = Retry(
        total=retries,
        backoff_factor=0.5,
        status_forcelist=[500, 502, 503, 504]
    )
    adapter = HTTPAdapter(max_retries=retry)
    session.mount('http://', adapter)
    session.mount('https://', adapter)

    return session

# Usage
proxies = get_proxy("wp_user123", "password", country="US")
session = create_session(proxies)

response = session.get("https://example.com", timeout=30)

aiohttp (Async)​

For high-performance async HTTP requests.

Installation​

pip install aiohttp

Basic Usage​

import aiohttp
import asyncio

async def fetch(url):
    proxy = "http://wp_user123:password@proxy.weproxies.com:1080"

    async with aiohttp.ClientSession() as session:
        async with session.get(url, proxy=proxy) as response:
            return await response.text()

# Run
result = asyncio.run(fetch("https://api.ipify.org"))
print(result)

Concurrent Requests​

import aiohttp
import asyncio

async def fetch_with_proxy(session, url, proxy):
    async with session.get(url, proxy=proxy, timeout=30) as response:
        return await response.json()

async def fetch_all(urls, username, password):
    proxy = f"http://{username}:{password}@proxy.weproxies.com:1080"

    async with aiohttp.ClientSession() as session:
        tasks = [fetch_with_proxy(session, url, proxy) for url in urls]
        return await asyncio.gather(*tasks, return_exceptions=True)

# Fetch multiple URLs concurrently
urls = [
    "https://api.ipify.org?format=json",
    "https://httpbin.org/ip",
    "https://ifconfig.me/ip"
]

results = asyncio.run(fetch_all(urls, "wp_user123", "password"))
for result in results:
    print(result)

With Country Rotation​

import aiohttp
import asyncio
import random

COUNTRIES = ["US", "GB", "DE", "FR", "JP"]

async def fetch_from_country(session, url, username, password, country):
    proxy = f"http://{username}-country-{country}:{password}@proxy.weproxies.com:1080"

    async with session.get(url, proxy=proxy) as response:
        return {
            "country": country,
            "data": await response.json()
        }

async def scrape_with_rotation(urls, username, password):
    async with aiohttp.ClientSession() as session:
        tasks = []
        for url in urls:
            country = random.choice(COUNTRIES)
            tasks.append(fetch_from_country(session, url, username, password, country))

        return await asyncio.gather(*tasks)

# Usage
urls = ["https://httpbin.org/ip"] * 10
results = asyncio.run(scrape_with_rotation(urls, "wp_user123", "password"))

httpx (Modern Alternative)​

A modern, async-capable HTTP client.

Installation​

pip install httpx

Sync Usage​

import httpx

proxy = "http://wp_user123:password@proxy.weproxies.com:1080"

with httpx.Client(proxy=proxy) as client:
    response = client.get("https://api.ipify.org?format=json")
    print(response.json())

Async Usage​

import httpx
import asyncio

async def fetch():
    proxy = "http://wp_user123:password@proxy.weproxies.com:1080"

    async with httpx.AsyncClient(proxy=proxy) as client:
        response = await client.get("https://api.ipify.org?format=json")
        return response.json()

result = asyncio.run(fetch())
print(result)

Best Practices​

1. Use Environment Variables​

import os

PROXY_USER = os.environ.get("WEPROXIES_USER")
PROXY_PASS = os.environ.get("WEPROXIES_PASS")

2. Implement Proper Timeouts​

response = requests.get(url, proxies=proxies, timeout=(10, 30))
# (connect_timeout, read_timeout)

3. Handle Errors Gracefully​

try:
    response = requests.get(url, proxies=proxies, timeout=30)
    response.raise_for_status()
except requests.exceptions.ProxyError as e:
    print(f"Proxy error: {e}")
except requests.exceptions.Timeout as e:
    print(f"Timeout: {e}")
except requests.exceptions.RequestException as e:
    print(f"Request failed: {e}")

4. Rotate User Agents​

import random

USER_AGENTS = [
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36",
    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36"
]

headers = {"User-Agent": random.choice(USER_AGENTS)}
response = requests.get(url, proxies=proxies, headers=headers)