HTTPX

HTTPX is a fully featured HTTP client for Python 3 that provides a broadly requests-compatible API while adding first-class support for both synchronous and asynchronous programming models. It supports HTTP/1.1 and HTTP/2 out of the box, ships an optional command-line client, and can dispatch requests directly to WSGI or ASGI applications for in-process testing.

Built by the Encode organization (also behind Starlette and Uvicorn), HTTPX layers a friendly, typed API on top of the lower-level httpcore transport library, giving developers connection pooling, streaming responses, proxy support, and strict timeout handling without sacrificing the ergonomics that made requests popular.

What You Get

• A Client/AsyncClient pair with identical APIs for sync and async code, plus module-level httpx.get()/httpx.post() shortcuts
• Native HTTP/2 support (opt-in via the http2 extra) alongside HTTP/1.1
• Direct-to-app transports (WSGITransport, ASGITransport) for testing web apps without a running server
• Connection pooling, streaming request/response bodies, and multipart file uploads
• A pluggable httpcore-based transport layer with a MockTransport for unit-testing HTTP calls
• An optional CLI (httpx[cli]) for making requests from the terminal with syntax-highlighted output

Common Use Cases

• Calling external REST APIs from a Python backend service, sync or async
• Writing integration tests for FastAPI/Starlette apps via ASGITransport without binding a real port
• Streaming large file downloads or uploads with bounded memory usage
• Migrating an existing requests-based codebase to async with minimal API changes
• Building HTTP/2-aware clients that need multiplexed connections to modern APIs

Under The Hood

Architecture — HTTPX separates concerns cleanly across a few layers: _client.py (2,019 lines) defines a BaseClient holding shared state (auth, headers, cookies, timeouts, redirect policy) that both the synchronous Client and asynchronous AsyncClient subclass; _api.py exposes stateless module-level functions (get, post, request, stream, etc.) that construct a short-lived Client under the hood for one-off calls; _models.py (1,277 lines) implements Request/Response/Headers/URL value objects; and the _transports/ package (default.py, asgi.py, wsgi.py, mock.py, base.py) implements the actual wire-level dispatch, delegating real network I/O to the httpcore library while ASGITransport/WSGITransport bypass the network entirely to call an application object in-process — this is what makes HTTPX popular for testing async web frameworks.

Tech Stack — Pure Python 3.9+, built with hatchling/hatch-fancy-pypi-readme. Core runtime dependencies are minimal and deliberate: httpcore==1.* (transport), certifi (CA bundle), idna (IDN support), and anyio (async concurrency abstraction, enabling both asyncio and Trio backends). Optional extras (h2 for HTTP/2, socksio for SOCKS proxies, click/rich/pygments for the CLI, brotli/zstandard for extra content-encoding support) keep the base install lean while allowing opt-in capability.

Code Quality — The project advertises and maintains 100% test coverage (tool.coverage.run config enforces this), with 37 test modules under tests/ covering client behavior, transports, models, and edge cases like redirects and multipart encoding. Strict mypy mode is enabled project-wide (tool.mypy: strict = true), and ruff lint rules (E, F, I, B, PIE) are enforced. Internal modules use a leading-underscore convention (_client.py, _models.py) to clearly separate public API surface (re-exported via __init__.py) from implementation detail.

API Design — HTTPX deliberately mirrors the requests API (httpx.get(url), response .json()/.text/.status_code) so migration is close to a drop-in replacement, while extending it with async def equivalents on AsyncClient using the identical method names and signatures. Context-manager usage (with httpx.Client() as client: / async with httpx.AsyncClient() as client:) is the documented idiom for connection reuse, and the library is fully type-annotated, giving strong editor autocomplete and static-analysis support out of the box.