# 如何借助 Claude Code，把 Polymarket 的 5 分钟 BTC 市场变成月入 1万美元的交易机器人
**作者**: 套利豪仔
**日期**: 2026-04-29T08:05:00.000Z
**来源**: [https://x.com/pritipatelfgoo/status/2049399538931449954](https://x.com/pritipatelfgoo/status/2049399538931449954)
---
大多数人玩 Polymarket 就像去赌场一样：选个方向，双手合十祈祷，第二天再来看结果
但我现在不这么操作了
我专攻 BTC（比特币）的 5 分钟盘。每 5 分钟就会开一个新盘口：BTC 的价格会高于还是低于目标价？你买入份额，等待盘口结算。要么赚，要么赔，接着开启下一轮。
每天 400 多个盘口，24 小时连轴转，周末无休。
我搭建了一个自动交易机器人，大部分代码都是 Claude Code 帮忙写的。总成本：每个月 25 美元。
过去 30 天：净赚 14200 美元。胜率：71%。平均持仓时间：3 分 12 秒。
以下就是我打造它的完整过程
## 写在前面：
这个机器人是基于 4 个开源代码库、Claude Code 以及一台 5 美元的 VPS（虚拟机）运行的。这里没有任何其他付费，下面提供的所有链接都完全免费
首先需要了解为什么 5 分钟盘与众不同
传统的 Polymarket 盘口通常需要几天甚至几周才会结算。比如你花 42 美分买入“特朗普赢得 2028 年大选”，然后苦等三个月，祈祷自己押中了。
5 分钟 BTC 盘口则截然相反。它们每 5 分钟结算一次。运行周期如下：
- 开盘给出一个目标价——即 BTC 的价格基准
- 你买入“看涨 (UP)”或“看跌 (DOWN)”份额
- 5 分钟后，智能合约读取 Chainlink 预言机的喂价数据
- 如果 BTC 现价高于目标价 -> “看涨”份额兑付 1 美元，“看跌”份额归零
- 紧接着立即开启下一个新盘口
无需漫长等待，不用担心交易逻辑失效，更没有隔夜风险。
但这里有个难点：5 分钟的时间窗口对传统技术指标来说太短了。RSI、MACD、EMA —— 在 5 分钟级别里没一个靠得住。信噪比低得令人发指。
所以我不再盯着指标看，而是开始研究订单薄
## 首先：搞懂资金的真实流向
在写下哪怕一行代码之前，必须先弄明白到底在交易什么。
Polymarket 采用的是一种混合型中央限价订单簿（Central Limit Order Book）模式。为了保证速度，订单撮合在链下进行，随后通过 Polygon 上的 CTF Exchange 智能合约在链上结算。每一笔交易都具备原子性——条件代币的铸造和转移都在一笔交易中完成
Polymarket 上没有市价单。所有的交易都是限价单。当你在界面上点击“买入”时，它实际上是以最优卖价下了一个限价单。这一点至关重要，因为在 5 分钟的窗口期内，以 48 美分成交还是 52 美分成交，往往决定了你是盈利还是亏损
我订阅了 Polymarket 的 WebSocket，用来接收实时的订单簿更新。不采用轮询，没有延迟。终端界面显示双边的实时深度，每当有订单下达或取消，都会立刻刷新
在动代码之前，我盯着这些数据整整看了两周
我发现：
- 聪明的资金通常在开盘后 30-90 秒进场——绝不会一开盘就冲进去
- 单边出现大额订单，大约有 63% 的概率能预测最终结果——单靠这一个指标还不够，但如果结合价格数据，就是一个强烈的信号
- 在最后 60 秒，订单簿会变得非常薄弱——这正是大多数散户资金进场并被“收割”的时候
第一步：多源价格分歧
目标价是由 Chainlink 提供的。但是，BTC 同时在几十家交易所进行交易，而且各个平台的价格总是存在差异。
我同步抓取了三个数据源的 BTC 价格：
```
import asyncio
import aiohttp
async def get_prices():
async with aiohttp.ClientSession() as session:
binance = session.get("https://api.binance.com/api/v3/ticker/price?symbol=BTCUSDT")
coinbase = session.get("https://api.coinbase.com/v2/prices/BTC-USD/spot")
chainlink = get_chainlink_price() # on-chain read
results = await asyncio.gather(binance, coinbase, chainlink)
return {
"binance": float((await results[0].json())["price"]),
"coinbase": float((await results[1].json())["data"]["amount"]),
"chainlink": results[2],
}
```
当币安（Binance）和 Coinbase 上的价格都涨到了目标价之上，而 Chainlink 还没有更新时——这就是一个“价差（gap）”。 Chainlink 的喂价迟早会跟上。问题在于，它是否能在 5 分钟的结算窗口关闭前跟上。
Claude Code 分析了过去 3 周的历史价格背离数据，发现了这样一个规律
```
> "analyze the lag between Binance/Coinbase price movements
and Chainlink feed updates. what's the average delay?
what's the probability that Chainlink follows within 5 minutes?"
Claude: "Average Chainlink update lag: 14 seconds after
major exchange price movements. When both Binance and
Coinbase move >$50 in the same direction within 30 seconds,
Chainlink follows within 2 minutes 94% of the time."
```
当两家交易所的数据一致时，后续如期兑现的概率高达 94%。这可不是抛硬币碰运气。这就是实打实的交易优势
## 第二步：订单簿失衡检测
价格分歧能告诉你 BTC 实际的走向，而订单簿则暴露了其他交易员以为它会怎么走。
```
def calculate_imbalance(order_book):
"""
Measures the ratio of buy-side depth to sell-side depth.
Values > 1.0 = more buyers than sellers = bullish pressure.
"""
bid_depth = sum(order["size"] for order in order_book["bids"][:10])
ask_depth = sum(order["size"] for order in order_book["asks"][:10])
if ask_depth == 0:
return float('inf')
return round(bid_depth / ask_depth, 3)
```
失衡比率一旦超过 1.8，意味着买方正在大举挂单，买盘堆积；若低于 0.55，则说明卖方占据主导。
但光看这些冷冰冰的数据还不够。进场的时机才是关键：
```
def detect_smart_entry(imbalance_history, threshold=1.8, window_seconds=90):
"""
Smart money enters 30-90 seconds after market open.
If imbalance spikes during that window, it's a signal.
"""
early_window = [
ib for ib in imbalance_history
if 30 <= ib["seconds_since_open"] <= window_seconds
]
if not early_window:
return None
max_imbalance = max(ib["ratio"] for ib in early_window)
if max_imbalance >= threshold:
return {
"direction": "UP",
"strength": max_imbalance,
"confidence": min(max_imbalance / 2.5, 0.95)
}
elif min(ib["ratio"] for ib in early_window) <= 1/threshold:
return {
"direction": "DOWN",
"strength": 1 / min(ib["ratio"] for ib in early_window),
"confidence": min((1/min(ib["ratio"] for ib in early_window)) / 2.5, 0.95)
}
return None
```
当那些真正懂行的资金在开盘的前 90 秒大举挂单，而且价格分歧也印证了这个走向时——这就是我果断出手的时刻。
## 第三步：信号融合
单靠哪一个信号都不行。只看价格分歧：胜率 63%。只看订单簿失衡：胜率 58%。两者结合：胜率 71%。
Claude Code 编写了信号融合器：
```
def should_trade(price_data, order_book, market):
"""
Only trade when both signals agree.
Kill everything else.
"""
# Signal 1: Price divergence
binance_delta = price_data["binance"] - market["price_to_beat"]
coinbase_delta = price_data["coinbase"] - market["price_to_beat"]
exchanges_agree = (
(binance_delta > 50 and coinbase_delta > 50) or
(binance_delta < -50 and coinbase_delta < -50)
)
if not exchanges_agree:
return None # no clear divergence
direction = "UP" if binance_delta > 0 else "DOWN"
# Signal 2: Order book confirmation
imbalance = calculate_imbalance(order_book)
book_confirms = (
(direction == "UP" and imbalance > 1.8) or
(direction == "DOWN" and imbalance < 0.55)
)
if not book_confirms:
return None # divergence without book support = trap
# Both signals agree
confidence = min(0.95, 0.6 + abs(binance_delta) / 500 + abs(imbalance - 1.0) / 5)
return {
"direction": direction,
"confidence": round(confidence, 3),
"size": kelly_size(confidence, market["price"], bankroll=2000),
}
```
85% 的 5 分钟窗口在这一步会被直接过滤掉。按兵不动。机器人只有在两个信号完美共振时才会果断进场。
## 第四步：执行时机
这是绝大多数人容易犯错的地方。他们一看到信号就立马满仓杀入。在 Polymarket 上，这无异于自寻死路。
别忘了：这里没有市价单。一切都是限价单。在短短的 5 分钟窗口里，成交速度决定一切。
```
async def execute_trade(signal, market, ws_connection):
"""
Place order at optimal timing:
- Not too early (signal might reverse)
- Not too late (can't fill, can't exit)
- Sweet spot: 60-180 seconds after market open
"""
seconds_since_open = market["elapsed_seconds"]
if seconds_since_open < 60:
await asyncio.sleep(60 - seconds_since_open) # wait for confirmation
if seconds_since_open > 180:
return None # too late - can't exit if wrong
# Place limit order at current best price
side = "buy" if signal["direction"] == "UP" else "buy" # always buying shares
token_id = market["up_token"] if signal["direction"] == "UP" else market["down_token"]
order = await place_limit_order(
token_id=token_id,
price=market["best_ask"][signal["direction"].lower()],
size=signal["size"],
)
return order
```
最佳窗口期是开盘后的 60 到 180 秒之间。早于 60 秒，信号还没完全确认；晚于 180 秒，万一行情反转，连跑路的时间都不够。
## 第五步：提前离场（结算前平仓）
这也是我和大多数 5 分钟盘交易员做法截然不同的地方。
绝大多数人会死扛到结算。48 美分买入，干等盘口出结果，要么拿到 1 美元，要么血本无归。
我可不这么干。
只要能锁定利润，我就会提前获利了结。要知道，在整个 5 分钟里，这些份额是可以在订单簿上持续交易的。如果我以 48 美分买入了“看涨 (UP)”，随后价格涨到了 72 美分，我会直接卖给买盘（bid side）套现，稳赚这 24 美分的差价，绝不干等最终的结算。
```
async def monitor_position(position, market, ws_connection):
"""
Three exit conditions:
1. Profit target: sell when shares hit 75c+ (we entered around 48-52c)
2. Stop loss: sell if shares drop below 35c
3. Time exit: if <60 seconds remain, hold to resolution
"""
while True:
current_price = await get_current_price(position["token_id"])
time_remaining = market["resolution_time"] - time.time()
# Exit 1: Profit target
if current_price >= 0.75:
await sell_shares(position, current_price)
return {"exit": "PROFIT_TARGET", "pnl": current_price - position["entry"]}
# Exit 2: Stop loss
if current_price <= 0.35:
await sell_shares(position, current_price)
return {"exit": "STOP_LOSS", "pnl": current_price - position["entry"]}
# Exit 3: Time - hold to resolution
if time_remaining < 60:
return {"exit": "HOLD_TO_RESOLUTION", "pnl": "pending"}
await asyncio.sleep(2)
```
为什么要提前离场？
因为链上结算有延迟。当你买入份额时，交易需要在 Polygon 上铸造、确认并最终结算。这都要花时间。如果你在只剩 90 秒的时候买入，万一行情走势不对，你可能根本卖不掉，因为你的份额还没结算完成呢。
提前离场能直接抹掉这个风险。赚走潜在利润的 60-70%，然后潇洒地转战下一个 5 分钟盘。
## 第六步：引擎循环
整个机器人的运作机制就像一台生命周期引擎。每一个 5 分钟的窗口期，都是一轮完整的循环周期：
```
async def run_engine():
"""
Main loop. One market lifecycle per 5-minute window.
"""
bankroll = 2000
daily_pnl = 0
trades_today = 0
while True:
market = await get_next_market()
print(f"[{datetime.now()}] New market: {market['question']}")
print(f" Price to Beat: ${market['price_to_beat']:,.2f}")
# Wait for the entry window (60 seconds after open)
await wait_for_entry_window(market)
# Collect signals
prices = await get_prices()
order_book = await get_order_book(market)
signal = should_trade(prices, order_book, market)
if signal is None:
print(f" SKIP - no signal convergence")
await wait_for_next_market(market)
continue
# Execute
position = await execute_trade(signal, market)
if position is None:
print(f" SKIP - execution window missed")
await wait_for_next_market(market)
continue
# Monitor and exit
result = await monitor_position(position, market)
daily_pnl += result.get("pnl", 0)
trades_today += 1
print(f" {result['exit']} | PNL: ${result['pnl']:.2f}")
print(f" Daily: ${daily_pnl:.2f} | Trades: {trades_today}")
# Update bankroll
bankroll += result.get("pnl", 0)
await wait_for_next_market(market)
```
每天有 400 多个这样的窗口期。机器人只在其中 50 到 60 个窗口出手交易，其余时间全部过滤掉。
## 技术栈
```
| Tool | Cost | What It Does |
| -------------------- | ------ | ------------------------------------------------ |
| Claude Code | $20/mo | Strategy logic, signal analysis, code generation |
| VPS (Hetzner) | $5/mo | Runs the engine 24/7 |
| Polymarket WebSocket | Free | Real-time order book data |
| Binance API | Free | BTC price feed |
| Coinbase API | Free | BTC price feed (cross-reference) |
| Chainlink feed | Free | On-chain price (resolution source) |
| Total | $25/mo | |
```
成果：30 天战绩
第一周基本都在调教模型。起步胜率在 59%。单靠订单簿失衡这一个指标，假信号太多了。
加上了价格分歧过滤器后，胜率直接跳到了 66%。
把进场窗口期从最初的 30-240 秒，精准压缩到了 60-180 秒之间。胜率飙升到了 71%。
随后引入了 75 美分提前止盈的策略。虽然这导致每笔成功交易的平均利润从 47 美元降到了 34 美元，但每笔亏损交易的平均损失却大幅缩减，从 52 美元骤降至 19 美元。最终效果：每周净赚 3100 美元。
过去 30 天数据汇总：
- 交易盘口总数：1,847 个
- 胜率：71%
- 单笔平均盈利：+34 美元
- 单笔平均亏损：-19 美元
- 净利润：+14,200 美元
- 夏普比率 (Sharpe Ratio)：2.84
- 单日最高盈利：+1,100 美元
- 单日最大亏损：-280 美元
- 最大回撤：-640 美元
这个机器人运行在芬兰赫尔辛基一台每个月 5 美元的 VPS 上。我每天早上只看一眼。多数日子里，我也就是扫一眼当天的盈亏数字，然后关掉网页就完事了。
## 踩过的坑（哪些做法行不通）
- 逢盘必做： 每天 400 多个盘口，绝大多数都是噪音。我的机器人只有在两个独立信号相互印证时才会进场。85% 的窗口期都被我直接放弃了。
- 死扛到结算： 结算延迟会带来风险。在 75 美分时提前平仓，其收益表现始终优于持有到最终结算。
- 单一数据源： 光看币安，准确率只有 57%。加上 Coinbase 交叉验证，准确率提高到了 63%。再加上订单簿失衡指标，胜率才最终冲到了 71%。
- 在最后 60 秒交易： 万一做错了，根本没有时间跑路。此时订单簿变得极薄，买卖价差也会拉大。所以我彻底砍掉了所有临近结束前的进场操作。
- 依赖 RSI/MACD 等技术指标： 在 5 分钟级别里纯属废话，噪音太多。我完全抛弃了技术指标，转而死磕订单流和价格分歧。
## 为什么这套策略眼下依然奏效
Polymarket 上的 5 分钟 BTC 盘口还算是相对新鲜的事物。我所利用的这些订单簿规律之所以存在，主要是因为大多数交易员都在犯以下错误：
- 进场太早（信号还没确认就急着上车）
- 进场太晚（拖到最后 60 秒，买卖价差已经被彻底拉大）
- 死扛到结算，不懂得提前获利了结
- 全凭直觉做单，毫无多源信号交叉验证的意识
随着时间推移，这些套利空间必然会被逐渐压缩。随着更多机器人入场，买卖价差会越来越小，交易优势也会随之缩水。今天一单能赚 34 美元的策略，半年后可能就只能赚 15 美元了。
但至少在眼下，这扇盈利的时间窗口依然敞开着。
## 没人愿意谈论的残酷真相
亏损是必然的。有些日子机器人会满盘皆绿（亏损），有些周你会觉得交易优势正在消失。
这套逻辑的核心不在于永不亏损，而在于如何通过 1847 次反复操作，做到“小输、大赢”。
我所使用的代码库如下：
- github.com/warproxxx/poly_data —— 获取用于回测的历史交易数据。
- github.com/Polymarket/polymarket-cli —— 负责扫描市场并下单。
- github.com/Polymarket/agents —— 智能体框架及 LLM（大语言模型）集成。
- github.com/KaustubhPatange/polymarket-trade-engine —— 5 分钟盘的市场引擎架构。
其中 80% 的逻辑代码由 Claude Code 完成，我负责制定策略，剩下的交由 VPS 运行。
每月 25 美元成本。一个周末搞定开发。每天只需盯着一个网页。
钱包地址:wallet
## 相关链接
- [套利豪仔](https://x.com/pritipatelfgoo)
- [@pritipatelfgoo](https://x.com/pritipatelfgoo)
- [10K](https://x.com/pritipatelfgoo/status/2049399538931449954/analytics)
- [github.com/warproxxx/poly_data](https://github.com/warproxxx/poly_data)
- [github.com/Polymarket/polymarket-cli](https://github.com/Polymarket/polymarket-cli)
- [github.com/Polymarket/agents](https://github.com/Polymarket/agents)
- [github.com/KaustubhPatange/polymarket-trade-engine](https://github.com/KaustubhPatange/polymarket-trade-engine)
- [Upgrade to Premium](https://x.com/i/premium_sign_up)
- [4:05 PM · Apr 29, 2026](https://x.com/pritipatelfgoo/status/2049399538931449954)
- [10.6K Views](https://x.com/pritipatelfgoo/status/2049399538931449954/analytics)
- [View quotes](https://x.com/pritipatelfgoo/status/2049399538931449954/quotes)
---
*导出时间: 2026/4/30 11:27:19*