pmxtjs - API Reference

npm install pmxtjs

import pmxt from 'pmxtjs';

// Initialize exchanges (server starts automatically!)
const poly = new pmxt.Polymarket();
const kalshi = new pmxt.Kalshi();

// Search for markets
const markets = await poly.searchMarkets("Trump");
console.log(markets[0].title);

async fetchMarkets(params?: MarketFilterParams): Promise<UnifiedMarket[]>

const markets = await polymarket.fetchMarkets({ 
  limit: 20, 
  offset: 0,
  sort: 'volume' // 'volume' | 'liquidity' | 'newest'
});

async searchMarkets(query: string, params?: MarketFilterParams): Promise<UnifiedMarket[]>

const results = await kalshi.searchMarkets('Fed rates', { 
  limit: 10,
  searchIn: 'title' // 'title' (default) | 'description' | 'both'
});

async getMarketsBySlug(): Promise<UnifiedMarket[]>

// Polymarket: use URL slug
const polyMarkets = await polymarket.getMarketsBySlug('who-will-trump-nominate-as-fed-chair');

// Kalshi: use market ticker (auto-uppercased)
const kalshiMarkets = await kalshi.getMarketsBySlug('KXFEDCHAIRNOM-29');

async fetchOHLCV(id: string, params?: HistoryFilterParams): Promise<PriceCandle[]>

const markets = await polymarket.searchMarkets('Trump');
const outcomeId = markets[0].outcomes[0].id; // Get the outcome ID

const candles = await polymarket.fetchOHLCV(outcomeId, {
  resolution: '1h', // '1m' | '5m' | '15m' | '1h' | '6h' | '1d'
  start: new Date('2024-01-01'),
  end: new Date('2024-01-31'),
  limit: 100
});

async fetchOrderBook(): Promise<OrderBook>

const orderBook = await kalshi.fetchOrderBook('FED-25JAN');
console.log('Best bid:', orderBook.bids[0].price);
console.log('Best ask:', orderBook.asks[0].price);

async fetchTrades(id: string, params?: HistoryFilterParams): Promise<Trade[]>

const trades = await kalshi.fetchTrades('FED-25JAN', {
  resolution: '1h',
  limit: 100
});

async createOrder(params?: CreateOrderParams): Promise<Order>

// Limit Order Example
const order = await polymarket.createOrder({
  marketId: '663583',
  outcomeId: '10991849228756847439673778874175365458450913336396982752046655649803657501964',
  side: 'buy',
  type: 'limit',
  amount: 10,        // Number of contracts
  price: 0.55        // Required for limit orders (0.0-1.0)
});

console.log(`Order ${order.id}: ${order.status}`);

// Market Order Example
const order = await kalshi.createOrder({
  marketId: 'FED-25JAN',
  outcomeId: 'FED-25JAN-YES',
  side: 'sell',
  type: 'market',
  amount: 5          // Price not needed for market orders
});

async cancelOrder(): Promise<Order>

const cancelledOrder = await polymarket.cancelOrder('order-123');
console.log(cancelledOrder.status); // 'cancelled'

async fetchOrder(): Promise<Order>

const order = await kalshi.fetchOrder('order-456');
console.log(`Filled: ${order.filled}/${order.amount}`);

async fetchOpenOrders(): Promise<Order[]>

// All open orders
const allOrders = await polymarket.fetchOpenOrders();

// Open orders for specific market
const marketOrders = await kalshi.fetchOpenOrders('FED-25JAN');

allOrders.forEach(order => {
  console.log(`${order.side} ${order.amount} @ ${order.price}`);
});

async fetchPositions(): Promise<Position[]>

const positions = await kalshi.fetchPositions();
positions.forEach(pos => {
  console.log(`${pos.outcomeLabel}: ${pos.size} @ $${pos.entryPrice}`);
  console.log(`Unrealized P&L: $${pos.unrealizedPnL}`);
});

async fetchBalance(): Promise<Balance[]>

const balances = await polymarket.fetchBalance();
console.log(balances);
// [{ currency: 'USDC', total: 1000, available: 950, locked: 50 }]

import pmxt from 'pmxtjs';

const exchange = new pmxt.Polymarket({
  privateKey: process.env.POLYMARKET_PRIVATE_KEY
});

// 1. Check balance
const [balance] = await exchange.fetchBalance();
console.log(`Available: $${balance.available}`);

// 2. Search for a market
const markets = await exchange.searchMarkets('Trump');
const market = markets[0];
const outcome = market.outcomes[0];

// 3. Place a limit order
const order = await exchange.createOrder({
  marketId: market.id,
  outcomeId: outcome.id,
  side: 'buy',
  type: 'limit',
  amount: 10,
  price: 0.50
});

console.log(`Order placed: ${order.id}`);

// 4. Check order status
const updatedOrder = await exchange.fetchOrder(order.id);
console.log(`Status: ${updatedOrder.status}`);
console.log(`Filled: ${updatedOrder.filled}/${updatedOrder.amount}`);

// 5. Cancel if needed
if (updatedOrder.status === 'open') {
  await exchange.cancelOrder(order.id);
  console.log('Order cancelled');
}

// 6. Check positions
const positions = await exchange.fetchPositions();
positions.forEach(pos => {
  console.log(`${pos.outcomeLabel}: ${pos.unrealizedPnL > 0 ? '+' : ''}$${pos.unrealizedPnL.toFixed(2)}`);
});

interface UnifiedMarket {
  id: string; // 
  title: string; // 
  description: string; // 
  outcomes: MarketOutcome[]; // 
  resolutionDate: string; // 
  volume24h: number; // 
  volume: number; // 
  liquidity: number; // 
  openInterest: number; // 
  url: string; // 
  image: string; // 
  category: string; // 
  tags: string[]; // 
}

interface MarketOutcome {
  id: string; // 
  label: string; // 
  price: number; // 
  priceChange24h: number; // 
  metadata: object; // Exchange-specific metadata (e.g., clobTokenId for Polymarket)
}

interface PriceCandle {
  timestamp: number; // 
  open: number; // 
  high: number; // 
  low: number; // 
  close: number; // 
  volume: number; // 
}

interface OrderBook {
  bids: OrderLevel[]; // 
  asks: OrderLevel[]; // 
  timestamp: number; // 
}

interface OrderLevel {
  price: number; // 
  size: number; // 
}

interface Trade {
  id: string; // 
  price: number; // 
  amount: number; // 
  side: string; // 
  timestamp: number; // 
}

interface Order {
  id: string; // 
  marketId: string; // 
  outcomeId: string; // 
  side: string; // 
  type: string; // 
  price: number; // 
  amount: number; // 
  status: string; // 
  filled: number; // 
  remaining: number; // 
  timestamp: number; // 
  fee: number; // 
}

interface Position {
  marketId: string; // 
  outcomeId: string; // 
  outcomeLabel: string; // 
  size: number; // 
  entryPrice: number; // 
  currentPrice: number; // 
  unrealizedPnL: number; // 
  realizedPnL: number; // 
}

interface Balance {
  currency: string; // 
  total: number; // 
  available: number; // 
  locked: number; // 
}

interface ExchangeCredentials {
  apiKey: string; // API key for the exchange
  privateKey: string; // Private key for signing transactions
  apiSecret: string; // API secret (if required by exchange)
  passphrase: string; // Passphrase (if required by exchange)
}

interface BaseRequest {
  credentials?: ExchangeCredentials; // 
}

interface MarketFilterParams {
  limit?: number; // 
  offset?: number; // 
  sort?: string; // 
  searchIn?: string; // 
}

interface HistoryFilterParams {
  resolution: string; // 
  start?: string; // 
  end?: string; // 
  limit?: number; // 
}

interface CreateOrderParams {
  marketId: string; // 
  outcomeId: string; // 
  side: string; // 
  type: string; // 
  amount: number; // 
  price?: number; // 
}