Enum RateLimitCategory

pub enum RateLimitCategory {
    Quote,
    Historical,
    Orders,
    Standard,
}

Rate limit categories based on official KiteConnect API documentation

KiteConnect API enforces different rate limits for different types of operations to ensure fair usage and system stability. Understanding these categories is crucial for building responsive applications that don’t hit rate limits.

Category Details

• Quote: Real-time market data (most restrictive at 1 req/sec)
• Historical: Historical market data (3 req/sec)
• Orders: Trading operations (10 req/sec)
• Standard: General operations (3 req/sec)

Rate Limit Enforcement

Rate limits are enforced using a token bucket algorithm where:

1. Each category has a bucket with a specific capacity
2. Tokens are consumed for each request
3. Tokens are refilled at the category’s rate
4. Requests wait when no tokens are available

Example

use kiteconnect_async_wasm::connect::endpoints::RateLimitCategory;

let category = RateLimitCategory::Quote;
assert_eq!(category.requests_per_second(), 1);

let category = RateLimitCategory::Orders;
assert_eq!(category.requests_per_second(), 10);

Variants

Quote

Quote endpoints: 1 request/second

Includes real-time market data endpoints like quotes, LTP, and OHLC. These have the most restrictive limits due to the high-frequency nature of market data and server load considerations.

Historical

Historical candle endpoints: 3 requests/second

Includes historical OHLC data endpoints. These limits balance the need for historical analysis with server resource management.

Orders

Order placement endpoints: 10 requests/second

Includes order placement, modification, and cancellation endpoints. Higher limits support active trading while preventing system abuse.

Standard

All other endpoints: 3 requests/second

Default category for portfolio, profile, and other general operations. Provides good throughput for typical application usage patterns.

Implementations

impl RateLimitCategory

pub fn requests_per_second(&self) -> u32

Get the rate limit for this category (requests per second)

Returns

The maximum number of requests allowed per second for this category

Example

use kiteconnect_async_wasm::connect::endpoints::RateLimitCategory;

assert_eq!(RateLimitCategory::Quote.requests_per_second(), 1);
assert_eq!(RateLimitCategory::Historical.requests_per_second(), 3);  
assert_eq!(RateLimitCategory::Orders.requests_per_second(), 10);
assert_eq!(RateLimitCategory::Standard.requests_per_second(), 3);

pub fn min_delay(&self) -> Duration

Get the minimum delay between requests for this category

Trait Implementations

impl Clone for RateLimitCategory

fn clone(&self) -> RateLimitCategory

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RateLimitCategory

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

Formats the value using the given formatter.

impl Hash for RateLimitCategory

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for RateLimitCategory

fn eq(&self, other: &RateLimitCategory) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for RateLimitCategory

impl StructuralPartialEq for RateLimitCategory