Struct DhanClient 

pub struct DhanClient { /* private fields */ }

Core HTTP client for the DhanHQ REST API v2.

Wraps reqwest::Client and injects the required authentication headers into every request. Header values are validated at request time so public credential input cannot panic during client construction or token rotation.

Example

use dhan_rs::client::DhanClient;

let client = DhanClient::new("1000000001", "your-access-token");
// client.get::<MyResponse>("/v2/orders").await?;

Implementations

impl DhanClient

pub async fn generate_access_token( client_id: &str, pin: &str, totp: &str, ) -> Result<TokenResponse>

Generate an access token using client credentials and TOTP.

Requires TOTP to be enabled on the Dhan account.

Endpoint: POST https://auth.dhan.co/app/generateAccessToken

Arguments

• client_id — The Dhan Client ID.
• pin — 6-digit Dhan PIN.
• totp — 6-digit TOTP code from an authenticator app.

Example

let client = DhanClient::new("1000000001", "");
let token = DhanClient::generate_access_token("1000000001", "123456", "654321").await?;
println!("Access token: {}", token.access_token);

pub async fn renew_token(&mut self) -> Result<TokenResponse>

Renew the current access token for another 24 hours.

Only works for tokens generated from Dhan Web that are still active. This expires the current token and returns a new one.

Endpoint: GET /v2/RenewToken

Note

The RenewToken endpoint uses dhanClientId as its client identification header, unlike most other endpoints that use client-id. This method handles the difference automatically.

pub async fn generate_consent( client_id: &str, app_id: &str, app_secret: &str, ) -> Result<AppConsentResponse>

Step 1: Generate a consent session for API key-based login.

Validates the app_id and app_secret and creates a new session.

Endpoint: POST https://auth.dhan.co/app/generate-consent?client_id={dhanClientId}

Returns an AppConsentResponse containing a consent_app_id to be used in the browser redirect step.

pub fn consent_login_url(consent_app_id: &str) -> String

Step 2: Build the browser login URL for user consent.

Open this URL in a browser. After the user authenticates, they will be redirected to the redirect URL configured for the API key, with a tokenId query parameter appended.

use dhan_rs::DhanClient;
let url = DhanClient::consent_login_url("940b0ca1-3ff4-4476-b46e-03a3ce7dc55d");
// → "https://auth.dhan.co/login/consentApp-login?consentAppId=940b0ca1-..."

pub async fn consume_consent( token_id: &str, app_id: &str, app_secret: &str, ) -> Result<TokenResponse>

Step 3: Consume the consent to obtain an access token.

Uses the token_id obtained from the browser redirect after the user logged in.

Endpoint: POST https://auth.dhan.co/app/consumeApp-consent?tokenId={tokenId}

pub async fn partner_generate_consent( partner_id: &str, partner_secret: &str, ) -> Result<PartnerConsentResponse>

Step 1 (Partner): Generate a partner consent session.

Endpoint: POST https://auth.dhan.co/partner/generate-consent

pub fn partner_consent_login_url(consent_id: &str) -> String

Step 2 (Partner): Build the browser login URL for partner consent.

Open this URL in a browser. After the user authenticates, they will be redirected with a tokenId query parameter.

pub async fn partner_consume_consent( token_id: &str, partner_id: &str, partner_secret: &str, ) -> Result<TokenResponse>

Step 3 (Partner): Consume the partner consent to obtain an access token.

Endpoint: POST https://auth.dhan.co/partner/consume-consent?tokenId={tokenId}

impl DhanClient

pub async fn place_multi_order( &self, req: &MultiOrderRequest, ) -> Result<MultiOrderResponse>

Place multiple orders without an alert condition.

Endpoint: POST /v2/alerts/multi/orders

pub async fn place_conditional_trigger( &self, req: &ConditionalTriggerRequest, ) -> Result<ConditionalTriggerResponse>

Place a new conditional trigger.

Endpoint: POST /v2/alerts/orders

pub async fn modify_conditional_trigger( &self, alert_id: &str, req: &ConditionalTriggerRequest, ) -> Result<ConditionalTriggerResponse>

Modify an existing conditional trigger.

Endpoint: PUT /v2/alerts/orders/{alertId}

pub async fn delete_conditional_trigger( &self, alert_id: &str, ) -> Result<ConditionalTriggerResponse>

Delete a conditional trigger.

Endpoint: DELETE /v2/alerts/orders/{alertId}

pub async fn get_conditional_trigger( &self, alert_id: &str, ) -> Result<ConditionalTriggerDetail>

Get a specific conditional trigger by its ID.

Endpoint: GET /v2/alerts/orders/{alertId}

pub async fn get_all_conditional_triggers( &self, ) -> Result<Vec<ConditionalTriggerDetail>>

Get all conditional triggers.

Endpoint: GET /v2/alerts/orders

impl DhanClient

pub async fn get_rolling_option_data( &self, req: &RollingOptionRequest, ) -> Result<RollingOptionResponse>

Fetch continuous expired-option chart data.

Endpoint: POST /v2/charts/rollingoption

pub async fn get_technical_metrics( &self, req: &TechnicalMetricsRequest, ) -> Result<TechnicalMetricsResponse>

Fetch point-in-time technical indicators for the latest closed candle.

Endpoint: POST /v2/data/technical

pub async fn get_market_movers( &self, req: &MarketMoversRequest, ) -> Result<MarketMoversResponse>

Fetch instruments ranked by OI, volume, or price movement.

Endpoint: POST /v2/data/marketmovers

pub async fn get_company_info( &self, req: &CompanyInfoRequest, ) -> Result<CompanyInfoResponse>

Fetch selected company overview, ratio, or shareholding sections.

Endpoint: POST /v2/data/companyinfo

impl DhanClient

pub async fn generate_tpin(&self) -> Result<()>

Generate a T-PIN on the user’s registered mobile number.

Returns 202 Accepted on success.

Endpoint: GET /v2/edis/tpin

pub async fn generate_edis_form( &self, req: &EdisFormRequest, ) -> Result<EdisFormResponse>

Generate an eDIS form for CDSL T-PIN entry.

Endpoint: POST /v2/edis/form

pub async fn generate_bulk_edis_form( &self, req: &EdisBulkFormRequest, ) -> Result<EdisFormResponse>

Generate one eDIS form for multiple ISINs.

Endpoint: POST /v2/edis/bulkform

pub async fn inquire_edis(&self, isin: &str) -> Result<EdisInquiry>

Inquire the eDIS status for a stock by ISIN.

Pass "ALL" as the ISIN to get status of all holdings.

Endpoint: GET /v2/edis/inquire/{isin}

impl DhanClient

pub async fn create_forever_order( &self, req: &CreateForeverOrderRequest, ) -> Result<OrderResponse>

Create a new forever order.

Endpoint: POST /v2/forever/orders

pub async fn modify_forever_order( &self, order_id: &str, req: &ModifyForeverOrderRequest, ) -> Result<OrderResponse>

Modify an existing forever order.

Endpoint: PUT /v2/forever/orders/{order-id}

pub async fn delete_forever_order( &self, order_id: &str, ) -> Result<OrderResponse>

Delete a pending forever order.

Endpoint: DELETE /v2/forever/orders/{order-id}

pub async fn get_all_forever_orders(&self) -> Result<Vec<ForeverOrderDetail>>

Retrieve all existing forever orders.

Endpoint: GET /v2/forever/all

pub async fn get_all_forever_orders_openapi( &self, ) -> Result<Vec<ForeverOrderDetail>>

Retrieve all forever orders using the route in Dhan’s linked OpenAPI.

Dhan’s HTML endpoint example currently uses /v2/forever/all, exposed by Self::get_all_forever_orders, while its summary and linked OpenAPI use this /v2/forever/orders route. Both are explicit so the caller can select the contract available to its account/environment.

Endpoint: GET /v2/forever/orders

impl DhanClient

pub async fn calculate_margin( &self, req: &MarginCalculatorRequest, ) -> Result<MarginCalculatorResponse>

Calculate margin requirement for a single order.

Endpoint: POST /v2/margincalculator

pub async fn calculate_multi_margin( &self, req: &MultiMarginRequest, ) -> Result<MultiMarginResponse>

Calculate margin requirements for multiple scripts in a single request.

Endpoint: POST /v2/margincalculator/multi

pub async fn get_fund_limit(&self) -> Result<FundLimit>

Retrieve fund limits for the trading account.

Returns balance, margin utilised, collateral, and other fund details.

Endpoint: GET /v2/fundlimit

impl DhanClient

pub async fn get_global_stock_orders(&self) -> Result<Vec<GlobalStockOrder>>

Retrieve all Global Stocks orders.

Endpoint: GET /v2/globalstocks/orders

pub async fn place_global_stock_order( &self, request: &GlobalStockOrderRequest, ) -> Result<GlobalStockOrderStatusResponse>

Place a Global Stocks order.

Endpoint: POST /v2/globalstocks/orders

pub async fn get_global_stock_order( &self, order_id: &str, ) -> Result<GlobalStockOrder>

Retrieve a Global Stocks order by ID.

Endpoint: GET /v2/globalstocks/orders/{order-id}

pub async fn modify_global_stock_order( &self, order_id: &str, request: &GlobalStockModifyOrderRequest, ) -> Result<GlobalStockOrderStatusResponse>

Modify a Global Stocks order.

Endpoint: PUT /v2/globalstocks/orders/{order-id}

pub async fn cancel_global_stock_order( &self, order_id: &str, ) -> Result<GlobalStockOrderStatusResponse>

Cancel a Global Stocks order.

Endpoint: DELETE /v2/globalstocks/orders/{order-id}

pub async fn estimate_global_stock_order( &self, request: &GlobalStockEstimatorRequest, ) -> Result<GlobalStockEstimatorResponse>

Estimate charges for a Global Stocks transaction.

Endpoint: POST /v2/globalstocks/transEstimate

pub async fn calculate_global_stock_margin( &self, request: &GlobalStockEstimatorRequest, ) -> Result<GlobalStockMarginResponse>

Calculate Global Stocks margin requirements.

Endpoint: POST /v2/globalstocks/margincalculator

pub async fn get_global_stock_trades(&self) -> Result<Vec<GlobalStockTrade>>

Retrieve all Global Stocks trades.

Endpoint: GET /v2/globalstocks/trades

pub async fn get_global_stock_trades_for_security( &self, security_id: &str, ) -> Result<Vec<GlobalStockTrade>>

Retrieve Global Stocks trades for one security.

Endpoint: GET /v2/globalstocks/trades/{security-id}

pub async fn get_global_stock_market_status( &self, ) -> Result<GlobalStockMarketStatus>

Retrieve Global Stocks market status.

Endpoint: GET /v2/globalstocks/marketstatus

pub async fn get_global_stock_holdings(&self) -> Result<Vec<GlobalStockHolding>>

Retrieve Global Stocks holdings.

Endpoint: GET /v2/globalstocks/holdings

pub async fn get_global_stock_fund_limit(&self) -> Result<GlobalStockFundLimit>

Retrieve Global Stocks cash and margin limits.

Endpoint: GET /v2/globalstocks/fundlimit

impl DhanClient

pub async fn get_daily_historical( &self, req: &HistoricalDataRequest, ) -> Result<CandleData>

Retrieve daily OHLCV candle data for an instrument.

Data is available back to the instrument’s inception date.

Endpoint: POST /v2/charts/historical

pub async fn get_intraday_historical( &self, req: &IntradayDataRequest, ) -> Result<CandleData>

Retrieve intraday OHLCV candle data for an instrument.

Supports 1, 5, 15, 25, and 60-minute intervals. Only 90 days of data can be polled per request.

Endpoint: POST /v2/charts/intraday

impl DhanClient

pub async fn download_compact_instruments_csv() -> Result<Bytes>

Download Dhan’s compact all-segment instrument master as raw CSV bytes.

pub async fn download_detailed_instruments_csv() -> Result<Bytes>

Download Dhan’s detailed all-segment instrument master as raw CSV bytes.

pub async fn download_segment_instruments_csv( &self, segment: InstrumentSegment, ) -> Result<Bytes>

Download the detailed instrument CSV for one exchange segment.

Endpoint: GET /v2/instrument/{exchangeSegment}

impl DhanClient

pub async fn set_ip(&self, req: &SetIpRequest) -> Result<IpSetResponse>

Set a primary or secondary static IP for the account.

Once set, the IP cannot be modified for the next 7 days.

Endpoint: POST /v2/ip/setIP

Example

let client = DhanClient::new("1000000001", "your-access-token");
let req = SetIpRequest {
    dhan_client_id: "1000000001".into(),
    ip: "10.200.10.10".into(),
    ip_flag: IpFlag::PRIMARY,
};
let resp = client.set_ip(&req).await?;
println!("{}: {}", resp.status, resp.message);

pub async fn modify_ip(&self, req: &SetIpRequest) -> Result<IpSetResponse>

Modify a previously set primary or secondary static IP.

Can only be used when IP modification is allowed (once every 7 days).

Endpoint: PUT /v2/ip/modifyIP

pub async fn get_ip(&self) -> Result<IpInfo>

Get the currently configured static IPs and their modification dates.

Endpoint: GET /v2/ip/getIP

Example

let client = DhanClient::new("1000000001", "your-access-token");
let info = client.get_ip().await?;
if let Some(ip) = &info.primary_ip {
    println!("Primary IP: {ip}");
}

impl DhanClient

pub async fn get_ltp( &self, instruments: &MarketQuoteRequest, ) -> Result<MarketQuoteResponse<TickerData>>

Retrieve LTP (Last Traded Price) for a list of instruments.

Up to 1000 instruments per request (rate limit: 1 req/sec).

Endpoint: POST /v2/marketfeed/ltp

pub async fn get_ohlc( &self, instruments: &MarketQuoteRequest, ) -> Result<MarketQuoteResponse<OhlcData>>

Retrieve OHLC + LTP for a list of instruments.

Up to 1000 instruments per request (rate limit: 1 req/sec).

Endpoint: POST /v2/marketfeed/ohlc

pub async fn get_quote( &self, instruments: &MarketQuoteRequest, ) -> Result<MarketQuoteResponse<QuoteData>>

Retrieve full market depth (quote) data for a list of instruments.

Includes depth, OHLC, OI, volume and circuit limits. Up to 1000 instruments per request (rate limit: 1 req/sec).

Endpoint: POST /v2/marketfeed/quote

impl DhanClient

pub async fn get_option_chain( &self, req: &OptionChainRequest, ) -> Result<OptionChainResponse>

Retrieve real-time Option Chain for a given underlying and expiry.

Returns OI, Greeks, Volume, LTP, Best Bid/Ask and IV across all strikes.

Rate limit: 1 unique request every 3 seconds.

Endpoint: POST /v2/optionchain

pub async fn get_expiry_list( &self, req: &ExpiryListRequest, ) -> Result<ExpiryListResponse>

Retrieve all active expiry dates for an underlying instrument.

Rate limit: 1 unique request every 3 seconds.

Endpoint: POST /v2/optionchain/expirylist

impl DhanClient

pub async fn place_order( &self, req: &PlaceOrderRequest, ) -> Result<OrderResponse>

Place a new order.

Endpoint: POST /v2/orders

pub async fn modify_order( &self, order_id: &str, req: &ModifyOrderRequest, ) -> Result<OrderResponse>

Modify a pending order.

Endpoint: PUT /v2/orders/{order-id}

pub async fn cancel_order(&self, order_id: &str) -> Result<OrderResponse>

Cancel a pending order.

Endpoint: DELETE /v2/orders/{order-id}

pub async fn slice_order( &self, req: &PlaceOrderRequest, ) -> Result<Vec<OrderResponse>>

Slice an order into multiple legs (for quantities over freeze limit).

Endpoint: POST /v2/orders/slicing

pub async fn get_orders(&self) -> Result<Vec<OrderDetail>>

Retrieve all orders for the day.

Endpoint: GET /v2/orders

pub async fn get_order(&self, order_id: &str) -> Result<OrderDetail>

Retrieve a specific order by its ID.

Endpoint: GET /v2/orders/{order-id}

pub async fn get_order_by_correlation_id( &self, correlation_id: &str, ) -> Result<OrderDetail>

Retrieve an order by its correlation ID.

Endpoint: GET /v2/orders/external/{correlation-id}

pub async fn get_trades(&self) -> Result<Vec<TradeDetail>>

Retrieve all trades for the day.

Endpoint: GET /v2/trades

pub async fn get_trades_for_order( &self, order_id: &str, ) -> Result<Vec<TradeDetail>>

Retrieve trades for a specific order.

Endpoint: GET /v2/trades/{order-id}

impl DhanClient

pub async fn get_holdings(&self) -> Result<Vec<Holding>>

Retrieve all holdings in the demat account.

Endpoint: GET /v2/holdings

pub async fn get_positions(&self) -> Result<Vec<Position>>

Retrieve all open positions for the day.

Endpoint: GET /v2/positions

pub async fn convert_position(&self, req: &ConvertPositionRequest) -> Result<()>

Convert a position’s product type (e.g. intraday → delivery).

Returns 202 Accepted on success.

Endpoint: POST /v2/positions/convert

pub async fn exit_all_positions(&self) -> Result<ExitAllResponse>

Exit all active positions and cancel all open orders.

Endpoint: DELETE /v2/positions

impl DhanClient

pub async fn get_profile(&self) -> Result<UserProfile>

Retrieve the user profile.

Can also be used to validate that an access token is still active.

Endpoint: GET /v2/profile

Example

let client = DhanClient::new("1000000001", "your-access-token");
let profile = client.get_profile().await?;
println!("Token valid until: {}", profile.token_validity);

impl DhanClient

pub async fn get_ledger_response( &self, from_date: &str, to_date: &str, ) -> Result<LedgerResponse>

Retrieve Trading Account Ledger Report for a date range.

Dates should be in YYYY-MM-DD format.

Endpoint: GET /v2/ledger?from-date={from}&to-date={to}

pub async fn get_ledger( &self, from_date: &str, to_date: &str, ) -> Result<Vec<LedgerEntry>>

Retrieve ledger entries while preserving the pre-0.1.7 return type.

New callers that need the documented client metadata should use Self::get_ledger_response.

pub async fn get_trade_history( &self, from_date: &str, to_date: &str, page: u32, ) -> Result<Vec<TradeHistoryEntry>>

Retrieve historical trade data for a date range.

Dates should be in YYYY-MM-DD format. Use page = 0 as default. The response is paginated.

Endpoint: GET /v2/trades/{from-date}/{to-date}/{page}

impl DhanClient

pub async fn place_super_order( &self, req: &PlaceSuperOrderRequest, ) -> Result<OrderResponse>

Place a new super order.

Endpoint: POST /v2/super/orders

pub async fn modify_super_order( &self, order_id: &str, req: &ModifySuperOrderRequest, ) -> Result<OrderResponse>

Modify a pending super order.

Endpoint: PUT /v2/super/orders/{order-id}

pub async fn cancel_super_order( &self, order_id: &str, leg: &str, ) -> Result<OrderResponse>

Cancel a super order leg.

Cancelling the ENTRY_LEG cancels all legs.

Endpoint: DELETE /v2/super/orders/{order-id}/{order-leg}

pub async fn cancel_super_order_no_content( &self, order_id: &str, leg: &str, ) -> Result<()>

Cancel a super order leg when the server follows the HTML contract and returns a successful empty response.

Dhan’s linked OpenAPI describes a 200 JSON OrderResponse for this operation, while the HTML page describes 202 Accepted with no body. Self::cancel_super_order models the OpenAPI form; this method models the HTML form without attempting to deserialize an empty response.

Endpoint: DELETE /v2/super/orders/{order-id}/{order-leg}

pub async fn get_super_orders(&self) -> Result<Vec<SuperOrderDetail>>

Retrieve all super orders for the day.

Endpoint: GET /v2/super/orders

impl DhanClient

pub async fn manage_kill_switch( &self, status: &str, ) -> Result<KillSwitchResponse>

Activate or deactivate the kill switch for the current trading day.

Pass "ACTIVATE" or "DEACTIVATE" as the status parameter.

Endpoint: POST /v2/killswitch?killSwitchStatus={status}

pub async fn get_kill_switch_status(&self) -> Result<KillSwitchResponse>

Retrieve current kill switch status.

Endpoint: GET /v2/killswitch

pub async fn set_pnl_exit( &self, req: &PnlExitRequest, ) -> Result<PnlExitResponse>

Configure P&L-based auto-exit for the current trading day.

Endpoint: POST /v2/pnlExit

pub async fn stop_pnl_exit(&self) -> Result<PnlExitResponse>

Disable the active P&L-based exit configuration.

Endpoint: DELETE /v2/pnlExit

pub async fn get_pnl_exit(&self) -> Result<PnlExitConfig>

Fetch the currently active P&L-based exit configuration.

Endpoint: GET /v2/pnlExit

impl DhanClient

pub fn new( client_id: impl Into<String>, access_token: impl Into<String>, ) -> Self

Create a new DhanClient with the given client ID and access token.

Uses the default API base URL (https://api.dhan.co).

pub fn with_base_url( client_id: impl Into<String>, access_token: impl Into<String>, base_url: impl Into<String>, ) -> Self

Create a new DhanClient pointing at a custom base URL.

Useful for testing against a sandbox or mock server.

pub fn try_new( client_id: impl Into<String>, access_token: impl Into<String>, ) -> Result<Self>

Fallible variant of Self::new that validates credential header values at construction time.

pub fn try_with_base_url( client_id: impl Into<String>, access_token: impl Into<String>, base_url: impl Into<String>, ) -> Result<Self>

Fallible variant of Self::with_base_url that validates credential header values at construction time.

pub fn http(&self) -> &Client

Returns a reference to the underlying reqwest::Client.

pub fn client_id(&self) -> &str

Returns the Dhan client ID.

pub fn access_token(&self) -> &str

Returns the current access token.

pub fn set_access_token(&mut self, token: impl Into<String>)

Replace the access token (e.g. after renewal).

pub fn try_set_access_token(&mut self, token: impl Into<String>) -> Result<()>

Validate and replace the access token without deferring invalid-header errors to a later request.

pub fn base_url(&self) -> &str

Returns the base URL.

pub async fn get<R: DeserializeOwned>(&self, path: &str) -> Result<R>

Perform a GET request and deserialize the JSON response.

pub async fn post<B: Serialize, R: DeserializeOwned>( &self, path: &str, body: &B, ) -> Result<R>

Perform a POST request with a JSON body and deserialize the response.

pub async fn post_without_body<R: DeserializeOwned>( &self, path: &str, ) -> Result<R>

Perform a POST request without a request body and deserialize the successful JSON response.

pub async fn put<B: Serialize, R: DeserializeOwned>( &self, path: &str, body: &B, ) -> Result<R>

Perform a PUT request with a JSON body and deserialize the response.

pub async fn delete<R: DeserializeOwned>(&self, path: &str) -> Result<R>

Perform a DELETE request and deserialize the JSON response.

pub async fn delete_no_content(&self, path: &str) -> Result<()>

Perform a DELETE request that returns no body (expects 202 Accepted).

pub async fn get_no_content(&self, path: &str) -> Result<()>

Perform a GET request that returns no body (expects 202 Accepted).

pub async fn post_no_content<B: Serialize>( &self, path: &str, body: &B, ) -> Result<()>

Perform a POST request that returns no body (expects 202 Accepted).

Trait Implementations

impl Clone for DhanClient

fn clone(&self) -> DhanClient

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DhanClient

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

Formats the value using the given formatter.