Making HTTP Requests with Rust Reqwest

Introduction

Modern web applications depend heavily on HTTP communication to interact with APIs, fetch external data, and integrate with third-party services. Rust has emerged as a powerful language for building high-performance web applications, and reqwest stands as the de facto standard HTTP client library for the Rust ecosystem. Whether you are building a Next.js API route handler that needs to call external services, or constructing a backend service that integrates with multiple REST APIs, reqwest provides the functionality you need with the performance you expect from Rust.

This guide explores how to leverage reqwest to build robust, type-safe HTTP clients that take advantage of Rust's memory safety guarantees and zero-cost abstractions. From basic GET requests to advanced configurations suitable for production workloads, you will learn everything needed to implement effective HTTP communication in your Rust applications.

For teams working across multiple technologies, understanding how to build reliable HTTP clients is essential for full-stack web development projects that span frontend and backend components.

Setting Up Your Rust Project with Reqwest

Getting started with reqwest requires configuring your Cargo.toml with the appropriate dependencies and feature flags. The library offers a modular design that lets you include only the features your application needs.

Cargo.toml Configuration

[dependencies]
reqwest = { version = "0.12", features = ["json", "blocking"] }
tokio = { version = "1", features = ["full"] }
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"

Understanding Feature Flags

The json feature is essential for most applications as it enables automatic JSON serialization and deserialization through integration with Serde, eliminating boilerplate code for common patterns. This feature automatically handles the conversion between Rust data structures and JSON payloads, making it an essential tool for type-safe API development.

The blocking feature provides a synchronous API that blocks the current thread, perfect for CLI tools, simple scripts, or when async complexity isn't warranted. When building web services or applications that handle many concurrent connections, omit this flag and use the default async API instead.

For TLS configuration, you can choose between native-tls for system-level certificate stores (Windows Security, macOS Security, OpenSSL on Linux) or rustls-tls for a pure-Rust implementation. The rustls option provides greater flexibility for custom certificate authorities and specific cipher suites.

Additional compression features like gzip, brotli, and zstd enable automatic decompression of response bodies, which is essential when working with modern APIs that use content encoding. The cookies feature enables automatic cookie handling, maintaining session state across requests automatically.

Configuring the Async Runtime

Reqwest requires an async runtime to function, with Tokio being the most common choice. The simplest approach uses the #[tokio::main] attribute macro, which creates a multi-threaded runtime for your application:

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
    let client = reqwest::Client::new();
    let response = client.get("https://api.example.com").send().await?;
    println!("Status: {}", response.status());
    Ok(())
}

For more control over the runtime configuration, you can use tokio::runtime::Builder to customize thread count, execution mode, and other parameters:

use tokio::runtime::Builder;

fn main() {
    let runtime = Builder::new_multi_thread()
        .worker_threads(4)
        .enable_all()
        .build()
        .unwrap();

    runtime.block_on(async {
        let client = reqwest::Client::new();
        // Your async code here
    });
}

This flexibility allows you to optimize runtime behavior for your specific workload, whether you need high throughput for many concurrent requests or minimal resource usage for simple applications. When building production web applications, proper async runtime configuration is critical for achieving optimal performance.

Building Type-Safe API Clients

One of Rust's greatest strengths is its type system, and reqwest integrates seamlessly with serde to provide compile-time guarantees about your API interactions.

Defining Request and Response Structures

use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize)]
pub struct User {
    pub id: u32,
    pub name: String,
    pub email: String,
}

#[derive(Debug, Serialize)]
pub struct CreateUserRequest {
    pub name: String,
    pub email: String,
}

Automatic JSON Serialization

When you call the .json() method on a response, reqwest automatically handles the deserialization process using Serde. This approach provides type safety and compile-time checking, ensuring your code correctly handles the structure of incoming data. If the JSON structure doesn't match your Rust struct, you'll get a clear error at runtime, making debugging straightforward.

For sending data, the .json() method on a request builder automatically serializes your data structure:

let create_request = CreateUserRequest {
    name: "John Doe".to_string(),
    email: "[email protected]".to_string(),
};

let response = client
    .post("https://api.example.com/users")
    .json(&create_request)
    .send()
    .await?;

The importance of proper error handling cannot be overstated when working with external APIs. Network failures, malformed responses, and API errors can all cause failures. A robust error type helps distinguish between different failure modes, which is essential for maintainable web applications:

use thiserror::Error;

#[derive(Debug, Error)]
pub enum ApiClientError {
    #[error("HTTP request failed: {0}")]
    Reqwest(#[from] reqwest::Error),
    
    #[error("API error: {status} - {message}")]
    Api { status: reqwest::StatusCode, message: String },
    
    #[error("Invalid response format")]
    InvalidResponse,
}

For API error responses that include structured error details in the body, you can define error response types and handle them explicitly:

#[derive(Debug, Deserialize)]
pub struct ApiErrorResponse {
    pub error: String,
    pub code: u16,
}

match response.json::<ApiErrorResponse>().await {
    Ok(error_body) => {
        return Err(ApiClientError::Api {
            status: response.status(),
            message: error_body.error,
        });
    }
    Err(_) => {
        return Err(ApiClientError::InvalidResponse);
    }
}

Conclusion

Reqwest provides a powerful, ergonomic foundation for HTTP communication in Rust applications. Its type-safe design, seamless serde integration, and flexible feature set make it the ideal choice for everything from simple API calls to complex microservice architectures.

By following the patterns and practices outlined in this guide, you can build HTTP clients that are reliable, performant, and maintainable. The investment in proper error handling, type-safe data structures, and connection management pays dividends as your application scales.

Next Steps

• Build a complete API client for a real-world service
• Explore integration with web frameworks like Axum or Actix-web
• Implement observability middleware for request logging and metrics
• Experiment with HTTP/2 connection management for high-throughput scenarios

Building robust HTTP clients is just one aspect of creating high-performance web applications. At Digital Thrive, our team specializes in designing and implementing full-stack solutions that leverage Rust's performance advantages while maintaining clean, maintainable codebases. Whether you need help with API integration design, performance optimization, or building microservices from scratch, we have the expertise to bring your vision to life.

Sources

1. Rust Web Development: Making HTTP Requests - Comprehensive guide covering Reqwest setup, async/blocking APIs, JSON handling, and error patterns
2. Rust Lang Official: Reqwest Crate Documentation - Official crate documentation with complete API reference for v0.12
3. Rust HTTP Client Tutorial: From Basics to Production - Production-focused tutorial covering middleware, connection pooling, and retry logic
4. Oxide Computer: Building with Reqwest - Real-world implementation guide with practical examples and best practices
5. Rust How-To: Handle HTTP Responses - Focus on streaming responses and memory-efficient handling