Rust Reqwest Proxy Integration

The reqwest crate is the de facto HTTP client for Rust. It supports proxy configuration through the Proxy builder, including HTTP, HTTPS, and SOCKS5 protocols.

Cargo.toml Dependencies

[dependencies]
reqwest = { version = "0.12", features = ["json", "socks"] }
tokio = { version = "1", features = ["full"] }

Basic HTTP Proxy

use reqwest::Proxy;

#[tokio::main] async fn main() -> Result<(), Box<dyn std::error::Error>> { let proxy = Proxy::all("http://YOUR_USERNAME:YOUR_PASSWORD@gate.hexproxies.com:8080")?;

let client = reqwest::Client::builder() .proxy(proxy) .timeout(std::time::Duration::from_secs(30)) .build()?;

let resp = client.get("https://httpbin.org/ip").send().await?; println!("Status: {}", resp.status()); println!("Body: {}", resp.text().await?);

Ok(()) } ```

SOCKS5 Proxy

Enable the socks feature in your Cargo.toml, then use the socks5 scheme:

let proxy = Proxy::all("socks5://YOUR_USERNAME:YOUR_PASSWORD@gate.hexproxies.com:1080")?;

let client = reqwest::Client::builder() .proxy(proxy) .build()?; ```

Sticky Sessions

let session_user = "YOUR_USERNAME-session-rust001";
let proxy_url = format!(
    "http://{}:YOUR_PASSWORD@gate.hexproxies.com:8080",
    session_user
);
let proxy = Proxy::all(&proxy_url)?;

Concurrent Proxied Requests

use futures::future::join_all;

let urls = vec![ "https://httpbin.org/ip", "https://httpbin.org/headers", "https://httpbin.org/get", ];

let tasks: Vec<_> = urls.into_iter().map(|url| { let client = client.clone(); tokio::spawn(async move { match client.get(url).send().await { Ok(resp) => println!("{}: {}", url, resp.status()), Err(e) => eprintln!("{}: {}", url, e), } }) }).collect();

join_all(tasks).await; ```

Retry with Backoff

async fn fetch_with_retry(
    client: &reqwest::Client,
    url: &str,
    max_retries: u32,
) -> Result<String, reqwest::Error> {
    let mut last_err = None;
    for attempt in 0..max_retries {
        match client.get(url).send().await {
            Ok(resp) if resp.status().is_success() => {
                return resp.text().await;
            }
            Ok(resp) if resp.status().as_u16() == 429 || resp.status().as_u16() == 503 => {
                tokio::time::sleep(std::time::Duration::from_secs(2u64.pow(attempt))).await;
            }
            Ok(resp) => {
                eprintln!("Non-retryable status: {}", resp.status());
                return resp.text().await;
            }
            Err(e) => {
                last_err = Some(e);
                tokio::time::sleep(std::time::Duration::from_secs(2u64.pow(attempt))).await;
            }
        }
    }
    Err(last_err.unwrap())
}

Environment-Based Configuration

let proxy_url = std::env::var("HEX_PROXY_URL")
    .expect("HEX_PROXY_URL must be set");
let proxy = Proxy::all(&proxy_url)?;

Reqwest also respects the standard HTTP_PROXY and HTTPS_PROXY environment variables if no explicit proxy is set on the client builder.