How to Make an HTTP Request in Rust

By the end of this page, you will understand how HTTP requests are typically made in Rust, why the standard library does not include a full HTTP client, and how to use a crate such as reqwest to send requests, check status codes, and safely add URL-encoded query parameters.

Rust's standard library focuses on core building blocks such as strings, collections, file I/O, networking primitives, and concurrency. It does not provide a high-level HTTP client.

That means if you want to make HTTP requests in Rust, you usually use a community crate. The most common beginner-friendly choice is [reqwest], which provides a simple API for sending HTTP requests.

Why this matters

HTTP requests are used everywhere in real programs:

• calling APIs
• downloading files
• checking whether a service is online
• sending form data
• authenticating users

A good HTTP client should help you:

• build URLs safely
• send requests using methods like GET and POST
• inspect status codes such as 200 OK or 404 Not Found
• handle network errors cleanly

Key idea

In Rust, the usual workflow is:

1. Add an HTTP client crate to Cargo.toml
2. Send a request
3. Check the returned Response
4. Read the status code or body if needed

For URL encoding, you should avoid manually concatenating strings when query values may contain spaces, &, ?, or other special characters. Instead, use helper methods that encode parameters correctly for you.

Think of Rust's standard library as a basic toolbox.

It gives you essentials like:

• a hammer
• a screwdriver
• measuring tape

But an HTTP client is more like a specialized power tool. It is extremely useful, but not part of the smallest core set of tools.

So when you need to talk to a website or API, you reach for an external crate like reqwest.

For query parameters, imagine writing an address on a package. If the address contains spaces or special symbols, you need to format it correctly so the delivery system understands it. URL encoding does that formatting for web addresses.

The easiest way to make an HTTP request in Rust is with the reqwest crate.

Add the dependency

In Cargo.toml:

[dependencies]
reqwest = { version = "0.12", features = ["blocking"] }

The blocking feature is useful for simple scripts and beginner examples.

Simple GET request

use reqwest::blocking::get;
use std::error::Error;

fn main() -> Result<(), Box<dyn Error>> {
    let response = get("https://httpbin.org/status/200")?;

    println!("Status: {}", response.status());

    Ok(())
}

What this does

• get(...) sends a GET request
• it returns a Response

Consider this example:

use reqwest::blocking::Client;
use std::error::Error;

fn main() -> Result<(), Box<dyn Error>> {
    let client = Client::new();

    let response = client
        .get("https://httpbin.org/get")
        .query(&[("q", "rust language")])
        .send()?;

    println!("Status: {}", response.status());

    Ok(())
}

Here is what happens step by step:

1. Client::new() creates an HTTP client.
2. .get("https://httpbin.org/get") prepares a GET request.
3. .query(&[("q", "rust language")]) adds a query parameter.
   • Rust passes the key q
   • Rust passes the value rust language
   • reqwest URL-encodes the value safely

HTTP requests in Rust are common in many types of software.

API clients

A Rust service may call another API to fetch:

• user profiles
• payment status
• weather data
• shipping updates

Health checks

A monitoring script can send a request to a service endpoint and verify that it returns 200 OK.

Command-line tools

A CLI written in Rust might:

• test whether a URL is reachable
• verify a deployment endpoint
• query a web service

Data ingestion

A backend job can request data from a remote server, then process or store it.

Search and filtering

Applications often send query parameters such as:

• ?q=rust
• ?page=2
• ?sort=desc

Using a proper query builder avoids broken URLs and encoding bugs.

In real Rust codebases, developers usually avoid one-off string concatenation for URLs and instead use clients and helper methods.

Common patterns

Reuse a Client

Instead of calling a top-level get everywhere, many projects create a Client once and reuse it.

use reqwest::blocking::Client;

fn build_client() -> Client {
    Client::new()
}

This keeps code organized and is often more efficient.

Check status explicitly

if response.status().is_success() {
    println!("Request succeeded");
} else {
    println!("Request failed with status: {}", response.status());
}

Guard clauses for errors

use reqwest::blocking::get;
use std::error::Error;

fn check_url(url: &)  <(), < Error>> {
      = (url)?;

     !response.().() {
         ((, response.()).());
    }

    (())
}

Beginners often run into a few common problems when making HTTP requests in Rust.

1. Expecting HTTP support in the standard library

Rust's standard library does not include a high-level HTTP client.

Incorrect idea

// This kind of API does not exist in std
// let response = std::http::get("https://example.com");

Fix

Add a crate like reqwest in Cargo.toml.

2. Manually building query strings unsafely

Problem

let term = "rust language & web";
let url = format!("https://example.com/search?q={}", term);

This can produce an invalid or misleading URL because special characters are not encoded.

Better

let response = client
    .get("https://example.com/search")
    .query(&[("q", "rust language & web")])
    .send()?;

Here are some useful comparisons related to making HTTP requests in Rust.

[dependencies]
reqwest = { version = "0.12", features = ["blocking"] }

Simple request

let response = reqwest::blocking::get("https://example.com")?;
println!("{}", response.status());

Reusable client

let client = reqwest::blocking::Client::new();
let response = client.get("https://example.com").send()?;

Add query parameters safely

let response = client
    .get("https://example.com/search")
    .query(&[("q", "rust language"), ("page", "1")])
    .send()?;

Check status

Why doesn't Rust's standard library include HTTP requests?

Rust keeps the standard library relatively small and focused on core features. High-level HTTP support is usually provided by crates such as reqwest.

What crate should I use for HTTP requests in Rust?

For most beginners and many real projects, reqwest is the most common choice because it is ergonomic and well documented.

How do I check only the HTTP status code in Rust?

Send the request, get the Response, and call response.status().

How do I URL-encode query parameters in Rust?

The safest option is to use .query(...) with reqwest::Client, which encodes parameters for you.

Is 404 Not Found returned as a Rust error?

Usually no. A 404 is often a valid HTTP response, so you need to inspect the status code yourself.

Should I use blocking or async reqwest?

Use blocking for simple scripts and learning. Use async reqwest when working inside an async application.

• Rust crates — HTTP functionality usually comes from external crates rather than the standard library.
• Result and error handling — HTTP requests can fail due to networking, invalid URLs, or timeouts.
• Ownership and borrowing — useful when passing URLs, clients, and query values around functions.
• Async programming in Rust — relevant when using the async version of reqwest.
• Serialization with Serde — often used when sending or parsing JSON in HTTP requests.
• TCP networking — HTTP is built on lower-level network communication.
• Status codes — important for understanding what the server response means.
• URL encoding — necessary for safely placing user input into query strings.