Python SDK

Overview

The Limitless Exchange Python SDK (limitless-sdk) is an async-first Python client built on top of aiohttp. It provides:

Fully asynchronous HTTP and WebSocket clients
Pydantic models for type-safe request and response handling
Automatic venue caching for EIP-712 order signing
Built-in retry logic for transient API failures
WebSocket streaming with auto-reconnect

The SDK requires Python 3.9+ and uses async/await throughout. All network calls must be awaited inside an asyncio event loop.

Installation

pip install limitless-sdk

Quick Start

Initialize the HTTP client

import asyncio
import os
from limitless_sdk.api import HttpClient
from limitless_sdk import HMACCredentials

# Authenticate with a scoped API token (token ID + secret)
http_client = HttpClient(
    hmac_credentials=HMACCredentials(
        token_id=os.environ["LMTS_TOKEN_ID"],
        secret=os.environ["LMTS_TOKEN_SECRET"],
    ),
)

Fetch active markets

from limitless_sdk.markets import MarketFetcher

async def main():
    market_fetcher = MarketFetcher(http_client)
    markets = await market_fetcher.get_active_markets()

    for market in markets["data"]:
        print(market["title"], market["slug"])

    await http_client.close()

asyncio.run(main())

Check your positions

from limitless_sdk.portfolio import PortfolioFetcher

async def main():
    portfolio = PortfolioFetcher(http_client)
    positions = await portfolio.get_positions()

    for pos in positions.get("clob", []):
        print(pos["market"]["title"], pos["size"])

    await http_client.close()

asyncio.run(main())

Authentication

Authentication uses scoped API tokens with HMAC-SHA256 request signing. Generate one at limitless.exchange → profile menu → Api keys; you receive a token ID and a one-time secret (base64-encoded). Store the secret securely — it is shown only once.

HMAC headers lmts-api-key, lmts-timestamp, lmts-signature — the SDK builds and signs them for you when you pass HMAC credentials

Environment variables (recommended)
Root client

Store the token ID and secret in environment variables and pass them as HMAC credentials:

export LMTS_TOKEN_ID="your-token-id"
export LMTS_TOKEN_SECRET="your-base64-secret"

import os
from limitless_sdk.api import HttpClient
from limitless_sdk import HMACCredentials

http_client = HttpClient(
    hmac_credentials=HMACCredentials(
        token_id=os.environ["LMTS_TOKEN_ID"],
        secret=os.environ["LMTS_TOKEN_SECRET"],
    ),
)

The root Client composes all domain services and takes the same scoped-token credentials:

import os
from limitless_sdk import Client, HMACCredentials

client = Client(
    base_url="https://api.limitless.exchange",
    hmac_credentials=HMACCredentials(
        token_id=os.environ["LMTS_TOKEN_ID"],
        secret=os.environ["LMTS_TOKEN_SECRET"],
    ),
)

With hmac_credentials set, the SDK automatically generates and sends lmts-api-key, lmts-timestamp, and lmts-signature. Do not manually build HMAC headers when using the SDK client.

Legacy: an older API key (LIMITLESS_API_KEY, sent as the X-API-Key header) still works but is not recommended for new integrations. Prefer a scoped API token. If you must use it, pass HttpClient(api_key="lmts_your_key_here") or set the LIMITLESS_API_KEY environment variable.

Never hardcode API keys in source code or commit them to version control. Use environment variables or a secrets manager.

Client constructor

The recommended entrypoint is the root Client class, which composes all domain services (markets, portfolio, orders, API tokens, partner accounts, delegated orders):

from limitless_sdk import Client

client = Client(base_url="https://api.limitless.exchange")

For partner integrations using HMAC authentication:

from limitless_sdk import Client, HMACCredentials

client = Client(
    base_url="https://api.limitless.exchange",
    hmac_credentials=HMACCredentials(
        token_id="your-token-id",
        secret="your-base64-secret",
    ),
)

Parameter	Type	Default	Description
`base_url`	`str`	`https://api.limitless.exchange`	API base URL
`api_key`	`str \| None`	`None` (reads `LIMITLESS_API_KEY` env)	Legacy `X-API-Key` auth (still works; prefer a scoped API token)
`hmac_credentials`	`HMACCredentials \| None`	`None`	HMAC credentials for scoped API token auth (see Programmatic API)
`additional_headers`	`dict \| None`	`None`	Extra headers merged into every request

HttpClient (lower-level)

You can also use HttpClient directly for more control:

import os
from limitless_sdk.api import HttpClient
from limitless_sdk import HMACCredentials

http_client = HttpClient(
    base_url="https://api.limitless.exchange",
    hmac_credentials=HMACCredentials(
        token_id=os.environ["LMTS_TOKEN_ID"],
        secret=os.environ["LMTS_TOKEN_SECRET"],
    ),
)

Always call await http_client.close() when you are finished to cleanly shut down the underlying aiohttp session.

Logging

The SDK provides a ConsoleLogger with configurable log levels for debugging:

from limitless_sdk.types import ConsoleLogger, LogLevel

logger = ConsoleLogger(level=LogLevel.DEBUG)

Level	Description
`LogLevel.DEBUG`	Verbose output including headers, venue cache operations, and raw payloads
`LogLevel.INFO`	General operational messages
`LogLevel.WARN`	Warnings about potential issues
`LogLevel.ERROR`	Errors only

Set LogLevel.DEBUG during development to see request headers, venue cache hits/misses, and full API responses. Switch to INFO or WARN in production.

Source Code

The SDK is open source. Contributions and issue reports are welcome.

GitHub Repository

Browse the source, report issues, and contribute at github.com/limitless-labs-group/limitless-sdk

Disclaimer

USE AT YOUR OWN RISK. This SDK is provided as-is with no guarantees. You are solely responsible for any trading activity conducted through this software. Limitless Exchange is not available to users in the United States or other restricted jurisdictions. By using this SDK, you confirm compliance with all applicable local laws and regulations.

Next Steps

Markets

Discover markets, fetch orderbooks, and understand venue caching.

Market Pages

Browse markets by category with navigation, filters, and pagination.

Trading & Orders

Place GTC and FOK orders, cancel orders, and manage token approvals.

Portfolio & Positions

Track your open positions and trading history.

API Tokens

Derive, list, and revoke scoped HMAC tokens for partner integrations.

Partner Accounts

Create sub-accounts with server wallets or EOA verification.

Delegated Orders

Place orders on behalf of sub-accounts with server-side signing.

WebSocket Streaming

Subscribe to real-time orderbook and price updates.

Error Handling & Retry

Retry logic, error types, and debugging strategies.

Server Wallet Redemption and Withdrawal

For partner server-wallet sub-accounts, the SDK provides helper methods for payout settlement and treasury movement:

POST /portfolio/redeem — claim resolved positions
POST /portfolio/withdraw — transfer ERC20 funds from managed sub-accounts
POST /portfolio/withdrawal-addresses — allowlist an explicit treasury destination with Privy identity auth
DELETE /portfolio/withdrawal-addresses/:address — remove an allowlisted destination with Privy identity auth

Required scopes for apiToken auth: trading for redeem and withdrawal for withdraw. Allowlist add/delete calls use a Privy identity token instead of API-token/HMAC auth.

import os
from limitless_sdk import PartnerWithdrawalAddressInput

identity_token = os.environ["PRIVY_IDENTITY_TOKEN"]
treasury_address = "0x0F3262730c909408042F9Da345a916dc0e1F9787"

await client.partner_accounts.add_withdrawal_address(
    identity_token,
    PartnerWithdrawalAddressInput(address=treasury_address, label="treasury"),
)

withdraw = await client.server_wallets.withdraw(
    amount="1000000",
    on_behalf_of=child_profile_id,
    destination=treasury_address,
)

print(withdraw.destination)

Set on_behalf_of when withdrawing from a child server-wallet profile. destination is optional for child withdrawals; when omitted, the API defaults to the authenticated partner smart wallet when present, otherwise the authenticated partner account. You can omit on_behalf_of only when withdrawing the authenticated caller’s own server wallet to an explicit destination. See the full flow and scope guidance in Programmatic API.

Getting Started

Quick Start

TypeScript SDK

Go SDK

Rust SDK

WebSocket

Python SDK

Overview

Installation

Quick Start

Authentication

Client constructor

HttpClient (lower-level)

Logging

Source Code

GitHub Repository

Disclaimer

Next Steps

Markets

Market Pages

Trading & Orders

Portfolio & Positions

API Tokens

Partner Accounts

Delegated Orders

WebSocket Streaming

Error Handling & Retry

Server Wallet Redemption and Withdrawal

​Overview

​Installation

​Quick Start

​Authentication

​Client constructor

​HttpClient (lower-level)

​Logging

​Source Code

GitHub Repository

​Disclaimer

​Next Steps

Markets

Market Pages

Trading & Orders

Portfolio & Positions

API Tokens

Partner Accounts

Delegated Orders

WebSocket Streaming

Error Handling & Retry

​Server Wallet Redemption and Withdrawal

Overview

Installation

Quick Start

Authentication

Client constructor

HttpClient (lower-level)

Logging

Source Code

Disclaimer

Next Steps

Server Wallet Redemption and Withdrawal