Markets.

// Module 04, Filtering & Pagination
// Page through every active CLOB market in a category.

import { HttpClient, MarketFetcher } from '@limitless-exchange/sdk';

const httpClient = new HttpClient({ apiKey: process.env.LIMITLESS_API_KEY });
const marketFetcher = new MarketFetcher(httpClient);

async function* iterateMarkets(categoryId: number) {
  let page = 1;
  const limit = 50;

  while (true) {
    const markets = await marketFetcher.getActiveMarkets({
      page,
      limit,
      categoryId,
      tradeType: 'clob',
      sortBy:    'trending',
    });

    if (markets.length === 0) return;
    for (const m of markets) yield m;
    if (markets.length < limit) return; // last page
    page += 1;
  }
}

async function main() {
  let seen = 0;
  for await (const m of iterateMarkets(7 /* crypto */)) {
    seen += 1;
    if (m.liquidity > 10_000) console.log(m.slug, m.liquidity);
  }
  console.log(`Scanned ${seen} markets`);
}

main().catch(console.error);

# Module 04, Filtering & Pagination
# Page through every active CLOB market in a category.

import asyncio
from limitless_sdk import HttpClient
from limitless_sdk.markets import MarketFetcher

http_client = HttpClient()
market_fetcher = MarketFetcher(http_client)


async def iterate_markets(category_id: int):
    page, limit = 1, 50
    while True:
        response = await market_fetcher.get_active_markets(
            page=page,
            limit=limit,
            category_id=category_id,
            trade_type="clob",
            sort_by="trending",
        )
        markets = response["data"]
        if not markets:
            return
        for m in markets:
            yield m
        if len(markets) < limit:
            return
        page += 1


async def main() -> None:
    seen = 0
    async for m in iterate_markets(category_id=7):
        seen += 1
        if m["liquidity"] > 10_000:
            print(m["slug"], m["liquidity"])
    print(f"Scanned {seen} markets")

    await http_client.close()


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

// Module 04, Filtering & Pagination
// Page through every active CLOB market in a category.

package main

import (
    "context"
    "fmt"
    "log"

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

func main() {
    ctx := context.Background()
    client := limitless.NewHttpClient()
    marketFetcher := limitless.NewMarketFetcher(client)

    seen := 0
    page := 1
    limit := 50
    for {
        result, err := marketFetcher.GetActiveMarkets(ctx, &limitless.ActiveMarketsParams{
            Page:       page,
            Limit:      limit,
            CategoryID: 7, // crypto
            TradeType:  "clob",
            SortBy:     "trending",
        })
        if err != nil {
            log.Fatal(err)
        }
        for _, m := range result.Data {
            seen++
            if m.Liquidity > 10000 {
                fmt.Println(m.Slug, m.Liquidity)
            }
        }
        if len(result.Data) < limit {
            break
        }
        page++
    }
    fmt.Printf("Scanned %d markets\n", seen)
}

// Module 04, Market Detail
// Fetch a single market and map it into a typed model.

import { HttpClient, MarketFetcher } from '@limitless-exchange/sdk';

const httpClient = new HttpClient({ apiKey: process.env.LIMITLESS_API_KEY });
const marketFetcher = new MarketFetcher(httpClient);

interface Market {
  slug:       string;
  title:      string;
  tradeType:  'clob' | 'amm';
  isLive:     boolean;
  volume:     number;
  liquidity:  number;
}

function toMarket(raw: any): Market {
  return {
    slug:      raw.slug,
    title:     raw.title,
    tradeType: raw.tradeType,
    isLive:    raw.status === 'active' && !raw.expired,
    volume:    Number(raw.volume    ?? 0),
    liquidity: Number(raw.liquidity ?? 0),
  };
}

async function main() {
  const raw    = await marketFetcher.getMarket('will-btc-close-above-100k-eoy');
  const market = toMarket(raw);
  console.log(market);
}

main().catch(console.error);

# Module 04, Market Detail
# Fetch a single market and map it into a dataclass.

import asyncio
from dataclasses import dataclass
from limitless_sdk import HttpClient
from limitless_sdk.markets import MarketFetcher

http_client = HttpClient()
market_fetcher = MarketFetcher(http_client)


@dataclass
class Market:
    slug: str
    title: str
    trade_type: str
    is_live: bool
    volume: float
    liquidity: float


def to_market(raw: dict) -> Market:
    return Market(
        slug=raw["slug"],
        title=raw["title"],
        trade_type=raw["tradeType"],
        is_live=raw["status"] == "active" and not raw["expired"],
        volume=float(raw.get("volume", 0)),
        liquidity=float(raw.get("liquidity", 0)),
    )


async def main() -> None:
    raw = await market_fetcher.get_market("will-btc-close-above-100k-eoy")
    print(to_market(raw))
    await http_client.close()


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

// Module 04, Market Detail
// Fetch a single market and map it into a typed struct.

package main

import (
    "context"
    "fmt"
    "log"

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

type Market struct {
    Slug      string
    Title     string
    TradeType string
    IsLive    bool
    Volume    float64
    Liquidity float64
}

func toMarket(raw *limitless.Market) Market {
    return Market{
        Slug:      raw.Slug,
        Title:     raw.Title,
        TradeType: raw.TradeType,
        IsLive:    raw.Status == "active" && !raw.Expired,
        Volume:    raw.Volume,
        Liquidity: raw.Liquidity,
    }
}

func main() {
    ctx := context.Background()
    client := limitless.NewHttpClient()
    marketFetcher := limitless.NewMarketFetcher(client)

    raw, err := marketFetcher.GetMarket(ctx, "will-btc-close-above-100k-eoy")
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("%+v\n", toMarket(raw))
}