Struct RateLimitConfig 

pub struct RateLimitConfig {
    pub max_requests: usize,
    pub window_secs: Duration,
    pub get_id: fn(req: &ServiceRequest) -> String,
    pub on_exceed: fn(id: &String, config: &RateLimitConfig, req: &ServiceRequest) -> HttpResponse,
}

Configuration for rate limiting middleware.

This struct contains all the parameters needed to configure rate limiting behavior, including request limits, time windows, and callback functions for client identification and rate limit exceeded handling.

Examples

use actix_web::HttpResponse;
use actix_web_ratelimit::config::RateLimitConfig;

// Basic configuration
let config = RateLimitConfig::default()
    .max_requests(100)
    .window_secs(3600);

// Advanced configuration with custom handlers
let config = RateLimitConfig::default()
    .max_requests(10)
    .window_secs(60)
    .id(|req| {
        // Custom client identification based on API key
        req.headers()
            .get("X-API-Key")
            .and_then(|h| h.to_str().ok())
            .unwrap_or("anonymous")
            .to_string()
    })
    .exceeded(|id, _config, _req| {
        // Custom rate limit exceeded response
        HttpResponse::TooManyRequests()
            .body(format!("Rate limit exceeded for client: {}", id))
    });

Fields

max_requests: usize

Maximum number of requests allowed within the time window

window_secs: Duration

Duration of the sliding time window

get_id: fn(req: &ServiceRequest) -> String

Function to extract client identifier from the request. Typically extracts IP address, but can be customized for API keys, user IDs, etc.

on_exceed: fn(id: &String, config: &RateLimitConfig, req: &ServiceRequest) -> HttpResponse

Function called when rate limit is exceeded. Receives the client ID, configuration, and request, returns the HTTP response.

Implementations

impl RateLimitConfig

pub fn max_requests(self, value: usize) -> Self

Sets the maximum number of requests allowed within the time window.

Arguments

• value - Maximum number of requests (must be > 0)

Example

use actix_web_ratelimit::config::RateLimitConfig;

let config = RateLimitConfig::default().max_requests(100);

pub fn window_secs(self, value: u64) -> Self

Sets the time window duration in seconds for the sliding window algorithm.

Arguments

• value - Time window duration in seconds

Example

use actix_web_ratelimit::config::RateLimitConfig;

// Allow 100 requests per hour
let config = RateLimitConfig::default()
    .max_requests(100)
    .window_secs(3600);

pub fn id(self, fn_id: fn(req: &ServiceRequest) -> String) -> Self

Sets a custom function to extract client identifier from requests.

By default, the middleware uses the client’s IP address as identifier. This method allows customization based on headers, authentication, etc.

Arguments

• fn_id - Function that takes a ServiceRequest and returns a client identifier string

Examples

use actix_web_ratelimit::config::RateLimitConfig;

// Rate limit by API key
let config = RateLimitConfig::default()
    .id(|req| {
        req.headers()
            .get("X-API-Key")
            .and_then(|h| h.to_str().ok())
            .unwrap_or("anonymous")
            .to_string()
    });

// Rate limit by custom header
let config = RateLimitConfig::default()
    .id(|req| {
        // Extract user ID from custom header
        req.headers()
            .get("X-User-ID")
            .and_then(|h| h.to_str().ok())
            .unwrap_or("guest")
            .to_string()
    });

pub fn exceeded( self, fn_exceed: fn(id: &String, config: &RateLimitConfig, req: &ServiceRequest) -> HttpResponse, ) -> Self

Sets a custom function to handle rate limit exceeded scenarios.

By default, returns HTTP 429 with “Too many requests” message. This method allows customization of the response format, headers, etc.

Arguments

• fn_exceed - Function that takes client ID, config, and request, returns HTTP response

Examples

use actix_web::HttpResponse;
use actix_web_ratelimit::config::RateLimitConfig;

// Custom error response with details
let config = RateLimitConfig::default()
    .exceeded(|id, config, _req| {
        HttpResponse::TooManyRequests()
            .body(format!(
                "Rate limit exceeded for client: {}. Limit: {} requests per {} seconds.",
                id,
                config.max_requests,
                config.window_secs.as_secs()
            ))
    });

// Custom headers and retry-after
let config = RateLimitConfig::default()
    .exceeded(|_id, config, _req| {
        HttpResponse::TooManyRequests()
            .append_header(("Retry-After", config.window_secs.as_secs()))
            .append_header(("X-RateLimit-Limit", config.max_requests))
            .body("Rate limit exceeded. Please try again later.")
    });

Trait Implementations

impl Clone for RateLimitConfig

fn clone(&self) -> RateLimitConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for RateLimitConfig

fn default() -> Self

Creates a default rate limiting configuration.

Default Values

• max_requests: 10 requests
• window_secs: 100 seconds
• get_id: Extracts real IP address from connection info
• on_exceed: Returns HTTP 429 “Too Many Requests” with plain text body

Example

use actix_web_ratelimit::config::RateLimitConfig;

let config = RateLimitConfig::default();
assert_eq!(config.max_requests, 10);