http

The `http` crate provides the fundamental building blocks for HTTP in Rust—Request, Response, StatusCode, HeaderMap, etc. It's intentionally minimal, giving you types without the networking layer. This makes it perfect as a shared foundation (used by hyper, reqwest, axum, etc.), but means you'll need to pair it with other crates for actual HTTP functionality.

The API is well-designed and intuitive once you understand the builder patterns. Creating requests and responses feels natural, and the type system catches many mistakes at compile time. Documentation is decent with good API docs, though practical examples are sparse. You'll find yourself referring to higher-level frameworks' docs to understand common patterns.

Error messages are generally helpful, especially around header validation. The main learning curve comes from understanding ownership with body types and the HeaderMap API quirks (iterating headers with the same name isn't obvious initially). Community support is excellent since it's foundational to the Rust HTTP ecosystem—most HTTP-related Stack Overflow answers will touch on these types.

The `http` crate provides the foundational types (Request, Response, StatusCode, HeaderMap) that most Rust HTTP libraries build on top of. Coming from other ecosystems, I appreciated how straightforward the API is - creating requests and responses feels intuitive, and the builder pattern makes construction clean. The types are well-designed and compile quickly since this is just the type layer without actual I/O.

The documentation is decent with basic examples, though I found myself frequently looking at how higher-level frameworks like Axum or Hyper use these types to understand real-world patterns. Error messages are generally clear, especially around header validation and URI parsing. One gotcha: the crate doesn't include common middleware or body handling utilities, so you'll quickly need companion crates for practical work.

Day-to-day usage is smooth once you understand this is infrastructure rather than a complete HTTP client/server. It shines when building libraries or working with multiple HTTP frameworks that need a common type system. The stability and widespread adoption mean excellent compatibility across the ecosystem.

The `http` crate is the de facto standard for HTTP type definitions in Rust's ecosystem. It provides the core `Request`, `Response`, `HeaderMap`, `StatusCode`, and `Method` types that virtually every HTTP library builds upon. The API is well-designed with zero-cost abstractions - these are just data structures with minimal runtime overhead.

In production, this crate shines in its simplicity and stability. Breaking changes are rare and well-communicated. The `HeaderMap` implementation is particularly clever, optimizing for the common case of ASCII header names while supporting arbitrary bytes. Memory layout is efficient, and the types compose well across async runtimes (tokio, async-std, etc.).

The main limitation is that this is purely a types library - no actual networking, connection pooling, or client/server implementations. You'll pair it with `hyper`, `reqwest`, `axum`, or similar. This separation is intentional and actually beneficial for operations: you control resource management at the runtime layer while keeping request/response handling generic. Watch out for the `Extensions` type map - it's convenient but uses dynamic dispatch and can hide performance costs if overused.