Struct Response

struct Response { ... }

A Response to a submitted Request.

Implementations

impl Response

async fn upgrade(self: Self) -> Result<Upgraded>

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

impl Response

fn status(self: &Self) -> StatusCode

Get the StatusCode of this Response.

fn version(self: &Self) -> Version

Get the HTTP Version of this Response.

fn headers(self: &Self) -> &HeaderMap

Get the Headers of this Response.

fn headers_mut(self: &mut Self) -> &mut HeaderMap

Get a mutable reference to the Headers of this Response.

fn content_length(self: &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).
fn url(self: &Self) -> &Url

Get the final Url of this Response.

fn remote_addr(self: &Self) -> Option<SocketAddr>

Get the remote address used to get this Response.

fn extensions(self: &Self) -> &Extensions

Returns a reference to the associated extensions.

fn extensions_mut(self: &mut Self) -> &mut Extensions

Returns a mutable reference to the associated extensions.

async fn text(self: Self) -> Result<String>

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

# async fn run() -> Result<(), Box<dyn std::error::Error>> {
let content = reqwest::get("http://httpbin.org/range/26")
    .await?
    .text()
    .await?;

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

async fn text_with_charset(self: Self, default_encoding: &str) -> Result<String>

Get the full response text given a specific encoding.

This method decodes the response body with BOM sniffing and with malformed sequences replaced with the char::REPLACEMENT_CHARACTER. You can provide a default encoding for decoding the raw message, while the charset parameter of Content-Type header is still prioritized. For more information about the possible encoding name, please go to encoding_rs docs.

Note that the BOM is stripped from the returned String.

Optional

This requires the optional encoding_rs feature enabled.

Example

# async fn run() -> Result<(), Box<dyn std::error::Error>> {
let content = reqwest::get("http://httpbin.org/range/26")
    .await?
    .text_with_charset("utf-8")
    .await?;

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

async fn json<T: DeserializeOwned>(self: Self) -> Result<T>

Try to deserialize the response body as JSON.

Optional

This requires the optional json feature enabled.

Examples

# extern crate reqwest;
# extern crate serde;
#
# use reqwest::Error;
# use serde::Deserialize;
#
// This `derive` requires the `serde` dependency.
#[derive(Deserialize)]
struct Ip {
    origin: String,
}

# async fn run() -> Result<(), Error> {
let ip = reqwest::get("http://httpbin.org/ip")
    .await?
    .json::<Ip>()
    .await?;

println!("ip: {}", ip.origin);
# Ok(())
# }
#
# fn main() { }

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.

async fn bytes(self: Self) -> Result<Bytes>

Get the full response body as Bytes.

Example

# async fn run() -> Result<(), Box<dyn std::error::Error>> {
let bytes = reqwest::get("http://httpbin.org/ip")
    .await?
    .bytes()
    .await?;

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

async fn chunk(self: &mut Self) -> Result<Option<Bytes>>

Stream a chunk of the response body.

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

Example

# async fn run() -> Result<(), Box<dyn std::error::Error>> {
let mut res = reqwest::get("https://hyper.rs").await?;

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

fn error_for_status(self: Self) -> Result<Self>

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

Example

# use reqwest::Response;
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)
            );
        }
    }
}
# fn main() {}

fn error_for_status_ref(self: &Self) -> Result<&Self>

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

Example

# use reqwest::Response;
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)
            );
        }
    }
}
# fn main() {}

impl Debug for Response

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

impl Freeze for Response

impl RefUnwindSafe for Response

impl Send for Response

impl Sync for Response

impl Unpin for Response

impl UnsafeUnpin for Response

impl UnwindSafe for Response

impl<T> Any for Response

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for Response

fn borrow(self: &Self) -> &T

impl<T> BorrowMut for Response

fn borrow_mut(self: &mut Self) -> &mut T

impl<T> ErasedDestructor for Response

impl<T> From for Response

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> Instrument for Response

impl<T> PolicyExt for Response

fn and<P, B, E>(self: Self, other: P) -> And<T, P>
where
    T: Policy<B, E>,
    P: Policy<B, E>
fn or<P, B, E>(self: Self, other: P) -> Or<T, P>
where
    T: Policy<B, E>,
    P: Policy<B, E>

impl<T> WithSubscriber for Response

impl<T, U> Into for Response

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom for Response

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto for Response

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>

impl<T: Into<super::body::Body>> From for Response

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