Zerodha KiteConnect
API Setup

Zerodha KiteConnect is the official REST + WebSocket API for Zerodha accounts. It provides real-time quotes, historical candle data, order placement, position tracking, and WebSocket tick streams — everything needed for a complete live algo trading system.

Setup Steps

# config.json (NEVER commit to git — add to .gitignore!)
{
    "api_key":      "your_api_key_here",
    "api_secret":   "your_api_secret_here",
    "access_token": "saved_after_login"
}

Authentication Flow

from kiteconnect import KiteConnect
import json, os
from pathlib import Path

# ── Load credentials ──
with open("config.json") as f:
    cfg = json.load(f)

kite = KiteConnect(api_key=cfg["api_key"])

# ── Step 1: Generate login URL ──
login_url = kite.login_url()
print(f"Open this URL and login:\n{login_url}")

# ── Step 2: After login, extract request_token from redirect URL ──
# Redirect looks like: https://your-app.com/?request_token=XXXX&action=login&status=success
request_token = input("Paste request_token here: ")

# ── Step 3: Generate session (access_token) ──
data = kite.generate_session(request_token, api_secret=cfg["api_secret"])
access_token = data["access_token"]

# ── Step 4: Set and save access_token ──
kite.set_access_token(access_token)

cfg["access_token"] = access_token
with open("config.json", "w") as f:
    json.dump(cfg, f, indent=2)

print("✅ Session ready. access_token saved to config.json")
print(f"Profile: {kite.profile()['user_name']}")

Reusing a Saved Session

def get_kite_session(config_path: str = "config.json") -> KiteConnect:
    """Load KiteConnect session from saved access_token."""
    with open(config_path) as f:
        cfg = json.load(f)

    kite = KiteConnect(api_key=cfg["api_key"])
    kite.set_access_token(cfg["access_token"])

    try:
        profile = kite.profile()
        print(f"✅ Session active — {profile['user_name']}")
        return kite
    except Exception as e:
        print(f"❌ Session expired: {e}")
        print("Run login.py to generate a new session.")
        raise

# Use throughout your trading session
kite = get_kite_session()

Instruments — Finding Tokens

Every instrument on NSE/BSE has a unique instrument_token (integer). You need this token to request historical data, live quotes, or set up a WebSocket feed. Zerodha publishes a full instrument dump daily.

import pandas as pd

# Download full NSE instrument list
instruments = kite.instruments("NSE")
df_inst = pd.DataFrame(instruments)

print(df_inst.columns.tolist())
# ['instrument_token', 'exchange_token', 'tradingsymbol', 'name',
#  'last_price', 'expiry', 'strike', 'tick_size', 'lot_size',
#  'instrument_type', 'segment', 'exchange']

# ── Find NIFTY 50 Index token ──
nifty_row = df_inst[df_inst["tradingsymbol"] == "NIFTY 50"].iloc[0]
nifty_token = nifty_row["instrument_token"]
print(f"NIFTY 50 token : {nifty_token}")  # 256265

# ── Find BANKNIFTY token ──
bn_row   = df_inst[df_inst["tradingsymbol"] == "NIFTY BANK"].iloc[0]
bn_token = bn_row["instrument_token"]
print(f"BANKNIFTY token: {bn_token}")    # 260105

# ── Find RELIANCE equity token ──
reliance = df_inst[df_inst["tradingsymbol"] == "RELIANCE"]
reliance = reliance[reliance["instrument_type"] == "EQ"].iloc[0]
print(f"RELIANCE token : {reliance['instrument_token']}")

# ── Find NIFTY Futures (current expiry) ──
nf_futures = df_inst[
    (df_inst["tradingsymbol"].str.startswith("NIFTY")) &
    (df_inst["instrument_type"] == "FUT")
].sort_values("expiry")
print(nf_futures[["tradingsymbol", "expiry", "instrument_token", "lot_size"]].head(3))

Live Quotes

# ── LTP (Last Traded Price) — fastest quote ──
tokens = [256265, 260105]  # NIFTY 50, BANKNIFTY

ltp_data = kite.ltp(tokens)
for token, val in ltp_data.items():
    print(f"Token {token}: LTP = ₹{val['last_price']:,.2f}")

# ── Full quote (OHLC + depth + volume + OI) ──
quote = kite.quote([256265])
nifty_quote = quote["256265"]

print(f"\n-- NIFTY 50 Full Quote --")
print(f"LTP     : ₹{nifty_quote['last_price']:,.2f}")
print(f"Open    : ₹{nifty_quote['ohlc']['open']:,.2f}")
print(f"High    : ₹{nifty_quote['ohlc']['high']:,.2f}")
print(f"Low     : ₹{nifty_quote['ohlc']['low']:,.2f}")
print(f"Close   : ₹{nifty_quote['ohlc']['close']:,.2f}")
print(f"Volume  : {nifty_quote['volume']:,}")
print(f"Buy Qty : {nifty_quote['depth']['buy'][0]['quantity']:,}")
print(f"Sell Qty: {nifty_quote['depth']['sell'][0]['quantity']:,}")

API Error Handling — Production Patterns

from kiteconnect import KiteConnect
from kiteconnect.exceptions import (
    TokenException, NetworkException, DataException,
    GeneralException, InputException
)
import time

def safe_ltp(kite: KiteConnect, tokens: list, retries: int = 3) -> dict:
    """
    Fetch LTP with retry logic for network issues.
    Raises immediately on auth errors (TokenException).
    """
    for attempt in range(1, retries + 1):
        try:
            return kite.ltp(tokens)

        except TokenException:
            print("❌ Access token expired — re-authentication required")
            raise   # Never retry auth errors

        except NetworkException as e:
            print(f"⚠️  Network error (attempt {attempt}/{retries}): {e}")
            if attempt < retries:
                time.sleep(2 ** attempt)  # exponential backoff
            else:
                raise

        except DataException as e:
            print(f"⚠️  Data error: {e}")
            return {}  # Return empty — caller handles missing data

        except GeneralException as e:
            print(f"❌ General API error: {e}")
            raise

# Usage
ltp_data = safe_ltp(kite, [256265, 260105])
if ltp_data:
    nifty_ltp = ltp_data.get("256265", {}).get("last_price", None)
    print(f"NIFTY LTP: ₹{nifty_ltp}")

Quiz

Exercises

Lesson Summary