Axum — Ergonomic Modular Web Framework for Rust

What it is

Axum is a web application framework for Rust, built on top of Tokio (async runtime), Tower (middleware), and Hyper (HTTP). It differentiates itself from other Rust web frameworks through a macro-free routing API and type-safe extractors that leverage Rust's type system to parse request data at compile time.

The framework targets Rust developers building HTTP APIs, web services, and backend applications. Its tight integration with the Tower ecosystem means any Tower middleware or service works with Axum out of the box.

How it saves time or tokens

Axum eliminates boilerplate through its extractor pattern. Instead of manually parsing request bodies, query parameters, and headers, you declare them as function parameters and Axum handles deserialization. Compile-time type checking catches request parsing errors before runtime. The Tower middleware reuse means you do not write auth, logging, or rate-limiting from scratch.

How to use

1. Add axum and tokio to your Cargo.toml.
2. Define handler functions with typed extractors.
3. Build a router and start the server.

use axum::{routing::get, Router, extract::Query};
use serde::Deserialize;

#[derive(Deserialize)]
struct Params {
    name: String,
}

async fn greet(Query(params): Query<Params>) -> String {
    format!("Hello, {}!", params.name)
}

#[tokio::main]
async fn main() {
    let app = Router::new().route("/greet", get(greet));
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000")
        .await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

Example

// JSON request and response with validation
use axum::{routing::post, Json};
use serde::{Deserialize, Serialize};

#[derive(Deserialize)]
struct CreateUser { username: String, email: String }

#[derive(Serialize)]
struct User { id: u64, username: String }

async fn create_user(Json(payload): Json<CreateUser>) -> Json<User> {
    Json(User { id: 1, username: payload.username })
}

// Router
let app = Router::new().route("/users", post(create_user));

Related on TokRepo

• AI coding tools — Tools that help write and review Rust code with AI
• DevOps tools — Deploy and monitor Axum services in production

Common pitfalls

• Extractors run in the order of function parameters; putting a body extractor (Json) before a non-consuming extractor (Query) works, but using two body extractors in one handler causes a compile error.
• Forgetting to add .layer() for shared state means handlers cannot access your database pool or config.
• Axum requires exact path matching by default; trailing slashes cause 404s unless you add a fallback or normalize middleware.