Portfolio & Positions

Overview

The PortfolioFetcher retrieves your profile, open positions, and trading history from the Limitless Exchange API. It requires an authenticated HttpClient.

Setup

import (
    "os"

    limitless "github.com/limitless-labs-group/limitless-exchange-go-sdk/limitless"
)

client := limitless.NewHttpClient(
    limitless.WithHMACCredentials(limitless.HMACCredentials{
        TokenID: os.Getenv("LMTS_TOKEN_ID"),
        Secret:  os.Getenv("LMTS_TOKEN_SECRET"),
    }),
)
portfolio := limitless.NewPortfolioFetcher(client)

PortfolioFetcher requires an authenticated client. Use WithHMACCredentials with a scoped API token (recommended). The legacy LIMITLESS_API_KEY / WithAPIKey still works but is not recommended for new integrations.

Current profile

Use GetCurrentProfile() to fetch the authenticated caller’s private profile via GET /profiles/me. This is the preferred helper when the client is already authenticated and you do not want to pass a wallet address.

ctx := context.Background()
profile, err := portfolio.GetCurrentProfile(ctx)
if err != nil {
    log.Fatal(err)
}

fmt.Printf("Profile ID: %d\n", profile.ID)
fmt.Printf("Account: %s\n", profile.Account)
if profile.Rank != nil {
    fmt.Printf("Fee rate: %d bps\n", profile.Rank.FeeRateBps)
}

Fetching a profile by address

Use GetProfile() to retrieve your own profile by wallet address (the API returns 403 for any other address). Prefer GetCurrentProfile(), which needs no address. Other users’ public profiles are served by GET /profiles/public/{address}, which has no SDK method yet; call it with client.GetRaw.

profile, err := portfolio.GetProfile(ctx, "0xYOUR_WALLET_ADDRESS")
if err != nil {
    log.Fatal(err)
}

fmt.Printf("Username: %s\n", profile.Username)
fmt.Printf("Display name: %s\n", profile.DisplayName)
if profile.Rank != nil {
    fmt.Printf("Rank: %s (fee rate: %d bps)\n", profile.Rank.Name, profile.Rank.FeeRateBps)
}

UserProfile fields

Field	Type	Description
`ID`	`int`	User ID
`Account`	`string`	Wallet address
`Username`	`*string`	Username (nil if unset)
`DisplayName`	`*string`	Display name (nil if unset)
`Rank`	`*UserRank`	User rank with fee rate
`Points`	`*float64`	Accumulated points (nil if unset)

Fetching all positions

Use GetPositions() to retrieve all your open positions:

positions, err := portfolio.GetPositions(ctx)
if err != nil {
    log.Fatal(err)
}

fmt.Printf("CLOB positions: %d\n", len(positions.CLOB))
fmt.Printf("AMM positions: %d\n", len(positions.AMM))

The response is a PortfolioPositionsResponse with the following fields:

Field	Type	Description
`CLOB`	`[]CLOBPosition`	Positions on CLOB (order book) markets
`AMM`	`[]AMMPosition`	Positions on AMM (automated market maker) markets
`Points`	`*string`	Accumulated points (nil if unset)
`Rewards`	`*PortfolioRewards`	Accumulated rewards (nil if unset)

GetPositions, GetUserHistory and GetUserOrders always read the authenticated profile: the Go client has no per-request header hook for GET requests, so it cannot send x-on-behalf-of on a single call. To read a server-wallet sub-account, build a second HttpClient with WithAdditionalHeaders(map[string]string{"x-on-behalf-of": "<profileId>"}) and use it only for these reads. The header is rejected with 400 on POST /orders and the cancel endpoints, so never set it on the client that places or cancels orders.

CLOB positions

Use GetCLOBPositions() for CLOB-only positions, or iterate over positions.CLOB:

clobPositions, err := portfolio.GetCLOBPositions(ctx)
if err != nil {
    log.Fatal(err)
}

for _, pos := range clobPositions {
    fmt.Printf("%s — yes: %s, no: %s\n", pos.Market.Title, pos.TokensBalance.Yes, pos.TokensBalance.No)
}

CLOBPosition fields

Field	Type	Description
`Market`	`PositionMarket`	Market title, slug, and metadata
`MakerAddress`	`string`	Your wallet address
`Positions`	`CLOBPositionSides`	Position details per side
`TokensBalance`	`TokenBalance`	Current token balance (per-outcome)
`LatestTrade`	`LatestTrade`	Most recent trade on this position
`Orders`	`*CLOBPositionOrders`	Open orders (nil if none)

AMM positions

Use GetAMMPositions() for AMM-only positions:

ammPositions, err := portfolio.GetAMMPositions(ctx)
if err != nil {
    log.Fatal(err)
}

for _, pos := range ammPositions {
    fmt.Printf("%s — outcome: %d, unrealized PnL: %s\n",
        pos.Market.Title, pos.OutcomeIndex, pos.UnrealizedPnl)
}

AMMPosition fields

Field	Type	Description
`Market`	`PositionMarket`	Market title, slug, and metadata
`Account`	`string`	Your wallet address
`OutcomeIndex`	`int`	Outcome index
`CollateralAmount`	`string`	Collateral deposited
`OutcomeTokenAmount`	`string`	Outcome tokens held
`AverageFillPrice`	`string`	Average entry price
`RealizedPnl`	`string`	Realized profit and loss
`UnrealizedPnl`	`string`	Unrealized profit and loss

Trading history

Use GetUserHistory() to retrieve cursor-paginated trading history. The signature is GetUserHistory(ctx, cursor string, limit int) — pass an empty cursor for the first page, then *history.NextCursor for subsequent pages:

history, err := portfolio.GetUserHistory(ctx, "", 20) // first page, 20 items
if err != nil {
    log.Fatal(err)
}

fmt.Printf("Fetched %d trades\n", len(history.Data))
for _, entry := range history.Data {
    fmt.Printf("%+v\n", entry)
}

// Next page, if any
if history.NextCursor != nil {
    next, err := portfolio.GetUserHistory(ctx, *history.NextCursor, 20)
    if err != nil {
        log.Fatal(err)
    }
    _ = next
}

Complete example

package main

import (
    "context"
    "fmt"
    "log"
    "os"

    limitless "github.com/limitless-labs-group/limitless-exchange-go-sdk/limitless"
)

func main() {
    client := limitless.NewHttpClient(
        limitless.WithHMACCredentials(limitless.HMACCredentials{
            TokenID: os.Getenv("LMTS_TOKEN_ID"),
            Secret:  os.Getenv("LMTS_TOKEN_SECRET"),
        }),
    )
    portfolio := limitless.NewPortfolioFetcher(client)
    ctx := context.Background()

    // Fetch all positions
    positions, err := portfolio.GetPositions(ctx)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("CLOB positions: %d\n", len(positions.CLOB))
    for _, pos := range positions.CLOB {
        fmt.Printf("  %s — yes: %s, no: %s\n", pos.Market.Title, pos.TokensBalance.Yes, pos.TokensBalance.No)
    }

    fmt.Printf("\nAMM positions: %d\n", len(positions.AMM))
    for _, pos := range positions.AMM {
        fmt.Printf("  %s — unrealized PnL: %s\n", pos.Market.Title, pos.UnrealizedPnl)
    }

    // Fetch trading history (cursor-based; empty cursor = first page)
    history, err := portfolio.GetUserHistory(ctx, "", 10)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("\nRecent trades: %d\n", len(history.Data))
}

Getting Started

Quick Start

TypeScript SDK

Python SDK

Go SDK

Rust SDK

WebSocket

Overview

Setup

Current profile

Fetching a profile by address

UserProfile fields

Fetching all positions

CLOB positions

CLOBPosition fields

AMM positions

AMMPosition fields

Trading history

Complete example

​Overview

​Setup

​Current profile

​Fetching a profile by address

​UserProfile fields

​Fetching all positions

​CLOB positions

​CLOBPosition fields

​AMM positions

​AMMPosition fields

​Trading history

​Complete example

Overview

Setup

Current profile

Fetching a profile by address

UserProfile fields

Fetching all positions

CLOB positions

CLOBPosition fields

AMM positions

AMMPosition fields

Trading history

Complete example