Actix-web for Rust: Complete Guide with Examples

What is Actix-web and why do you need it?

Actix-web is a powerful, pragmatic, and extremely fast web framework for the Rust programming language. It is built on the actor model (Actix library) and the Tokio async runtime. Actix-web allows you to create high-performance web applications and APIs capable of handling millions of requests per second.

Why use Actix-web?

• Performance: Actix-web consistently ranks among the top three fastest web frameworks in the world (according to TechEmpower benchmarks), outperforming solutions like Go net/http and Node.js Express.
• Safety: Rust guarantees memory safety at compile time, eliminating entire classes of vulnerabilities (buffer overflows, data races).
• Type safety: Thanks to Rust's strict type system, many errors (e.g., incorrect JSON format) are caught at compile time.
• Asynchronicity: Full support for async/await allows handling thousands of concurrent connections without creating a thread for each.
• Ecosystem: Actix-web integrates easily with other Rust crates: serde (serialization), sqlx/diesel (databases), reqwest (HTTP client).

Actix-web is ideal for: REST APIs, microservices, WebSocket servers, high-load web applications, proxy servers.

Installing Actix-web

Since Actix-web is a library for Rust, installation is done via the cargo package manager (analogous to pip for Python).

Step 1. Make sure you have Rust installed. Check with the command:

rustc --versioncargo --version

If Rust is not installed, download it from rustup.rs.

Step 2. Create a new project:

cargo new my_actix_appcd my_actix_app

Step 3. Add Actix-web to dependencies. Open the Cargo.toml file and add:

[dependencies]actix-web = "4"

Step 4. Install dependencies and build the project:

cargo build

Done! Now you can use Actix-web in your project.

Quick Start: "Hello, World!" with Actix-web

Let's create a simple web server that responds to GET requests.

Example 1: Minimal server

// main.rsuse actix_web::{get, App, HttpResponse, HttpServer, Responder};

#[get("/")]async fn hello() -> impl Responder {    HttpResponse::Ok().body("Hello, World!")}

#[actix_web::main]async fn main() -> std::io::Result<()> {    HttpServer::new(|| {        App::new()            .service(hello)    })    .bind(("127.0.0.1", 8080))?    .run()    .await}

Run: cargo run

Check: Open your browser at http://127.0.0.1:8080 or run:

curl http://127.0.0.1:8080

You will see the response: Hello, World!

Main Methods and Functions of Actix-web

Let's look at the key elements of the framework. For each, a description, parameters, and a working example are provided.

1. #[get("/path")] — macro for handling GET requests

What it does: Decorates an async function, turning it into a handler for HTTP GET requests at the specified path.

Parameters: Path (string), can contain dynamic segments (e.g., /{id}).

Example:

use actix_web::{get, HttpResponse, Responder};

#[get("/user/{id}")]async fn get_user(path: actix_web::web::Path<String>) -> impl Responder {    let user_id = path.into_inner();    HttpRespons