Kite Connect JavaScript/TypeScript Client

The KiteTicker class is used to stream live market data via WebSockets. You must initialize it with your api_key and access_token, then call .connect(). You can listen to various events like ticks, connect, order_update, and error to handle incoming data and connection lifecycle changes.

import { KiteTicker } from "kiteconnect";

const apiKey = "your_api_key";
const accessToken = "generated_access_token";

const ticker = new KiteTicker({
  api_key: apiKey,
  access_token: accessToken,
});

ticker.connect();

ticker.on("ticks", (ticks: any[]) => {
  console.log("Ticks", ticks);
});

ticker.on("connect", () => {
  const tokens = [738561, 256265];
  ticker.subscribe(tokens);
  ticker.setMode(ticker.modeFull, tokens);
});

ticker.on("order_update", (order: any) => {
  console.log("Order update", order);
});

// Other available events: "disconnect", "error", "close", "message"

To use the REST-like APIs (e.g., managing portfolios, executing orders), initialize a KiteConnect instance with your api_key. You must then generate a session using a request_token and your api_secret to obtain an access_token. Once obtained, use setAccessToken() to authenticate subsequent requests.

import { KiteConnect } from "kiteconnect";

const apiKey = "your_api_key";
const apiSecret = "your_api_secret";
const requestToken = "your_request_token";

const kc = new KiteConnect({ api_key: apiKey });

async function init() {
  try {
    // 1. Generate session
    const response = await kc.generateSession(requestToken, apiSecret);
    
    // 2. Set the access token for subsequent calls
    kc.setAccessToken(response.access_token);
    
    // 3. Make authenticated calls
    const profile = await kc.getProfile();
    console.log("Profile:", profile);
  } catch (err) {
    console.error(err);
  }
}

init();

To use the Kite Connect API, instantiate the KiteConnect class with your api_key. You can also provide an access_token if you have already completed the login flow, a custom root endpoint, or a debug flag to log requests and responses to the console.

All API calls return a Promise, so you should use async/await or .then()/.catch() to handle the results and errors.

import { KiteConnect } from 'kiteconnect';

const apiKey = 'your_api_key';
const apiSecret = 'your_api_secret';
const requestToken = 'your_request_token';

const kc = new KiteConnect({ api_key: apiKey });

async function init() {
    try {
        // 1. Generate session to get access token
        const response = await kc.generateSession(requestToken, apiSecret);
        
        // 2. Set the access token for subsequent calls
        kc.setAccessToken(response.access_token);
        
        // 3. Make authenticated calls
        const profile = await kc.getProfile();
        console.log('Profile:', profile);
    } catch (err) {
        console.error(err);
    }
}

init();

To handle unreliable network conditions, you can enable client-side auto re-connection using ticker.autoReconnect(enabled, maxRetries, interval).

• enabled: Boolean to turn on auto-reconnect.
• maxRetries: Maximum number of reconnection attempts. Use -1 for infinite retries.
• interval: The time interval between reconnection attempts in seconds.

Events for Auto Re-connection:

• reconnect: Triggered when a reconnection attempt is made. The callback receives reconnect_count and reconnect_interval.
• noreconnect: Triggered when the maximum number of reconnection attempts is exceeded. The process will exit after this event.
• connect: Triggered again when a reconnection is successful.

import { KiteTicker } from "kiteconnect";

const ticker = new KiteTicker({
  api_key: "api_key",
  access_token: "access_token",
});

// Enable auto reconnect: 10 retries, 5 second interval
ticker.autoReconnect(true, 10, 5);

ticker.on("reconnect", (reconnect_count: any, reconnect_interval: any) => {
  console.log("Reconnecting: attempt - ", reconnect_count, " interval - ", reconnect_interval);
});

ticker.on("noreconnect", () => {
  console.log("Maximum reconnection attempts reached. Exiting.");
});

ticker.connect();

Use the following methods to interact with the order management system:

• placeOrder(variety, params): Places a new order. If params.autoslice is set to true, the response may include a children array containing individual slice results (either order_id or an error).
• modifyOrder(variety, order_id, params): Modifies an existing order.
• cancelOrder(variety, order_id, params?): Cancels an existing order.
• exitOrder(variety, order_id, params): A wrapper for cancelOrder used to exit positions.
• getOrders(): Retrieves all active orders.
• getOrderHistory(order_id): Retrieves the history for a specific order.
• getTrades(): Retrieves all trades data.
• getOrderTrades(order_id): Retrieves trades associated with a specific order.

// Place an order
const order = await kc.placeOrder(kc.VARIETY_REGULAR, {
    tradingsymbol: 'RELIANCE',
    exchange: kc.EXCHANGE_NSE,
    transaction_type: kc.TRANSACTION_TYPE_BUY,
    order_type: kc.ORDER_TYPE_LIMIT,
    quantity: 1,
    price: 2500
});

// Cancel an order
await kc.cancelOrder(kc.VARIETY_REGULAR, order.order_id);

The Kite Connect API requires an access token for authenticated requests. You can manage the session lifecycle using the following methods:

• generateSession(request_token, api_secret): Exchanges a request_token (obtained via the login flow) and your api_secret for an access_token. This method automatically sets the access token on the KiteConnect instance upon success.
• setAccessToken(accessToken): Manually sets the access token for the client.
• invalidateAccessToken(access_token?): Invalidates the current access token. If no token is provided, it uses the one stored in the instance.
• renewAccessToken(refresh_token, api_secret): Renews the access token using a refresh_token. This also automatically updates the instance with the new token.
• invalidateRefreshToken(refresh_token): Invalidates a specific refresh token.
• getLoginURL(): Returns the Kite Connect login URL with your api_key embedded, which you can redirect users to for authentication.

// Generate session
const session = await kc.generateSession(requestToken, apiSecret);

// Renew session
const newSession = await kc.renewAccessToken(refreshToken, apiSecret);

// Get login URL for redirection
const url = kc.getLoginURL();

Access real-time and historical market information:

• getInstruments(exchange?): Fetches instruments. If an exchange is provided, it fetches for that exchange; otherwise, it fetches all instruments.
• getQuote(instruments): Retrieves quote data for one or more instruments (format: exchange:tradingsymbol).
• getOHLC(instruments): Retrieves Open, High, Low, Close data.
• getLTP(instruments): Retrieves the Last Traded Price.
• getHistoricalData(instrument_token, interval, from_date, to_date, [continuous], [oi]): Fetches historical candle data.
  • interval: The time interval (e.g., 'minute', 'day').
  • from_date / to_date: Can be a string in 'YYYY-MM-DD HH:MM:SS' format or a JavaScript Date object. Note that Date objects preserve local timezone and are not converted to UTC.

// Get LTP for multiple instruments
const ltp = await kc.getLTP(['NSE:RELIANCE', 'NSE:TCS']);

// Get historical data
const candles = await kc.getHistoricalData(
    12345, 
    'day', 
    new Date('2023-01-01'), 
    new Date('2023-01-10')
);