Struct reqwest::Response

pub struct Response { /* fields omitted */ }

A Response to a submitted Request.

Methods

impl Response

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");

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::PayloadTooLarge => {
        println!("Request payload is too large!");
    }
    s => println!("Received response status: {:?}", s),
};

fn headers(&self) -> &Headers

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::<ContentLength>()
                .map(|ct_len| **ct_len)
                .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)?;
        }
    }
}

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.

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

Get the response text.

Example

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

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.

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());

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::BadRequest));
}

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, placing them into buf.

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

Read the exact number of bytes required to fill buf.

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

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

fn bytes(self) -> Bytes<Self>

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

fn chars(self) -> Chars<Self>

🔬 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.

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

Creates an adaptor which will chain this stream with another.

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

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