Automating Your Exit: Timing Trades Around Kalshi Resolution Windows

Buried in Rule 6.3(c) of the KalshiEX rulebook is a sentence most traders never read. When a contract expires and Kalshi can't determine the outcome, it "may use the last traded price of the Contract to determine the payout" (KalshiEX Rulebook, CFTC filing, p. 58).

Read that again. In an ambiguous resolution, the thin and widening order book you left your position sitting in doesn't just cost you on the way out. It becomes the settlement price.

Most Kalshi content treats entries as the hard part. Your exit is where the structural risk actually lives. Below is the timing math, the fee math, and three exit rule-sets a bot can execute without you watching.

**Key Takeaways** - Kalshi's outcome determination takes "anywhere from one hour to more than twelve hours" after close, and settlement typically follows about three hours later ([Kalshi](https://news.kalshi.com/p/what-is-the-market-life-cycle)) - Under Rule 6.3(c), an undeterminable outcome can be settled at the contract's **last traded price** ([Rulebook](https://www.cftc.gov/filings/orgrules/rules07012525155.pdf), p. 58) - A 409,512-observation study of Kalshi contracts found predictable price drift near resolution is "largely absorbed by trading costs," leaving executable returns **negative** ([Angelini & De Angelis](https://arxiv.org/abs/2606.07811), Jun 2026) - Kalshi charges **no settlement fee** ([Kalshi Fee Schedule](https://kalshi.com/docs/kalshi-fee-schedule.pdf), Jul 2026) - Exiting a single contract at 99¢ costs 1¢ — **100% of your remaining upside**, versus 7% on a 100-contract order at the same price (our calculation from Kalshi's published fee table)

The Kalshi Resolution Window Is Longer Than Most Bots Assume

Kalshi's own documentation defines four distinct events, not one. Market closure, determination, settlement, and payment are separate steps with separate clocks.

Determination "can take anywhere from one hour to more than twelve hours to complete after market closure," gated by when the source agency publishes its data. Settlement "typically happens three hours after market resolution but can sometimes be longer" (Kalshi).

That's a routine window of roughly 4 to 15 hours between your last chance to trade and your money moving. Nothing has gone wrong yet. This is the happy path.

Now add the review branch. If Kalshi initiates the Market Outcome Review Process, the Outcome Review Committee gets a full 24 hours to determine a final outcome (Rule 7.1(b)). Settlement then occurs on the date the committee reaches its determination — not before (Rulebook, p. 59).

Why this matters for automation: a bot that models "expiry" as a single timestamp is modeling something that doesn't exist. Capital is locked from close, not from settlement. If your position sizing assumes same-day recycling, a 12-hour determination breaks it — see position sizing and risk management for how to budget for locked capital.

Your Time-Based Trigger Can Be Moved Without Warning

Now for the detail that quietly breaks scheduled exits. Kalshi reserves the right to move the expiration date in both directions.

Rule 7.2(b) lets Kalshi push expiration later if anything prevents accurate determination — including a rescheduled or cancelled event, or delayed data from a source. Rule 7.2(c) lets Kalshi pull expiration earlier when the outcome occurs ahead of schedule (Rulebook, p. 60).

Rule 7.2(d) is the operative one. When expiration moves, "the Contract's last trading date and time are adjusted accordingly to occur no later than Expiration."

Kalshi's own docs give a concrete example. A student debt forgiveness market with a latest closure of December 31 would close the next morning instead if loans were forgiven on September 14 (Kalshi).

A bot with a hardcoded "exit 30 minutes before close" rule computed once at entry will silently miss its window on any early-expiring contract. The fix is cheap: re-read the market's close timestamp from the API on every decision tick, and treat the exit trigger as a function of the current close time. Never cache it at entry.

One implementation note that matters here. Kalshi's market object exposes several time fields, and they don't all mean the same thing. close_time is the one that gates trading, while expiration_time and latest_expiration_time describe the outer bound. Rule 7.2(d) moves the last trading time, so close_time is the field your exit logic should key on — and the one most likely to shift under you.

The Final Hour Is Structurally Hostile

This isn't a hunch. A June 2026 study analyzed 409,512 contract-minute observations across 2,876 Kalshi NBA contracts from 1,438 games, running April 2025 through May 2026 (Angelini & De Angelis, 2026). The paper is a preprint and not yet peer-reviewed, but the dataset size and method are worth taking seriously.

Two findings should reshape how you time exits.

First, Kalshi prices underreact to public information. A one-minute change in benchmark win probability moves the Kalshi midpoint only "about a 0.64-for-one" amount. The missing adjustment then predicts drift over the following minutes — 0.150 at a one-minute horizon rising to 0.236 at fifteen minutes.

Second, and this is the one that matters: that drift is not tradeable. The authors are blunt. "Executable-style returns that buy at the ask and sell at the bid are negative, indicating that the predictable midpoint drift is largely absorbed by trading costs."

**Citation capsule:** Angelini and De Angelis (2026) analyzed 409,512 contract-minute observations across 2,876 Kalshi NBA contracts, drawn from 1,438 games between April 2025 and May 2026. Their central finding: Kalshi prices incorporate only about 0.64 of each one-for-one update implied by public information. Prices move the right way, just not far enough. The residual gap then predicts drift over the following minutes. But that drift is not capturable — executable returns that buy at the ask and sell at the bid come out negative, because trading costs eat the movement. Underreaction also worsens when liquidity is thin. Forecast accuracy, meanwhile, barely improves over the final 24 hours: mean Brier score falls only from 0.204 to 0.199, and mean absolute error from 0.406 to 0.397.

The paper also found underreaction is "substantially greater when liquidity is low." Late-session books are where liquidity bottoms out, a pattern we mapped by contract type in the prediction market liquidity calendar.

All coefficients significant at the 1% level. Source: Angelini & De Angelis (2026), Table 6 (preprint, not yet peer-reviewed).

The practical read: late-window edges look real on midpoint data and evaporate on execution. Build exits that are pre-planned and time-triggered, not reactive to late-session price action. We covered the same trap from the backtest side in why backtests lie about prediction market strategies.

The Kalshi Exit-Fee Math Nobody Publishes

Kalshi's fee schedule, effective July 7, 2026, charges takers:

fees = round up(M × 0.07 × C × P × (1−P))

Where P is contract price in dollars, C is contract count, and M is a per-contract multiplier defaulting to 1. Maker fees use a 0.0175 coefficient with a multiplier defaulting to 0 (Kalshi Fee Schedule).

And here is the part that changes the whole calculation: there is no settlement fee. Kalshi states this plainly. Holding to settlement is free.

That single fact reframes the entire decision. Every early exit is a strictly additive cost you pay to avoid resolution risk. So the question is never "should I exit?" It's "is the resolution risk I'm dodging worth more than the fee?"

No fee page publishes the framing that actually matters. Express the exit fee as a share of the upside you're giving up — the remaining (1−P) you'd collect at settlement. The result is size-dependent in a way that surprises most people.

Fee columns are reproduced from Kalshi's published general trading fees table. Percentage columns are our own calculation, dividing each fee by the remaining (1−P) per contract. Source: Kalshi Fee Schedule, effective July 7, 2026.

Kalshi's published table lists a $0.01 fee to trade one contract at $0.99. Your remaining upside at that price is exactly $0.01. The fee eats all of it.

Trade 100 contracts at the same price and Kalshi charges $0.07 total — 7% of the $1.00 remaining upside. Same price, same rule, a 14× difference in relative cost.

**Citation capsule:** Kalshi's fee schedule, effective July 7, 2026, charges takers `round up(M × 0.07 × C × P × (1−P))`, where P is the contract price in dollars, C is the contract count, and M is a multiplier defaulting to 1. Maker fees use a 0.0175 coefficient with a multiplier defaulting to 0. Kalshi charges no settlement fee and no membership fee, though wire and card transactions can carry costs. Because holding to settlement is free, every early exit is an additive cost a trader chooses to pay in order to remove resolution risk. Expressed as a share of the remaining upside, that cost rises with price: Kalshi's own table shows a $0.01 fee to exit one contract at $0.99, which equals the entire $0.01 of upside remaining at that price.

The mechanism is the round-up. Fees round up to a whole unit, so tiny orders pay a minimum that swamps the formula. Small accounts get punished hardest exactly where the edge is thinnest. That's the same asymmetry we mapped in affordable prediction market bots for small accounts.

The operational rule that falls out of this is size-dependent. At 100 contracts or more, an early exit costs under 7% of remaining upside at any price, so it stays a usable risk-management tool right up to the close. At single-contract size you're already paying 10% from 80¢ up, and 100% at 99¢. Small accounts should either exit well before the window opens or stay out of ambiguous contracts entirely.

Three Kalshi Exit Rule-Sets a Bot Can Execute

Here's the part you can actually ship. Each rule uses only fields available from Kalshi's API on a normal decision tick.

Rule 1: The time-based flatten

The baseline. Exit everything at a fixed offset before close, recomputed live.

on each tick:
    close_ts = market.close_time          # re-read every tick, never cache
    if (close_ts - now) <= EXIT_BUFFER:
        flatten(position, order_type=limit, price=bid + 1)

Set EXIT_BUFFER from the contract's liquidity profile, not a round number. For actively-traded sports contracts, 15 to 30 minutes is workable. For thin economic contracts, hours.

The close_ts re-read is what protects you from Rule 7.2(c) early expiration. Cache it at entry and you'll eventually get caught.

Rule 2: The spread-width circuit breaker

Time isn't the only signal. Book quality degrades before the clock runs out, and the academic evidence says that degradation is where your edge dies.

on each tick:
    spread = best_ask - best_bid
    if spread > MAX_SPREAD or best_bid_size < MIN_SIZE:
        breaker_ticks += 1
    else:
        breaker_ticks = 0

    if breaker_ticks >= 3:                # persistent, not a one-tick blip
        flatten(position, order_type=limit, price=best_bid)

The three-tick confirmation matters. A single wide quote is noise; three consecutive is the book actually thinning. Exiting on the first wide print means paying the spread to escape a spread that wasn't there.

Pair this with a hard floor: never submit a market order into a book wider than your expected edge. That check alone prevents most late-session self-inflicted losses.

Rule 3: The ambiguity blacklist

The one nobody automates, and the highest-value of the three. Some contracts should never be held into resolution regardless of price.

Score each position on ambiguity risk before the window opens:

ambiguity_score = 0
if source_agency_publishes_on_delay:      ambiguity_score += 2
if outcome_depends_on_subjective_wording: ambiguity_score += 3
if event_is_reschedulable:                ambiguity_score += 2
if market_flagged_under_review:           ambiguity_score += 5   # hard exit

if ambiguity_score >= 3:
    exit_before_close(buffer=EXIT_BUFFER * 3)

The market_flagged_under_review check is free information. Under Rule 7.1(a), when Kalshi initiates the Market Outcome Review Process it "will post on its website that the Contract's Market Outcome is under review" (Rulebook, p. 59). That's a public signal your bot can poll.

Why the tripled buffer for ambiguous contracts? Because of Rule 6.3(c). If the outcome can't be determined, the last traded price may set the payout — and if it doesn't, the Outcome Review Committee's determination is "final and not subject to review." There's no appeal. Getting out early is the only control you have.

Where the Rules Break

Honest caveats, because these rules aren't free.

Rule 1 costs you the settlement premium. On contracts you'd have won, you're paying the fee and giving up the last few cents. On a high-hit-rate strategy that's a real drag. Backtest the buffer, don't assume it.

Rule 2 can be gamed. A wide book you exit into is a wide book someone else is quoting. Exiting on a spread signal in a thin market means trading against whoever widened it. Use limit orders at the bid, never market orders.

Rule 3 depends on judgment you have to encode manually. Nothing in the API tells you a contract's wording is subjective. That scoring has to come from reading contract terms once per series and storing the result.

The manipulation research is worth knowing about here, with a caveat. A June 2026 study of Polymarket's BTC contracts found order flow in the final ten seconds rose sharply after launch, with reversals immediately after settlement (Dai, Jia & Yu, 2026, preprint). That's a different venue with different settlement mechanics — Kalshi's centralized determination isn't UMA's oracle vote. But the structural lesson carries: the last minutes before a binary settles are where the incentive to push price is highest.

For the mechanics of how resolution and dispute processes actually work across both platforms, see how prediction markets resolve.

Test the Buffer Before You Trust It

Every number above is a starting point, not a setting. The right EXIT_BUFFER for BTC hourly contracts is not the right one for CPI.

The only way to find it is to sweep it. Run the same strategy across a range of exit buffers on historical data and look at the shape of the results, not the peak. A buffer that only works at exactly 22 minutes is overfit. One that works across 15 to 40 minutes is a real effect.

That's exactly what Turbine Studio is built for. You describe the strategy and the exit rule in plain language, backtest it against historical Kalshi order book data, sweep the exit buffer across a parameter range, and deploy the bot that survives. No infrastructure, no API plumbing, no writing the tick loop yourself.

The exit logic above is the kind of rule you'd otherwise spend a weekend implementing and a month debugging. Start with a paper-traded bot and let it prove the buffer before real capital touches it.

Build and backtest your exit rules on Turbine Studio →

Frequently Asked Questions

How long does Kalshi take to settle a contract?

Outcome determination takes "anywhere from one hour to more than twelve hours" after market close, depending on when the source agency publishes. Settlement typically follows about three hours later (Kalshi). If an outcome review is initiated, the committee has 24 hours to decide.

Does Kalshi charge a fee to hold a contract to settlement?

No. Kalshi's fee schedule states plainly that there is no settlement fee (Kalshi, effective July 2026). Trading fees apply only to matched orders. This makes every early exit an additive cost you're choosing to pay to remove resolution risk.

What happens if Kalshi can't determine a contract's outcome?

Under Rule 6.3(c), Kalshi may use the contract's last traded price to determine the payout. If no last traded price exists or it isn't a fair settlement, the Outcome Review Committee makes a binding determination that is "final and not subject to review" (Rulebook, p. 58).

Can Kalshi change when a contract expires?

Yes, in both directions. Rule 7.2(b) permits pushing expiration later for delayed data or rescheduled events. Rule 7.2(c) permits pulling it earlier when the outcome occurs ahead of schedule. Last trading time moves with it, so bots must re-read close timestamps rather than caching them.

Is there a tradeable edge in the final minutes before resolution?

The evidence says no. Kalshi prices underreact to news by roughly 0.64-for-one, and the resulting drift is statistically real. But executable returns that buy at the ask and sell at the bid are negative — trading costs absorb the drift (Angelini & De Angelis, 2026).

The Takeaways

• Model four timestamps, not one. Close, determination, settlement, and payment are separate events with separate clocks. Your capital locks at close, and determination alone can run past twelve hours before anyone gets paid.
• Never cache the close time. Rule 7.2 lets Kalshi move expiration in either direction, so re-read it every tick.
• Fees are asymmetric by size. Exiting a single contract at 99¢ costs 100% of your remaining upside. The same exit at 100 contracts costs 7%. If you're trading small, the arithmetic argues for getting out well before the window opens — or for skipping ambiguous contracts altogether.
• Late-window drift is a mirage. Real on midpoints, negative once you cross the spread.
• Blacklist ambiguity early. Rule 6.3(c) can settle an undeterminable contract at its last traded price, and the Outcome Review Committee's call is final with no appeal, so the thin book you abandon your position in may end up setting your payout.
• Sweep the buffer rather than guessing it. An exit offset that only works at one exact value is overfit.

Your entry decides whether a trade has edge. Your exit decides whether you keep it.

---

This article is for informational and educational purposes only. It is not investment advice, and nothing here is a recommendation to trade any specific contract. Prediction market trading involves risk of loss. Fee schedules and exchange rules change — verify current terms with Kalshi directly before trading. Rulebook citations reference the KalshiEX LLC rulebook as filed with the CFTC and may be superseded by later revisions.