Skip to main content
The DelegatedOrderService enables partners with the delegated_signing scope to place and cancel orders on behalf of their sub-accounts. The server signs orders using the sub-account’s managed Privy wallet — no private key management is needed on the partner side.
Delegated signing requires a sub-account created with CreateServerWallet: true. EOA sub-accounts sign their own orders.
Recommended setup: Store your HMAC credentials (TokenID / Secret) on your backend. Use this SDK server-side to sign partner-authenticated requests. Expose only your own app-specific endpoints to the frontend. Never expose HMAC secrets in browser bundles or client-side storage.

​
Access

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

client := limitless.NewClient(
    limitless.WithHMACCredentials(limitless.HMACCredentials{
        TokenID: tokenID,
        Secret:  secret,
    }),
)

// Use client.DelegatedOrders.*

​
Create a GTC delegated order

Builds an unsigned GTC (Good-Til-Cancelled) limit order locally and submits it to POST /orders with the OnBehalfOf profile ID. The server signs the order via the sub-account’s managed wallet. GTC orders remain on the orderbook until filled or explicitly cancelled. 
response, err := client.DelegatedOrders.CreateOrder(ctx, limitless.CreateDelegatedOrderParams{
    MarketSlug: "btc-100k",
    OrderType:  limitless.OrderTypeGTC,
    OnBehalfOf: partnerAccount.ProfileID,
    Args: limitless.GTCOrderArgs{
        TokenID: market.Tokens.Yes,
        Side:    limitless.SideBuy,
        Price:   0.55,
        Size:    10,
    },
})
if err != nil {
    log.Fatal(err)
}

fmt.Println(response.Order.ID)
Use PostOnly: true to ensure the order only rests on the book and is never filled immediately as a taker: 
response, err := client.DelegatedOrders.CreateOrder(ctx, limitless.CreateDelegatedOrderParams{
    MarketSlug: "btc-100k",
    OrderType:  limitless.OrderTypeGTC,
    OnBehalfOf: partnerAccount.ProfileID,
    Args: limitless.GTCOrderArgs{
        TokenID:  market.Tokens.Yes,
        Side:     limitless.SideBuy,
        Price:    0.55,
        Size:     10,
        PostOnly: true,
    },
})

​
Create a FAK delegated order

FAK (Fill-And-Kill) orders use the same Price and Size inputs as GTC, but they only consume immediately available liquidity and cancel any unmatched remainder. PostOnly is not supported for FAK orders. 
response, err := client.DelegatedOrders.CreateOrder(ctx, limitless.CreateDelegatedOrderParams{
    MarketSlug: "btc-100k",
    OrderType:  limitless.OrderTypeFAK,
    OnBehalfOf: partnerAccount.ProfileID,
    Args: limitless.FAKOrderArgs{
        TokenID: market.Tokens.Yes,
        Side:    limitless.SideBuy,
        Price:   0.45,
        Size:    10.0,
    },
})
if err != nil {
    log.Fatal(err)
}

if len(response.MakerMatches) > 0 {
    fmt.Printf("FAK order matched immediately with %d fill(s)\n", len(response.MakerMatches))
} else {
    fmt.Println("FAK remainder was cancelled.")
}

​
Create a FOK delegated order

FOK (Fill-Or-Kill) orders execute immediately at the best available price or are cancelled entirely — there are no partial fills. Instead of Price and Size, FOK orders use MakerAmount:
  • BUY: MakerAmount is the USDC amount to spend (e.g., 50.0 = spend $50 USDC)
  • SELL: MakerAmount is the number of shares to sell (e.g., 18.64 = sell 18.64 shares)
// BUY FOK — spend 1 USDC at market price
response, err := client.DelegatedOrders.CreateOrder(ctx, limitless.CreateDelegatedOrderParams{
    MarketSlug: "btc-100k",
    OrderType:  limitless.OrderTypeFOK,
    OnBehalfOf: partnerAccount.ProfileID,
    FeeRateBps: 300,
    Args: limitless.FOKOrderArgs{
        TokenID:     market.Tokens.Yes,
        Side:        limitless.SideBuy,
        MakerAmount: 1.0,
    },
})
if err != nil {
    log.Fatal(err)
}

if len(response.MakerMatches) > 0 {
    fmt.Printf("FOK order matched with %d fill(s)\n", len(response.MakerMatches))
} else {
    fmt.Println("FOK order was not matched — cancelled automatically")
}

// SELL FOK — sell 10 shares at market price
response, err = client.DelegatedOrders.CreateOrder(ctx, limitless.CreateDelegatedOrderParams{
    MarketSlug: "btc-100k",
    OrderType:  limitless.OrderTypeFOK,
    OnBehalfOf: partnerAccount.ProfileID,
    Args: limitless.FOKOrderArgs{
        TokenID:     market.Tokens.Yes,
        Side:        limitless.SideSell,
        MakerAmount: 10.0,
    },
})

​
Parameters

​
GTC order args (GTCOrderArgs)

FieldTypeDescription
MarketSlugstringMarket identifier
OrderTypeOrderTypelimitless.OrderTypeGTC
OnBehalfOfintProfile ID of the sub-account
Args.TokenIDstringPosition token ID (YES or NO) from market data
Args.SideSidelimitless.SideBuy or limitless.SideSell
Args.Pricefloat64Price between 0 and 1
Args.Sizefloat64Number of contracts
Args.PostOnlyboolOptional. true rejects the order if it would immediately match. Default false.
FeeRateBpsintFee rate in basis points (defaults to 300 if omitted)

​
FAK order args (FAKOrderArgs)

FieldTypeDescription
MarketSlugstringMarket identifier
OrderTypeOrderTypelimitless.OrderTypeFAK
OnBehalfOfintProfile ID of the sub-account
Args.TokenIDstringPosition token ID (YES or NO) from market data
Args.SideSidelimitless.SideBuy or limitless.SideSell
Args.Pricefloat64Price between 0 and 1
Args.Sizefloat64Number of contracts
FeeRateBpsintFee rate in basis points (defaults to 300 if omitted)

​
FOK order args (FOKOrderArgs)

FieldTypeDescription
MarketSlugstringMarket identifier
OrderTypeOrderTypelimitless.OrderTypeFOK
OnBehalfOfintProfile ID of the sub-account
Args.TokenIDstringPosition token ID (YES or NO) from market data
Args.SideSidelimitless.SideBuy or limitless.SideSell
Args.MakerAmountfloat64BUY: USDC to spend. SELL: shares to sell. Max 6 decimals.
FeeRateBpsintFee rate in basis points (defaults to 300 if omitted)

​
Cancel an order

message, err := client.DelegatedOrders.Cancel(ctx, orderID)

​
Cancel on behalf of a sub-account

message, err := client.DelegatedOrders.CancelOnBehalfOf(ctx, orderID, partnerAccount.ProfileID)

​
Cancel all orders in a market

message, err := client.DelegatedOrders.CancelAll(ctx, marketSlug)

​
Cancel all on behalf of a sub-account

message, err := client.DelegatedOrders.CancelAllOnBehalfOf(ctx, marketSlug, partnerAccount.ProfileID)

​
How it works

  1. The SDK builds an unsigned order locally with a zero verifying address and default fee rate (300 bps)
  2. For GTC and FAK orders, Price and Size are used; for FOK orders, MakerAmount is used (with TakerAmount always set to 1)
  3. The order is posted to POST /orders with OnBehalfOf and OwnerID set to the sub-account’s profile ID
  4. The server detects the delegated_signing scope and missing signature
  5. The server looks up the sub-account’s server wallet, builds EIP-712 typed data, and signs via Privy
  6. The signed order is submitted to the CLOB engine — GTC orders can rest on the book, FAK orders cancel unmatched remainder, and FOK orders either fully fill or cancel