Struct KiteConnect

pub struct KiteConnect { /* private fields */ }

Main client for interacting with the KiteConnect API

This struct provides async methods for all KiteConnect REST API endpoints. It handles authentication, request formatting, and response parsing automatically.

Thread Safety

KiteConnect implements Clone + Send + Sync, making it safe to use across multiple threads and async tasks. The underlying HTTP client uses connection pooling for optimal performance.

Example

use kiteconnect::connect::KiteConnect;
 
// Create a new client
let mut client = KiteConnect::new("your_api_key", "");
 
// Set access token (usually done via generate_session)
client.set_access_token("your_access_token");
 
// Use the API
let holdings = client.holdings().await?;
println!("Holdings: {:?}", holdings);

Cloning for Concurrent Use

use kiteconnect::connect::KiteConnect;
 
let client = KiteConnect::new("api_key", "access_token");
 
// Clone for use in different tasks
let client1 = client.clone();
let client2 = client.clone();
 
// Fetch data concurrently
let (holdings, positions) = tokio::try_join!(
    client1.holdings(),
    client2.positions()
)?;

Implementations

impl KiteConnect

pub fn new(api_key: &str, access_token: &str) -> Self

Creates a new KiteConnect client instance

Arguments

• api_key - Your KiteConnect API key
• access_token - Access token (can be empty string if using generate_session)

Example

use kiteconnect::connect::KiteConnect;
 
// Create client for authentication flow
let mut client = KiteConnect::new("your_api_key", "");
 
// Or create with existing access token
let client = KiteConnect::new("your_api_key", "your_access_token");

pub fn set_session_expiry_hook(&mut self, method: fn())

Sets a session expiry callback hook for this instance

This hook will be called when a session expires, allowing you to handle re-authentication or cleanup logic.

Arguments

• method - Callback function to execute on session expiry

Example

use kiteconnect::connect::KiteConnect;
 
fn handle_session_expiry() {
    println!("Session expired! Please re-authenticate.");
}
 
let mut client = KiteConnect::new("api_key", "access_token");
client.set_session_expiry_hook(handle_session_expiry);

pub fn session_expiry_hook(&self) -> Option<fn()>

Gets the current session expiry hook

Returns the session expiry callback function if one has been set.

Returns

Option<fn() -> ()> - The callback function, or None if not set

pub fn set_access_token(&mut self, access_token: &str)

Sets the access token for authenticated API requests

This is typically called automatically by generate_session, but can be used manually if you have a pre-existing access token.

Arguments

• access_token - The access token string

Example

use kiteconnect::connect::KiteConnect;
 
let mut client = KiteConnect::new("api_key", "");
client.set_access_token("your_access_token");

pub fn access_token(&self) -> &str

Gets the access token for this instance

pub fn login_url(&self) -> String

Generates the KiteConnect login URL for user authentication

This URL should be opened in a browser to allow the user to log in to their Zerodha account. After successful login, the user will be redirected to your redirect URL with a request_token parameter.

Returns

A login URL string that can be opened in a browser

Example

use kiteconnect::connect::KiteConnect;
 
let client = KiteConnect::new("your_api_key", "");
let login_url = client.login_url();
 
println!("Please visit: {}", login_url);
// User visits URL, logs in, and is redirected with request_token

Authentication Flow

1. Generate login URL with this method
2. Direct user to the URL in a browser
3. User completes login and is redirected with request_token
4. Use generate_session() with the request token to get access token

pub async fn generate_session( &mut self, request_token: &str, api_secret: &str, ) -> Result<JsonValue>

Generates an access token using the request token from login

This method completes the authentication flow by exchanging the request token (obtained after user login) for an access token that can be used for API calls. The access token is automatically stored in the client instance.

Arguments

• request_token - The request token received after user login
• api_secret - Your KiteConnect API secret

Returns

A Result<JsonValue> containing the session information including access token

Errors

Returns an error if:

• The request token is invalid or expired
• The API secret is incorrect
• Network request fails
• Response parsing fails

Example

use kiteconnect::connect::KiteConnect;
 
let mut client = KiteConnect::new("your_api_key", "");
 
// After user completes login and you receive the request_token
let session_data = client
    .generate_session("request_token_from_callback", "your_api_secret")
    .await?;
 
println!("Session created: {:?}", session_data);
// Access token is now automatically set in the client

Authentication Flow

1. Call login_url() to get login URL
2. User visits URL and completes login
3. User is redirected with request_token parameter
4. Call this method with the request token and API secret
5. Access token is automatically set for subsequent API calls

pub async fn invalidate_access_token( &self, access_token: &str, ) -> Result<Response>

Invalidates the access token

pub async fn renew_access_token( &mut self, access_token: &str, api_secret: &str, ) -> Result<JsonValue>

Request for new access token

pub async fn invalidate_refresh_token( &self, refresh_token: &str, ) -> Result<Response>

Invalidates the refresh token

pub async fn margins(&self, segment: Option<String>) -> Result<JsonValue>

Retrieves account balance and margin details

Returns margin information for trading segments including available cash, used margins, and available margins for different product types.

Arguments

• segment - Optional trading segment (“equity” or “commodity”). If None, returns all segments

Returns

A Result<JsonValue> containing margin data with fields like:

• available - Available margin for trading
• utilised - Currently utilized margin
• net - Net available margin
• enabled - Whether the segment is enabled

Errors

Returns an error if the API request fails or the user is not authenticated.

Example

use kiteconnect::connect::KiteConnect;
 
let client = KiteConnect::new("api_key", "access_token");
 
// Get margins for all segments
let all_margins = client.margins(None).await?;
println!("All margins: {:?}", all_margins);
 
// Get margins for specific segment
let equity_margins = client.margins(Some("equity".to_string())).await?;
println!("Equity available margin: {}", 
    equity_margins["data"]["available"]["live_balance"]);

pub async fn profile(&self) -> Result<JsonValue>

Get user profile details

pub async fn holdings(&self) -> Result<JsonValue>

Retrieves the user’s holdings (stocks held in demat account)

Holdings represent stocks that are held in the user’s demat account. This includes information about quantity, average price, current market value, profit/loss, and more.

Returns

A Result<JsonValue> containing holdings data with fields like:

• tradingsymbol - Trading symbol of the instrument
• quantity - Total quantity held
• average_price - Average buying price
• last_price - Current market price
• pnl - Profit and loss
• product - Product type (CNC, MIS, etc.)

Errors

Returns an error if the API request fails or the user is not authenticated.

Example

use kiteconnect::connect::KiteConnect;
 
let client = KiteConnect::new("api_key", "access_token");
 
let holdings = client.holdings().await?;
println!("Holdings: {:?}", holdings);
 
// Access specific fields
if let Some(data) = holdings["data"].as_array() {
    for holding in data {
        println!("Symbol: {}, Quantity: {}", 
            holding["tradingsymbol"], holding["quantity"]);
    }
}

pub async fn positions(&self) -> Result<JsonValue>

Retrieves the user’s positions (open positions for the day)

Positions represent open trading positions for the current trading day. This includes both intraday and carry-forward positions with details about profit/loss, margin requirements, and position status.

Returns

A Result<JsonValue> containing positions data with fields like:

• tradingsymbol - Trading symbol of the instrument
• quantity - Net position quantity
• buy_quantity - Total buy quantity
• sell_quantity - Total sell quantity
• average_price - Average position price
• pnl - Realized and unrealized P&L
• product - Product type (MIS, CNC, NRML)

Errors

Returns an error if the API request fails or the user is not authenticated.

Example

use kiteconnect::connect::KiteConnect;
 
let client = KiteConnect::new("api_key", "access_token");
 
let positions = client.positions().await?;
println!("Positions: {:?}", positions);
 
// Check for open positions
if let Some(day_positions) = positions["data"]["day"].as_array() {
    for position in day_positions {
        if position["quantity"].as_i64().unwrap_or(0) != 0 {
            println!("Open position: {} qty {}", 
                position["tradingsymbol"], position["quantity"]);
        }
    }
}

pub async fn place_order( &self, variety: &str, exchange: &str, tradingsymbol: &str, transaction_type: &str, quantity: &str, product: Option<&str>, order_type: Option<&str>, price: Option<&str>, validity: Option<&str>, disclosed_quantity: Option<&str>, trigger_price: Option<&str>, squareoff: Option<&str>, stoploss: Option<&str>, trailing_stoploss: Option<&str>, tag: Option<&str>, ) -> Result<JsonValue>

Place an order

pub async fn modify_order( &self, order_id: &str, variety: &str, quantity: Option<&str>, price: Option<&str>, order_type: Option<&str>, validity: Option<&str>, disclosed_quantity: Option<&str>, trigger_price: Option<&str>, parent_order_id: Option<&str>, ) -> Result<JsonValue>

Modify an open order

pub async fn cancel_order( &self, order_id: &str, variety: &str, parent_order_id: Option<&str>, ) -> Result<JsonValue>

Cancel an order

pub async fn exit_order( &self, order_id: &str, variety: &str, parent_order_id: Option<&str>, ) -> Result<JsonValue>

Exit a BO/CO order

pub async fn orders(&self) -> Result<JsonValue>

Retrieves a list of all orders for the current trading day

Returns all orders placed by the user for the current trading day, including pending, completed, rejected, and cancelled orders.

Returns

A Result<JsonValue> containing orders data with fields like:

• order_id - Unique order identifier
• tradingsymbol - Trading symbol
• quantity - Order quantity
• price - Order price
• status - Order status (OPEN, COMPLETE, CANCELLED, REJECTED)
• order_type - Order type (MARKET, LIMIT, SL, SL-M)
• product - Product type (MIS, CNC, NRML)

Errors

Returns an error if the API request fails or the user is not authenticated.

Example

use kiteconnect::connect::KiteConnect;
 
let client = KiteConnect::new("api_key", "access_token");
 
let orders = client.orders().await?;
println!("Orders: {:?}", orders);
 
// Check order statuses
if let Some(data) = orders["data"].as_array() {
    for order in data {
        println!("Order {}: {} - {}", 
            order["order_id"], 
            order["tradingsymbol"], 
            order["status"]);
    }
}

pub async fn order_history(&self, order_id: &str) -> Result<JsonValue>

Get the list of order history

pub async fn trades(&self) -> Result<JsonValue>

Get all trades

pub async fn order_trades(&self, order_id: &str) -> Result<JsonValue>

Get all trades for a specific order

pub async fn convert_position( &self, exchange: &str, tradingsymbol: &str, transaction_type: &str, position_type: &str, quantity: &str, old_product: &str, new_product: &str, ) -> Result<JsonValue>

Modify an open position product type

pub async fn mf_orders(&self, order_id: Option<&str>) -> Result<JsonValue>

Get all mutual fund orders or individual order info

pub async fn trigger_range( &self, transaction_type: &str, instruments: Vec<&str>, ) -> Result<JsonValue>

Get the trigger range for a list of instruments

pub async fn instruments(&self, exchange: Option<&str>) -> Result<JsonValue>

Get instruments list

pub async fn mf_instruments(&self) -> Result<JsonValue>

Get mutual fund instruments list

Trait Implementations

impl Clone for KiteConnect

fn clone(&self) -> KiteConnect

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for KiteConnect

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

Formats the value using the given formatter.

impl Default for KiteConnect

fn default() -> Self

Returns the “default value” for a type.