What is HTTPX and why use it instead of requests?

HTTPX is a modern Python HTTP client that supports both sync and async, plus HTTP/2 and HTTP/1.1. requests is sync-only and HTTP/1.1-only. For new code in 2026, HTTPX is the recommended choice — same API as requests for sync code, plus async/HTTP/2 when you need them.

Is HTTPX faster than requests?

For single requests, comparable. For 100+ concurrent requests, HTTPX async is 5-10x faster. HTTP/2 multiplexing further improves throughput on servers that support it (most modern APIs). For pure sync workloads, the speed difference is small.

Can I use HTTPX as a drop-in replacement for requests?

For most code, yes. The synchronous API is nearly identical. Differences: HTTPX uses Client (similar to requests.Session); some option names differ (verify=False vs SSLContext); response.json() works the same.

How do I make async HTTP calls with HTTPX?

Use AsyncClient with async/await. async with httpx.AsyncClient() as client: r = await client.get(url). For concurrent requests, use asyncio.gather() — that's where HTTPX async shines vs requests' sync nature.

Does HTTPX support proxies the same way requests does?

Yes. Pass proxies={'http://': proxy_url, 'https://': proxy_url} to the Client. For per-request proxies, use mounts={url: HTTPTransport(proxy=...)} for fine-grained routing per scheme/host.

How does HTTP/2 in HTTPX help my scraping?

HTTP/2 multiplexes multiple requests over one TCP connection, reducing handshake overhead. For scraping where you hit many endpoints on the same domain, HTTP/2 yields 2-3x throughput improvement vs HTTP/1.1. HTTPX negotiates HTTP/2 automatically when the server supports it.

What's the difference between HTTPX async and aiohttp?

HTTPX has the same API for sync and async — easier to migrate from requests. aiohttp is async-only with a different API. HTTPX is generally cleaner for mixed workflows; aiohttp is slightly faster on pure-async benchmarks. For most teams, HTTPX wins on developer ergonomics.

Should I rewrite all my requests code to HTTPX?

No — only when you have a reason. Reasons: you need async, you need HTTP/2, you want one client for sync+async, or you're starting a new project. If your existing requests code works and isn't a bottleneck, leave it alone.

Mastering HTTPX Client for Python (2026)

Alex R.

Wed May 06 2026

Quick verdict: HTTPX is the modern Python HTTP client — same API as requests for sync code, plus async support and HTTP/2. For new projects in 2026, HTTPX is the recommended pick. Existing requests code works fine; migrate when you need async, HTTP/2, or to consolidate sync + async into one library. Performance: 5-10x faster than requests for concurrent workloads, comparable for single requests.

This guide covers what HTTPX is, when to migrate from requests, performance comparisons, and 8 working examples for sync, async, streaming, HTTP/2, and proxies.

Install

pip install httpx
# For HTTP/2 support
pip install httpx[http2]

HTTPX vs requests vs aiohttp

Feature	requests	HTTPX	aiohttp
Sync API	Yes	Yes	No
Async API	No	Yes	Yes
HTTP/2	No	Yes	No (HTTP/3 in v4+)
API similarity to requests	Native	~95% drop-in	Different
Throughput (100 concurrent reqs)	Slow (sync)	Fast	Fastest

8 Working Examples

1. Basic GET (drop-in for requests)

import httpx
r = httpx.get("https://api.example.com/items")
print(r.json())

2. Client with persistent connection pool

with httpx.Client() as client:
    r1 = client.get("https://api.example.com/items")
    r2 = client.get("https://api.example.com/users")
# Connections are pooled and reused — much faster than separate calls

3. Async with concurrent requests

import asyncio
import httpx

async def main():
    urls = [f"https://api.example.com/items/{i}" for i in range(100)]
    async with httpx.AsyncClient() as client:
        rs = await asyncio.gather(*[client.get(u) for u in urls])
    return [r.json() for r in rs]

asyncio.run(main())

4. HTTP/2 enabled

with httpx.Client(http2=True) as client:
    r = client.get("https://www.cloudflare.com")
    print(r.http_version)  # "HTTP/2"

5. Through a proxy

proxy = "http://USER:[email protected]:8080"
with httpx.Client(proxies={"http://": proxy, "https://": proxy}) as client:
    r = client.get("https://api.example.com")

6. Streaming a large response

with httpx.stream("GET", "https://example.com/large-file.zip") as r:
    with open("local.zip", "wb") as f:
        for chunk in r.iter_bytes():
            f.write(chunk)

7. Custom timeouts

timeout = httpx.Timeout(30.0, connect=10.0, read=20.0)
with httpx.Client(timeout=timeout) as client:
    r = client.get("https://slow-api.com")

8. POST JSON with auth

r = httpx.post(
    "https://api.example.com/items",
    json={"name": "sample", "price": 42},
    headers={"Authorization": "Bearer YOUR_TOKEN"},
)
print(r.json())

Migrating From requests

For most code, the migration is a one-line import change:

# Before
import requests
r = requests.get(url, params={"q": "x"}, headers={"X-Key": "abc"})

# After
import httpx
r = httpx.get(url, params={"q": "x"}, headers={"X-Key": "abc"})

The 5% incompatibility cases:

Sessions: requests.Session() → httpx.Client()
Verify SSL: requests' verify=False works in HTTPX too, but for custom CA use verify=ssl.create_default_context(...)
Streaming: requests uses r.iter_content(); HTTPX uses r.iter_bytes() in a stream context
Proxies: requests accepts {"http": ..., "https": ...}; HTTPX needs trailing slash {"http://": ..., "https://": ...}

Async + Proxies for Scraping at Scale

import asyncio
import httpx

PROXY = "http://USER:[email protected]:8080"

async def fetch(client, url):
    r = await client.get(url, timeout=20)
    return r.text

async def main(urls):
    async with httpx.AsyncClient(
        proxies={"http://": PROXY, "https://": PROXY},
        http2=True,
        limits=httpx.Limits(max_connections=50),
    ) as client:
        return await asyncio.gather(*[fetch(client, u) for u in urls])

urls = ["https://example.com/" + str(i) for i in range(1000)]
results = asyncio.run(main(urls))

Through a rotating residential proxy with HTTPX async + HTTP/2, real-world throughput is 200-500 requests/second on a single client, vs 20-50/second with sync requests.