h11

h11 is a low-level HTTP/1.1 protocol implementation that operates as a pure state machine - you bring your own I/O. This design is brilliant for building custom HTTP servers/clients or understanding protocol internals, but it's not a drop-in solution. You'll work with event objects like Request, Response, Data, and EndOfMessage, feeding bytes in and getting events out. The state machine is rock-solid and handles edge cases correctly.

The documentation is thorough but assumes significant HTTP protocol knowledge. You need to understand chunked encoding, connection management, and state transitions. Error messages are generally clear when the state machine catches protocol violations. Type hints are present and helpful for IDE completion, though the event-based API takes time to internalize.

For most developers, higher-level libraries like httpx or aiohttp are better choices. h11 shines when you're building protocol-level tooling, proxies, or need precise control over HTTP wire protocol. It's what powers httpcore (used by httpx), so it's battle-tested in production.

h11 is a stateful HTTP/1.1 protocol implementation that separates protocol logic from I/O operations. This BYOIO (bring-your-own-I/O) design makes it incredibly flexible for building custom HTTP clients and servers. The state machine approach is rigorous—it catches protocol violations early and provides clear error messages about what transitions are valid. Memory usage is excellent since you control buffering entirely.

The API requires understanding HTTP/1.1 state transitions (IDLE → SEND_RESPONSE → DONE, etc.), which has a learning curve but prevents subtle protocol bugs. Connection reuse works well once you understand the state management. No built-in timeout handling means you implement that in your I/O layer. Error messages are informative when you violate protocol rules, though debugging state machine issues initially takes time.

Performance is solid for a pure-Python implementation. The lack of connection pooling or retry logic is intentional—h11 is a building block, not a batteries-included solution. This makes it perfect for frameworks like hypercorn/uvicorn but potentially too low-level for application code.

h11 is a low-level HTTP/1.1 protocol implementation that provides a state machine for parsing and serializing HTTP messages. It's deliberately designed as a "bring-your-own-I/O" library, meaning you handle all network operations yourself. This gives you complete control but requires deep understanding of HTTP semantics and async programming patterns.

The API is well-typed with good type hint coverage, making IDE autocomplete helpful. Error messages are clear when protocol violations occur, with specific exception types like ProtocolError that include contextual details. However, the documentation assumes significant HTTP knowledge - there's limited hand-holding for common patterns like chunked encoding or connection reuse.

Day-to-day usage involves managing Connection objects, sending Events through send(), and receiving parsed events via receive_data(). The state machine prevents invalid transitions, which is excellent for correctness but can be confusing when debugging why certain operations fail. You'll spend time reading the source code to understand nuances, especially around connection lifecycle management.