Markets

Overview

The MarketFetcher handles market discovery, individual market lookups, and orderbook retrieval. It also automatically caches venue contract addresses needed for order signing.

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"),
    }),
)
marketFetcher := limitless.NewMarketFetcher(client)

Fetching active markets

Use GetActiveMarkets() to retrieve a paginated list of all active markets:

ctx := context.Background()
result, err := marketFetcher.GetActiveMarkets(ctx, &limitless.ActiveMarketsParams{
    Page:   1,
    Limit:  10,
    SortBy: limitless.SortByNewest,
})
if err != nil {
    log.Fatal(err)
}

for _, m := range result.Data {
    fmt.Println(m.Title, m.Slug)
}

Parameter	Type	Default	Description
`Page`	`int`	`1`	Page number for pagination
`Limit`	`int`	`25` (server default)	Markets per page, 1 to 25; larger values are rejected with 400
`SortBy`	`ActiveMarketsSortBy`	`""`	Sort order

Sort options

Constant	Description
`SortByLPRewards`	Sort by LP rewards
`SortByEndingSoon`	Sort by markets ending soonest
`SortByNewest`	Sort by newest markets
`SortByHighValue`	Sort by highest value
`SortByTrending`	Sort by trending markets (Go SDK newer than v1.1.0)

Use pagination parameters to avoid large responses. Start with a small Limit and increment Page as needed.

Fetching a single market

Use GetMarket() to retrieve full details for a specific market:

market, err := marketFetcher.GetMarket(ctx, "btc-above-100k-march-2025")
if err != nil {
    log.Fatal(err)
}

fmt.Println(market.Title)
fmt.Println("YES token:", market.Tokens.Yes)
fmt.Println("NO token:", market.Tokens.No)
fmt.Println("Exchange:", market.Venue.Exchange)

The returned Market struct has the following key fields:

Field	Type	Description
`Title`	`string`	Human-readable market title
`Slug`	`string`	URL-friendly market identifier
`Tokens.Yes`	`string`	Token ID for the YES outcome
`Tokens.No`	`string`	Token ID for the NO outcome
`Venue.Exchange`	`string`	Exchange contract address (used as EIP-712 `verifyingContract`)
`Venue.Adapter`	`*string`	Adapter contract address (used for NegRisk token approvals)
`Markets`	`[]Market`	Sub-markets (for NegRisk group markets)

Token IDs are returned as strings. Pass them directly to OrderClient.CreateOrder() via FOKOrderArgs or GTCOrderArgs.

Fetching the orderbook

Use GetOrderBook() to retrieve current bids and asks for a market:

orderbook, err := marketFetcher.GetOrderBook(ctx, "btc-above-100k-march-2025")
if err != nil {
    log.Fatal(err)
}

fmt.Println("Bids:")
for _, bid := range orderbook.Bids {
    fmt.Printf("  Price: %.3f  Size: %.2f shares\n", bid.Price, bid.Size/1e6)
}

fmt.Println("Asks:")
for _, ask := range orderbook.Asks {
    fmt.Printf("  Price: %.3f  Size: %.2f shares\n", ask.Price, ask.Size/1e6)
}

fmt.Printf("Midpoint: %.4f\n", orderbook.AdjustedMidpoint)

Level Size and MinSize are in raw 6-decimal units (1 share = 1,000,000); MinSize is a decimal string. Price is not scaled.

Fetching user orders

Use GetUserOrders() to retrieve your open orders on a market (requires authentication):

orders, err := marketFetcher.GetUserOrders(ctx, "btc-above-100k-march-2025")
if err != nil {
    log.Fatal(err)
}

for _, order := range orders {
    fmt.Printf("Order %s: %s %s remaining of %s @ %s\n", order.ID, order.Side, order.RemainingSize, order.OriginalSize, order.Price)
}

Sizes and amounts are decimal strings in raw 6-decimal units; divide by 1e6 for shares or USDC. Go SDK v1.1.0 cannot decode a non-empty user-orders response; these fields exist on the SDK after v1.1.0.

Venue caching

Every call to GetMarket() automatically caches the venue contract addresses (exchange and adapter) for that market. The OrderClient reads from this cache when signing orders, so you do not need to manage venues manually.

Fetch the market

Calling GetMarket() retrieves and caches the venue:

market, err := marketFetcher.GetMarket(ctx, "btc-above-100k-march-2025")
// Venue is now cached for this slug

Check the cache

You can also access the venue cache directly:

venue, ok := marketFetcher.GetVenue("btc-above-100k-march-2025")
if ok {
    fmt.Println("Exchange:", venue.Exchange)
}

Place an order

The OrderClient automatically looks up the cached venue when you pass MarketSlug:

result, err := orderClient.CreateOrder(ctx, limitless.CreateOrderParams{
    OrderType:  limitless.OrderTypeGTC,
    MarketSlug: "btc-above-100k-march-2025",
    Args: limitless.GTCOrderArgs{
        TokenID: market.Tokens.Yes,
        Side:    limitless.SideBuy,
        Price:   0.65,
        Size:    10.0,
    },
})

Call GetMarket(slug) before placing orders on a market so the venue is cached. Otherwise the OrderClient fetches the market on the first order (logging a warning) and pays one extra round-trip.

Debugging venue cache

Enable LogLevelDebug logging to see venue cache operations:

logger := limitless.NewConsoleLogger(limitless.LogLevelDebug)
marketFetcher := limitless.NewMarketFetcher(client, limitless.WithMarketLogger(logger))

// Output will include lines like:
// [DEBUG] Venue cached for btc-above-100k-march-2025: exchange=0xA1b2... adapter=0xD4e5...
// [DEBUG] Venue cache hit for btc-above-100k-march-2025

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"),
        }),
    )
    marketFetcher := limitless.NewMarketFetcher(client)
    ctx := context.Background()

    // List active markets
    active, err := marketFetcher.GetActiveMarkets(ctx, &limitless.ActiveMarketsParams{Limit: 5})
    if err != nil {
        log.Fatal(err)
    }
    for _, m := range active.Data {
        fmt.Printf("%s — %s\n", m.Title, m.Slug)
    }

    // Get a specific market
    slug := active.Data[0].Slug
    market, err := marketFetcher.GetMarket(ctx, slug)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("\nMarket: %s\n", market.Title)
    fmt.Printf("YES token: %s\n", market.Tokens.Yes)
    fmt.Printf("NO token:  %s\n", market.Tokens.No)

    // Fetch the orderbook
    orderbook, err := marketFetcher.GetOrderBook(ctx, slug)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("\nOrderbook — %d bids, %d asks\n", len(orderbook.Bids), len(orderbook.Asks))
}

Getting Started

Quick Start

TypeScript SDK

Python SDK

Go SDK

Rust SDK

WebSocket

Overview

Setup

Fetching active markets

Sort options

Fetching a single market

Fetching the orderbook

Fetching user orders

Venue caching

Debugging venue cache

Complete example

​Overview

​Setup

​Fetching active markets

​Sort options

​Fetching a single market

​Fetching the orderbook

​Fetching user orders

​Venue caching

​Debugging venue cache

​Complete example

Overview

Setup

Fetching active markets

Sort options

Fetching a single market

Fetching the orderbook

Fetching user orders

Venue caching

Debugging venue cache

Complete example