Kalshi Fees: Complete Guide for Traders & Bots

Kalshi fees follow a formula-based structure that charges more on mid-priced contracts and less at the extremes — peaking at $0.02 per contract at 50 cents. This guide breaks down every fee on the platform — taker, maker, deposit, withdrawal — and models the fee impact on automated trading strategies with exact calculations for edge thresholds and bot optimization.

How Kalshi Trading Fees Work

Kalshi uses two fee formulas — one for takers (market orders that fill immediately) and one for makers (limit orders that rest on the book). Both are functions of contract price, producing a parabolic curve that peaks at 50-cent contracts where uncertainty is highest.

Taker Fee Formula

The taker fee is calculated as:

fee = ceil(0.07 × C × P × (1 - P))

Where C is the number of contracts and P is the contract price in dollars. The ceil function rounds up to the nearest cent. At a contract price of $0.50, one contract costs ceil(0.07 × 1 × 0.50 × 0.50) = ceil($0.0175) = $0.02 — the maximum taker fee per contract.

Maker Fee Formula

Maker fees use a coefficient of 0.0175, exactly 25% of the taker rate:

fee = ceil(0.0175 × C × P × (1 - P))

Maker fees apply only to resting limit orders when they execute. Placing or canceling an unfilled order costs nothing. This distinction matters for bots — a strategy that posts limit orders instead of crossing the spread pays 75% less in fees.

Fee Per Contract at Key Price Points

This table shows the per-contract fee (1 contract) and the batch fee (100 contracts) for both taker and maker orders:

The parabolic shape is the key insight. Contracts priced near the extremes (5-cent or 95-cent range) cost roughly 80% less in fees than 50-cent contracts. Agents that can identify high-conviction opportunities at price extremes get a structural fee advantage.

No Settlement Fees

Kalshi charges zero settlement fees. Winning contracts pay $1.00 and losing contracts expire at $0.00 with no deductions. This is a meaningful difference from traditional sportsbooks that embed their margin (vig) into every payout. On Kalshi, the only friction is the trading fee at entry and exit.

Non-Standard Fee Markets

Not all Kalshi markets use the standard 0.07 taker coefficient. Two categories get preferential treatment, and special events sometimes carry adjusted rates.

S&P 500 and Nasdaq-100 Markets

S&P 500 (INX ticker) and Nasdaq-100 (NASDAQ100 ticker) markets use a halved taker coefficient of 0.035, cutting trading costs by 50% compared to standard markets. At 50-cent contracts, taker fees drop from $1.75 per 100 contracts to $0.88 per 100 contracts. Maker fees scale proportionally. This applies to all iterations of INX and NASDAQ100 markets — daily ranges, weekly ranges, and yearly ranges.

The reduced fee exists because these index markets attract high-frequency flow and tight spreads. Lower fees encourage liquidity provision, which benefits Kalshi’s market quality metrics. For agents running index-tracking strategies, the 50% fee reduction materially improves the edge calculation.

Special Event Markets

Elections, major championships, and awards ceremonies may carry adjusted fee schedules. Kalshi posts upcoming fee changes on its fee schedule page before they take effect. Bots should programmatically check the fee schedule endpoint or subscribe to Kalshi’s announcements channel to avoid stale fee assumptions in their edge models.

Deposit and Withdrawal Fees

Trading fees only matter if your capital is on the platform. Here is the complete cost structure for moving money in and out of Kalshi:

For agents running automated strategies, the deposit method matters for capital efficiency. ACH is free but slow — a bot that needs to deploy capital quickly after detecting an opportunity loses 1-3 days. Crypto deposits via USDC settle in minutes with only network gas fees (typically under $1 on Polygon or Base). The 2% debit card fee is almost never worth it for serious volume: depositing $10,000 costs $200 in fees before a single trade.

Kalshi vs Polymarket Fees

Polymarket has historically been the low-fee alternative — zero trading fees on most markets. That changes on March 30, 2026, when Polymarket expands taker fees to eight new categories including politics, finance, economics, culture, weather, tech, mentions, and general markets.

Fee Comparison by Contract Price (100 Contracts)

Polymarket’s taker coefficient is 0.0625 versus Kalshi’s 0.07, a 10.7% fee advantage per trade on comparable markets. At 50-cent contracts, Polymarket charges $1.56 per 100 contracts versus Kalshi’s $1.75 — a $0.19 spread per 100 contracts.

Post-March 30 Polymarket Fee Landscape

After March 30, 2026, Polymarket’s new peak effective rates by category are: sports (0.75%), finance (1.00%), politics (1.00%), tech (1.00%), and crypto (1.80%). Geopolitical and world events markets remain permanently fee-free. Makers receive rebates between 20% and 50% depending on the category.

Annual Fee Drag at Scale

For a bot trading exclusively on fee-enabled markets:

These estimates assume an average contract price of 50 cents and all-taker execution. Maker strategies reduce both columns significantly — Kalshi makers pay 25% of taker fees, and Polymarket makers receive 20-50% rebates. For a detailed head-to-head comparison beyond fees, see the Kalshi vs Polymarket comparison.

Fee-Adjusted Edge for Agents

The fee-adjusted edge threshold is the minimum probability advantage a bot needs to be profitable after fees. This is the number that determines whether a signal is worth trading.

The Core Calculation

For a binary contract at price P with taker fee coefficient k:

required_edge = k × P × (1 - P) / (P × (1 - P))
required_edge = k

Wait — that simplifies too cleanly. The real calculation depends on what “edge” means in context. For a bot that buys a Yes contract at price P believing the true probability is P + edge:

import math

def kalshi_taker_fee(contracts: int, price: float, coefficient: float = 0.07) -> float:
    """Calculate Kalshi taker fee in dollars."""
    return math.ceil(coefficient * contracts * price * (1 - price) * 100) / 100

def required_edge(price: float, coefficient: float = 0.07) -> float:
    """Minimum probability edge to break even after fees on a single contract.

    Edge = fee_per_contract / expected_payout_sensitivity
    At price P, buying 1 Yes contract:
      - Cost: P + fee
      - Win payout: $1.00
      - Break-even true probability: (P + fee) / 1.00
      - Required edge: fee / 1.00 = fee per contract
    But fee itself depends on P, so:
    """
    fee = kalshi_taker_fee(1, price, coefficient)
    # Edge needed: the fee as a fraction of the contract range
    # True prob must exceed price by at least fee to break even
    return fee  # in dollars — convert to percentage of $1 contract

def fee_table():
    """Print fee-adjusted edge at key price points."""
    prices = [0.05, 0.10, 0.25, 0.50, 0.75, 0.90, 0.95]
    print(f"{'Price':>6} {'Taker Fee':>10} {'Maker Fee':>10} {'Taker Edge%':>12} {'Maker Edge%':>12}")
    print("-" * 52)
    for p in prices:
        taker = kalshi_taker_fee(1, p, 0.07)
        maker = kalshi_taker_fee(1, p, 0.0175)
        # Required edge as percentage points
        taker_edge = taker * 100  # fee in cents = edge in percentage points
        maker_edge = maker * 100
        print(f"{p:>6.2f} {taker:>10.4f} {maker:>10.4f} {taker_edge:>11.2f}% {maker_edge:>11.2f}%")

fee_table()

Running this produces the minimum edge required at each price point:

At 50-cent contracts, a taker needs at least 2 percentage points of edge to break even. A maker needs just 1 point. At price extremes, both converge to the 1-cent minimum fee floor, so the required edge is 1% regardless of strategy.

Practical Example: News-Sentiment Bot

Consider a news-sentiment bot that places 50 taker trades per day at an average contract price of 50 cents, buying 3 contracts per trade:

daily_trades = 50
contracts_per_trade = 3
avg_price = 0.50

daily_fee = sum(
    kalshi_taker_fee(contracts_per_trade, avg_price)
    for _ in range(daily_trades)
)
monthly_fee = daily_fee * 30
annual_fee = daily_fee * 365

print(f"Fee per trade: ${kalshi_taker_fee(contracts_per_trade, avg_price):.2f}")
print(f"Daily fee drag: ${daily_fee:.2f}")
print(f"Monthly fee drag: ${monthly_fee:.2f}")
print(f"Annual fee drag: ${annual_fee:.2f}")
# Output:
# Fee per trade: $0.06
# Daily fee drag: $3.00
# Monthly fee drag: $90.00
# Annual fee drag: $1,095.00

At $1,095 annually, fees eat into any strategy that does not maintain consistent edge. Switching to maker orders drops this to roughly $274 per year — a 75% reduction that often makes the difference between a profitable and unprofitable bot. For Kelly Criterion-based position sizing, the fee drag must be subtracted from the expected edge before computing optimal bet size.

Fee Rounding for Subpenny and Fractional Markets

Markets with subpenny pricing (tapered_deci_cent or deci_cent tick structures) and fractional contracts produce sub-cent balance changes on fills. Kalshi resolves this with a three-component fee system per fill:

Net fee = trade fee + rounding fee - rebate (always >= $0.00)

A fee accumulator tracks cumulative rounding overpayment across all fills of an order. Once the accumulator exceeds $0.01, a whole-cent rebate is issued. This ensures the total fee across many small fills converges to what a single equivalent fill would cost.

For example, buying 3 contracts at $0.055 (three 1-lot matches) produces rounding fees of $0.0065 per fill. On the second fill, the accumulator hits $0.013, triggering a $0.01 rebate that offsets most of that fill’s fee.

Settlement rounding also applies: when a position settles, the raw payout is floored to the nearest cent, and the fractional remainder is recorded as a settlement fee (always less than $0.01).

Bots reconciling fills cannot simply multiply price x quantity to get expected balance changes — the rounding fees and rebates must be accounted for. Use Decimal arithmetic and track the accumulator per order.

Fee Optimization Strategies for Bots

Reducing fee drag is one of the highest-leverage optimizations for any automated Kalshi trading bot. Here are the strategies that matter most.

Use Maker Orders When Latency Allows

The single biggest fee reduction: switch from market orders to limit orders. Maker fees are 25% of taker fees. If your signal does not require instant execution — and most do not — posting a limit order at or near the current best offer saves 75% on fees. The Kalshi API supports limit orders with time-in-force parameters that let bots control how long orders rest on the book.

Target Price Extremes

Contracts near 5-15 cents or 85-95 cents carry the lowest absolute fees. A bot that focuses on high-conviction tail events pays $0.01 per contract (taker) regardless of volume. Combined with maker orders, the fee per contract at these prices rounds down to near zero on batch orders.

Batch Orders for Volume Efficiency

The ceil function in Kalshi’s formula means small orders overpay relative to large ones. One contract at 50 cents costs $0.02 (taker), but 100 contracts cost $1.75 — not $2.00. The rounding penalty is largest on single-contract trades. Bots should batch orders where possible to avoid per-contract rounding overhead.

Cross-Platform Fee Arbitrage

When the same event trades on both Kalshi and Polymarket, the fee spread creates arbitrage opportunities. If Kalshi Yes is at 52 cents and Polymarket No is at 47 cents (implying 53 cents Yes), the 1-cent spread might be eaten by fees on one platform but not the other. Bots running cross-market strategies must compute fee-adjusted expected value on both sides before executing. The Polymarket fee expansion on March 30, 2026 narrows the fee gap — previously zero-fee Polymarket categories now carry costs that make some arbitrage windows viable on Kalshi that were not before.

Monitor the Fee Schedule Programmatically

Kalshi publishes its fee schedule at kalshi.com/fee-schedule and includes fee parameters in its API responses. Bots should pull fee coefficients dynamically rather than hardcoding 0.07 and 0.0175. This is especially important for S&P 500 and Nasdaq-100 markets where the coefficient is 0.035, and for special event markets where Kalshi may temporarily adjust rates. Agents that set up automated Kalshi trading should include fee schedule checks in their initialization logic to avoid stale fee assumptions.

For a broader view of how fees fit into the overall trading layer architecture, see the prediction market trading layer guide. Agents on the Kalshi platform should treat fee optimization as a core component of their execution engine, not an afterthought.