Struct Client 

pub struct Client { /* private fields */ }

HTTP client for making typed requests against a Target server.

A Client is created in one of three modes depending on which send variants you need:

Constructor	send() (async)	send_sync() (blocking)	Safe in async context
Client::new_async	✓	✗	✓
Client::new_sync	✗	✓	✓
Client::new	✓	✓	✗ — panics if called inside a tokio runtime

reqwest::blocking::Client internally creates its own single-threaded tokio runtime. If you call Client::new() (or Client::new_sync()) from within an existing async context (e.g. inside #[tokio::main]) it will panic. Use Client::new_async() when your program is async-first and only call Client::new_sync() / Client::new() before entering any async runtime.

Example

// Async-only client — safe inside #[tokio::main]
let client = Client::new_async(Target::Localhost(8080));

let items: Vec<Item> = client.get("/items").send().await?;
let created: Item = client.post("/items").json(NewItem { name: "w".into() }).send().await?;

Implementations

impl Client

pub fn new_async(target: Target) -> Self

Creates an async-only client. Safe to call from any context, including inside #[tokio::main]. Calling .send_sync() on builders from this client will panic.

pub fn new_sync(target: Target) -> Self

Creates a sync-only client. Must not be called from within an async context (inside #[tokio::main] or similar) — doing so panics. Calling .send() on builders from this client will panic with a message pointing to Client::new_async.

Panics

Panics at construction time if called inside a tokio runtime (same restriction as reqwest::blocking::Client). Prefer Client::new_async for async contexts.

pub fn new(target: Target) -> Self

Creates a client supporting both async and blocking sends.

Panics

Panics immediately if called from within an async context (e.g. inside #[tokio::main], tokio::spawn, or any .await call chain). This happens because reqwest::blocking::Client creates its own internal tokio runtime, and Rust/tokio forbids nesting two runtimes in the same thread.

If you are in an async context, use Client::new_async instead. If you only need blocking calls, use Client::new_sync before entering any runtime.

Example

// Correct — called from synchronous main before any async runtime starts
fn main() {
    let client = Client::new(Target::Localhost(8080));
    // ... use client.send_sync() and client.send() via manual runtime
}

// WRONG — will panic at runtime:
// #[tokio::main]
// async fn main() { let client = Client::new(...); }  // panics!

pub fn base_url(&self) -> String

Returns the base URL derived from the configured Target.

pub fn get(&self, endpoint: impl Into<String>) -> RequestBuilder<'_>

Starts a GET request builder for endpoint.

pub fn post(&self, endpoint: impl Into<String>) -> RequestBuilder<'_>

Starts a POST request builder for endpoint.

pub fn put(&self, endpoint: impl Into<String>) -> RequestBuilder<'_>

Starts a PUT request builder for endpoint.

pub fn delete(&self, endpoint: impl Into<String>) -> RequestBuilder<'_>

Starts a DELETE request builder for endpoint.

pub fn patch(&self, endpoint: impl Into<String>) -> RequestBuilder<'_>

Starts a PATCH request builder for endpoint.

pub fn head(&self, endpoint: impl Into<String>) -> RequestBuilder<'_>

Starts a HEAD request builder for endpoint.

pub fn options(&self, endpoint: impl Into<String>) -> RequestBuilder<'_>

Starts an OPTIONS request builder for endpoint.

Trait Implementations

impl Clone for Client

fn clone(&self) -> Client

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.