Crate actix_web

Actix Web is a powerful, pragmatic, and extremely fast web framework for Rust.

Examples

use actix_web::{get, web, App, HttpServer, Responder};

#[get("/hello/{name}")]
async fn greet(name: web::Path<String>) -> impl Responder {
    format!("Hello {}!", name)
}

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

Documentation & Community Resources

In addition to this API documentation, several other resources are available:

• Website & User Guide
• Examples Repository
• Community Chat on Discord

To get started navigating the API docs, you may consider looking at the following pages first:

• App: This struct represents an Actix Web application and is used to configure routes and other common application settings.

• HttpServer: This struct represents an HTTP server instance and is used to instantiate and configure servers.

• web: This module provides essential types for route registration as well as common utilities for request handlers.

• HttpRequest and HttpResponse: These structs represent HTTP requests and responses and expose methods for creating, inspecting, and otherwise utilizing them.

Features

• Supports HTTP/1.x and HTTP/2
• Streaming and pipelining
• Powerful request routing with optional macros
• Full Tokio compatibility
• Keep-alive and slow requests handling
• Client/server WebSockets support
• Transparent content compression/decompression (br, gzip, deflate, zstd)
• Multipart streams
• Static assets
• SSL support using OpenSSL or Rustls
• Middlewares (Logger, Session, CORS, etc)
• Integrates with the awc HTTP client
• Runs on stable Rust 1.54+

Crate Features

• cookies - cookies support (enabled by default)
• macros - routing and runtime macros (enabled by default)
• compress-brotli - brotli content encoding compression support (enabled by default)
• compress-gzip - gzip and deflate content encoding compression support (enabled by default)
• compress-zstd - zstd content encoding compression support (enabled by default)
• openssl - HTTPS support via openssl crate, supports HTTP/2
• rustls - HTTPS support via rustls 0.20 crate, supports HTTP/2
• rustls-0_21 - HTTPS support via rustls 0.21 crate, supports HTTP/2
• rustls-0_22 - HTTPS support via rustls 0.22 crate, supports HTTP/2
• rustls-0_23 - HTTPS support via rustls 0.23 crate, supports HTTP/2
• secure-cookies - secure cookies support

Re-exports

• pub use crate::error::Error;
• pub use crate::error::ResponseError;

Modules

• body
  Traits and structures to aid consuming and writing HTTP payloads.
• cookie
  HTTP cookie parsing and cookie jar management.
• dev
  Lower-level types and re-exports.
• error
  Error and Result module
• guard
  Route guards.
• http
  Various HTTP related types.
• middleware
  A collection of common middleware.
• rt
  A selection of re-exports from tokio and actix-rt.
• test
  Various helpers for Actix applications to use during testing.
• web
  Essentials helper functions and types for application registration.

Macros

• services
  Macro to help register different types of services at the same time.

Structs

• App
  The top-level builder for an Actix Web application.
• CustomizeResponder
  Allows overriding status code and headers (including cookies) for a Responder.
• HttpRequest
  An incoming request.
• HttpResponse
  An outgoing response.
• HttpResponseBuilder
  An HTTP response builder.
• HttpServer
  An HTTP Server.
• Resource
  A collection of Routes that respond to the same path pattern.
• Route
  A request handler with guards.
• Scope
  A collection of Routes, Resources, or other services that share a common path prefix.

Enums

• Either
  Combines two extractor or responder types into a single type.

Traits

• FromRequest
  A type that implements FromRequest is called an extractor and can extract data from the request. Some types that implement this trait are: Json, Header, and Path.
• Handler
  The interface for request handlers.
• HttpMessage
  Trait that implements general purpose operations on HTTP messages.
• Responder
  Trait implemented by types that can be converted to an HTTP response.

Type Aliases

• Result
  A convenience Result for Actix Web operations.

Attribute Macros

• connect
  Creates route handler with actix_web::guard::Connect.
• delete
  Creates route handler with actix_web::guard::Delete.
• get
  Creates route handler with actix_web::guard::Get.
• head
  Creates route handler with actix_web::guard::Head.
• main
  Marks async main function as the Actix Web system entry-point.
• options
  Creates route handler with actix_web::guard::Options.
• patch
  Creates route handler with actix_web::guard::Patch.
• post
  Creates route handler with actix_web::guard::Post.
• put
  Creates route handler with actix_web::guard::Put.
• route
  Creates resource handler, allowing multiple HTTP method guards.
• routes
  Creates resource handler, allowing multiple HTTP methods and paths.
• scope
  Prepends a path prefix to all handlers using routing macros inside the attached module.
• test
  Marks async test functions to use the Actix Web system entry-point.
• trace
  Creates route handler with actix_web::guard::Trace.