httpcore

httpcore is the underlying engine that powers httpx, and using it directly gives you fine-grained control over HTTP connection lifecycle. The connection pooling is exceptionally well-designed with configurable limits, keepalive settings, and proper connection state tracking. You can set max_connections and max_keepalive_connections independently, which is crucial for tuning resource usage under load.

The async/sync dual API is seamless, and the retry/timeout behavior is explicit rather than magical - you control exactly what happens. The library exposes clear hooks for observability through trace callbacks, letting you instrument request/response cycles, connection acquisition, and TLS handshakes without monkey-patching. Error handling is predictable with well-defined exception hierarchy (ConnectError, ReadTimeout, PoolTimeout).

Memory footprint is minimal since it's truly low-level. The 1.0 release stabilized the API after some breaking changes in 0.x versions, but migration was straightforward. Under heavy load, connection pool behavior is deterministic - you get PoolTimeout when exhausted rather than mysterious hangs. The HTTP/2 support is production-ready with proper stream multiplexing.

httpcore is truly low-level, sitting beneath httpx as a transport layer. The documentation exists but assumes you already understand HTTP connection pooling, keep-alive semantics, and async/sync paradigms deeply. I spent considerable time reading source code to understand connection lifecycle management because the examples are minimal. Error messages are technically accurate but cryptic - you'll see exceptions about connection states without much context about what you did wrong.

The API is clean once you grasp it, but common tasks require more boilerplate than you'd expect. Managing ConnectionPool instances, handling retries, and dealing with timeouts all need manual implementation. Debugging connection issues is challenging because the abstraction is so thin you're essentially debugging TCP-level problems. Stack Overflow has very few httpcore-specific answers; you're mostly on your own with GitHub issues.

Unless you're building a custom HTTP client or need precise control over connection management, you're better off with httpx or requests. The learning curve isn't justified for typical API consumption tasks.

httpcore provides the building blocks for HTTP client implementations rather than a ready-to-use client. You'll work directly with connection pools, request/response cycles, and HTTP/1.1 vs HTTP/2 protocol specifics. The API is well-structured with clear separation between sync and async implementations, but you need solid understanding of HTTP internals to use it effectively.

Type hints are excellent throughout - IDE autocompletion works perfectly for connection lifecycle methods, pool management, and request parameters. Error handling is explicit with distinct exceptions for network errors, timeouts, and protocol issues, though the error messages can be terse and assume HTTP expertise. Documentation covers the core concepts but lacks practical examples for common patterns like retries or connection pooling strategies.

This is the foundation underlying httpx, and it shows - the abstractions are clean but minimal. You'll spend time implementing connection management logic that higher-level clients handle automatically. Great for building custom HTTP clients or understanding HTTP internals, but overkill for typical application development.