Historical data.

// Module 11, Fetching Your Trade History
// GET /portfolio/trades returns an array of your AMM fills (no pagination).
// Every entry includes blockTimestamp, outcomeTokenPrice, outcomeTokenNetCost,
// strategy ('Buy' | 'Sell'), and the full market object.

import { createHmac } from 'node:crypto';

const BASE = 'https://api.limitless.exchange';

function signedHeaders(method: string, pathWithQuery: string, body = ''): Record<string, string> {
  const ts  = new Date().toISOString();
  const msg = `${ts}\n${method}\n${pathWithQuery}\n${body}`;
  const sig = createHmac('sha256', Buffer.from(process.env.LMTS_TOKEN_SECRET!, 'base64'))
    .update(msg)
    .digest('base64');
  return {
    'lmts-api-key':   process.env.LMTS_TOKEN_ID!,
    'lmts-timestamp': ts,
    'lmts-signature': sig,
  };
}

type Trade = {
  blockTimestamp:      string;   // ISO 8601
  collateralAmount:    string;
  market: {
    conditionId:     string;
    expirationDate:  string;
    id:              string;
    slug:            string;
    title:           string;
  };
  outcomeIndex:        number;   // 0 = YES, 1 = NO
  outcomeTokenAmount:  string;
  outcomeTokenAmounts: string[];
  outcomeTokenNetCost: string;
  outcomeTokenPrice:   string;
  strategy:            'Buy' | 'Sell';
  transactionHash:     string;
};

async function fetchMyTrades(): Promise<Trade[]> {
  const res = await fetch(`${BASE}/portfolio/trades`, {
    headers: signedHeaders('GET', '/portfolio/trades'),
  });
  if (!res.ok) throw new Error(`HTTP ${res.status}`);
  return (await res.json()) as Trade[];
}

(async () => {
  const trades = await fetchMyTrades();
  console.log(`Fetched ${trades.length} AMM trades`);

  for (const t of trades) {
    const side = t.outcomeIndex === 0 ? 'YES' : 'NO';
    console.log(t.blockTimestamp, t.strategy, side,
                '@', t.outcomeTokenPrice, ', ', t.market.slug);
  }

  // For CLOB fills, splits, merges, claims, use /portfolio/history
  // with page + limit (and optional from/to ISO timestamps).
})();

# Module 11, Fetching Your Trade History
# GET /portfolio/trades returns an array of your AMM fills (no pagination).
# Each entry: blockTimestamp, outcomeTokenPrice, outcomeTokenNetCost,
# strategy ('Buy' | 'Sell'), and the market object.

import asyncio
import base64
import datetime
import hashlib
import hmac
import os
import httpx

BASE = "https://api.limitless.exchange"


def signed_headers(method: str, path_with_query: str, body: str = "") -> dict[str, str]:
    now = datetime.datetime.now(datetime.timezone.utc)
    ts  = now.strftime("%Y-%m-%dT%H:%M:%S.") + f"{now.microsecond // 1000:03d}Z"
    msg = f"{ts}\n{method}\n{path_with_query}\n{body}"
    sig = base64.b64encode(
        hmac.new(base64.b64decode(os.environ["LMTS_TOKEN_SECRET"]),
                 msg.encode("utf-8"), hashlib.sha256).digest()
    ).decode("ascii")
    return {
        "lmts-api-key":   os.environ["LMTS_TOKEN_ID"],
        "lmts-timestamp": ts,
        "lmts-signature": sig,
    }


async def fetch_my_trades() -> list[dict]:
    async with httpx.AsyncClient(timeout=10.0) as client:
        resp = await client.get(f"{BASE}/portfolio/trades", headers=signed_headers("GET", "/portfolio/trades"))
        resp.raise_for_status()
        return resp.json()  # array, not wrapped


async def main() -> None:
    trades = await fetch_my_trades()
    print(f"Fetched {len(trades)} AMM trades")

    for t in trades:
        side = "YES" if t["outcomeIndex"] == 0 else "NO"
        print(
            t["blockTimestamp"], t["strategy"], side,
            "@", t["outcomeTokenPrice"], ", ", t["market"]["slug"],
        )

    # For CLOB fills, splits, merges, claims, use /portfolio/history
    # with required page + limit, optional from/to (ISO 8601).


if __name__ == "__main__":
    asyncio.run(main())

// Module 11, Fetching Your Trade History
// GET /portfolio/trades returns an array of your AMM fills (no pagination).

package main

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/base64"
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "os"
    "time"
)

const base = "https://api.limitless.exchange"

func signedHeaders(method, pathWithQuery, body string) map[string]string {
    ts := time.Now().UTC().Format("2006-01-02T15:04:05.000Z")
    msg := ts + "\n" + method + "\n" + pathWithQuery + "\n" + body
    secret, _ := base64.StdEncoding.DecodeString(os.Getenv("LMTS_TOKEN_SECRET"))
    mac := hmac.New(sha256.New, secret)
    mac.Write([]byte(msg))
    sig := base64.StdEncoding.EncodeToString(mac.Sum(nil))
    return map[string]string{
        "lmts-api-key":   os.Getenv("LMTS_TOKEN_ID"),
        "lmts-timestamp": ts,
        "lmts-signature": sig,
    }
}

type TradeMarket struct {
    ConditionID    string `json:"conditionId"`
    ExpirationDate string `json:"expirationDate"`
    ID             string `json:"id"`
    Slug           string `json:"slug"`
    Title          string `json:"title"`
}

type Trade struct {
    BlockTimestamp      string      `json:"blockTimestamp"`
    CollateralAmount    string      `json:"collateralAmount"`
    Market              TradeMarket `json:"market"`
    OutcomeIndex        int         `json:"outcomeIndex"` // 0 = YES, 1 = NO
    OutcomeTokenAmount  string      `json:"outcomeTokenAmount"`
    OutcomeTokenAmounts []string    `json:"outcomeTokenAmounts"`
    OutcomeTokenNetCost string      `json:"outcomeTokenNetCost"`
    OutcomeTokenPrice   string      `json:"outcomeTokenPrice"`
    Strategy            string      `json:"strategy"` // "Buy" | "Sell"
    TransactionHash     string      `json:"transactionHash"`
}

func main() {
    req, err := http.NewRequest(http.MethodGet, base+"/portfolio/trades", nil)
    if err != nil {
        log.Fatal(err)
    }
    for k, v := range signedHeaders("GET", "/portfolio/trades", "") {
        req.Header.Set(k, v)
    }

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        log.Fatal(err)
    }
    defer resp.Body.Close()

    var trades []Trade
    if err := json.NewDecoder(resp.Body).Decode(&trades); err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Fetched %d AMM trades\n", len(trades))
    for _, t := range trades {
        side := "YES"
        if t.OutcomeIndex == 1 {
            side = "NO"
        }
        fmt.Printf("%s %s %s @ %s, %s\n",
            t.BlockTimestamp, t.Strategy, side,
            t.OutcomeTokenPrice, t.Market.Slug)
    }

    // For CLOB fills, splits, merges, claims, call /portfolio/history
    // with required page + limit (and optional from/to ISO 8601).
}