Unlocking the Power of Rust: A Beginner’s Guide to Reqwest

Rust, the modern equivalent of C, has taken the programming world by storm. Its strong open-source community has made it a viable option for full-stack applications. With its boundless potential comes the need for seamless data connections. But how do we request data from external sources?

Introducing Reqwest: The HTTP Library for Rust

Reqwest is a powerful library built for fetching resources using the HTTP protocol. It offers a simplified API for making GET and POST requests, along with a fully-featured Client module for applying headers, cookies, and redirect policies. Reqwest follows Rust’s async protocol, making it efficient and easy to use.

Building a Spotify Search Client with Reqwest

Let’s create a simple search client using the Spotify API. We’ll skip the official authentication flow for simplicity, but you can grab a sample API token to follow along. Our project will involve making basic GET requests, authenticating with headers, and serializing JSON responses into usable structs.

Making Our First GET Request

Create a new project with Cargo and add the required dependencies to your cargo.toml file. Then, let’s call one of Spotify’s API endpoints:
rust
let res = reqwest::get("https://api.spotify.com/v1/search/tracks?q=hello").await?;

Matching on StatusCode

We’ll likely want to branch off to different behavior depending on the response. We can match on the request’s StatusCode for this:
rust
match res.status() {
StatusCode::OK => println!("Received a 200 status response!"),
StatusCode::UNAUTHORIZED => println!("Authentication failed!"),
_ => println!("Something went wrong!"),
}

Specifying Content Types as Headers

Let’s add some headers to our query:
rust
let client = reqwest::Client::new();
let res = client
.get("https://api.spotify.com/v1/search/tracks?q=hello")
.header("Content-Type", "application/json")
.header("Accept", "application/json")
.header("Authorization", format!("Bearer {}", AUTH_TOKEN))
.send()
.await?;

Deserializing to JSON

Now we’ve received our search results. How can we turn this into a useful data structure? Let’s model the data we want to receive using nested structs and serialize the response using Serde:
“`rust

[derive(Deserialize)]

struct ApiResponse {
tracks: Vec,
}

[derive(Deserialize)]

struct Track {
id: String,
name: String,
artist: String,
}
“`
Creating a CLI Client

Let’s massage this data into something human-readable:
“`rust
fn print_tracks(tracks: Vec) {
for track in tracks {
println!(“{} by {}”, track.name, track.artist);
}
}

fn main() {
let query = std::env::args().nth(1).unwrap();
let res = client
.get(&format!(“https://api.spotify.com/v1/search/tracks?q={}”, query))
.header(“Content-Type”, “application/json”)
.header(“Accept”, “application/json”)
.header(“Authorization”, format!(“Bearer {}”, AUTH_TOKEN))
.send()
.await?;

match res.status() {
    StatusCode::OK => {
        let api_response: ApiResponse = res.json().await?;
        print_tracks(api_response.tracks);
    }
    _ => println!("Something went wrong!"),
}

}
“`
Conclusion

This tutorial showcased the power and simplicity of the Reqwest library. With its async protocol and simplified API, Reqwest makes it easy to request data from external sources. Whether you’re building a full-stack application or a simple CLI client, Reqwest is the perfect tool for the job.