Programmatic API

​

Recommended architecture

​

Overview

​

Partner lifecycle

import { Client, HMACCredentials } from '@limitless-exchange/sdk';

const client = new Client({
  baseURL: 'https://api.limitless.exchange',
});

const derived = await client.apiTokens.deriveToken(identityToken, {
  label: 'my-trading-bot',
  scopes: ['trading', 'account_creation', 'delegated_signing'],
});

const scopedClient = new Client({
  baseURL: 'https://api.limitless.exchange',
  hmacCredentials: {
    tokenId: derived.tokenId,
    secret: derived.secret,
  },
});

const account = await scopedClient.partnerAccounts.createAccount({
  displayName: 'user-alice',
  createServerWallet: true,
});
// account.profileId, account.account

import { OrderType, Side } from '@limitless-exchange/sdk';

const gtcOrder = await scopedClient.delegatedOrders.createOrder({
  marketSlug: 'btc-100k',
  orderType: OrderType.GTC,
  onBehalfOf: account.profileId,
  args: {
    tokenId: market.tokens.yes,
    side: Side.BUY,
    price: 0.55,
    size: 10,
    postOnly: true, // Optional for GTC only
  },
});

const fakOrder = await scopedClient.delegatedOrders.createOrder({
  marketSlug: 'btc-100k',
  orderType: OrderType.FAK,
  onBehalfOf: account.profileId,
  args: {
    tokenId: market.tokens.yes,
    side: Side.BUY,
    price: 0.45,
    size: 10,
  },
});

const fokOrder = await scopedClient.delegatedOrders.createOrder({
  marketSlug: 'btc-100k',
  orderType: OrderType.FOK,
  onBehalfOf: account.profileId,
  args: {
    tokenId: market.tokens.yes,
    side: Side.BUY,
    makerAmount: 10, // spend 10 USDC
  },
});

​

Scopes

​

Scope requirements by operation

​

Sub-account modes

​

Server wallet (Web2 partners)

​

Lifecycle after a trade

1. Order execution - Place and cancel orders through POST /orders or the SDK DelegatedOrderService.
2. Portfolio resolution state - Portfolio endpoints such as GET /portfolio/positions and GET /portfolio/{account}/positions may later show status: RESOLVED and winningOutcomeIndex once the winning side is known.
3. On-chain payout settlement - Winning positions become redeemable only after the underlying conditional token payout has been reported on-chain.

​

Redemption and withdrawal support

• POST /portfolio/redeem to submit redeemPositions for a resolved condition.
• POST /portfolio/withdraw to transfer ERC20 funds from a managed sub-account server wallet to the partner’s own account or smart wallet.

​

EOA (Web3 partners)

​

End-to-end flow

1. Register the user’s wallet (once per address) — POST /profiles/partner-accounts with EOA headers. The response returns profileId and the wallet account. If a profile already exists for that address, the API returns 409 Conflict — your app should reuse the stored profileId instead of re-registering.
2. Persist the mapping in your backend — save at least walletAddress → profileId (and your own user id if you have one). You are not storing a Limitless “session object”; you are storing your app’s record so you know which profileId to pass on orders. See What to persist below.
3. User signs each order — build the order per EIP-712 signing and have the user sign in the browser (e.g. wagmi/viem/ethers). maker and signer must be the user’s EOA address.
4. Submit the order from your backend (HMAC) — POST /orders with HMAC auth, onBehalfOf set to the user’s profileId, and ownerId set to that same profileId when you send a signed order body. The order’s maker / signer must match the sub-account wallet. (If you use delegated signing with an unsigned order, the server sets ownerId for you — that path is for server-wallet sub-accounts, not pure EOA signing.)

​

Common EOA auth error

• ownerId = user’s profileId
• onBehalfOf = same user’s profileId
• order.maker and order.signer = that user’s wallet address

​

Architecture (browser + backend)

• Browser: connect wallet (e.g. wagmi + RainbowKit); sign the ownership proof for step 1; sign EIP-712 orders for step 3. Never put partner HMAC secrets in client bundles.
• Backend (Next.js Route Handlers, server actions, or a separate API): holds the scoped token tokenId / secret; signs every request to api.limitless.exchange with HMAC; forwards POST /orders after the client submits the signed order payload (or proxies market data as needed).

​

What to persist for EOA partners

​

Delegated order types

​

GTC (Good-Til-Cancelled)

​

FAK (Fill-And-Kill)

​

FOK (Fill-Or-Kill)

import { OrderType, Side } from '@limitless-exchange/sdk';

// FAK BUY — fill immediately up to 10 shares at 0.45, cancel remainder
const response = await scopedClient.delegatedOrders.createOrder({
  marketSlug: 'btc-100k',
  orderType: OrderType.FAK,
  onBehalfOf: account.profileId,
  args: {
    tokenId: market.tokens.yes,
    side: Side.BUY,
    price: 0.45,
    size: 10,
  },
});

if (response.makerMatches?.length) {
  console.log(`Matched immediately with ${response.makerMatches.length} fill(s)`);
} else {
  console.log('No immediate fill. Remainder was cancelled.');
}

​

Reading sub-account data

​

How it works

GET /portfolio/positions HTTP/1.1
Host: api.limitless.exchange
lmts-api-key: <your-token-id>
lmts-signature: <hmac-signature>
lmts-timestamp: <unix-ms>
x-on-behalf-of: 1292711

​

Requirements

1. Scope — your API token must include the delegated_signing scope.
2. Ownership — the target profile must be a sub-account linked to your partner profile.
3. Auth — use your existing HMAC flow (lmts-api-key, lmts-signature, lmts-timestamp). Nothing new.

​

Supported endpoints

​

Without the header

​

Error responses

​

HMAC authentication

​

API endpoints

​

SDK support