Struct reqwest::blocking::RequestBuilder

source ·

pub struct RequestBuilder { /* private fields */ }

Expand description

A builder to construct the properties of a Request.

To construct a RequestBuilder, refer to the Client documentation.

Implementations§

source §

impl RequestBuilder

Add a Header to this Request.

use reqwest::header::USER_AGENT;

let client = reqwest::blocking::Client::new();
let res = client.get("https://www.rust-lang.org")
    .header(USER_AGENT, "foo")
    .send()?;

source

pub fn headers(self, headers: HeaderMap) -> RequestBuilder

Add a set of Headers to the existing ones on this Request.

The headers will be merged in to any already set.

use reqwest::header::{HeaderMap, HeaderValue, USER_AGENT, CONTENT_TYPE};

fn construct_headers() -> HeaderMap {
    let mut headers = HeaderMap::new();
    headers.insert(USER_AGENT, HeaderValue::from_static("reqwest"));
    headers.insert(CONTENT_TYPE, HeaderValue::from_static("image/png"));
    headers
}

let file = fs::File::open("much_beauty.png")?;
let client = reqwest::blocking::Client::new();
let res = client.post("http://httpbin.org/post")
    .headers(construct_headers())
    .body(file)
    .send()?;

source

pub fn basic_auth<U, P>( self, username: U, password: Option, ) -> RequestBuilder
where U: Display, P: Display,

Enable HTTP basic authentication.

let client = reqwest::blocking::Client::new();
let resp = client.delete("http://httpbin.org/delete")
    .basic_auth("admin", Some("good password"))
    .send()?;

source

pub fn bearer_auth<T>(self, token: T) -> RequestBuilder
where T: Display,

Enable HTTP bearer authentication.

let client = reqwest::blocking::Client::new();
let resp = client.delete("http://httpbin.org/delete")
    .bearer_auth("token")
    .send()?;

source

pub fn body<T: Into<Body>>(self, body: T) -> RequestBuilder

Set the request body.

§Examples

Using a string:

let client = reqwest::blocking::Client::new();
let res = client.post("http://httpbin.org/post")
    .body("from a &str!")
    .send()?;

Using a File:

let file = std::fs::File::open("from_a_file.txt")?;
let client = reqwest::blocking::Client::new();
let res = client.post("http://httpbin.org/post")
    .body(file)
    .send()?;

Using arbitrary bytes:

// from bytes!
let bytes: Vec<u8> = vec![1, 10, 100];
let client = reqwest::blocking::Client::new();
let res = client.post("http://httpbin.org/post")
    .body(bytes)
    .send()?;

source

pub fn timeout(self, timeout: Duration) -> RequestBuilder

Enables a request timeout.

The timeout is applied from when the request starts connecting until the response body has finished. It affects only this request and overrides the timeout configured using ClientBuilder::timeout().

source

pub fn query<T: Serialize + ?Sized>(self, query: &T) -> RequestBuilder

Modify the query string of the URL.

Modifies the URL of this request, adding the parameters provided. This method appends and does not overwrite. This means that it can be called multiple times and that existing query parameters are not overwritten if the same key is used. The key will simply show up twice in the query string. Calling .query(&[("foo", "a"), ("foo", "b")]) gives "foo=a&foo=b".

let client = reqwest::blocking::Client::new();
let res = client.get("http://httpbin.org")
    .query(&[("lang", "rust")])
    .send()?;

§Note

This method does not support serializing a single key-value pair. Instead of using .query(("key", "val")), use a sequence, such as .query(&[("key", "val")]). It’s also possible to serialize structs and maps into a key-value pair.

§Errors

This method will fail if the object you provide cannot be serialized into a query string.

source

pub fn version(self, version: Version) -> RequestBuilder

Set HTTP version

source

pub fn form<T: Serialize + ?Sized>(self, form: &T) -> RequestBuilder

Send a form body.

Sets the body to the url encoded serialization of the passed value, and also sets the Content-Type: application/x-www-form-urlencoded header.

let mut params = HashMap::new();
params.insert("lang", "rust");

let client = reqwest::blocking::Client::new();
let res = client.post("http://httpbin.org")
    .form(&params)
    .send()?;

§Errors

This method fails if the passed value cannot be serialized into url encoded format

source

pub fn json<T: Serialize + ?Sized>(self, json: &T) -> RequestBuilder

Send a JSON body.

Sets the body to the JSON serialization of the passed value, and also sets the Content-Type: application/json header.

§Optional

This requires the optional json feature enabled.

§Examples

let mut map = HashMap::new();
map.insert("lang", "rust");

let client = reqwest::blocking::Client::new();
let res = client.post("http://httpbin.org")
    .json(&map)
    .send()?;

§Errors

Serialization can fail if T’s implementation of Serialize decides to fail, or if T contains a map with non-string keys.

source

pub fn multipart(self, multipart: Form) -> RequestBuilder

Sends a multipart/form-data body.


let client = reqwest::blocking::Client::new();
let form = reqwest::blocking::multipart::Form::new()
    .text("key3", "value3")
    .file("file", "/path/to/field")?;

let response = client.post("your url")
    .multipart(form)
    .send()?;

See multipart for more examples.

source

pub fn build(self) -> Result<Request>

Build a Request, which can be inspected, modified and executed with Client::execute().

source

pub fn send(self) -> Result<Response>

Constructs the Request and sends it the target URL, returning a Response.

§Errors

This method fails if there was an error while sending request, redirect loop was detected or redirect limit was exhausted.

source

pub fn try_clone(&self) -> Option<RequestBuilder>

Attempts to clone the RequestBuilder.

None is returned if a body is which can not be cloned. This can be because the body is a stream.

§Examples

With a static body

let client = reqwest::blocking::Client::new();
let builder = client.post("http://httpbin.org/post")
    .body("from a &str!");
let clone = builder.try_clone();
assert!(clone.is_some());

Without a body

let client = reqwest::blocking::Client::new();
let builder = client.get("http://httpbin.org/get");
let clone = builder.try_clone();
assert!(clone.is_some());

With a non-clonable body

let client = reqwest::blocking::Client::new();
let builder = client.get("http://httpbin.org/get")
    .body(reqwest::blocking::Body::new(std::io::empty()));
let clone = builder.try_clone();
assert!(clone.is_none());