Polymarket US Markets, Risk and Execution

This page covers the settings that decide where and how much a platform: polymarket_us Bot trades: the market selector, the three risk keys Polymarket US accepts (max_position, price_floor and price_ceiling), loop.interval, and the deployment risk limits you set when you deploy. It also explains how the Bot prices entries and exits, and the checks every order has to pass. For every accepted key at a glance, see All Polymarket US parameters; for the keys Studio rejects, see Not available on Polymarket US.

Market selection

A Polymarket US Bot always trades exactly one market. Set one selector. If you set more than one, slug wins, then event_slug, then query.

All three pass Studio's checks and can be deployed. Studio's AI is set up to save a concrete market.slug, which is the predictable choice.

market.slug

The exact market the Bot trades, for example a daily temperature contract. Nothing is looked up at startup: every order, position read and open-order read uses this slug.

• The slug isn't checked when you save. A wrong slug shows up once the Bot runs, as "market ... is not active" or "market missing" errors.
• No rollover. When a dated market closes, the Bot stays pointed at it and every order is refused. To trade the next market in a series, update the slug and redeploy.

market.event_slug

When the Bot starts, it searches open events, takes the one whose slug matches exactly, and trades that event's first active market. It chooses once and keeps that market until it restarts.

• In an event with several markets, "first" depends on how Polymarket US orders them, and may not be the outcome you meant.
• If no open market matches, the Bot logs a configuration error and stops before its first loop.
• On regular Polymarket, event_slug alone is rejected. On Polymarket US it's accepted.

market.query

A free-text search. At startup the Bot trades the first active market in the results. It doesn't pick the most liquid one, and results can change between restarts, so treat it as a discovery tool rather than something to deploy. If the search finds no open market, the Bot logs a configuration error and stops before its first loop.

Note: The rolling daily selector (market.recurring) exists only for the Polymarket US leg of an arbitrage strategy. A single-venue Polymarket US strategy rejects it.

Risk and loop

risk.max_position

A whole number of contracts, 1 or more. Decimals are dropped: 2.5 becomes 2. How it's used depends on the strategy:

On every strategy, the running Bot also refuses a buy that would take the contracts you hold plus your resting orders in the market past the lower of max_position and the deploy dialog's Max open contracts (open contracts would be 6, exceeding risk.max_position=5). Sells are never capped.

Note: The deploy dialog's Max contracts per order caps every order. Studio pre-fills it from your strategy's largest single order: the biggest rule size (1 when omitted), min(max_position, 10) for mean_reversion, max_position for observation_momentum, min(max_position, 5) for pre_announcement_drift, fade_size for panic_fade and 1 for spread_capture. A larger entry is refused; sell_all and the built-in exits are split to fit.

risk.price_floor and risk.price_ceiling

price_floor defaults to 0 and must be below 1. price_ceiling must be above 0, at most 1, and above the floor. Leaving the ceiling out is an error. What they do depends on the strategy:

• Custom entries: the price of the side you buy (the YES price for buy_yes, 1 − YES for buy_no) is clamped into the range. The trade still happens; only the limit price moves. See Entries.
• mean_reversion: buys YES only when price_floor < price ≤ entry_low, and buys NO only when entry_high ≤ price < price_ceiling.
• panic_fade: enters only between floor and ceiling, and exits if YES drops below price_floor.
• observation_momentum and pre_announcement_drift: enter only while the YES price is strictly between floor and ceiling. The pre_announcement_drift exit ignores the range.
• spread_capture: bids are placed no lower than the floor and offers no higher than the ceiling.

If you want a price range to block a custom entry, add a price condition to the rule. Clamping alone won't stop it.

loop.interval

Seconds between runs, 10 or more. Decimals are dropped (10.9 becomes 10, and 9.9 is rejected). The Bot runs, then waits interval seconds, so the real cadence is a little longer than the interval. observation_momentum and panic_fade sample the price once per loop, so the interval also sets how their windows fill.

Deployment risk limits

When you deploy, the Risk limits section of the deploy dialog sets hard caps. They aren't part of the YAML and a strategy can't override them. Studio pre-fills them from your strategy; see Deployment risk limits. When you redeploy a Bot, the dialog starts from the limits it already runs with. An order that breaks a limit is refused, not shrunk. On Polymarket US:

The deploy dialog doesn't show Max daily loss for Polymarket US, because the Bot doesn't read it: nothing stops a Polymarket US Bot on losses except your sell_all rules.

For example, a max_position: 2 mean_reversion strategy pre-fills 2 contracts and $2 per order, 2 open contracts and $20 of daily notional.

Order pricing and execution

Entries

Every entry (buy_yes, buy_no and the built-in strategies' buys) is a good-till-cancel limit order for a whole number of contracts:

1. Price. The Bot uses the last trade price for YES. If there is none, it uses the current price, then the midpoint of the best bid and offer. For buy_no the NO price is 1 − that YES price. (spread_capture is the exception: it prices its quotes around the midpoint.)
2. Clamp. Custom entries clamp that price into [price_floor, price_ceiling].
3. Round. The price is sent on a 1-cent grid.
4. Rest. The order doesn't chase the offer. If nobody trades at your limit, it rests until it fills or something cancels it.

A custom entry is also skipped while any order is resting in the market, and when your buying power doesn't cover it. Pair entries with a cancel_all rule if an unfilled order should not wait forever.

Exits

sell_all and the built-in exits sell your whole position on the side you hold with market orders (panic_fade and pre_announcement_drift sell only what their own entry bought, on its side):

• A position larger than Max contracts per order is split into several orders of at most min(40, Max contracts per order) contracts, sent one after another.
• An exit needs a bid to sell into, not a two-sided book. A sell that only reduces your position isn't held back by the API error breaker or Max daily notional traded.
• If a piece is refused or rejected, the exit stops there; the rest is retried on the next loop if the rule still matches. A rejected order is logged as rejected (order_rejected), never as placed.

cancel_all, and spread_capture's refresh, cancel only this Bot's open orders. Polymarket US orders carry no client id, so the Bot remembers the id of every order the exchange accepts from it; the memory survives restarts and redeploys, but not stopping the Bot. Orders you placed by hand and other Bots' orders are never cancelled. In paper mode every paper order is the Bot's own.

Checks before every order

Before sending any order, the Bot confirms all of the following. If one fails, the order is refused and that loop ends with an error in the Bot log.

These checks can't be turned off.