FAK order explained: how Fill-And-Kill works on Polymarket

A short answer: a FAK order (Fill-And-Kill) on Polymarket is a market-style instruction that attempts immediate execution against the CLOB and cancels any unfilled remainder. This guide, written for active traders, explains execution mechanics, how FAK behaves at the tick level, common failure modes, and practical tactics for intra-market arbitrage and tight markets.

Key takeaways

• FAK executes immediately against resting orders on Polymarket's CLOB and cancels any leftover quantity; think of it as a market order with automatic cancellation of the residual.
• The CLOB helper in the SDK exposes a single createMarketOrder utility that returns FAK behaviour; FAKs have built-in slippage protection compared with naive market fills.
• Near-tick and tick-size changes (0.01 vs 0.001) can change effective execution. Always check tick size and midpoint before routing a FAK.
• FAK removes maker risk but exposes you to partial fills, slippage, taker fees, resolution, and oracle dispute risk — never call a FAK execution "risk-free" without listing these.
• For intra-market arbitrage, FAKs are useful to capture fleeting edges, but you must budget for partial fills, fees, and settlement timing.

Why Polymarket uses FAK (the practical rationale)

Polymarket's CLOB supports both limit orders and a market-order helper that behaves as FAK. The design matches the exchange's gasless, UX-first approach: most users expect instant execution when they choose market-style routing, but the protocol must also avoid indefinite open positions left by aggressive market orders. FAK meets both needs — it executes immediately and kills the remainder, preventing lingering aggressive orders from sitting on the book.

Execution mechanics (step-by-step)

1. You instruct the client or SDK to create a market order. The helper issues a FAK against the CLOB.
2. The order walks the book, matching against resting limit orders at ascending price levels (for buys) or descending levels (for sells), until either the target quantity is filled or no further liquidity exists at permissible prices.
3. Any quantity not matched instantly is cancelled (killed). You never leave an open, aggressive limit order behind.
4. The exchange charges taker fees on executed quantity. Maker fees are zero for resting liquidity you hit.

Tick sizes and their effect on FAK

Polymarket uses a dynamic tick size. Ordinarily it's $0.01, but when prices approach extremes (above 0.96 or below 0.04) the tick tightens to $0.001. Two practical consequences:

• Price steps you may cross while walking the book change. On a tightened tick, a FAK can execute at more granular price points, reducing slippage for very skewed markets.
• Your midpoint and perceived edge may shift when tick size changes. Always check the current tick before sizing a FAK.

Slippage, partial fills, and the role of the SDK helper

FAK is designed to avoid leaving open quantity, but it does not guarantee full fill. Partial fills happen when the resting book depth is insufficient for your size at the time of submission. The SDK createMarketOrder helper typically returns the executed quantity and average price so you can react programmatically.

Two common patterns traders use:

• Small-size, repeated FAKs: break a large target into many small FAKs and submit in rapid sequence to consume visible liquidity while reducing per-order price impact.
• Aggressive single FAK: use when you need immediate exposure and accept likely slippage and taker fees.

Fees and economics

Polymarket applies taker fees by category (variable, currently between 0% and 1.8% per the platform's fee bands). Maker fees are zero. For short-lived arbitrage where margins are thin, explicitly include taker fees in your edge calculation. If you route orders through a Builder, builder fees (basis points) and the Builder Program tiers may also affect economics.

Risks you must account for

Never call a FAK execution "risk-free" without listing the following risks:

• Resolution and oracle disputes: UMA disputes can pause settlement and change realised P&L timing.
• Slippage and partial fills: FAK can fill partially or at worse-than-expected prices while cancelling the remainder.
• Fee changes and builder fees: taker fees and builder fees reduce realized edge.
• Settlement timing and merge/redeem lag: tokens are ERC-1155 and require CTF operations to create and redeem complete sets.
• Smart-contract and operational risk: while Polymarket sponsors gas through the Relayer, smart-contract bugs or relayer outages are protocol-level risks.

Common failure modes and how to detect them

• Immediate partial fill: returned execution shows smaller quantity than requested — handle programmatically by re-evaluating the remaining target.
• Zero fill: book moved before your submission. Check best_bid_ask and last_trade_price via the Market WebSocket or CLOB reads and consider resubmission logic.
• Unexpected tick change: if the tick tightens while your strategy assumed $0.01 steps, your expected slippage profile may be invalidated. Subscribe to tick_size_change events on the Market WS.

Practical tactics for arbitrage and tight markets

• For intra-market binary arbitrage (buying both sides when Σ bestAsk < $1.00), prefer small simultaneous FAKs on both legs to avoid one leg filling while the other does not. If one leg partially fills, you may be left net-long or short — be prepared to hedge or unwind.
• Monitor the book off-chain: use Market WS best_bid_ask and last_trade_price to ensure the liquidity you expect remains present before sending FAKs.
• When trading near resolution or in very tight spreads, reduce order size and increase frequency. Spread behaviour is ephemeral in liquid markets and may close in seconds.
• Factor in taker fees and builder fees when you compute edge. A nominal edge can vanish once fees and partial-fill risk are included.

How this affects your trading

If you trade frequently or run an arbitrage bot, treat FAK as your default market execution primitive on Polymarket. Its immediate-cancel behaviour prevents you from leaving passive, aggressively priced orders on the book, but it does introduce execution uncertainty. Build logic to:

• Check tick size and best_bid_ask immediately before each FAK.
• Limit order size relative to visible depth; prefer many small FAKs to a single large one when the book is thin.
• Record executed quantities and average prices for post-trade accounting; the SDK helper returns these values.
• Always include taker and builder fees in profitability checks and include resolution and settlement risk in your post-trade reconciliation.

Resources and next reads

• Polymarket CLOB explainer: /guides/polymarket-clob-explained
• Intra-market arbitrage mechanics: /guides/intra-market-binary-arbitrage-explained
• Full arbitrage primer: /guides/polymarket-arbitrage-complete-guide

Closing note

FAK order explained concisely: it is a market-style FAK that executes immediately on Polymarket's CLOB and cancels any remainder. Use it to capture fleeting edges, but design around partial fills, tick changes, and fees.

Frequently asked questions

What's the difference between a FAK and a plain market order on Polymarket?

Polymarket exposes a market-order helper that implements Fill-And-Kill semantics: it executes immediately against resting liquidity and cancels any unfilled remainder. In practice, that means you won't leave an aggressive limit order on the book after submission; residual quantity is cancelled. The SDK's createMarketOrder returns executed quantity and average price so you can handle partial fills.

How should I size FAK orders for arbitrage?

Size FAKs against visible book depth. When the spread is thin, break your target into multiple small FAKs to reduce per-order price impact. For binary intra-market arbitrage, submit the two legs simultaneously at sizes you can reasonably expect the top-of-book to fill; be prepared to hedge if one leg only partially fills.

Do FAK orders pay maker or taker fees?

FAK executions are treated as taker fills and are subject to Polymarket's taker fees (variable by category). Maker fees for resting liquidity are zero. If you route through a Builder, builder fees in basis points may also apply.

Can a FAK execution be reversed if UMA disputes resolution?

No — UMA disputes affect resolution and settlement timing after trading is complete. Trades executed with FAK are final on-chain; however, resolution disputes can delay redeem/settle operations and thus affect the timing of realized P&L.

How can I detect a tick-size change before sending a FAK?

Subscribe to the Market WS (wss://ws-subscriptions-clob.polymarket.com/ws/market) and listen for tick_size_change events. Also query the CLOB's public reads for current tick metadata. Adjust sizing and slippage expectations when ticks tighten from $0.01 to $0.001 near price extremes.