reqwest

reqwest is the de facto standard HTTP client for the Rust ecosystem, built on top of hyper and Tokio. It wraps the low-level plumbing of connection pooling, TLS negotiation, and HTTP/1.1-2 (with experimental HTTP/3) framing behind a small, discoverable API surface, so most applications need only a handful of calls to send a request and deserialize a response.

Beyond the basics, reqwest ships first-class support for JSON, form and multipart bodies, cookie stores, redirect policies, proxies (including system-proxy detection), and swappable TLS backends (rustls by default, native-tls or vendored OpenSSL optionally). It also compiles to WebAssembly for browser environments and offers a synchronous blocking client for scripts and CLIs that don’t want to pull in an async runtime.

What You Get

• An async Client built on hyper/hyper-util with automatic connection pooling and keep-alive
• An optional blocking module exposing a synchronous API for scripts, CLIs, and non-async codebases
• Built-in JSON, form-urlencoded, and multipart request/response helpers gated behind Cargo features
• A pluggable TLS layer — rustls (default), native-tls, or vendored OpenSSL — selected via feature flags
• Cookie store, configurable redirect policy, proxy support (including system-proxy autodetection), and experimental HTTP/3

Common Use Cases

• Calling third-party REST or JSON APIs from an async Rust service (web backend, worker, CLI)
• Building typed API clients for external services with reqwest::Client plus serde-derived request/response structs
• Downloading or uploading files and multipart payloads with streaming bodies
• Web scraping or crawling tools that need cookie persistence and redirect following out of the box
• Compiling to WASM to make HTTP calls from browser-targeted Rust code

Under The Hood

Architecture — reqwest layers a request-builder API (async_impl::client::Client/RequestBuilder in src/async_impl/client.rs and src/async_impl/request.rs) over a tower::Service stack composed from hyper-util’s connection-pooling client, a TowerRedirectPolicy (src/redirect.rs), an optional CookieService (src/cookie.rs), and a Connector/BoxedConnectorService abstraction (src/connect.rs) that resolves DNS (via GaiResolver or optional hickory-dns), negotiates TLS, and dials proxies (src/proxy.rs). The blocking module (src/blocking/) wraps the same async client and drives it from a dedicated background Tokio runtime, so synchronous callers get an equivalent API without spinning their own executor. A parallel wasm module (src/wasm/) swaps the hyper transport for the browser fetch API when targeting wasm32-unknown-unknown.

Tech Stack — Rust 2021 edition, minimum supported Rust version 1.85.0. Core dependencies are hyper 1.x and hyper-util for HTTP/1.1 and HTTP/2 transport, tower/tower-service/tower-http for middleware (retry, timeout, redirect-following), tokio for async I/O, http/http-body/http-body-util for the request/response types, and url for URL parsing. TLS is feature-gated: rustls (default, via hyper-rustls and rustls-platform-verifier) or native-tls/native-tls-vendored. Optional features pull in serde/serde_json/serde_urlencoded (JSON/form/query), cookie/cookie_store (cookies), mime_guess (multipart), encoding_rs (charset), and h3/h3-quinn/quinn (experimental HTTP/3).

Code Quality — the crate carries an extensive tests/ suite (client.rs, redirect.rs, cookie.rs, multipart.rs, proxy.rs, timeouts.rs, retry.rs, gzip/brotli/deflate/zstd compression, connector_layers.rs, badssl.rs, upgrade.rs, wasm_simple.rs) exercised against a local support test-server harness, plus a ci.rs smoke test and dedicated blocking-client tests. Nearly every public type and method carries doc comments with runnable examples, feature gating is used consistently to keep optional dependencies out of default builds, and errors are unified behind a boxed Error/BoxError type (src/error.rs) rather than leaking transport-specific error types to callers.

API Design — the builder pattern (Client::get(url).header(...).query(...).json(&body).send().await?) reads close to plain English and mirrors patterns from Python’s requests, which is a deliberate design goal stated in the README. Feature flags keep the dependency footprint minimal by default while making advanced capabilities (cookies, multipart, streaming, HTTP/3) a single Cargo.toml line away. The blocking and async APIs are intentionally near-identical, which lowers the cost of switching between sync scripts and async services.