rust's powerful actor system and most fun web framework

Type Safe

Forget about stringly typed objects, from request to response, everything has types.

Feature Rich

Actix provides a lot of features out of box. WebSockets, HTTP/2, pipelining etc.


Easily create your own libraries that any Actix application can use.

Blazingly Fast

Actix is blazingly fast. Don't take our word for it -- see for yourself!

extern crate actix_web;
use actix_web::{server, App, HttpRequest, Responder};

fn greet(req: &HttpRequest) -> impl Responder {
    let to = req.match_info().get("name").unwrap_or("World");
    format!("Hello {}!", to)

fn main() {
    server::new(|| {
            .resource("/", |r| r.f(greet))
            .resource("/{name}", |r| r.f(greet))
    .expect("Can not bind to port 8000")

Flexible Responders

Handler functions in actix can return a wide range of objects that implement the Responder trait. This makes it a breeze to return consistent responses from your APIs.

struct Measurement {
    temperature: f32,

fn hello_world() -> impl Responder {
    "Hello World!"

fn current_temperature(_req: HttpRequest) -> impl Responder {
    Json(Measurement { temperature: 42.3 })

Powerful Extractors

Actix comes with a powerful extractor system that extracts data from the incoming HTTP request and passes it to your view functions. Not only does this make for a convenient API but it also means that your view functions can be synchronous code and still benefit from asynchronous IO handling.

struct Event {
    timestamp: f64,
    kind: String,
    tags: Vec<String>,

fn capture_event(evt: Json<Event>) -> impl Responder {
    let id = store_event_in_db(evt.timestamp, evt.kind, evt.tags);
    format!("got event {}", id)

Easy Form Handling

Handling multipart/urlencoded form data is easy. Just define a structure that can be deserialized and actix will handle the rest.

struct Register {
    username: String,
    country: String,

fn register(data: Form<Register>) -> impl Responder {
    format!("Hello {} from {}!", data.username,

Request Routing

An actix app comes with a URL routing system that lets you match on URLs and invoke individual handlers. For extra flexibility, scopes can be used.

fn index(req: HttpRequest) -> impl Responder {
    "Hello from the index page"

fn hello(path: Path<String>) -> impl Responder {
    format!("Hello {}!", *path)

fn main() {
        .resource("/", |r| r.method(Method::GET).with(index))
        .resource("/hello/{name}", |r| r.method(Method::GET).with(hello))