Polymarket FAK order: how Fill-And-Kill market orders work

A Polymarket FAK order (Fill-And-Kill) is the platform's market-order primitive that attempts immediate execution and cancels any unfilled remainder. Use this when you need fast, immediate fills and are willing to accept slippage or partial execution rather than waiting for a limit order. This guide explains how FAK orders behave on the CLOB, how Polymarket's slippage protection works, and practical patterns active traders use today.

Key takeaways

• A Polymarket FAK order is a market order that executes immediately and automatically cancels the leftover volume.
• Polymarket's CLOB exposes a createMarketOrder helper that submits FAK orders; Fill-And-Kill reduces exposure to indefinite open orders.
• Slippage protection is built into FAK orders: price impact limits can cause partial fills or zero fill rather than extreme fills, but you still face execution risk and taker fees.
• Use FAK for time-sensitive flows (arbitrage capture, endgame adjustments) and avoid it when you need guaranteed price or full size.
• Always account for resolution risk, slippage, fees, partial fills, and settlement timing when using FAK orders.

What exactly is a Polymarket FAK order?

FAK stands for Fill-And-Kill. On Polymarket's Central Limit Order Book (CLOB), a FAK order is the market-style execution that:

• walks the book immediately at the best available prices,
• fills as much size as liquidity allows at those prices,
• and cancels any remaining unmatched quantity instantly.

Polymarket's SDK surfaces this behavior through a createMarketOrder helper that wraps the underlying order placement, approvals, and any necessary wallet setup. All Polymarket transactions route through the Relayer, so FAK orders are gasless for end users.

How slippage protection works for FAK orders

Slippage protection prevents a market order from transacting at wildly different prices than expected. On Polymarket:

• FAK orders will consume book liquidity up to the specified size but include safeguards that can cap acceptable price impact. If the required price exceeds the allowed impact, the order can partially fill and cancel the remainder rather than sweeping into extreme prices.
• The CLOB enforces tick sizes (usually $0.01, tightening to $0.001 near extremes). Tick size affects how many price levels the FAK will step through.
• The FAK helper in the SDK implements sensible defaults for slippage; builders and advanced traders can set tighter limits when they programmatically route orders.

Slippage protection reduces the chance of catastrophic fills but does not eliminate execution risk. You can still receive a partial fill or pay substantially more (or less) than midpoint if the book is thin.

When to use a FAK order (and when not to)

Good uses

• Arbitrage capture where latency is crucial and you accept partial fills. For intra-market arb, the speed of a FAK can be the difference between pocketing an edge or losing it to other takers.
• Time-sensitive position adjustments close to news or resolution windows when you must trade immediately.
• Quick exits when you prioritise leaving the book fast over price certainty.

Poor use cases

• When you need guaranteed price or complete execution for a specific size — use a limit order instead.
• Thin, illiquid markets where sweeping the book risks paying large spreads relative to midpoint.
• Strategies that cannot tolerate partial fills without complex rebalancing logic.

Execution mechanics and fees to expect

• FAK orders are taker executions and therefore may incur taker fees. Maker fees on Polymarket are zero, but taker fees are variable by category (0%–1.8%). Account for taker fees when sizing trades and evaluating slippage.
• Polymarket sponsors transaction gas via the Relayer; you only need pUSD to trade.
• The SDK returns execution reports, which include the filled quantity, average price paid, and fee amounts. Use these programmatic receipts to reconcile P&L and for downstream logic (e.g., re-attempting fills if partial).

Practical patterns for active traders

1. Conservative arb capture

• Submit a FAK with a conservative max-impact setting. If you get a partial fill, the remaining margin still gives you a predictable maximum loss exposure. Re-submit smaller follow-up orders only after assessing the new book.

2. Two-step endgame flow

• Use a tight limit at the best ask when you can wait a few seconds. If the limit does not fill and the event moves, cancel and issue a FAK with a controlled slippage cap.

3. Bulk liquidation

• Split a large target size into multiple FAKs sized to match typical depth at the top-of-book. This reduces the chance of sweeping deep levels and lowers realised slippage.

4. Builder integration

• If routing through a Builder, the Polymarket Builder Program and the Relayer support attribution and builder fees. Builder tiers affect daily relayer limits and rewards; design your FAK usage to respect rate limits and attribution headers where required.

Reading fills and handling partial execution

Always parse the exchange's execution report after a FAK:

• Confirm filled quantity and average price. Reconcile fees and update position state.
• If partially filled, decide whether to attempt another FAK, post a limit, or leave the residual unfilled. Your choice should reflect urgency, expected market movement, and fee sensitivity.

Automated systems should implement a small wait-and-check loop rather than aggressive re-submission to avoid unnecessary fee spend or being throttled by relayer limits.

Risks and failure modes (do not call FAK trading risk-free)

Using FAK reduces time-on-book but does not remove risk. The key risks are:

• Slippage and partial fills: you may not receive full size at desired price levels.
• Fee exposure: FAK orders are taker fills and may incur up to the applicable taker fee for the market category.
• Resolution and settlement risk: outcomes settle through UMA; disputes can delay redeeming winning tokens.
• Smart-contract and operational risk: although Polymarket is gasless and uses well-known frameworks (CTF), any on-chain system carries platform risk.
• Geographic and compliance restrictions: Polymarket blocks orders from certain jurisdictions and prohibits VPN evasion.

Always pair statements about mathematical edges with these risks; Fill-And-Kill makes execution fast, not guaranteed or riskless.

How this affects your trading

If you trade actively on Polymarket, understand that FAK orders are the platform's market-order instrument and are best for speed-first, size-second workflows. Use the SDK's createMarketOrder helper to submit FAKs with sensible slippage caps, monitor fills programmatically, and prefer limit orders when you need tighter price control. Account for taker fees and the possibility of partial fills in your position management, risk limits, and post-trade logic.

FAK orders are a tool — use them when immediacy matters, and design fallback rules when a FAK does not fully execute.

Frequently asked questions

What's the difference between a Polymarket FAK order and a limit order?

A FAK order attempts immediate execution against the book and cancels the unfilled remainder; a limit order posts to the book at a specific price and may sit until matched. Use FAK when you prioritise speed; use limit orders when you prioritise price and guaranteed size.

Can a FAK order cause me to pay a much worse price than expected?

Yes. Although FAK orders include slippage protection, thin books can still produce large price impact. The FAK helper allows slippage caps to limit extreme fills, which may result in partial execution instead of a full, poor-price fill.

Are FAK orders gasless on Polymarket?

Yes. Polymarket routes transactions through its Relayer so wallet deployment, approvals, and FAK order placement are gasless for end users. You still need pUSD to trade.

Do I pay fees for a FAK order?

FAK orders are taker executions and may incur taker fees. Polymarket's maker fees are zero; taker fees vary by category (currently between 0% and 1.8%).

How should I handle partial fills from a FAK order?

Check the execution report for filled quantity and average price, then decide whether to re-submit another FAK, post a limit order for the remaining size, or accept the partial fill. Automated strategies should include small wait loops and fee-aware retry logic.