Fyers Go SDK : fyers-api-v3 - v1.7.0

package main

import (
    "fmt"
    "log"
    fyersgosdk "github.com/FyersDev/fyers-go-sdk"
)

func main() {
    appId := "AAAAAAAAA-100"
	appSecret := "XY...."
	redirectUrl := "https://trade.fyers.in/api-login/redirect-uri/index.html"

    // 1. Initialize client (auth only)
    fyClient := fyersgosdk.SetClientData(appId, appSecret, redirectUrl)
    fmt.Println("Login URL:", fyClient.GetLoginURL())

    // 2. After user authorizes, exchange auth code for access token
    authCode := "eyjb...."
    response, err := fyClient.GenerateAccessToken(authCode, fyClient)
    if err != nil {
        log.Fatal("Error generating access token:", err)
    }
    fmt.Println("Response:", response)

    // 3. Use FyersModel for all API calls (profile, orders, data, etc.)
    accessToken := "eyjb...."
    fyModel := fyersgosdk.NewFyersModel(appId, accessToken)
    profile, err := fyModel.GetProfile()
    if err != nil {
        log.Fatal("Error getting profile:", err)
    }
    fmt.Println("Profile:", profile)
}

package main

import (
    "fmt"
    "log"
    fyersgosdk "github.com/FyersDev/fyers-go-sdk"
)

func main() {
    appId := "AAAAAAAAA-100"
	accessToken := "eyjb...."

    fyModel := fyersgosdk.NewFyersModel(appId, accessToken)

    // Quotes
    symbols := []string{"NSE:SBIN-EQ", "NSE:NIFTY50-INDEX"} // Quotes (up to 50 symbols)
    quotes, err := fyModel.GetStockQuotes(symbols)
    fmt.Println("Quotes:", quotes)

    // Quotes via POST - same shape, but symbols travel in the body so you can
    // request many more of them in one call.
    quotesV2, err := fyModel.GetStockQuotesV2(symbols)
    fmt.Println("Quotes (v2):", quotesV2)

    // History
    history, err := fyModel.GetHistory(fyersgosdk.HistoryRequest{
        Symbol: "NSE:SBIN-EQ", Resolution: "30", DateFormat: "1",
        RangeFrom: "2021-01-01", RangeTo: "2021-01-02", ContFlag: "",
    })
    fmt.Println("History:", history)
}

package main

import (
    "fmt"
    fyersgosdk "github.com/FyersDev/fyers-go-sdk"
)

func main() {
    fyModel := fyersgosdk.NewFyersModel("AAAAAAAAA-100", "eyjb....")

    // Futures chain for an index or underlying
    chain, err := fyModel.GetFuturesChain(fyersgosdk.FuturesChainRequest{
        Symbol: "NSE:NIFTY50-INDEX",
    })
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println("Futures chain:", chain)

    // Expired FNO workflow: expiry dates → contracts → historical candles
    expiry, err := fyModel.GetExpiryDates(fyersgosdk.ExpiryDatesRequest{
        UnderlyingSymbol: "NSE:NIFTY50-INDEX",
        RangeFrom:        "2024-01-01",
        RangeTo:          "2024-12-31",
        DateFormat:       "1",
    })
    fmt.Println("Expiry dates:", expiry)

    contracts, err := fyModel.GetHistoryUnderlyingSymbols(fyersgosdk.HistoryUnderlyingSymbolsRequest{
        UnderlyingSymbol: "NSE:NIFTY50-INDEX",
        ExpiryDate:       "2024-11-28",
    })
    fmt.Println("Expired contracts:", contracts)

    history, err := fyModel.GetFNOHistoricalData(fyersgosdk.FNOHistoricalDataRequest{
        Symbol:     "NSE:NIFTY24NOV22500CE",
        Resolution: "5",
        DateFormat: "1",
        RangeFrom:  "2024-11-01",
        RangeTo:    "2024-11-28",
        IncludeGreeks: "1",
        IncludeOi:     "1",
    })
    fmt.Println("FNO historical data:", history)
}

package main

import (
    "fmt"
    "log"
    fyersgosdk "github.com/FyersDev/fyers-go-sdk"
)

func main() {
    appId := "AAAAAAAAA-100"
	accessToken := "eyjb...."

    // Place Order
    fyModel := fyersgosdk.NewFyersModel(appId, accessToken)
    response, err := fyModel.SingleOrderAction(fyersgosdk.OrderRequest{
        Symbol: "NSE:IDEA-EQ", Qty: 1, Type: 1, Side: 1, ProductType: "CNC",
        LimitPrice: 100, Validity: "DAY", DisclosedQty: 0, OfflineOrder: false,
    })
    fmt.Println("Response:", response)
}

package main

import (
    "fmt"
    fyersgosdk "github.com/FyersDev/fyers-go-sdk"
)

func main() {
    fyModel := fyersgosdk.NewFyersModel("AAAAAAAAA-100", "eyjb....")

    // Place with take-profit / stop-loss overlays (sync endpoint only)
    response, err := fyModel.SingleOrderAction(fyersgosdk.OrderRequest{
        Symbol:      "NSE:SBIN-EQ",
        Qty:         10,
        Type:        1,
        Side:        1,
        ProductType: fyersgosdk.ProductIntraday,
        LimitPrice:  500.0,
        Validity:    "DAY",
        TakeProfit:  10.5, // optional float
        StopLoss:    5.0,  // optional float — omit either field (or leave 0) if not needed
        LegType:     fyersgosdk.LegTypePoints, // 1 = points, 2 = percent
    })
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println("Response:", response)

    // Update TP and remove SL on an open order
    mod, err := fyModel.ModifyOrder(fyersgosdk.ModifyOrderRequest{
        Id:            "23072800012345",
        TakeProfit:    15.0,
        ClearStopLoss: true, // sends "stopLoss": null
    })
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println("Modify:", mod)

    // Attach TP/SL to an open position
    attach, err := fyModel.AttachPositionLegs(fyersgosdk.AttachPositionLegsRequest{
        PositionID: "NSE:SBIN-EQ-INTRADAY",
        TakeProfit: 2.5,
        StopLoss:   1.5,
        LegType:    fyersgosdk.LegTypePercent,
    })
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println("Attach:", attach)
}

package main

import (
	"fmt"
	"os"
	"os/signal"
	"syscall"

	fyersws "github.com/FyersDev/fyers-go-sdk/websocket"
)

func main() {
	appId := "AAAAAAAAA-100"
	token := "eyjb...."
	accessToken := fmt.Sprintf("%s:%s", appId, token)
	symbols := []string{"NSE:SBIN-EQ"}
	datatype := "SymbolUpdate" // "SymbolUpdate", "DepthUpdate"

	var dataSocket *fyersws.FyersDataSocket
	onConnect := func() {
		dataSocket.Subscribe(symbols, datatype)
	}

	dataSocket = fyersws.NewFyersDataSocket(
		accessToken, // Access token in the format "appid:accesstoken"
		"",          // Log path - leave empty to auto-create logs in the current directory
		true,        // Lite mode disabled. Set to true if you want a lite response
		false,       // Save response in a log file instead of printing it
		true,        // Enable auto-reconnection to WebSocket on disconnection
		50,          // reconnectRetry: max reconnect attempts (cap 50)
		onConnect,   // Callback: subscribe on every connect (first + after reconnect)
		onClose,     // Callback function to handle WebSocket connection close events
		onError,     // Callback function to handle WebSocket errors
		onMessage,   // Callback function to handle incoming messages from the WebSocket
	)

	err := dataSocket.Connect()
	if err != nil {
		fmt.Printf("failed to connect to Data Socket: %v", err)
		return
	}

	sigChan := make(chan os.Signal, 1)
	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)

	<-sigChan
	fmt.Println("\nReceived interrupt signal, closing connection...")

	dataSocket.CloseConnection()
	fmt.Println("Data Socket connection closed")

}

func onMessage(message fyersws.DataResponse) {
	fmt.Printf("Response: %s\n", message)
}

func onError(message fyersws.DataError) {
	fmt.Printf("Error: %s\n", message)
}

func onClose(message fyersws.DataClose) {
	fmt.Printf("Connection closed: %s\n", message)
}

// Step 1: Initialize client (appId, appSecret, redirectUrl)
fyClient := fyersgosdk.SetClientData(appId, appSecret, redirectUrl)

// Step 2: Generate login URL
loginURL := fyClient.GetLoginURL()
fmt.Println("Please visit:", loginURL)

// Step 3: User authorizes; you get auth code from redirect URL
// Step 4: Exchange auth code for access token (returns JSON string)
response, err := fyClient.GenerateAccessToken(authCode, fyClient)

// Step 5: Exchange refresh token for access token
response, err := fyClient.GenerateAccessTokenFromRefreshToken(refreshToken, pin, fyClient)

// Step 6: Create FyersModel for all API calls
fyModel := fyersgosdk.NewFyersModel(appId, accessToken)

// Data WebSocket (symbols, lite/full mode)
var dataSocket *fyersws.FyersDataSocket
onConnect := func() {
    dataSocket.Subscribe(symbols, datatype)
}

dataSocket = fyersws.NewFyersDataSocket(
    accessToken, // Access token in the format "appid:accesstoken"
    "",          // Log path - leave empty to auto-create logs in the current directory
    true,        // Lite mode disabled. Set to true if you want a lite response
    false,       // Save response in a log file instead of printing it
    true,        // Enable auto-reconnection to WebSocket on disconnection
    50,          // reconnectRetry: max reconnect attempts (cap 50)
    onConnect,   // Callback: subscribe on every connect (first + after reconnect)
    onClose,     // Callback function to handle WebSocket connection close events
    onError,     // Callback function to handle WebSocket errors
    onMessage,   // Callback function to handle incoming messages from the WebSocket
)

err := dataSocket.Connect()
if err != nil {
    fmt.Printf("failed to connect to Data Socket: %v", err)
    return
}

sigChan := make(chan os.Signal, 1)
signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)

<-sigChan
fmt.Println("\nReceived interrupt signal, closing connection...")

dataSocket.CloseConnection()

// Order WebSocket (trades, positions, orders)
orderSocket := fyersws.NewFyersOrderSocket(
    accessToken,      // Access token in the format "appid:accesstoken"
    false,            // Write to file - set to true if you want to save responses to a log file
    "",               // Log path - leave empty to auto-create logs in the current directory
    onOrderTrades,    // Callback function to handle trade events
    onOrderPositions, // Callback function to handle position events
    onOrderUpdates,   // Callback function to handle order events
    onOrderGeneral,   // Callback function to handle general events
    onOrderError,     // Callback function to handle WebSocket errors
    nil,   // Callback function called when WebSocket connection is established
    onOrderClose,     // Callback function to handle WebSocket connection close events
    true,             // Enable auto-reconnection to WebSocket on disconnection
    5,                // Maximum number of reconnection attempts
)

// Establish a connection to the Fyers Order WebSocket
err := orderSocket.Connect()
if err != nil {
    fmt.Printf("failed to connect to Order Socket: %v", err)
    return
}

if len(tradeOperations) > 0 {
    orderSocket.SubscribeMultiple(tradeOperations)
}

sigChan := make(chan os.Signal, 1)
signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)

<-sigChan
fmt.Println("\nReceived interrupt signal, closing connection...")

orderSocket.CloseConnection()