我用 Claude 分析了 1000 万条 Polymarket 机器人交易数据：揭秘机器人如何日赚 1000 美元以上

对于普通交易者来说，一个短期的 Polymarket 市场看起来很简单：

比特币五分钟后会涨还是跌？

而交易机器人看到的则是一个完全不同的问题。

它需要同时追踪标的资产价格、到期时间、买卖双方的流动性、相关市场以及自身的实时库存：

• 订阅我的 Telegram 频道获取更多内容✍️🤫：**https://t.me/+VDXq5wkZ2AIxMDBi

钱包链接：https://polymarket.com/@bonereaper?via=dan-kwpx

当人类还在决定是买涨还是买跌时，机器人可能已经完成了以下操作：

**> 获取了新的价格信号 > 重新定价了结果 > 将其与合约价格进行了比较 > 检查了相邻市场 > 下达了多个限价单 > 重塑了其整个仓位**

这就是为什么其中一些系统能将微小的定价差距转化为超过 1,000 美元的日利润。

我通过 Claude 分析了 Polymarket 短期加密 涨跌市场 中 1,000 多个 机器人的活动以及 超过 1,000 万次 的执行。

起初，这些交易看起来完全混乱。同一个钱包买入涨，几秒钟后又加仓跌，卖出部分初始仓位，最终在市场结束时同时持有两种结果。

但一旦你重建完整的交易生命周期，这种混乱就开始变得有意义。其背后通常有一个非常具体的系统。

以下是整个机器的工作原理 👇

1. 为什么要在 Polymarket 上使用交易机器人

机器人的主要优势并非完美的 比特币 预测。

其优势在于速度、一致性以及处理比人类实时监控更多信息的能力：

钱包链接：https://polymarket.com/@0xb55fa1296e6ec55d0ce53d93b9237389f11764d4-1777575277609?via=dan-kwpx

短期合约的定价不仅仅取决于 比特币 当前是上涨还是下跌。

算法还需要考虑：

**> 与开盘价的差距 > 最新变动的速度 > 剩余时间 > 当前波动率 > 订单簿深度 > 涨和跌的价格 > 相关市场的表现 > 用于结算的精确数据源**

在一个五分钟的市场中，真正的机会可能只存在 几秒钟。

当人类还在切换图表时，另一个算法可能已经在吸收可用流动性并替换其订单。

大多数交易机器人围绕五个核心组件构建：

1. 数据层 - 流式传输外部价格和订单簿更新
2. 信号引擎 - 检测可能影响结果的变化
3. 概率模型 - 计算独立的公平概率
4. 执行引擎 - 下达、取消和调整订单
5. 风险管理器 - 控制仓位规模并阻止超出预设限制的交易

机器人可以直接从订单簿计算的一个信号是买方和卖方成交量之间的不平衡：

1def orderbook_imbalance(bids, asks):
2    bid_volume = sum(size for price, size in bids)
3    ask_volume = sum(size for price, size in asks)
4
5    total_volume = bid_volume + ask_volume
6
7    if total_volume == 0:
8        return 0.0
9
10    return (
11        bid_volume - ask_volume
12    ) / total_volume
13
14bids = [
15    (0.48, 1_250),
16    (0.47, 920),
17    (0.46, 680)
18]
19
20asks = [
21    (0.49, 640),
22    (0.50, 510),
23    (0.51, 430)
24]
25
26imbalance = orderbook_imbalance(bids, asks)
27
28print(f"订单簿不平衡度: {imbalance:.2%}")

正值 表示所分析的订单簿部分有更多买方成交量。负值 表示卖方成交量更大。仅凭这个信号并不能证明价格会变动。

大额订单可以被取消，远离最佳价格的流动性可能永远不会影响执行。

但结合 比特币 的走势、剩余时间和外部价格数据源，它就成为了更强信号的一部分。

机器人之所以有用，并非因为它能自动交易每一个市场波动。一个强大的系统通过拒绝大多数交易机会来获得优势，使其在成为仓位之前就被过滤掉。

2. 收到信号后，机器人使用贝叶斯定理更新概率 🧮

假设 涨 的交易价格为 41 美分。

比特币 突然加速上涨，成交量增加，订单簿开始显示出更强的买方压力。

人类可能会想：

这次走势看起来很强劲。

涨

可能被低估了

而算法需要一个更精确的答案：

这个信号到底将

涨

的概率改变了多少？

这就是 贝叶斯定理 发挥作用的地方。

钱包链接：https://polymarket.com/@0xce25e214d5cfe4f459cf67f08df581885aae7fdc-1777575398144?via=dan-kwpx

贝叶斯定理 允许模型从一个现有的概率开始，并在收到新证据后更新它。

公式是：

P(涨 | 信号) = P(信号 | 涨) × P(涨) / [P(信号 | 涨) × P(涨) + P(信号 | 跌) × P(跌)]

其中：

P(涨)

* 是新信号出现前的概率 *

P(信号 | 涨)

* 是该信号在出现涨的结果之前出现的频率 *

P(信号 | 跌)

* 是该信号在出现跌的结果之前出现的频率 *

P(涨 | 信号)

是更新后的概率

假设：

*涨的初始概率是 41% 该信号在 64% 的历史 *

涨

* 情景中出现 同样的信号在 35% 的 *

跌

情景中出现

1def bayes_update(
2    prior_up,
3    signal_given_up,
4    signal_given_down
5):
6    numerator = signal_given_up * prior_up
7
8    denominator = (
9        numerator
10        + signal_given_down * (1 - prior_up)
11    )
12
13    return numerator / denominator
14
15prior = 0.41
16
17posterior = bayes_update(
18    prior_up=prior,
19    signal_given_up=0.64,
20    signal_given_down=0.35
21)
22
23print(f"先前概率: {prior:.2%}")
24print(f"更新后概率: {posterior:.2%}")

更新后的估计值约为 56%。如果合约仍在以 41 美分 交易，机器人会看到一个可衡量的差距：

*内部公允价值 - 56% 市场价格 - 41 美分 理论优势 - 15 个百分点*

对人类来说，这看起来像是一个强劲的交易想法。但对 机器人 来说，它是公允价值与当前市场价格之间的一个具体差异。

然而，贝叶斯定理 并非预测捷径。

如果模型对弱信号赋予过多权重，或者多次计算相同的信息，结果将始终是扭曲的。

价格变动、成交量增加和订单簿不平衡可能看起来像是三个独立的确认信号，而实际上它们只是同一事件的三种影响。

一个强大的模型需要考虑这种重叠。

3. 被错误定价的合约并不自动意味着盈利交易

即使模型将涨的价值定为 56%，以 41 美分 买入它并不会自动产生利润。

实际执行成本包括：

*> 吃单方费用 > 买卖价差 > 滑点 > 部分成交 > 价格恶化 > 模型不确定性*

因此，机器人会计算 净优势——即在实际执行仓位后剩余的优势。

1def calculate_net_edge(
2    model_probability,
3    execution_price,
4    fee,
5    slippage,
6    safety_buffer
7):
8    gross_edge = (
9        model_probability - execution_price
10    )
11
12    net_edge = (
13        gross_edge
14        - fee
15        - slippage
16        - safety_buffer
17    )
18
19    return gross_edge, net_edge
20
21gross, net = calculate_net_edge(
22    model_probability=0.56,
23    execution_price=0.47,
24    fee=0.017,
25    slippage=0.005,
26    safety_buffer=0.010
27)
28
29print(f"总优势: {gross:.2%}")
30print(f"净优势: {net:.2%}")

最初的九个百分点差距在扣除成本后下降到大约六个百分点。

如果流动性有限，机器人可能只能以 47 美分 的价格成交一小部分仓位。剩余部分可能需要以更高的价格购买。

在完整仓位建立之前，优势可能已经消失。同样的逻辑也适用于 二元套利。

如果可以在扣除所有成本后以低于 1 美元的价格同时获得等量的 涨和跌，那么最终会有一方支付 1 美元。

但系统必须使用真实的成交量加权执行价格，而不仅仅是订单簿顶部可见的最具吸引力的价格。

这就是为什么回测和实盘交易经常产生截然不同结果的原因。人类注意到一个异常价格。而 机器人 必须证明在计入市场成本后仍有足够的价值剩余。

4. 最佳优势往往存在于相关市场之间 🕸

短期合约并非孤立波动。

一次比特币的波动可能会影响以下所有市场：

> 当前的

BTC

* 5 分钟窗口 > 下一个五分钟窗口 > *

BTC

* 15 分钟 > *

BTC

* 1 小时 > 相关的 *

ETH

和

SOL

市场

但这些市场并不总是以相同的速度更新。

每个合约都有自己的订单簿、流动性、开盘水平和参与者。

例如：

>

BTC

* 5 分钟可能立即重新定价 > *

BTC

* 15 分钟的反应可能低于预期 > 相邻窗口可能保留其之前的订单簿不平衡 > 一个合约可能变得昂贵 > 另一个合约可能继续基于过时的假设进行交易*

钱包链接：https://polymarket.com/@flippingsharks?via=dan-kwpx

机器人会衡量相关市场之间的差距是否已超出其正常范围。

一个简单的工具是 z-score：

Z = (当前价差 − 平均价差) / 标准差

1def spread_zscore(
2    current_spread,
3    average_spread,
4    spread_deviation
5):
6    return (
7        current_spread - average_spread
8    ) / spread_deviation
9
10z = spread_zscore(
11    current_spread=0.112,
12    average_spread=0.036,
13    spread_deviation=0.025
14)
15
16print(f"价差 z-score: {z:.2f}")

读数高于 3 意味着当前差距远超出模型通常观察到的范围。

这并不会自动产生交易。一个市场可能确实滞后了。或者，先变动的市场可能已经吸收了相邻合约尚未处理的信息。

机器人 也不能仅仅通过比较 BTC 5 分钟和 BTC 15 分钟的 涨 价格来进行比较。

它们有不同的开盘水平和不同的剩余时间。

一个严谨的系统会比较每个合约偏离其自身公允价值模型的程度。

人类观察一个市场。而机器人观察的是一个由相关概率组成的网络，并识别出暂时偏离整体的部分。

5. 机器人将优势转化为仓位的五种方式 🔄

一旦信号被确认，概率被更新，并且净优势仍然为正，最有趣的阶段就开始了。

机器人必须决定 如何建立和管理仓位。

在将单个执行分组为完整的交易周期后，出现了五种重复的模式。

1️⃣ 动态仓位轮动

该系统会持续更新其观点，并可能在同一个合约内多次改变方向。假设模型在五分钟市场开始时认为 涨 被低估了。

它开始通过限价单积累 涨。

然后情况发生了变化：

比特币

* 失去动力 价格回到开盘水平附近 买方从订单簿中消失 模型的 *

涨

概率下降

机器人 不必持有原始仓位直到结算。它可以卖出部分 涨，取消剩余订单，并开始积累 跌。

如果市场再次变化，仓位可以再次重建。目标不是在第一次尝试时就完美地确定最终结果。

目标是保持更多地暴露于当前价格低于模型更新估计的那一方。

这种方法的优势在于机器人可以立即放弃过时的观点。

主要缺点是反复的错误反转。

在一个噪音较大的窗口中，系统可能会：

在上涨后买入

涨

* 在回调后减少 转向 *

跌

* 在下次上涨后减少 *

跌

执行成本和反复的仓位变动会逐渐侵蚀最初的優勢。

因此，轮动机器人只应在新信号足够强，足以覆盖退出、重建仓位以及可能再次出错的成本时，才改变方向：

钱包链接：https://polymarket.com/@trinity42?via=dan-kwpx

2️⃣ 时间套利

传统的 套利 出现在可以同时以低于 1 美元的价格购买 涨和跌 时。

时间套利则是在不同时间点建立两个方向的头寸。想象一下，市场开盘后不久 比特币 大幅上涨。

跌跌至 26 美分，机器人以平均价格 27.4 美分逐渐积累了 750 份合约。两分钟后，比特币 回吐了大部分涨幅，交易价格接近开盘水平。

现在 涨 变得更便宜，机器人以平均价格 49.8 美分 购买了 750 份 涨。

最终结构是：

*750 份跌，价格 27.4 美分 750 份涨，价格 49.8 美分 每对完整组合的总成本 - 77.2 美分*

无论最终结果如何，每对组合中有一份合约会支付 1 美元。这产生了每对组合 22.8 美分的毛利润，未扣除费用和执行成本。关键在于，27.4 美分的跌和 49.8 美分的涨从未同时出现过。

机器人从两种不同的市场状态中创造了套利机会。然而，第一次购买仍然面临方向性风险。

如果 比特币 继续上涨，机器人可能永远无法获得足够有吸引力的涨价格来完成配对。

那么它将持有 750 份继续贬值的跌合约。

因此，系统会追踪：

*每方持有的数量 两种结果的平均成本 已保护库存的成本 未配对方向性头寸的规模 等待第二方的最长时间*

一些机器人以较小的区块构建结构。

他们可能先购买 100 份跌，等待能够添加 100 份涨，完成第一个受保护的对子，然后才继续增加规模。

这降低了最大潜在回报，但也限制了留下大量单边头寸的风险。

时间套利在具有多次有意义双向波动的市场中表现最佳。

持续的单向走势是其最困难的环境：

钱包链接：https://polymarket.com/@garvy?via=dan-kwpx

3️⃣ 库存做市机器人

该系统不管理单个仓位。它管理整个合约库存。

它可能交易：

*BTC、ETH 和 SOL 5 分钟、15 分钟、1 小时和 4 小时市场 跨多个窗口的涨和跌*

机器人小额买卖，同时持续追踪其库存的总成本。假设它已经积累了一个合约的双方头寸。临近到期时，跌成为明显的赢家，价格上涨至 98 美分。

机器人可能不会简单地等待结算，而是：

*卖出部分昂贵的跌库存 在结算前释放资金 保留主要仓位的剩余部分 以 2 美分购买少量涨 将可用资金转移到另一个市场*

购买低价方最初可能看起来不寻常。

但一个 1-2 美分的小仓位可以作为针对突然最后波动的廉价保护。如果情况没有变化，成本是有限的。如果比特币意外突破开盘水平，这个小涨仓位可以抵消其他地方的损失。

库存机器人还可以利用相关市场之间的差异。

一个合约可能提供良好的入场价格。另一个可能为退出提供更深的流动性。第三个可能以异常低的价格提供相反方向。

主要挑战是整个库存的平均成本。

如果平均涨成本是 56 美分，平均跌成本是 49 美分，那么一个受保护的对子成本是 1.05 美元。

结算只支付 1 美元。

要收回这五美分的差额，系统需要从出售昂贵库存、维持可控的方向性不平衡、赚取做市商返佣或更有效地跨市场转移资本中获得额外收益：

钱包链接：https://polymarket.com/@polkadot-frog?via=dan-kwpx

4️⃣ 对冲方向性机器人

这种结构介于纯套利和完全方向性仓位之间。

假设机器人持有：

*280 份涨 257 份跌*

前 257 份涨和 257 份跌构成了一个受保护的基础。无论最终结果如何，这个区块的某一方将支付 257 美元。剩余的 23 份涨合约创造了一个方向性倾向。

如果涨是最终结果，这些额外的合约会增加收益。如果跌是最终结果，相反方向的仓位覆盖了大部分风险。

该系统实际上是在说：

我的模型目前看好涨，但我不希望整个仓位都依赖于一个结果。

不平衡的规模可以在市场过程中变化。当信心增加时，机器人会增加涨。当信号减弱时，它会减少涨或购买额外的跌。

持有双方并不自动意味着结构是高效的。

如果受保护的对子是在 1 美元以上建立的，它们会产生一个保证的负利润率。

假设平均对子成本是 1.04 美元。额外的 23 份涨合约必须首先弥补受保护基础的损失，以及费用和滑点。

只有在那之后，整个仓位才会变得盈利。

在某些情况下，昂贵的对冲比维持一个较小的方向性仓位效率更低：

钱包链接：https://polymarket.com/@uuddlrlr?via=dan-kwpx

5️⃣ 末期结算捕获机器人

最后一种模式几乎完全专注于市场的收盘阶段。

当一个结果接近确定时，可能的最终方可能仍在以 98-99 美分交易。机器人购买剩余的可用成交量，等待 1 美元的支付。

例如：

*入场价 98.6 美分 支付价 1 美元 每份合约毛利润 - 1.4 美分*

每次操作的回报很小，因此系统会扫描大量市场并使用可观的成交量。

这种策略看起来可能高度可预测，但其回报分布非常不均匀。

如果 99 次操作每次产生一美分，而一次 99 美分的仓位结算错误，之前的收益可能会消失。

那一次错误的执行可能源于：

*最后一秒的剧烈波动 价格数据源之间的差异 错误的开盘水平 延迟的结算更新 对市场规则的误解 订单活跃时间过长*

因此，一个末期结算系统需要的不仅仅是速度。

它必须确切知道哪个数据源决定结果，以及当前价值距离合约边界有多远。

最终的仓位结构可以通过编程方式分析。

1def inspect_position(
2    up_quantity,
3    down_quantity,
4    up_average_price,
5    down_average_price
6):
7    protected_pairs = min(
8        up_quantity,
9        down_quantity
10    )
11
12    directional_up = max(
13        up_quantity - down_quantity,
14        0
15    )
16
17    directional_down = max(
18        down_quantity - up_quantity,
19        0
20    )
21
22    pair_cost = (
23        up_average_price
24        + down_average_price
25    )
26
27    return {
28        "protected_pairs": protected_pairs,
29        "extra_up": directional_up,
30        "extra_down": directional_down,
31        "average_pair_cost": pair_cost,
32        "pair_margin": 1 - pair_cost
33    }
34
35position = inspect_position(
36    up_quantity=280,
37    down_quantity=257,
38    up_average_price=0.51,
39    down_average_price=0.46
40)
41
42print(position)

但最终的快照仍然不能揭示完整的策略。

要理解这个系统，你需要知道仓位是如何建立的，哪些部分被卖出了，以及平均成本是如何随时间变化的。

6. 发现错误定价还不够——机器人仍需捕获它 🎯

假设机器人发现了一个以总价 94 美分购买 涨和跌 的机会。它提交了两个订单。涨 完全成交。

在 跌 成交之前，市场变动，可用流动性消失，第二方变得更昂贵。

套利机会不复存在。

机器人 现在持有一个开放的方向性 涨 仓位。

这就是库存风险。

一个强大的系统不能仅仅识别异常价格。它必须管理整个执行过程。

它需要决定：

*等待第二方多长时间 何时调整限价单 可接受的不平衡程度 何时作为挂单方，何时作为吃单方执行 在优势消失后是否减少第一方仓位*

处理这个问题的一种方法是通过受 Avellaneda–Stoikov 模型启发的逻辑。

核心思想很简单：可接受的报价应根据已持有的库存而变化。

一个简化的公式是：

保留价格 = 公平价格 − 库存 × 风险 × 波动率² × 时间

1def reservation_price(
2    fair_price,
3    inventory,
4    risk_aversion,
5    volatility,
6    time_remaining
7):
8    inventory_adjustment = (
9        inventory
10        * risk_aversion
11        * volatility ** 2
12        * time_remaining
13    )
14
15    return fair_price - inventory_adjustment
16
17quote = reservation_price(
18    fair_price=0.57,
19    inventory=0.40,
20    risk_aversion=0.80,
21    volatility=0.18,
22    time_remaining=0.25
23)
24
25print(f"库存调整后报价: {quote:.3f}")

如果机器人已经持有过多的涨，它应该变得不太愿意购买额外的 涨。

同时，它可以变得更积极地获取 跌 以减少不平衡。

订单类型也很重要：

GTC

* 保持有效直至成交或取消 *

GTD

* 在指定时间到期 *

FOK

* 全部成交或取消 *

FAK

* 成交可用数量并取消剩余部分 *

Post-only

确保订单增加流动性

在一个五分钟的市场中，执行质量可能比初始预测更重要。

模型即使能正确估算公允价值，但如果建仓速度过慢或平均价格不理想，仍然可能亏损。

7. 最后一步是仓位管理和资金保护 🛡

即使有很强的优势，也不应该把所有可用资金都投入到一个市场中。

总存在以下可能性：

*模型高估了信号强度 对手盘没有成交 流动性消失 平均执行价格比预期更差 多个相关仓位同时贬值*

仓位管理的常见起点是 Kelly 公式。

公式如下：

f = (b × p − q) ÷ b

\*

其中：

p

* 是成功的概率 *

q = 1 − p

* 是失败的概率 *

b

* 是相对于风险金额的净赔率 *

f

\ 是全 Kelly 资本比例*

在实际操作中，许多系统只使用该结果的一部分。

1def fractional_kelly(
2    win_probability,
3    entry_price,
4    fraction=0.25
5):
6    lose_probability = 1 - win_probability
7
8    net_odds = (
9        1 - entry_price
10    ) / entry_price
11
12    full_kelly = (
13        net_odds * win_probability
14        - lose_probability
15    ) / net_odds
16
17    return max(
18        full_kelly * fraction,
19        0
20    )
21
22allocation = fractional_kelly(
23    win_probability=0.61,
24    entry_price=0.50,
25    fraction=0.25
26)
27
28print(f"Capital allocation: {allocation:.2%}")

使用分数 Kelly 可以降低因一次不准确的模型估算或糟糕的执行而对策略造成重大损害的可能性。

系统随后会应用硬性限制：

*每个仓位的最大规模 每个资产的最大敞口 未对冲库存的上限 每日亏损限额 当数据变得不可靠时紧急停机*

相关性也很重要。

BTC 5 分钟、BTC 15 分钟、ETH 5 分钟和 SOL 5 分钟看起来是独立的市场，但在加密货币的广泛波动中，它们可能同时贬值。

风险管理者的职责不是最大化每个有吸引力机会的仓位规模。

它的职责是确保单一情景不会导致系统无法继续运行。

8. 完整机器人栈的构成 ⚙️

一个现代的 Polymarket 机器人并不是一个简单的 Python 脚本，用来比较 Binance 和 Up 的价格。

它通常运行在多个层级之上。

第一层 - 市场数据

外部价格、官方解析数据源、实时订单簿、近期成交记录以及机器人自身订单的状态。

第二层 - 信号

价格变动、成交量、波动率、订单簿不平衡以及相关市场之间的价差。

第三层 - 概率

每当有意义的的新信息出现时，模型会更新公允概率。

第四层 - 仓位逻辑

系统在轮动、时间套利、库存管理、方向性对冲或延迟解析执行之间进行选择。

第五层 - 执行与风险

在库存和仓位规模保持在预设限制内的同时，进行下单、撤单和调整。

第六层 - 研究

使用 Claude 分析交易历史、识别重复出现的结构、编写回测并研究不成功的交易周期。

高级循环看起来可能是这样的。

1async def run_bot():
2    while True:
3        state = await receive_market_update()
4
5        signal = build_signal(state)
6        probability = update_probability_model(
7            state,
8            signal
9        )
10
11        edge = scan_for_edge(
12            state,
13            probability
14        )
15
16        if not edge["tradable"]:
17            continue
18
19        position_plan = choose_position_model(
20            state,
21            edge
22        )
23
24        orders = build_execution_plan(
25            state,
26            position_plan
27        )
28
29        if risk_manager_approves(
30            orders,
31            state
32        ):
33            await send_orders(orders)

Claude 可以帮助识别在数百万次历史执行中重复出现的结构。

但低延迟的交易循环本身应保持确定性：接收数据、应用规则、检查限制、提交订单。

结论：盈利的机器人远不止选择看涨或看跌

短周期市场看似是简单的方向性合约。

一个盈利的系统执行着更长的序列：

*接收新信号 将其转换为概率 检查净优势 比较相关市场 选择仓位结构 管理执行过程 控制风险*

有些 机器人 会在同一个窗口期内多次在看涨和看跌之间切换。另一些则在不同的时间点累积双边仓位。还有一些管理着跨多个时间框架的大量库存。另一些则维持一个受保护的基础仓位，并带有轻微的方向性倾向。

另外一组则专注于在解析前捕捉剩余的价差。

但核心公式通常是相似的：

*可靠的数据 + 独立的概率估算 扣除成本后的优势 正确的仓位结构 精确的执行 可控的风险*

这些 机器人 并不知道比特币五分钟后的价格。

它们只是更快地计算出当前每个可能结果应该值多少钱。

感谢您阅读我的文章，欢迎提供反馈！

在 X 上关注我 ✌️： https://x.com/Dan1ro0

加入我的 Telegram 获取更多内容 ✍️： https://t.me/+VDXq5wkZ2AIxMDBi