Requests vs HTTPX vs aiohttp: Proxy Support

requests is the default choice for anything that does not need concurrency. Proxies are a dict keyed by URL scheme, passed per request or set on a Session. The docs are explicit that requests "does not provide any kind of non-blocking IO", so scaling beyond a handful of parallel fetches means threads or a different library.

import requests

# HTTP proxy port for the dedicated slot us-mob-01
PROXY = "http://u_4a9c:p_2X7q@proxy.mobileproxies.org:8000"
proxies = {"http": PROXY, "https": PROXY}

r = requests.get("https://api.ipify.org", proxies=proxies, timeout=20)
print(r.text)  # carrier IP, not your machine's

SOCKS support arrived in requests 2.10.0 and is an optional extra: pip install "requests[socks]", which pulls in PySocks. The scheme controls DNS: socks5:// resolves hostnames on your machine, socks5h:// resolves them on the proxy, which is what you usually want with a remote mobile proxy. We cover the full pattern, including auth, retries and rotation, in our Python requests SOCKS5 proxy example.

HTTPX gives you a requests-like API in both flavors: a synchronous Client and an AsyncClient. Proxying is configured with a single proxy= argument on the client (or on top-level calls like httpx.get). Note the naming: the older proxies= argument was deprecated in HTTPX 0.26 and removed in 0.28, so snippets written for requests need that one change.

import asyncio
import httpx

PROXY = "http://u_4a9c:p_2X7q@proxy.mobileproxies.org:8000"

# Sync client
with httpx.Client(proxy=PROXY, timeout=20) as client:
    print(client.get("https://api.ipify.org").text)

# Async client - same API, awaited
async def main():
    async with httpx.AsyncClient(proxy=PROXY, timeout=20) as client:
        r = await client.get("https://api.ipify.org")
        print(r.text)

asyncio.run(main())

For SOCKS, install the extra with pip install httpx[socks] and pass a socks5:// URL, for example httpx.Client(proxy="socks5://u_4a9c:p_2X7q@proxy.mobileproxies.org:1080"). Since 0.28 HTTPX also treats socks5h as a valid scheme for proxy-side DNS resolution. If you need different proxies for different schemes or hosts, the mounts= dict maps URL patterns to httpx.HTTPTransport(proxy=...) instances.

HTTPX is also the only one of the three with optional HTTP/2: install httpx[http2] and pass http2=True. It is off by default, and it only kicks in when the server supports it, but for scraping targets that fingerprint clients at the protocol level, having the option matters.

aiohttp is built for asyncio from the ground up; there is no synchronous mode. HTTP proxies are supported natively: pass proxy= to an individual request or to the ClientSession itself, with credentials embeddable in the proxy URL. The docs note that support for proxies you connect to over https:// is limited; a plain http:// proxy endpoint that tunnels HTTPS traffic via CONNECT, which is how most mobile proxy gateways work, is the supported path.

import asyncio
import aiohttp

PROXY = "http://u_4a9c:p_2X7q@proxy.mobileproxies.org:8000"

async def main():
    # Session-level proxy; can also pass proxy= per request
    async with aiohttp.ClientSession(proxy=PROXY) as session:
        async with session.get("https://api.ipify.org") as resp:
            print(await resp.text())

asyncio.run(main())

SOCKS is not in aiohttp itself. The standard answer is the third-party aiohttp-socks package, which provides a ProxyConnector supporting SOCKS4(a), SOCKS5(h) and HTTP proxies, with remote DNS (rdns) defaulting to on for SOCKS5.

# pip install aiohttp-socks
import asyncio
import aiohttp
from aiohttp_socks import ProxyConnector

async def main():
    connector = ProxyConnector.from_url(
        "socks5://u_4a9c:p_2X7q@proxy.mobileproxies.org:1080"
    )
    async with aiohttp.ClientSession(connector=connector) as session:
        async with session.get("https://api.ipify.org") as resp:
            print(await resp.text())

asyncio.run(main())

Whether SOCKS5 is even worth the extra dependency depends on your use case; for most scraping jobs the HTTP CONNECT port behaves identically for HTTPS targets. We break down the real differences in SOCKS5 vs HTTP proxies.

An honest note first: with a dedicated mobile proxy, the HTTP client is rarely your bottleneck. Each slot is a real SIM in a real modem, so its bandwidth and sensible request rate are bounded by the carrier connection, not by how fast Python can open sockets. Mobile IPs earn their keep on trust (they sit behind carrier-grade NAT shared with real subscribers), not on raw throughput, and they cost more than datacenter IPs. Plan concurrency around the proxy, then pick the client that matches that plan:

One more architectural choice interacts with the client: whether your IP rotates. A dedicated slot with API-triggered rotation pairs naturally with a long-lived session object in any of the three libraries, while forced rotation changes how you think about connection reuse. See rotating vs static mobile proxies for how to choose.

Sources

• • requests docs - Proxies and SOCKS (proxies= dict, requests[socks], socks5 vs socks5h, env vars)
• • HTTPX docs - Proxies (proxy=, mounts=, httpx[socks])
• • HTTPX docs - HTTP/2 (httpx[http2], http2=True, off by default)
• • HTTPX docs - Environment variables (trust_env behavior)
• • HTTPX changelog (proxies= deprecated in 0.26, removed in 0.28; socks5h accepted in 0.28)
• • aiohttp docs - Client advanced usage (proxy=, trust_env, HTTPS proxy limits)
• • aiohttp-socks on PyPI (ProxyConnector, SOCKS4/5, rdns)