Struct RateLimiter

pub struct RateLimiter { /* private fields */ }

Rate limiter for KiteConnect API endpoints

This struct provides intelligent rate limiting for all KiteConnect API calls to ensure compliance with official API limits and prevent API key suspension.

Features

• Per-category limits: Different limits for quotes, historical data, orders, etc.
• Automatic delays: Inserts precise delays when limits would be exceeded
• Thread-safe: Supports concurrent requests from multiple threads
• Configurable: Can be enabled/disabled as needed
• Zero-overhead: Minimal performance impact when limits aren’t reached

Rate Limit Categories

Category	Limit (req/sec)	Endpoints
Quote	1	Real-time quotes, LTP, OHLC
Historical	3	Historical candle data
Orders	10	Order placement/modification
Standard	10	All other endpoints

Usage

The rate limiter is automatically integrated into KiteConnect and requires no manual configuration. It’s enabled by default and operates transparently.

Example

use kiteconnect_async_wasm::connect::rate_limiter::RateLimiter;
use kiteconnect_async_wasm::connect::endpoints::KiteEndpoint;

let rate_limiter = RateLimiter::new(true); // enabled

// Check if request can proceed immediately
let can_proceed = rate_limiter.can_request_immediately(&KiteEndpoint::Quote).await;
if can_proceed {
    println!("Request can be made immediately");
}

// Wait for rate limit compliance and make request
rate_limiter.wait_for_request(&KiteEndpoint::Quote).await;
println!("Request made with rate limiting");

Performance

• Fast path: When limits aren’t reached, overhead is ~1-2 microseconds
• Memory: Uses minimal memory (only active categories tracked)
• Scalability: Handles hundreds of concurrent requests efficiently

Implementations

impl RateLimiter

pub fn new(enabled: bool) -> Self

Create a new rate limiter

pub async fn wait_for_request(&self, endpoint: &KiteEndpoint)

Wait for rate limit compliance before making a request

This method will return immediately if no delay is needed, or will sleep for the required duration to comply with rate limits.

Arguments

• endpoint - The endpoint being accessed

Example

use kiteconnect_async_wasm::connect::{RateLimiter, KiteEndpoint};

let rate_limiter = RateLimiter::new(true);

// This will wait if needed to comply with rate limits
rate_limiter.wait_for_request(&KiteEndpoint::Quote).await;

// Now it's safe to make the API request
println!("Making quote request...");

pub async fn can_request_immediately(&self, endpoint: &KiteEndpoint) -> bool

Check if a request can be made without waiting

Returns true if the request can be made immediately, false if rate limiting would cause a delay.

pub async fn get_delay_for_request(&self, endpoint: &KiteEndpoint) -> Duration

Get the delay required before making a request

Returns Duration::ZERO if no delay is needed.

pub async fn get_stats(&self) -> RateLimiterStats

Get rate limiter statistics

Returns information about current rate limiter state for monitoring.

pub fn set_enabled(&mut self, enabled: bool)

Enable or disable rate limiting

pub fn is_enabled(&self) -> bool

Check if rate limiting is enabled

Trait Implementations

impl Clone for RateLimiter

fn clone(&self) -> RateLimiter

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RateLimiter

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for RateLimiter

fn default() -> Self

Returns the “default value” for a type.