Kite Connect API Go Client

The kiteticker package provides WebSocket capabilities for streaming live market data and order updates.

Workflow:

1. Initialize the ticker with kiteticker.New(apiKey, accessToken).
2. Register event callbacks using the On... methods (e.g., OnTick, OnConnect, OnError).
3. Call ticker.Serve() to start the connection.
4. Inside the OnConnect callback, use ticker.Subscribe(instTokens) to subscribe to specific instruments.
5. Optionally change the subscription mode using ticker.SetMode(mode, instTokens). The default mode is ModeQuote.

Available Callbacks:

• OnError(func(err error))
• OnClose(func(code int, reason string))
• OnConnect(func())
• OnReconnect(func(attempt int, delay time.Duration))
• OnNoReconnect(func(attempt int))
• OnTick(func(tick kitemodels.Tick))
• OnOrderUpdate(func(order kiteconnect.Order))

package main

import (
	"fmt"
	"time"

	kiteconnect "github.com/zerodha/gokiteconnect/v4"
	kitemodels "github.com/zerodha/gokiteconnect/v4/models"
	kiteticker "github.com/zerodha/gokiteconnect/v4/ticker"
)

var (
	ticker *kiteticker.Ticker
)

var (
	instToken = []uint32{408065, 112129}
)

func onError(err error) {
	fmt.Println("Error: ", err)
}

func onClose(code int, reason string) {
	fmt.Println("Close: ", code, reason)
}

func onConnect() {
	fmt.Println("Connected")
	err := ticker.Subscribe(instToken)
	if err != nil {
		fmt.Println("err: ", err)
	}
	err = ticker.SetMode(kiteticker.ModeFull, instToken)
	if err != nil {
		fmt.Println("err: ", err)
	}
}

func onTick(tick kitemodels.Tick) {
	fmt.Println("Tick: ", tick)
}

func onReconnect(attempt int, delay time.Duration) {
	fmt.Printf("Reconnect attempt %d in %fs\n", attempt, delay.Seconds())
}

func onNoReconnect(attempt int) {
	fmt.Printf("Maximum no of reconnect attempt reached: %d", attempt)
}

func onOrderUpdate(order kiteconnect.Order) {
	fmt.Printf("Order: ", order.OrderID)
}

func main() {
	apiKey := "my_api_key"
	accessToken := "my_access_token"

	ticker = kiteticker.New(apiKey, accessToken)

	ticker.OnError(onError)
	ticker.OnClose(onClose)
	ticker.OnConnect(onConnect)
	ticker.OnReconnect(onReconnect)
	ticker.OnNoReconnect(onNoReconnect)
	ticker.OnTick(onTick)
	ticker.OnOrderUpdate(onOrderUpdate)

	ticker.Serve()
}

To interact with the REST-like APIs, follow the Kite Connect login flow:

1. Initialize the client using kiteconnect.New(apiKey).
2. Retrieve the login URL via kc.GetLoginURL() to obtain a requestToken through the Kite Connect login process.
3. Exchange the requestToken and your apiSecret for a session using kc.GenerateSession(requestToken, apiSecret).
4. Set the resulting AccessToken on your client instance using kc.SetAccessToken(data.AccessToken) to authorize subsequent requests.

package main

import (
	"fmt"
	kiteconnect "github.com/zerodha/gokiteconnect/v4"
)

const (
	apiKey    string = "my_api_key"
	apiSecret string = "my_api_secret"
)

func main() {
	// Create a new Kite connect instance
	kc := kiteconnect.New(apiKey)

	// Login URL from which request token can be obtained
	fmt.Println(kc.GetLoginURL())

	// Obtained request token after Kite Connect login flow
	requestToken := "request_token_obtained"

	// Get user details and access token
	data, err := kc.GenerateSession(requestToken, apiSecret)
	if err != nil {
		fmt.Printf("Error: %v", err)
		return
	}

	// Set access token
	kc.SetAccessToken(data.AccessToken)

	// Get margins
	margins, err := kc.GetUserMargins()
	if err != nil {
		fmt.Printf("Error getting margins: %v", err)
	}
	fmt.Println("margins: ", margins)
}

Good Till Trigger (GTT) orders allow you to set conditions that, when met, trigger a specific order. The library provides two main types of GTT orders via the Trigger interface:

1. Single Leg (GTTTypeSingle): Monitors a single trigger value. Use GTTSingleLegTrigger to implement this.
2. Two-Leg / OCO (GTTTypeOCO): Monitors two trigger values (an upper and a lower bound). Executing one leg automatically cancels the other. Use GTTOneCancelsOtherTrigger to implement this.

To place or modify these orders, you use GTTParams, which encapsulates the trading symbol, exchange, transaction type, product, and the specific Trigger implementation.

// Example of a Single Leg GTT
trigger := &kiteconnect.GTTSingleLegTrigger{
	TriggerParams: kiteconnect.TriggerParams{
		TriggerValue: 1500.0,
		LimitPrice:   1505.0,
		Quantity:     10,
	},
}

params := kiteconnect.GTTParams{
	Tradingsymbol:   "RELIANCE",
	Exchange:        "NSE",
	LastPrice:       1495.0,
	TransactionType: "BUY",
	Product:         "CNC",
	Trigger:         trigger,
}

// Place the GTT
resp, err := client.PlaceGTT(params)

When creating an alert of type AlertTypeATO, you must include a Basket in your AlertParams. A Basket contains multiple BasketItems, each representing an order to be placed when the alert condition is met.

Each BasketItem requires:

• Type: The type of item.
• TradingSymbol and Exchange.
• Params: An AlertOrderParams object defining the order details (transaction type, product, quantity, price, etc.).

params := kiteconnect.AlertParams{
	Name:             "ATO Alert",
	Type:             kiteconnect.AlertTypeATO,
	LHSExchange:      "NSE",
	LHSTradingSymbol: "INFY",
	LHSAttribute:     "ltp",
	Operator:         kiteconnect.AlertOperatorGE,
	RHSType:          "constant",
	RHSConstant:      1500.0,
	Basket: &kiteconnect.Basket{
		Name: "My Basket",
		Items: []kiteconnect.BasketItem{
			{
				Type:          "order",
				  TradingSymbol: "INFY",
				  Exchange:      "NSE",
				  Params: kiteconnect.AlertOrderParams{
					  TransactionType: "BUY",
				  Quantity:        10,
				  OrderType:       "MARKET",
				},
			},
		},
}