Portfolio

Access positions, holdings, order book, trade book, limits, and user profile through the Go SDK.

GetPositions, GetHoldings, GetOrderBook, and GetTradeBook return the API data payload as typed slices. GetUserDetails and GetLimits keep the { status, data } envelope (user.Data, limits.Data). Field names match live edge.arrow.trade responses.

Positions

positions, err := client.GetPositions()
if err != nil {
    log.Fatal(err)
}
for _, p := range positions {
    fmt.Printf("%s (%s) qty=%s product=%s\n", p.Symbol, p.Exchange, p.Qty, p.Product)
    fmt.Printf("  Day buy: %s @ %s\n", p.DayBuyQty, p.DayBuyAvgPrice)
    fmt.Printf("  Day sell: %s @ %s\n", p.DaySellQty, p.DaySellAvgPrice)
    if p.Ltp != "" && p.Ltp != "0" {
        fmt.Println("  LTP:", p.Ltp)
    }
}

Sample response

{
  "userID": "AJ0001",
  "token": "1398464",
  "exchange": "MCXFO",
  "symbol": "GOLDPETAL30JUN26F",
  "segment": "FO",
  "product": "M",
  "qty": "0",
  "avgPrice": "0",
  "dayBuyQty": "1",
  "daySellQty": "1",
  "dayBuyAmount": "14675",
  "dayBuyAvgPrice": "14675",
  "daySellAmount": "14673",
  "daySellAvgPrice": "14673",
  "ltp": "0",
  "tickSize": "1",
  "lotSize": "1",
  "close": "0",
  "optionType": "XX"
}

Position fields

Go field	JSON	Description
UserID	userID	User identifier
Token	token	Instrument token
Exchange	exchange	Exchange code (e.g. NSE, NFO, MCXFO)
Symbol	symbol	Trading symbol
Segment	segment	Segment (e.g. CM, FO)
Product	product	Product type (I / C / M)
Qty	qty	Net position quantity
AvgPrice	avgPrice	Average entry price
DayBuyQty	dayBuyQty	Intraday buy quantity
DaySellQty	daySellQty	Intraday sell quantity
Ltp	ltp	Last traded price (may be "0" off-hours)
TickSize	tickSize	Tick size
LotSize	lotSize	Lot size
Close	close	Previous close
OptionType	optionType	Option type (CE, PE, XX)
RealisedPnL	realisedPnL	Realized P&L (may be empty)
UnrealisedMarkToMarket	unrealisedMarkToMarket	Unrealized MTM (may be empty)

See also Positions API.

Holdings

holdings, err := client.GetHoldings()
if err != nil {
    log.Fatal(err)
}
for _, h := range holdings {
    tradingSymbol := "N/A"
    if len(h.Symbols) > 0 {
        tradingSymbol = h.Symbols[0].TradingSymbol
    }
    fmt.Printf("%s qty=%s sellable=%s avg=%s\n", tradingSymbol, h.Qty, h.SellableQty, h.AvgPrice)
}

Holdings fields

Go field	Description
Symbols	Per-exchange entries: Symbol, TradingSymbol, Exchange, Token
Qty	Total quantity
AvgPrice	Average purchase price
UsedQty	Quantity already used
T1Qty	T+1 quantity
DepositoryQty	Depository quantity
CollateralQty	Collateral quantity
SellableQty	Quantity available to sell
Ltp	Last traded price
Pnl	P&L (may be empty until LTP is populated)
Close	Previous close

Order Book

orders, err := client.GetOrderBook()
if err != nil {
    log.Fatal(err)
}
for _, o := range orders {
    fmt.Printf("%s %s %s %s @ %s status=%s\n",
        o.ID, o.Symbol, o.TransactionType, o.Quantity, o.Price, o.OrderStatus)
    if o.RejectReason != "" {
        fmt.Println("  Reason:", o.RejectReason)
    }
}

OrderTime is returned as the API string (Go does not rewrite it to epoch seconds).

Order book fields (common)

Go field	Description
ID	Order identifier (use for modify/cancel)
UserID	User identifier
AccountID	Account identifier
Exchange	Exchange code
Symbol	Trading symbol
Token	Instrument token
OrderStatus	PENDING, OPEN, COMPLETE, CANCELLED, REJECTED, etc.
ReportType	Event type (e.g. Fill, Rejected)
TransactionType	B or S
Order	LMT, MKT, etc.
Quantity / Price	Order size and price
FillShares / AveragePrice	Fill quantity and average
RejectReason	Present when rejected
Remarks	Order tag
Validity	DAY, IOC, etc.
OrderTriggerPrice	Trigger price for stop orders

Trade Book

trades, err := client.GetTradeBook()
if err != nil {
    log.Fatal(err)
}
for _, t := range trades {
    fmt.Printf("%s %s fill %s @ %s %s\n", t.OrderID, t.Symbol, t.Quantity, t.FillPrice, t.FillTime)
}

var mcx []arrow.Trade
for _, t := range trades {
    if t.Exchange == "MCXFO" {
        mcx = append(mcx, t)
    }
}

Trade book fields

Go field	Description
OrderID	Related order identifier
ID	Trade / event identifier
Exchange	Exchange code
Symbol	Trading symbol
Quantity	Trade quantity
Product	Product type
TransactionType	B or S
FillPrice	Execution price
FillTime	Fill timestamp

Note

Trade rows use OrderID, not orderNo.

User Limits & Funds

limits, err := client.GetLimits()
if err != nil {
    log.Fatal(err)
}
for _, allocation := range limits.Data.Allocations {
    fmt.Println("Segment:", allocation["segment"], "cash:", allocation["cashCurrent"])
}
fmt.Println("Allocated:", limits.Data.Margin["allocated"])
fmt.Println("Usable margin:", limits.Data.Margin["usableMargin"])
fmt.Println("Net PnL:", limits.Data.Margin["netPnl"])

Margin summary fields (live)

Field	Description
allocated	Total allocated margin
utilized	Margin utilized
usableMargin	Margin available for trading
netPnl	Net P&L
mtmLoss	Mark-to-market loss
totalCash	Total cash
spanMargin	SPAN margin
exposureMargin	Exposure margin
totalMargin	Total margin

Allocation fields

Field	Description
segment	CM, FO, MCX, etc.
cashCurrent	Current cash
cashOpening	Opening cash
cashEqCurrent	Current cash equivalent
nonCashCurrent	Current non-cash

See Funds API for additional REST reference.

User Details

user, err := client.GetUserDetails()
if err != nil {
    log.Fatal(err)
}
fmt.Println("User ID:", user.Data.ID)
fmt.Println("Name:", user.Data.Name)
fmt.Println("Email:", user.Data.Email)
fmt.Println("TOTP enabled:", user.IsTotpEnabled())
fmt.Println("Has NSE:", user.HasExchangeAccess("NSE"))

Helpers on *User: HasDefaultBankAccount(), GetDefaultBankAccount(), HasExchangeAccess(exchange), IsTotpEnabled().

Complete Example

package main

import (
    "fmt"
    "log"

    "github.com/arrow-trade/go-arrow/arrow"
)

func portfolioDashboard(client *arrow.Client) {
    user, err := client.GetUserDetails()
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Welcome,", user.Data.Name)

    limits, _ := client.GetLimits()
    if limits != nil {
        fmt.Println("Usable margin:", limits.Data.Margin["usableMargin"])
    }

    holdings, _ := client.GetHoldings()
    fmt.Println("Holdings:", len(holdings))

    positions, _ := client.GetPositions()
    fmt.Println("Position rows:", len(positions))

    orders, _ := client.GetOrderBook()
    open := 0
    for _, o := range orders {
        if o.OrderStatus == "PENDING" || o.OrderStatus == "OPEN" {
            open++
        }
    }
    fmt.Printf("Today's orders: %d (%d open)\n", len(orders), open)

    trades, _ := client.GetTradeBook()
    fmt.Println("Trades executed:", len(trades))
}