Struct Response 

pub struct Response { /* private fields */ }

A Response to a submitted Request.

Implementations

impl Response

pub fn status(&self) -> StatusCode

Get the StatusCode of this Response.

pub fn version(&self) -> Version

Get the HTTP Version of this Response.

pub fn headers(&self) -> &HeaderMap

Get the Headers of this Response.

pub fn headers_mut(&mut self) -> &mut HeaderMap

Get a mutable reference to the Headers of this Response.

pub fn content_length(&self) -> Option<u64>

Get the content length of the response, if it is known.

This value does not directly represents the value of the Content-Length header, but rather the size of the response’s body. To read the header’s value, please use the Response::headers method instead.

Reasons it may not be known:

• The response does not include a body (e.g. it responds to a HEAD request).
• The response is gzipped and automatically decoded (thus changing the actual decoded length).

pub fn url(&self) -> &Url

Get the final Url of this Response.

pub fn remote_addr(&self) -> Option<SocketAddr>

Get the remote address used to get this Response.

pub fn extensions(&self) -> &Extensions

Returns a reference to the associated extensions.

pub fn extensions_mut(&mut self) -> &mut Extensions

Returns a mutable reference to the associated extensions.

pub async fn text(self) -> Result<String, Error>

Get the full response text.

This method decodes the response body with BOM sniffing and with malformed sequences replaced with the char::REPLACEMENT_CHARACTER. Encoding is determined from the charset parameter of Content-Type header, and defaults to utf-8 if not presented.

Note that the BOM is stripped from the returned String.

Note

If the charset feature is disabled the method will only attempt to decode the response as UTF-8, regardless of the given Content-Type

Example

let content = reqwest::get("http://httpbin.org/range/26")
    .await?
    .text()
    .await?;

println!("text: {content:?}");

pub async fn json<T>(self) -> Result<T, Error>

where T: DeserializeOwned,

Try to deserialize the response body as JSON.

Optional

This requires the optional json feature enabled.

Examples

// This `derive` requires the `serde` dependency.
#[derive(Deserialize)]
struct Ip {
    origin: String,
}

let ip = reqwest::get("http://httpbin.org/ip")
    .await?
    .json::<Ip>()
    .await?;

println!("ip: {}", ip.origin);

Errors

This method fails whenever the response body is not in JSON format, or it cannot be properly deserialized to target type T. For more details please see serde_json::from_reader.

pub async fn bytes(self) -> Result<Bytes, Error>

Get the full response body as Bytes.

Example

let bytes = reqwest::get("http://httpbin.org/ip")
    .await?
    .bytes()
    .await?;

println!("bytes: {bytes:?}");

pub async fn chunk(&mut self) -> Result<Option<Bytes>, Error>

Stream a chunk of the response body.

When the response body has been exhausted, this will return None.

Example

let mut res = reqwest::get("https://hyper.rs").await?;

while let Some(chunk) = res.chunk().await? {
    println!("Chunk: {chunk:?}");
}

pub fn bytes_stream(self) -> impl Stream<Item = Result<Bytes, Error>>

Convert the response into a Stream of Bytes from the body.

Example

use futures_util::StreamExt;

let mut stream = reqwest::get("http://httpbin.org/ip")
    .await?
    .bytes_stream();

while let Some(item) = stream.next().await {
    println!("Chunk: {:?}", item?);
}

Optional

This requires the optional stream feature to be enabled.

pub fn error_for_status(self) -> Result<Response, Error>

Turn a response into an error if the server returned an error.

Example

fn on_response(res: Response) {
    match res.error_for_status() {
        Ok(_res) => (),
        Err(err) => {
            // asserting a 400 as an example
            // it could be any status between 400...599
            assert_eq!(
                err.status(),
                Some(reqwest::StatusCode::BAD_REQUEST)
            );
        }
    }
}

pub fn error_for_status_ref(&self) -> Result<&Response, Error>

Turn a reference to a response into an error if the server returned an error.

Example

fn on_response(res: &Response) {
    match res.error_for_status_ref() {
        Ok(_res) => (),
        Err(err) => {
            // asserting a 400 as an example
            // it could be any status between 400...599
            assert_eq!(
                err.status(),
                Some(reqwest::StatusCode::BAD_REQUEST)
            );
        }
    }
}

impl Response

pub async fn upgrade(self) -> Result<Upgraded, Error>

Consumes the response and returns a future for a possible HTTP upgrade.

Trait Implementations

impl Debug for Response

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<T> From<Response<T>> for Response

where T: Into<Body>,

fn from(r: Response<T>) -> Response

Converts to this type from the input type.