Struct reqwest::Response

pub struct Response { /* fields omitted */ }

A Response to a submitted Request.

Methods

impl Response

pub fn url(&self) -> &Url

Get the final Url of this Response.

Example

let resp = reqwest::get("http://httpbin.org/redirect/1")?;
assert_eq!(resp.url().as_str(), "http://httpbin.org/get");

pub fn status(&self) -> StatusCode

Get the StatusCode of this Response.

Examples

let resp = reqwest::get("http://httpbin.org/get")?;
if resp.status().is_success() {
    println!("success!");
} else if resp.status().is_server_error() {
    println!("server error!");
} else {
    println!("Something else happened. Status: {:?}", resp.status());
}

use reqwest::Client;
use reqwest::StatusCode;
let client = Client::new();
let resp = client.post("http://httpbin.org/post")
            .body("possibly too large")
            .send()?;
match resp.status() {
    StatusCode::OK => println!("success!"),
    StatusCode::PAYLOAD_TOO_LARGE => {
        println!("Request payload is too large!");
    }
    s => println!("Received response status: {:?}", s),
};

pub fn headers(&self) -> &HeaderMap

Get the Headers of this Response.

Example

Checking the Content-Length header before reading the response body.

let client = Client::new();
let mut resp = client.head("http://httpbin.org/bytes/3000").send()?;
if resp.status().is_success() {
    let len = resp.headers().get(CONTENT_LENGTH)
                .and_then(|ct_len| ct_len.to_str().ok())
                .and_then(|ct_len| ct_len.parse().ok())
                .unwrap_or(0);
    // limit 1mb response
    if len <= 1_000_000 {
        let mut buf = Vec::with_capacity(len as usize);
        let mut resp = reqwest::get("http://httpbin.org/bytes/3000")?;
        if resp.status().is_success() {
            ::std::io::copy(&mut resp, &mut buf)?;
        }
    }
}

pub fn version(&self) -> Version

Get the HTTP Version of this Response.

pub fn json<T: DeserializeOwned>(&mut self) -> Result<T>

Try and deserialize the response body as JSON using serde.

Examples

#[derive(Deserialize)]
struct Ip {
    origin: String,
}

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

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]. [serde_json::from_reader]: https://docs.serde.rs/serde_json/fn.from_reader.html

pub fn text(&mut self) -> Result<String>

Get the response text.

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

Example

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

Note

This consumes the body. Trying to read more, or use of response.json() will return empty values.

pub fn copy_to<W: ?Sized>(&mut self, w: &mut W) -> Result<u64> where     W: Write,

Copy the response body into a writer.

This function internally uses [std::io::copy] and hence will continuously read data from the body and then write it into writer in a streaming fashion until EOF is met.

On success, the total number of bytes that were copied to writer is returned. [std::io::copy]: https://doc.rust-lang.org/std/io/fn.copy.html

Example

let mut resp = reqwest::get("http://httpbin.org/range/5")?;
let mut buf: Vec<u8> = vec![];
resp.copy_to(&mut buf)?;
assert_eq!(b"abcde", buf.as_slice());

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

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

Example

let res = reqwest::get("http://httpbin.org/status/400")?
    .error_for_status();
if let Err(err) = res {
    assert_eq!(err.status(), Some(reqwest::StatusCode::BAD_REQUEST));
}

Trait Implementations

impl Debug for Response

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Read for Response

fn read(&mut self, buf: &mut [u8]) -> Result<usize>

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

unsafe fn initializer(&self) -> Initializer

🔬 This is a nightly-only experimental API. (read_initializer)

Determines if this Reader can work with buffers of uninitialized memory.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>

Read all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Read all bytes until EOF in this source, appending them to buf.

fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>

Read the exact number of bytes required to fill buf.

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self

Creates a "by reference" adaptor for this instance of Read.

Important traits for Bytes<R>

impl<R> Iterator for Bytes<R> where
    R: Read,  type Item = Result<u8, Error>;

fn bytes(self) -> Bytes<Self>

Transforms this Read instance to an [Iterator] over its bytes.

Important traits for Chars<R>

impl<R> Iterator for Chars<R> where
    R: Read,  type Item = Result<char, CharsError>;

fn chars(self) -> Chars<Self>

Deprecated since 1.27.0

: Use str::from_utf8 instead: https://doc.rust-lang.org/nightly/std/str/struct.Utf8Error.html#examples

🔬 This is a nightly-only experimental API. (io)

the semantics of a partial read/write of where errors happen is currently unclear and may change

Transforms this Read instance to an [Iterator] over [char]s.

Important traits for Chain<T, U>

impl<T, U> Read for Chain<T, U> where
    T: Read,
    U: Read, 

fn chain<R>(self, next: R) -> Chain<Self, R> where     R: Read,

Creates an adaptor which will chain this stream with another.

Important traits for Take<T>

impl<T> Read for Take<T> where
    T: Read, 

fn take(self, limit: u64) -> Take<Self>

Creates an adaptor which will read at most limit bytes from it.