The official TypeScript/JavaScript for communicating with the Kite Connect API.
Kite Connect is a set of REST-like APIs that expose many capabilities required to build a complete investment and trading platform. Execute orders in real time, manage user portfolio, stream live market data (WebSockets), and more, with the simple HTTP API collection.
Zerodh DFAC a Technology (c) 2024. Licensed under the MIT License.
- NodeJS v18.0.0+
Install via npm
npm install kiteconnect@latest
Or via yarn
yarn add kiteconnect
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 {
await generateSession();
await getProfile();
} catch (err) {
console.error(err);
}
}
async function generateSession() {
try {
const response = await kc.generateSession(requestToken, apiSecret);
kc.setAccessToken(response.access_token);
console.log("Session generated:", response);
} catch (err) {
console.error("Error generating session:", err);
}
}
async function getProfile() {
try {
const profile = await kc.getProfile();
console.log("Profile:", profile);
} catch (err) {
console.error("Error getting profile:", err);
}
}
// Initialize the API calls
init();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", onTicks);
ticker.on("connect", subscribe);
ticker.on("disconnect", onDisconnect);
ticker.on("error", onError);
ticker.on("close", onClose);
ticker.on("order_update", onTrade);
function onTicks(ticks: any[]): void {
console.log("Ticks", ticks);
}
function subscribe(): void {
const tokens = [738561, 256265];
ticker.subscribe(tokens);
ticker.setMode(ticker.modeFull, tokens);
}
function onDisconnect(error: Error): void {
console.log("Closed connection on disconnect", error);
}
function onError(error: Error): void {
console.log("Closed connection on error", error);
}
function onClose(reason: string): void {
console.log("Closed connection on close", reason);
}
function onTrade(order: any): void {
console.log("Order update", order);
}Optionally, you can enable client-side auto re-connection to automatically reconnect if the connection is dropped. It is very useful when the client-side network is unreliable and patchy.
Enable auto re-connection with a preferred interval and time. For example:
// Enable auto reconnect with 5 second interval and retry for maximum of 20 times.
ticker.autoReconnect(true, 20, 5);
// You can also set re-connection times to -1 for infinite re-connections
ticker.autoReconnect(true, -1, 5);-
Event
reconnectingis called when auto re-connection is triggered and event callback carries two additional paramsreconnection interval setandcurrent re-connection count. -
Event
noreconnectis called when number of auto re-connections exceeds the maximum re-connection count set. For example if maximum re-connection count is set as20then after 20th re-connection this event will be triggered. Also note that the current process is exited when this event is triggered. -
Event
connectwill be triggered again when re-connection succeeds.
Here is an example demonstrating auto reconnection.
import { KiteTicker } from "kiteconnect";
const apiKey = "your_api_key";
const accessToken = "generated_access_token";
const ticker = new KiteTicker({
api_key: "api_key",
access_token: "access_token",
});
ticker.autoReconnect(true, 10, 5);
ticker.connect();
ticker.on("ticks", onTicks);
ticker.on("connect", subscribe);
ticker.on("noreconnect", () => {
console.log("noreconnect");
});
ticker.on("reconnect", (reconnect_count: any, reconnect_interval: any) => {
console.log(
"Reconnecting: attempt - ",
reconnect_count,
" interval - ",
reconnect_interval
);
});
function onTicks(ticks: any[]) {
console.log("Ticks", ticks);
}
function subscribe() {
const items = [738561];
ticker.subscribe(items);
ticker.setMode(ticker.modeFull, items);
}npm run test
$ npm install typedoc --save-dev
$ npx typedoc --out ./docs
In a typical web application where a new instance of views, controllers etc. are created per incoming HTTP request, you will need to initialise a new instance of Kite client per request as well. This is because each individual instance represents a single user that's authenticated, unlike an admin API where you may use one instance to manage many users.
Hence, in your web application, typically:
- You will initialise an instance of the Kite client
- Redirect the user to the
login_url() - At the redirect url endpoint, obtain the
request_tokenfrom the query parameters - Initialise a new instance of Kite client,
use
request_access_token()to obtain theaccess_tokenalong with authenticated user data - Store this response in a session and use the
stored
access_tokenand initialise instances of Kite client for subsequent API calls.
COREPACK_ENABLE_STRICT=0 pnpx nx build