Crate reqwest [−] [src]
reqwest
The reqwest
crate provides a convenient, higher-level HTTP Client.
It handles many of the things that most people just expect an HTTP client to do for them.
- Uses system-native TLS
- Plain bodies, JSON, urlencoded, (TODO: multipart)
- Customizable redirect policy
- (TODO: Cookies)
The reqwest::Client
is synchronous, making it a great fit for
applications that only require a few HTTP requests, and wish to handle
them synchronously. When hyper releases with asynchronous support,
reqwest
will be updated to use it internally, but still provide a
synchronous Client, for convenience. A reqwest::async::Client
will also
be added.
Making a GET request
For a single request, you can use the get
shortcut method.
use std::io::Read; let mut resp = reqwest::get("https://www.rust-lang.org").unwrap(); assert!(resp.status().is_success()); let mut content = String::new(); resp.read_to_string(&mut content);
As you can see, reqwest's Response
struct implements Rust's
Read
trait, so many useful standard library and third party crates will
have convenience methods that take a Response
anywhere T: Read
is
acceptable.
If you plan to perform multiple requests, it is best to create a Client
and reuse it, taking advantage of keep-alive connection pooling.
Making POST requests (or setting request bodies)
There are several ways you can set the body of a request. The basic one is
by using the body()
method of a RequestBuilder
. This lets you set the
exact raw bytes of what the body should be. It accepts various types,
including String
, Vec<u8>
, and File
. If you wish to pass a custom
Reader, you can use the reqwest::Body::new()
constructor.
let client = reqwest::Client::new().unwrap(); let res = client.post("http://httpbin.org/post") .body("the exact body that is sent") .send();
Forms
It's very common to want to send form data in a request body. This can be done with any type that can be serialized into form data.
This can be an array of tuples, or a HashMap
, or a custom type that
implements Serialize
.
// This will POST a body of `foo=bar&baz=quux` let params = [("foo", "bar"), ("baz", "quux")]; let client = reqwest::Client::new().unwrap(); let res = client.post("http://httpbin.org/post") .form(¶ms) .send();
JSON
There is also a json
method helper on the RequestBuilder
that works in
a similar fashion the form
method. It can take any value that can be
serialized into JSON.
// This will POST a body of `{"lang":"rust","body":"json"}` let mut map = HashMap::new(); map.insert("lang", "rust"); map.insert("body", "json"); let client = reqwest::Client::new().unwrap(); let res = client.post("http://httpbin.org/post") .json(&map) .send();
Modules
header |
Headers container, and common header fields. |
mime |
Re-exporting the mime crate, for convenience. |
Macros
try_ |
Structs
Body |
Body type for a request. |
Client |
A |
Error |
The Errors that may occur when processing a |
RedirectPolicy |
A type that controls the policy on how to handle the following of redirects. |
RequestBuilder |
A builder to construct the properties of a |
Response |
A Response to a submitted |
Url |
A parsed URL record. |
Enums
HttpVersion |
Represents a version of the HTTP spec. |
HyperError |
A set of errors that can occur parsing HTTP streams. |
Method |
The Request Method (VERB) |
StatusCode |
An HTTP status code ( |
UrlError |
Errors that can occur during parsing. |
Traits
IntoUrl |
A helper trait to convert common objects into a Url. |
Functions
get |
Shortcut method to quickly make a |
Type Definitions
Result |
A |