Transaction Fees

The ConstantFeeModel applies the absolute value of a constant fee to each order. It's the default fee model of the DefaultBrokerageModel if you trade Forex, CFD, or Crypto assets. Use this model to set zero transaction fees.

security.SetFeeModel(new ConstantFeeModel(0.05m));

security.set_fee_model(ConstantFeeModel(0.05))

The following table describes the arguments the model accepts:

To view the implementation of this model, see the LEAN GitHub repository.

The AlpacaFeeModel models the fees of Alpaca.

security.SetFeeModel(new AlpacaFeeModel());

security.set_fee_model(AlpacaFeeModel())

The AlpacaFeeModel charges zero fees for Equity and Equity Options trading. For Crypto trades, it charges a 0.15% maker and 0.25% taker fee. If you add liquidity to the order book by placing a limit order that doesn't cross the spread, you pay maker fees. If you remove liquidity from the order book by placing an order that crosses the spread, you pay taker fees. Alpaca adjusts your fees based on your 30-day trading volume, but we don't currently model these metrics to adjust fees.

The AlpacaFeeModel charges fees in the currency you receive from a trade. For example, if you buy ETHBTC, you pay fees in ETH. If you sell ETHBTC, you pay fees in BTC.

To view the implementation of this model, see the LEAN GitHub repository.

The BinanceFeeModel models the fees of spot trades on Binance and Binance US.

security.SetFeeModel(new BinanceFeeModel());

security.set_fee_model(BinanceFeeModel())

The following table describes the arguments the model accepts:

The BinanceFeeModel charges the order fees of Binance and Binance US at the VIP 0 level, which is a 0.1% maker and taker fee. If you add liquidity to the order book by placing a limit order that doesn't cross the spread, you pay maker fees. If you remove liquidity from the order book by placing an order that crosses the spread, you pay taker fees. Binance adjusts your fees based on your 30-day trading volume and BNB balance, but we don't currently model these metrics to adjust fees.

The BinanceFeeModel charges fees in the currency you receive from a trade. For example, if you buy ETHBTC, you pay fees in ETH. If you sell ETHBTC, you pay fees in BTC.

To view the implementation of this model, see the LEAN GitHub repository.

The BinanceFuturesFeeModel models the Binance Futures live trading fees.

security.SetFeeModel(new BinanceFuturesFeeModel());

security.set_fee_model(BinanceFuturesFeeModel())

The following table describes the arguments the model accepts:

By default, the BinanceFuturesFeeModel charges the order fees of Binance Futures at the Regular User level. If you add liquidity to the order book by placing a limit order that doesn't cross the spread, you pay maker fees. If you remove liquidity from the order book by placing an order that crosses the spread, you pay taker fees. Binance adjusts your fees based on your 30-day trading volume and BNB balance, but we don't currently model these metrics to adjust fees.

The BinanceFuturesFeeModel charges fees in the currency you receive from a trade. For example, if you buy BTCUSD, you pay fees in BTC. If you sell BTCUSD, you pay fees in USD.

To view the implementation of this model, see the LEAN GitHub repository.

The BinanceCoinFuturesFeeModel models the Binance Coin Futures live trading fees.

security.SetFeeModel(new BinanceCoinFuturesFeeModel());

security.set_fee_model(BinanceCoinFuturesFeeModel())

The following table describes the arguments the model accepts:

By default, the BinanceCoinFuturesFeeModel charges the order fees of Binance Coin Futures at the Regular User level. If you add liquidity to the order book by placing a limit order that doesn't cross the spread, you pay maker fees. If you remove liquidity from the order book by placing an order that crosses the spread, you pay taker fees. Binance adjusts your fees based on your 30-day trading volume and BNB balance, but we don't currently model these metrics to adjust fees.

The BinanceCoinFuturesFeeModel charges fees in the currency you receive from a trade. For example, if you buy BTCUSDT, you pay fees in BTC. If you sell BTCUSDT, you pay fees in USDT.

To view the implementation of this model, see the LEAN GitHub repository.

The BitfinexFeeModel models the Bitfinex live trading fees.

security.SetFeeModel(new BitfinexFeeModel());

security.set_fee_model(BitfinexFeeModel())

The BitfinexFeeModel charges a 0.1% maker fee and a 0.2% taker fee. If you place a limit order that hits a hidden order or you add liquidity to the order book by placing a limit order that doesn't cross the spread, you pay maker fees. If you place a hidden order or you remove liquidity from the order book by placing an order that crosses the spread, you pay taker fees. Bitfinex adjusts your fees based on your 30-day trading volume and LEO balance, but we don't currently model these metrics to adjust fees.

The BitfinexFeeModel charges fees in the currency you receive from a trade. For example, if you buy ETHBTC, you pay fees in ETH. If you sell ETHBTC, you pay fees in BTC.

To view the implementation of this model, see the LEAN GitHub repository.

The BybitFeeModel models the Bybit live trading fees.

security.SetFeeModel(new BybitFeeModel());

security.set_fee_model(BybitFeeModel())

The following table describes the arguments the model accepts:

The BybitFeeModel charges the order fees of Bybit at the VIP 0 level, which is a 0.1% maker and taker fee for spot trades. If you add liquidity to the order book by placing a limit order that doesn't cross the spread, you pay maker fees. If you remove liquidity from the order book by placing an order that crosses the spread, you pay taker fees. Bybit adjusts your fees based on your 30-day trading volume, net borrowings, or asset balance, but we don't currently model these metrics to adjust fees. Bybit also charges different fees for fiat-Crypto pairs, (for example, USDT/EUR), but the BybitFeeModel charges the same fee rate for all pairs.

The BybitFeeModel charges fees in the currency you receive from a trade. For example, if you buy ETHBTC, you pay fees in ETH. If you sell ETHBTC, you pay fees in BTC.

To view the implementation of this model, see the LEAN GitHub repository.

The BybitFuturesFeeModel models the Bybit live trading fees.

security.SetFeeModel(new BybitFuturesFeeModel());

security.set_fee_model(BybitFuturesFeeModel())

The following table describes the arguments the model accepts:

The BybitFuturesFeeModel charges the order fees of Bybit at the VIP 0 level, which is a 0.02% maker and a 0.055% taker fee for Crypto Futures trades. If you add liquidity to the order book by placing a limit order that doesn't cross the spread, you pay maker fees. If you remove liquidity from the order book by placing an order that crosses the spread, you pay taker fees. Bybit adjusts your fees based on your 30-day trading volume, net borrowings, or asset balance, but we don't currently model these metrics to adjust fees.

The BybitFuturesFeeModel charges fees in the currency you receive from a trade. For example, if you buy BTCUSDT, you pay fees in BTC. If you sell BTCUSDT, you pay fees in USDT.

To view the implementation of this model, see the LEAN GitHub repository.

The CoinbaseFeeModel models the Coinbase live trading fees.

security.SetFeeModel(new CoinbaseFeeModel());

security.set_fee_model(CoinbaseFeeModel())

The CoinbaseFeeModel models the order fees of Coinbase at the $50K-100K pricing tier for all Crypto pairs, so it charges a 0.5% maker and taker fee for most pairs. The following table shows the Coinbase Stable Pairs, which charge a 0% maker fee and a 0.1% taker fee:

If you add liquidity to the order book by placing a limit order that doesn't cross the spread, you pay maker fees. If you remove liquidity from the order book by placing an order that crosses the spread, you pay taker fees. Coinbase adjusts your fees based on your 30-day trading volume, but we don't currently model trading volume to adjust fees.

The CoinbaseFeeModel models the adjustments Coinbase has made to their fees over time. The following table shows the fees for each time period:

The CoinbaseFeeModel charges fees in the quote currency.

To view the implementation of this model, see the LEAN GitHub repository.

The InteractiveBrokersFeeModel models the fees of Interactive Brokers.

security.SetFeeModel(new InteractiveBrokersFeeModel());

security.set_fee_model(InteractiveBrokersFeeModel())

The following table describes the arguments the model accepts:

The following table describes which currency the InteractiveBrokersFeeModel charges fees in for each asset class:

The following sections describe the trading fees of each asset class. To view the implementation of this model, see the LEAN GitHub repository.

US Equities

US Equity trades cost $0.005/share with a $1 minimum fee and a 0.5% maximum fee.

Equity Options and Index Options

Equity Options and Index Options fees are a function of your monthly volume and the premium of the contract you trade. The following table shows the fees for each volume tier:

By default, LEAN models your fees at the tier with the lowest monthly volume. To adjust the fee tier, manually set the fee model and provide a monthlyOptionsTradeAmountInContractsmonthly_options_trade_amount_in_contracts argument.

The following table shows how the model determines the premium for each order type and direction:

There is no fee to exercise Option contracts.

Forex

Forex fees are a function of your monthly Forex trading volume. The following table shows the fee tiers:

By default, LEAN models your fees at the tier with the lowest monthly volume. To adjust the fee tier, manually set the fee model and provide a monthlyForexTradeAmountInUSDollarsmonthly_forex_trade_amount_in_us_dollars argument.

US Futures

US Futures fees depend on the contracts you trade. The following table shows the base fee per contract for each Future:

If you trade a contract that's not in the preceding table, the base fee is $0.85/contract and the exchange fee is $1.60/contract.

In addition to the base fee and exchange fee, there is a $0.02/contract regulatory fee.

Futures Options

Futures Options fees depend on the contracts you trade. The following table shows the base fee per contract for each Future:

If you trade a contract that's not in the preceding table, the base fee is $0.85/contract and the exchange fee is $1.60/contract.

In addition to the base fee and exchange fee, there is a $0.02/contract regulatory fee.

CFD

CFD trades cost 0.002% of the trade value. The following table shows the minimum fee for each quote currency:

CFD trading fees are denominated in the quote currency of the CFD product.

The KrakenFeeModel models the fees of Kraken.

security.SetFeeModel(new KrakenFeeModel());

security.set_fee_model(KrakenFeeModel())

The KrakenFeeModel model the order fees of Kraken. For trading pairs that contain only Crypto assets, this fee model models the lowest tier in Kraken's tiered fee structure, which is a 0.16% maker fee and a 0.26% taker fee. If you add liquidity to the order book by placing a limit order that doesn't cross the spread, you pay maker fees. If you remove liquidity from the order book by placing an order that crosses the spread, you pay taker fees. For trading pairs that have any of the following currencies as the base currency in the pair, the fee is 0.2%:

• CAD
• EUR
• GBP
• JPY
• USD
• USDT
• DAI
• USDC

The KrakenFeeModel charges fees in the quote currency for buy orders and in the base currency for sell orders. To override these settings, define the KrakenOrderProperties.

public override void Initialize()
{
    // Set the default order properties
    DefaultOrderProperties = new KrakenOrderProperties()
    {
        FeeInBase = true,
        FeeInQuote = false
    };
}

public override void OnData(Slice slice)
{
    // Override the default order properties
    LimitOrder(_symbol, quantity, limitPrice, 
               orderProperties: new KrakenOrderProperties
               { 
                   FeeInQuote = true, 
                   FeeInBase = false 
               });
}

def initialize(self) -> None:
    # Set the default order properties
    self.default_order_properties = KrakenOrderProperties()
    self.default_order_properties.fee_in_base = True
    self.default_order_properties.fee_in_quote = False

def on_data(self, slice: Slice) -> None:
    # Override the default order properties
    order_properties = KrakenOrderProperties()
    order_properties.fee_in_quote = True
    order_properties.fee_in_base = False
    self.limit_order(self._symbol, quantity, limit_price, order_properties=order_properties)

Kraken adjusts your fees based on your 30-day trading volume, but the KrakenFeeModel don't currently model trading volume to adjust fees.

To view the implementation of this model, see the LEAN GitHub repository.

The SamcoFeeModel models the fees of Samco.

security.SetFeeModel(new SamcoFeeModel());

security.set_fee_model(SamcoFeeModel())

The SamcoFeeModel models the order fees of Samco by its Equity Intraday fee structure. The following table shows the fees:

The SamcoFeeModel charges fees in INR.

To view the implementation of this model, see the LEAN GitHub repository.

The TDAmeritradeFeeModel models the fees of TD Ameritrade.

security.SetFeeModel(new TDAmeritradeFeeModel());

security.set_fee_model(TDAmeritradeFeeModel())

The TDAmeritradeFeeModel charges $0 USD for Equity trades.

To view the implementation of this model, see the LEAN GitHub repository.

The TradeStationFeeModel models the fees of TradeStation.

security.SetFeeModel(new TradeStationFeeModel());

security.set_fee_model(TradeStationFeeModel())

The following sections describe the trading fees of each asset class. To view the implementation of this model, see the LEAN GitHub repository.

US Equities

US Equity trades are free for US residents. For non-US residents, they cost $5 USD per order.

Equity Options

Equity Option trades cost $0.60 USD per contract. For non-US residents, they cost an extra $5 USD per order.

Futures

Futures trades cost $1.50 USD per contract.

The WolverineFeeModel models the fees of Wolverine Execution Services.

security.SetFeeModel(new WolverineFeeModel());

security.set_fee_model(WolverineFeeModel())

The following table describes the arguments the model accepts:

The WolverineFeeModel charges fees in USD.

To view the implementation of this model, see the LEAN GitHub repository.

The ZerodhaFeeModel models the fees of Zerodha.

security.SetFeeModel(new ZerodhaFeeModel());

security.set_fee_model(ZerodhaFeeModel())

The ZerodhaFeeModel models the order fees of Zerodha with its Equity Intraday fee structure. The following table shows the fees:

The ZerodhaFeeModel charges fees in INR.

To view the implementation of this model, see the LEAN GitHub repository.