Back to Details

execution

Compare original and translation side by side

🇺🇸

Original

English
🇨🇳

Translation

Chinese

Execution Service - Complete API Reference

执行服务 - 完整API参考文档

Execute trades on Polymarket and Kalshi with slippage protection, maker orders, and order management.
在Polymarket和Kalshi平台上执行交易，支持滑点保护、挂单（Maker）订单与订单管理功能。

Supported Platforms

支持的平台

PlatformOrder TypesFeatures
PolymarketLimit, Market, Maker-0.5% maker rebate, GTC/FOK
KalshiLimit, MarketUS regulated
平台订单类型功能特性
PolymarketLimit（限价单）、Market（市价单）、Maker（挂单）-0.5%挂单返佣，支持GTC/FOK
KalshiLimit（限价单）、Market（市价单）受美国监管

Chat Commands

聊天命令

Place Orders

下单

/execute buy poly <market> YES 100 @ 0.52   # Limit buy on Polymarket
/execute sell kalshi <market> NO 50 @ 0.48  # Limit sell on Kalshi
/execute market-buy poly <market> YES 100   # Market buy
/execute market-sell poly <market> NO 50    # Market sell
/execute buy poly <market> YES 100 @ 0.52   # 在Polymarket上下限价买单
/execute sell kalshi <market> NO 50 @ 0.48  # 在Kalshi上下限价卖单
/execute market-buy poly <market> YES 100   # 市价买单
/execute market-sell poly <market> NO 50    # 市价卖单

Maker Orders (Rebates)

挂单（Maker订单，享返佣）

/execute maker-buy poly <market> YES 100 @ 0.52   # Post-only buy
/execute maker-sell poly <market> NO 50 @ 0.48    # Post-only sell
/execute maker-buy poly <market> YES 100 @ 0.52   # 仅挂单的买单（享返佣）
/execute maker-sell poly <market> NO 50 @ 0.48    # 仅挂单的卖单（享返佣）

Protected Orders (Slippage Protection)

保护型订单（滑点保护）

/execute protected-buy poly <market> YES 100 --max-slippage 1%
/execute protected-sell poly <market> NO 50 --max-slippage 0.5%
/execute protected-buy poly <market> YES 100 --max-slippage 1%

Order Management

带滑点保护的买单，最大滑点1%

/orders open                                # View open orders
/orders open poly                           # Open orders on Polymarket
/orders cancel <order-id>                   # Cancel specific order
/orders cancel-all                          # Cancel all open orders
/orders cancel-all poly                     # Cancel all on Polymarket
/execute protected-sell poly <market> NO 50 --max-slippage 0.5%

Slippage Estimation

带滑点保护的卖单，最大滑点0.5%

/estimate-slippage poly <market> buy 1000   # Estimate slippage for $1000 buy
/estimate-slippage kalshi <market> sell 500 # Estimate for $500 sell
undefined

TypeScript API Reference

订单管理

Create Execution Service

—
typescript
import { createExecutionService } from 'clodds/execution';

const executor = createExecutionService({
  polymarket: {
    apiKey: process.env.POLY_API_KEY,
    apiSecret: process.env.POLY_API_SECRET,
    passphrase: process.env.POLY_API_PASSPHRASE,
    privateKey: process.env.PRIVATE_KEY,
  },
  kalshi: {
    apiKey: process.env.KALSHI_API_KEY,
    privateKey: process.env.KALSHI_PRIVATE_KEY,
  },

  // Defaults
  defaultSlippageTolerance: 0.5,  // 0.5%
  autoLogTrades: true,
});
/orders open                                # 查看所有未成交订单
/orders open poly                           # 查看Polymarket平台的未成交订单
/orders cancel <order-id>                   # 取消指定订单
/orders cancel-all                          # 取消所有未成交订单
/orders cancel-all poly                     # 取消Polymarket平台的所有未成交订单

Limit Orders

滑点估算

typescript
// Buy limit order
const order = await executor.buyLimit({
  platform: 'polymarket',
  marketId: 'market-123',
  side: 'YES',
  size: 100,           // $100
  price: 0.52,         // 52 cents
  timeInForce: 'GTC',  // Good-til-cancel
});

console.log(`Order placed: ${order.orderId}`);
console.log(`Status: ${order.status}`);

// Sell limit order
const sellOrder = await executor.sellLimit({
  platform: 'polymarket',
  marketId: 'market-123',
  side: 'YES',
  size: 100,
  price: 0.55,
});
/estimate-slippage poly <market> buy 1000   # 估算1000美元买单的滑点
/estimate-slippage kalshi <market> sell 500 # 估算500美元卖单的滑点

Market Orders

TypeScript API参考文档

—

创建执行服务

typescript
// Market buy - executes immediately at best price
const order = await executor.marketBuy({
  platform: 'polymarket',
  marketId: 'market-123',
  side: 'YES',
  size: 100,
});

console.log(`Filled at: ${order.avgFillPrice}`);
console.log(`Filled size: ${order.filledSize}`);

// Market sell
const sellOrder = await executor.marketSell({
  platform: 'kalshi',
  marketId: 'TRUMP-WIN',
  side: 'YES',
  size: 50,
});
typescript
import { createExecutionService } from 'clodds/execution';

const executor = createExecutionService({
  polymarket: {
    apiKey: process.env.POLY_API_KEY,
    apiSecret: process.env.POLY_API_SECRET,
    passphrase: process.env.POLY_API_PASSPHRASE,
    privateKey: process.env.PRIVATE_KEY,
  },
  kalshi: {
    apiKey: process.env.KALSHI_API_KEY,
    privateKey: process.env.KALSHI_PRIVATE_KEY,
  },

  // 默认配置
  defaultSlippageTolerance: 0.5,  // 0.5%
  autoLogTrades: true,
});

Maker Orders (Post-Only)

限价单

typescript
// Maker buy - only executes as maker (gets rebate)
const order = await executor.makerBuy({
  platform: 'polymarket',
  marketId: 'market-123',
  side: 'YES',
  size: 100,
  price: 0.52,
});

// Will be rejected if it would execute immediately as taker
if (order.status === 'rejected') {
  console.log('Price too aggressive - would be taker');
}

// Maker sell
const sellOrder = await executor.makerSell({
  platform: 'polymarket',
  marketId: 'market-123',
  side: 'NO',
  size: 50,
  price: 0.48,
});
typescript
// 买入限价单
const order = await executor.buyLimit({
  platform: 'polymarket',
  marketId: 'market-123',
  side: 'YES',
  size: 100,           // 100美元
  price: 0.52,         // 0.52美元
  timeInForce: 'GTC',  // 有效至取消（默认）
});

console.log(`订单已提交：${order.orderId}`);
console.log(`状态：${order.status}`);

// 卖出限价单
const sellOrder = await executor.sellLimit({
  platform: 'polymarket',
  marketId: 'market-123',
  side: 'YES',
  size: 100,
  price: 0.55,
});

Protected Orders (Slippage Protection)

市价单

typescript
// Protected buy - checks slippage before executing
const order = await executor.protectedBuy({
  platform: 'polymarket',
  marketId: 'market-123',
  side: 'YES',
  size: 100,
  maxSlippage: 0.5,  // 0.5% max slippage
});

if (order.status === 'rejected') {
  console.log(`Rejected: slippage would be ${order.estimatedSlippage}%`);
} else {
  console.log(`Executed with ${order.actualSlippage}% slippage`);
}

// Protected sell
const sellOrder = await executor.protectedSell({
  platform: 'kalshi',
  marketId: 'TRUMP-WIN',
  side: 'YES',
  size: 50,
  maxSlippage: 1,
});
typescript
// 市价买入 - 立即以最优价格成交
const order = await executor.marketBuy({
  platform: 'polymarket',
  marketId: 'market-123',
  side: 'YES',
  size: 100,
});

console.log(`成交均价：${order.avgFillPrice}`);
console.log(`成交金额：${order.filledSize}`);

// 市价卖出
const sellOrder = await executor.marketSell({
  platform: 'kalshi',
  marketId: 'TRUMP-WIN',
  side: 'YES',
  size: 50,
});

Order Management

挂单（仅挂单，Post-Only）

typescript
// Cancel specific order
await executor.cancelOrder('polymarket', orderId);

// Cancel all orders on platform
await executor.cancelAllOrders('polymarket');

// Cancel all orders for a market
await executor.cancelAllOrders('polymarket', { marketId: 'market-123' });

// Get open orders
const openOrders = await executor.getOpenOrders('polymarket');

for (const order of openOrders) {
  console.log(`${order.orderId}: ${order.side} ${order.size} @ ${order.price}`);
  console.log(`  Status: ${order.status}`);
  console.log(`  Filled: ${order.filledSize}/${order.size}`);
}
typescript
// 挂单买入 - 仅作为挂方成交（可获返佣）
const order = await executor.makerBuy({
  platform: 'polymarket',
  marketId: 'market-123',
  side: 'YES',
  size: 100,
  price: 0.52,
});

// 如果会立即作为吃方成交，订单将被拒绝
if (order.status === 'rejected') {
  console.log('价格过于激进 - 将会成为吃方');
}

// 挂单卖出
const sellOrder = await executor.makerSell({
  platform: 'polymarket',
  marketId: 'market-123',
  side: 'NO',
  size: 50,
  price: 0.48,
});

Slippage Estimation

保护型订单（滑点保护）

typescript
// Estimate slippage before executing
const estimate = await executor.estimateSlippage({
  platform: 'polymarket',
  marketId: 'market-123',
  side: 'buy',
  size: 1000,
});

console.log(`For $1000 buy:`);
console.log(`  Avg fill price: ${estimate.avgFillPrice}`);
console.log(`  Expected slippage: ${estimate.slippagePct}%`);
console.log(`  Total filled: ${estimate.totalFilled}`);
console.log(`  Levels consumed: ${estimate.levelsConsumed}`);
typescript
// 保护型买入 - 执行前检查滑点
const order = await executor.protectedBuy({
  platform: 'polymarket',
  marketId: 'market-123',
  side: 'YES',
  size: 100,
  maxSlippage: 0.5,  // 最大滑点0.5%
});

if (order.status === 'rejected') {
  console.log(`订单被拒绝：预估滑点为${order.estimatedSlippage}%`);
} else {
  console.log(`已执行，实际滑点为${order.actualSlippage}%`);
}

// 保护型卖出
const sellOrder = await executor.protectedSell({
  platform: 'kalshi',
  marketId: 'TRUMP-WIN',
  side: 'YES',
  size: 50,
  maxSlippage: 1,
});

Order Types

订单管理

TypeDescriptionBest For
LimitExecute at specific price or betterPrice-sensitive orders
MarketExecute immediately at best availableUrgent execution
MakerPost-only, gets rebateCollecting rebates
ProtectedChecks slippage before executingLarge orders
typescript
// 取消指定订单
await executor.cancelOrder('polymarket', orderId);

// 取消平台上的所有订单
await executor.cancelAllOrders('polymarket');

// 取消某个市场的所有订单
await executor.cancelAllOrders('polymarket', { marketId: 'market-123' });

// 获取未成交订单
const openOrders = await executor.getOpenOrders('polymarket');

for (const order of openOrders) {
  console.log(`${order.orderId}: ${order.side} ${order.size} @ ${order.price}`);
  console.log(`  状态：${order.status}`);
  console.log(`  已成交：${order.filledSize}/${order.size}`);
}

Time In Force

滑点估算

ValueDescription
GTCGood-til-cancel (default)
FOKFill-or-kill - all or nothing
IOCImmediate-or-cancel - fill what you can
typescript
// 执行前估算滑点
const estimate = await executor.estimateSlippage({
  platform: 'polymarket',
  marketId: 'market-123',
  side: 'buy',
  size: 1000,
});

console.log(`针对1000美元买入单：`);
console.log(`  成交均价：${estimate.avgFillPrice}`);
console.log(`  预估滑点：${estimate.slippagePct}%`);
console.log(`  总成交金额：${estimate.totalFilled}`);
console.log(`  消耗的档位：${estimate.levelsConsumed}`);

Fee Structure

订单类型

Polymarket (Verified Jan 2026)

—
  • Most markets: 0% maker, 0% taker (zero fees)
  • 15-min crypto markets: Dynamic taker fees up to ~3% at 50/50 odds; makers eligible for rebate program
类型描述适用场景
限价单（Limit）以指定价格或更优价格成交对价格敏感的订单
市价单（Market）立即以最优可用价格成交急需成交的订单
挂单（Maker）仅挂单成交，可获返佣赚取返佣的场景
保护型订单（Protected）执行前检查滑点大额订单

Kalshi

有效期限（Time In Force）

  • Taker: Formula-based ~1.2% average, capped at ~2%
  • Maker: ~0.17% (formula-based)
取值描述
GTC有效至取消（默认）
FOK全部成交或取消 - 要么全成，要么取消
IOC立即成交或取消 - 能成交多少算多少

Best Practices

手续费结构

—

Polymarket（2026年1月验证）

  1. Use maker orders when possible - Pay no fees on Polymarket (most markets)
  2. Check slippage before large orders
  3. Use protected orders for size > $500
  4. Set appropriate timeInForce - GTC for patient orders, FOK for all-or-nothing
  5. Monitor open orders - Cancel stale orders
  6. Start small - Test with small sizes first
  • 大部分市场：挂单（Maker）0手续费，吃单（Taker）0手续费（零手续费）
  • 15分钟加密货币市场：吃单手续费动态调整，在50/50赔率时最高约3%；挂单用户可参与返佣计划
—

Kalshi

—
  • 吃单（Taker）：基于公式计算，平均约1.2%，上限约2%
  • 挂单（Maker）：约0.17%（基于公式计算）
—

最佳实践

—
  1. 尽可能使用挂单（Maker）订单 - 在Polymarket的大部分市场中无需支付手续费
  2. 大额订单前先检查滑点
  3. 订单金额超过500美元时使用保护型订单
  4. 设置合适的有效期限（timeInForce） - 耐心等待成交的订单用GTC，必须全部成交的订单用FOK
  5. 监控未成交订单 - 取消失效的订单
  6. 从小额开始 - 先用小额订单测试