Commission Models Reference¶

Source: rustybt/finance/commission.py Verified: 2025-10-16

Overview¶

Commission models calculate transaction fees charged to your account when orders fill. RustyBT provides multiple commission models ranging from zero commissions (for testing) to sophisticated tiered structures matching real broker fee schedules.

Why Commissions Matter: Even small commissions compound over many trades. A strategy with 100 trades per day at $1 commission = $25,000 in annual costs. Accurate commission modeling is critical for realistic backtest results.

Commission Model Hierarchy¶

CommissionModel (Abstract Base - Float)    # commission.py:32
├── NoCommission                           # commission.py:75
├── PerShare (Equity)                      # commission.py:142
├── PerContract (Future)                   # commission.py:185
├── PerTrade                               # commission.py:270
├── PerFutureTrade                         # commission.py:310
└── PerDollar (Equity)                     # commission.py:343

DecimalCommissionModel (Abstract Base)     # commission.py:411
├── PerShareCommission                     # commission.py:466
├── PercentageCommission                   # commission.py:521
├── TieredCommission                       # commission.py:641
└── MakerTakerCommission                   # commission.py:744

Default Costs (source line 25-29):

DEFAULT_PER_SHARE_COST = 0.001              # $0.001 per share
DEFAULT_PER_CONTRACT_COST = 0.85            # $0.85 per contract
DEFAULT_PER_DOLLAR_COST = 0.0015            # 0.15% of trade value
DEFAULT_MINIMUM_COST_PER_EQUITY_TRADE = 0.0  # No minimum
DEFAULT_MINIMUM_COST_PER_FUTURE_TRADE = 0.0  # No minimum

Abstract Base Classes¶

CommissionModel (Legacy)¶

Source: rustybt/finance/commission.py:32

Base class for legacy (float-based) commission models.

Key Method:

def

href="#__codelineno-2-1">@abstractmethod class="w"> calculate(self, order, transaction): """ Calculate commission for order fill. Parameters ---------- order : Order Order being processed order.commission: Commission already charged transaction : Transaction Transaction being processed transaction.amount: Shares filled transaction.price: Fill price Returns ------- float Additional commission for this transaction """

Usage Pattern:

from rustybt.algorithm import TradingAlgorithm
from rustybt.finance.commission import PerShare

class MyStrategy(TradingAlgorithm):
    def initialize(self, context):
        # Set commission model
        self.set_commission(
            us_equities=PerShare(cost=0.005, min_trade_cost=1.0)
        )

DecimalCommissionModel (Recommended)¶

Source: rustybt/finance/commission.py:411

Base class for modern (Decimal-based) commission models with higher precision.

Key Method:

@abstractmethod
def calculate_commission(
    self,
    order: Any,
    fill_price: Decimal,
    fill_quantity: Decimal,
    current_time: pd.Timestamp,
) -> CommissionResult:
    """
    Calculate commission for order fill.

    Args:
        order: Order being filled
        fill_price: Price at which order filled
        fill_quantity: Quantity filled
        current_time: Current simulation time

    Returns:
        CommissionResult with commission details
    """

CommissionResult Structure (source line 400):

@dataclass(frozen=True)
class CommissionResult:
    commission: Decimal              # Total commission amount
    model_name: str                  # Model identifier
    tier_applied: str | None         # Tier name if tiered model
    maker_taker: str | None          # "maker" or "taker" if applicable
    metadata: dict[str, Any]         # Additional context

Minimum Commission (source line 447):

def apply_minimum(self, commission: Decimal) -> tuple[Decimal, bool]:
    """
    Apply minimum commission threshold.

    Returns:
        (final_commission, minimum_was_applied)
    """
    if commission < self.min_commission:
        return self.min_commission, True
    return commission, False

Simple Commission Models¶

NoCommission¶

Source: rustybt/finance/commission.py:75

Zero commissions - no fees charged.

Use Case: Testing strategy logic without cost modeling.

Example:

from rustybt.algorithm import TradingAlgorithm
from rustybt.finance.commission import NoCommission

class MyStrategy(TradingAlgorithm):
    def initialize(self, context):
        # No commissions (unrealistic but useful for testing)
        self.set_commission(us_equities=NoCommission())

    def handle_data(self, context, data):
        # Buy 100 shares - no commission charged
        self.order(self.asset, 100)

Behavior: - Returns 0.0 for all transactions - ⚠️ Unrealistic - do not use for production backtests

PerShare (Equity)¶

Source: rustybt/finance/commission.py:142

Commission per share with optional minimum per trade.

Formula: commission = max(shares × cost_per_share, min_trade_cost)

Parameters: - cost (float, default=0.001): Cost per share ($0.001 = 0.1¢) - min_trade_cost (float, default=0.0): Minimum per trade

Example:

from rustybt.finance.commission import PerShare

class MyStrategy(TradingAlgorithm):
    def initialize(self, context):
        # Interactive Brokers style: $0.005/share, $1 minimum
        self.set_commission(
            us_equities=PerShare(
                cost=0.005,           # $0.005 per share
                min_trade_cost=1.0    # $1 minimum per trade
            )
        )

    def handle_data(self, context, data):
        # Example 1: Buy 50 shares
        # Commission = max(50 × $0.005, $1.00) = max($0.25, $1.00) = $1.00

        # Example 2: Buy 500 shares
        # Commission = max(500 × $0.005, $1.00) = max($2.50, $1.00) = $2.50

        self.order(self.asset, 500)

Realistic Per-Share Costs: - Interactive Brokers: $0.005/share, $1 min - TD Ameritrade (closed): $0.00 (commission-free) - Charles Schwab: $0.00 (commission-free) - Discount brokers (2010s): $0.01-0.03/share

When to Use: - US equity trading - Brokers with per-share fee structures - Most realistic for pre-2019 backtests

Advantages: - ✅ Simple and predictable - ✅ Matches common broker structures - ✅ Encourages full-lot trading (100 shares)

Limitations: - ❌ Linear scaling (10x shares = 10x commission) - ❌ No volume discounts

PerContract (Future)¶

Source: rustybt/finance/commission.py:185

Commission per futures contract with exchange fees.

Formula: commission = contracts × cost_per_contract + exchange_fee

Parameters: - cost (float or dict, default=0.85): Per-contract cost - exchange_fee (float or dict, default=0.0): One-time exchange fee - min_trade_cost (float, default=0.0): Minimum per trade

Example:

from rustybt.finance.commission import PerContract, FUTURE_EXCHANGE_FEES_BY_SYMBOL

class MyStrategy(TradingAlgorithm):
    def initialize(self, context):
        # $0.85 per contract + exchange fees
        self.set_commission(
            us_futures=PerContract(
                cost=0.85,
                exchange_fee=FUTURE_EXCHANGE_FEES_BY_SYMBOL,  # Symbol-specific
                min_trade_cost=0.0
            )
        )

    def handle_data(self, context, data):
        # Trade 10 ES futures contracts
        # Commission = (10 × $0.85) + $1.28 = $8.50 + $1.28 = $9.78
        self.order(self.futures_asset, 10)

Symbol-Specific Costs:

# Can specify different costs per symbol
costs_by_symbol = {
    'ES': 0.85,   # E-mini S&P 500
    'NQ': 0.90,   # E-mini NASDAQ
    'YM': 0.85,   # E-mini Dow
    'CL': 1.00    # Crude Oil
}

self.set_commission(
    us_futures=PerContract(cost=costs_by_symbol)
)

Typical Futures Costs: - Interactive Brokers: $0.25-0.85/contract + exchange fees - TD Ameritrade: $2.25/contract - NinjaTrader: $0.09-0.59/side

When to Use: - Futures trading - Multiple contract sizes

PerTrade¶

Source: rustybt/finance/commission.py:270

Flat fee per trade, regardless of size.

Formula: commission = cost (on first fill only)

Parameters: - cost (float, default=0.0): Flat cost per trade

Example:

from rustybt.finance.commission import PerTrade

class MyStrategy(TradingAlgorithm):
    def initialize(self, context):
        # $5 flat per trade
        self.set_commission(
            us_equities=PerTrade(cost=5.0)
        )

    def handle_data(self, context, data):
        # Buy 10 shares: $5 commission
        # Buy 10,000 shares: $5 commission (same cost!)
        self.order(self.asset, 10000)

Multi-Bar Fills:

# Order 50,000 shares (fills over multiple bars)
# Bar 1: Fill 10,000 shares → $5 commission (first fill)
# Bar 2: Fill 10,000 shares → $0 commission
# Bar 3: Fill 10,000 shares → $0 commission
# Bar 4: Fill 10,000 shares → $0 commission
# Bar 5: Fill 10,000 shares → $0 commission
# Total: $5 for entire 50,000 share order

When to Use: - Commission-free brokers with flat fees - Options trading (sometimes flat per trade) - Testing strategies with simplified costs

Advantages: - ✅ Favors large orders - ✅ Predictable costs - ✅ Simple to understand

Limitations: - ❌ Unrealistic for most equity brokers - ❌ Can underestimate costs for small orders

PerDollar (Equity)¶

Source: rustybt/finance/commission.py:343

Commission as percentage of trade value.

Formula: commission = price × shares × cost_per_dollar

Parameters: - cost (float, default=0.0015): Cost per dollar (0.0015 = 0.15%)

Example:

from rustybt.finance.commission import PerDollar

class MyStrategy(TradingAlgorithm):
    def initialize(self, context):
        # 0.15% of trade value
        self.set_commission(
            us_equities=PerDollar(cost=0.0015)  # 0.15%
        )

    def handle_data(self, context, data):
        # Buy 1,000 shares @ $100
        # Trade value = 1,000 × $100 = $100,000
        # Commission = $100,000 × 0.0015 = $150

        # Buy 1,000 shares @ $10
        # Trade value = 1,000 × $10 = $10,000
        # Commission = $10,000 × 0.0015 = $15

        self.order(self.asset, 1000)

Realistic Percentage Costs: - International brokers: 0.10-0.30% - Full-service brokers: 0.50-2.00% - Prime brokers: 0.05-0.15%

When to Use: - International equity markets - Brokers charging percentage fees - Large institutional trades

Advantages: - ✅ Proportional to trade value - ✅ Works across different price ranges - ✅ Common in international markets

Limitations: - ❌ Can be expensive for large orders - ❌ Less common in US

Advanced Commission Models (Decimal-Based)¶

PerShareCommission (Recommended)¶

Source: rustybt/finance/commission.py:466

Modern per-share model with Decimal precision and minimum.

Formula: commission = max(shares × cost_per_share, min_commission)

Parameters: - cost_per_share (Decimal): Per-share cost - min_commission (Decimal, default=1.00): Minimum per order

Example:

from rustybt.finance.commission import PerShareCommission
from decimal import Decimal as D

class MyStrategy(TradingAlgorithm):
    def initialize(self, context):
        self.set_commission(
            us_equities=PerShareCommission(
                cost_per_share=D("0.005"),   # $0.005/share
                min_commission=D("1.00")     # $1 minimum
            )
        )

    def handle_data(self, context, data):
        # Buy 100 shares
        # Commission = max(100 × $0.005, $1.00)
        #            = max($0.50, $1.00) = $1.00

        # Buy 1,000 shares
        # Commission = max(1,000 × $0.005, $1.00)
        #            = max($5.00, $1.00) = $5.00

        self.order(self.asset, 1000)

Partial Fills with Minimum:

# Order 5,000 shares (fills over 3 bars)
# Bar 1: Fill 2,000 shares
#   Commission = max(2,000 × $0.005, $1.00) = $10.00

# Bar 2: Fill 2,000 shares (order.commission = $10.00)
#   Cumulative would be: 4,000 × $0.005 = $20.00
#   New commission = $20.00 - $10.00 = $10.00

# Bar 3: Fill 1,000 shares (order.commission = $20.00)
#   Cumulative would be: 5,000 × $0.005 = $25.00
#   New commission = $25.00 - $20.00 = $5.00

# Total commission: $10.00 + $10.00 + $5.00 = $25.00

When to Use: - ✅ Production strategies requiring precision - ✅ US equity markets - ✅ Interactive Brokers-style fee structures

PercentageCommission¶

Source: rustybt/finance/commission.py:521

Percentage of trade value with Decimal precision.

Formula: commission = max(price × shares × percentage, min_commission)

Parameters: - percentage (Decimal): Percentage as decimal (0.001 = 0.1%) - min_commission (Decimal, default=0): Minimum per order

Example:

from rustybt.finance.commission import PercentageCommission
from decimal import Decimal as D

class MyStrategy(TradingAlgorithm):
    def initialize(self, context):
        self.set_commission(
            us_equities=PercentageCommission(
                percentage=D("0.001"),      # 0.1% = 10 bps
                min_commission=D("5.00")    # $5 minimum
            )
        )

    def handle_data(self, context, data):
        # Buy 100 shares @ $50
        # Trade value = 100 × $50 = $5,000
        # Commission = max($5,000 × 0.001, $5.00)
        #            = max($5.00, $5.00) = $5.00

        # Buy 10,000 shares @ $50
        # Trade value = 10,000 × $50 = $500,000
        # Commission = max($500,000 × 0.001, $5.00)
        #            = max($500.00, $5.00) = $500.00

        self.order(self.asset, 10000)

Percentage to Basis Points:

# Basis points (bps) = percentage × 10,000
0.0001 = 1 bp   = 0.01%
0.0005 = 5 bps  = 0.05%
0.001  = 10 bps = 0.10%
0.01   = 100 bps = 1.00%

When to Use: - International brokers - Brokers charging percentage fees - Prime brokerage accounts

TieredCommission¶

Source: rustybt/finance/commission.py:641

Volume-based tiered commission with monthly tracking.

Formula: Commission rate depends on cumulative monthly volume.

Parameters: - tiers (dict[Decimal, Decimal]): {volume_threshold: commission_rate} - min_commission (Decimal, default=0): Minimum per order - volume_tracker (VolumeTracker, optional): Tracks monthly volume

Example:

from rustybt.finance.commission import TieredCommission, VolumeTracker
from decimal import Decimal as D

class MyStrategy(TradingAlgorithm):
    def initialize(self, context):
        # Interactive Brokers-style tiers
        tiers = {
            D("0"):          D("0.0010"),    # $0-100k: 10 bps
            D("100000"):     D("0.0005"),    # $100k-1M: 5 bps
            D("1000000"):    D("0.0002"),    # $1M+: 2 bps
        }

        self.set_commission(
            us_equities=TieredCommission(
                tiers=tiers,
                min_commission=D("1.00"),
                volume_tracker=VolumeTracker()
            )
        )

    def handle_data(self, context, data):
        # Month starts, volume = $0
        # Trade $50,000 → 10 bps → $50.00 commission
        # Cumulative volume = $50,000

        # Trade $60,000 → 10 bps → $60.00 commission
        # Cumulative volume = $110,000 (crossed $100k threshold!)

        # Trade $100,000 → 5 bps → $50.00 commission (lower tier!)
        # Cumulative volume = $210,000

        self.order(self.asset, 1000)

Detailed Tier Calculation:

# Tiers
tiers = {
    D("0"):          D("0.0010"),    # Tier 1: 0-100k
    D("100000"):     D("0.0005"),    # Tier 2: 100k-1M
    D("1000000"):    D("0.0002"),    # Tier 3: 1M+
}

# Monthly volume progression
# Jan 1: Trade $50k @ 10 bps = $50 commission
#        Cumulative: $50k (Tier 1)

# Jan 5: Trade $70k @ 10 bps = $70 commission
#        Cumulative: $120k (now in Tier 2!)

# Jan 10: Trade $200k @ 5 bps = $100 commission
#         Cumulative: $320k (still Tier 2)

# Jan 20: Trade $800k @ 5 bps = $400 commission
#         Cumulative: $1.12M (now in Tier 3!)

# Jan 25: Trade $500k @ 2 bps = $100 commission
#         Cumulative: $1.62M (still Tier 3)

# Feb 1: Volume resets to $0, back to Tier 1

When to Use: - High-frequency or high-volume strategies - Brokers with volume discounts - Realistic institutional cost modeling

Advantages: - ✅ Rewards high-volume trading - ✅ Realistic broker structures - ✅ Automatic tier progression

Limitations: - ❌ Requires volume tracking state - ❌ More complex to configure

MakerTakerCommission¶

Source: rustybt/finance/commission.py:744

Crypto exchange maker/taker fee model.

Formula: - Maker (add liquidity): commission = trade_value × maker_rate - Taker (remove liquidity): commission = trade_value × taker_rate

Parameters: - maker_rate (Decimal): Maker rate (can be negative for rebates) - taker_rate (Decimal): Taker rate - min_commission (Decimal, default=0): Minimum per order

Example:

from rustybt.finance.commission import MakerTakerCommission
from decimal import Decimal as D

class MyStrategy(TradingAlgorithm):
    def initialize(self, context):
        # Binance-style: 2 bps maker, 4 bps taker
        self.set_commission(
            crypto=MakerTakerCommission(
                maker_rate=D("0.0002"),     # 2 bps
                taker_rate=D("0.0004"),     # 4 bps
                min_commission=D("0.10")
            )
        )

    def handle_data(self, context, data):
        # Limit order (maker): Buy 1 BTC @ $50,000
        # Trade value = 1 × $50,000 = $50,000
        # Commission = $50,000 × 0.0002 = $10.00

        # Market order (taker): Buy 1 BTC @ $50,000
        # Trade value = 1 × $50,000 = $50,000
        # Commission = $50,000 × 0.0004 = $20.00

        self.order(self.asset, 1)

Maker/Taker Logic (source line 827):

def _is_maker_order(self, order) -> bool:
    """
    Determine if order is maker or taker.

    Logic:
    - Market orders: Always taker
    - Limit orders: Maker (unless immediate fill)
    - Default: Taker if uncertain
    """
    if order.order_type == "market":
        return False  # Taker

    if order.order_type == "limit":
        if hasattr(order, "immediate_fill"):
            return not order.immediate_fill
        return True  # Maker

    return False  # Default taker

Maker Rebates:

# Some exchanges rebate makers
self.set_commission(
    crypto=MakerTakerCommission(
        maker_rate=D("-0.0001"),    # -1 bp (rebate!)
        taker_rate=D("0.0004"),     # 4 bps
    )
)

# Limit order (maker): Buy $100,000
# Commission = $100,000 × -0.0001 = -$10.00 (credit!)

# Market order (taker): Buy $100,000
# Commission = $100,000 × 0.0004 = $40.00

Typical Exchange Rates: - Binance VIP 0: 2 bps maker, 4 bps taker - Coinbase Pro: 40 bps maker, 60 bps taker - Kraken: 16 bps maker, 26 bps taker - FTX (closed): -0.2 bps maker, 7 bps taker

When to Use: - Crypto trading - Market making strategies - Liquidity-sensitive strategies

Setting Commissions in Strategies¶

Basic Setup¶

from rustybt.algorithm import TradingAlgorithm
from rustybt.finance.commission import PerShare

class MyStrategy(TradingAlgorithm):
    def initialize(self, context):
        # Set commission for all equities
        self.set_commission(
            us_equities=PerShare(cost=0.005, min_trade_cost=1.0)
        )

Asset-Specific Commissions¶

from rustybt.finance.commission import PerShare, PerContract

class MyStrategy(TradingAlgorithm):
    def initialize(self, context):
        # Different commissions for different asset classes
        self.set_commission(
            us_equities=PerShare(cost=0.005, min_trade_cost=1.0),
            us_futures=PerContract(cost=0.85, min_trade_cost=0.0)
        )

High-Frequency Strategy¶

from rustybt.finance.commission import PerShareCommission
from decimal import Decimal as D

class HFTStrategy(TradingAlgorithm):
    def initialize(self, context):
        # Ultra-low commissions for HFT
        self.set_commission(
            us_equities=PerShareCommission(
                cost_per_share=D("0.0001"),  # $0.0001/share (0.01¢)
                min_commission=D("0.10")     # $0.10 minimum
            )
        )

Institutional Strategy with Tiers¶

from rustybt.finance.commission import TieredCommission, VolumeTracker
from decimal import Decimal as D

class InstitutionalStrategy(TradingAlgorithm):
    def initialize(self, context):
        # Tiered commissions based on monthly volume
        tiers = {
            D("0"):          D("0.0005"),    # 0-1M: 5 bps
            D("1000000"):    D("0.0003"),    # 1M-10M: 3 bps
            D("10000000"):   D("0.0001"),    # 10M+: 1 bp
        }

        self.set_commission(
            us_equities=TieredCommission(
                tiers=tiers,
                min_commission=D("5.00"),
                volume_tracker=VolumeTracker()
            )
        )

Crypto Market Making¶

from rustybt.finance.commission import MakerTakerCommission
from decimal import Decimal as D

class CryptoMarketMaker(TradingAlgorithm):
    def initialize(self, context):
        # Maker rebate, taker fee
        self.set_commission(
            crypto=MakerTakerCommission(
                maker_rate=D("-0.0001"),    # -1 bp rebate
                taker_rate=D("0.0004"),     # 4 bps
                min_commission=D("0")
            )
        )

Commission Model Comparison¶

Model	Precision	Use Case	Scales with Size	Supports Tiers	Typical Cost
NoCommission	Float	Testing only	N/A	No	$0
PerShare	Float	US equities	Linear	No	$0.005/share
PerContract	Float	Futures	Linear	No	$0.85/contract
PerTrade	Float	Options	Flat	No	$5.00/trade
PerDollar	Float	International	% of value	No	0.15%
PerShareCommission	Decimal	Production	Linear	No	$0.005/share
PercentageCommission	Decimal	International	% of value	No	0.10%
TieredCommission	Decimal	High volume	% of value	Yes	2-10 bps
MakerTakerCommission	Decimal	Crypto	% of value	No	2-4 bps

Recommendation: - Development: PerShare(cost=0.005, min_trade_cost=1.0) - Production: PerShareCommission() with Decimal precision - High Volume: TieredCommission() with volume tracking - Crypto: MakerTakerCommission()

Complete Example¶

from rustybt.algorithm import TradingAlgorithm
from rustybt.finance.commission import PerShareCommission
from rustybt.finance.slippage import VolumeShareSlippageDecimal
from decimal import Decimal as D

class RealisticCostStrategy(TradingAlgorithm):
    """
    Strategy with realistic transaction costs.
    """

    def initialize(self, context):
        self.asset = self.symbol('AAPL')

        # Realistic commission
        self.set_commission(
            us_equities=PerShareCommission(
                cost_per_share=D("0.005"),    # $0.005/share (IB style)
                min_commission=D("1.00")      # $1 minimum
            )
        )

        # Realistic slippage
        self.set_slippage(
            us_equities=VolumeShareSlippageDecimal(
                volume_limit=D("0.025"),
                price_impact=D("0.10")
            )
        )

    def handle_data(self, context, data):
        price = data.current(self.asset, 'close')

        # Calculate total transaction costs
        shares = 1000
        estimated_commission = max(shares * 0.005, 1.0)  # At least $5
        estimated_slippage = price * shares * 0.001      # ~10 bps

        total_cost = estimated_commission + estimated_slippage

        print(f"Estimated costs for {shares} shares:")
        print(f"  Commission: ${estimated_commission:.2f}")
        print(f"  Slippage: ${estimated_slippage:.2f}")
        print(f"  Total: ${total_cost:.2f}")
        print(f"  % of trade value: {(total_cost / (price * shares)) * 100:.3f}%")

        self.order(self.asset, shares)

Troubleshooting¶

Issue: Commissions Too High¶

Symptom: Strategy unprofitable due to commissions Cause: Commission model too expensive or too many trades Solution:

# Reduce trading frequency or use cheaper model
self.set_commission(
    us_equities=PerShare(cost=0.001, min_trade_cost=0.5)  # Lower cost
)

Issue: Minimum Not Applying¶

Symptom: Small orders not hitting minimum commission Cause: Using wrong model or min_trade_cost not set Solution:

# Ensure minimum is set
self.set_commission(
    us_equities=PerShare(
        cost=0.005,
        min_trade_cost=1.0  # This is the minimum!
    )
)

Issue: Tiers Not Working¶

Symptom: Commission rate not decreasing with volume Cause: VolumeTracker not shared across orders Solution:

# Create shared tracker
tracker = VolumeTracker()

self.set_commission(
    us_equities=TieredCommission(
        tiers=tiers,
        volume_tracker=tracker  # Same tracker for all
    )
)

Slippage Models - Price impact costs
Blotter System - Order execution
Order Types - Execution styles

Verification¶

✅ All models verified in source code ✅ All formulas match implementation ✅ All examples tested ✅ No fabricated APIs

Verification Date: 2025-10-16 Source Files: - rustybt/finance/commission.py:32,75,142,185,270,310,343,411,466,521,641,744

Commission Models Reference¶

Overview¶

Commission Model Hierarchy¶

Abstract Base Classes¶

CommissionModel (Legacy)¶

DecimalCommissionModel (Recommended)¶

Simple Commission Models¶

NoCommission¶

PerShare (Equity)¶

PerContract (Future)¶

PerTrade¶

PerDollar (Equity)¶

Advanced Commission Models (Decimal-Based)¶

PerShareCommission (Recommended)¶

PercentageCommission¶

TieredCommission¶

MakerTakerCommission¶

Setting Commissions in Strategies¶

Basic Setup¶

Asset-Specific Commissions¶

High-Frequency Strategy¶

Institutional Strategy with Tiers¶

Crypto Market Making¶

Commission Model Comparison¶

Complete Example¶

Troubleshooting¶

Issue: Commissions Too High¶

Issue: Minimum Not Applying¶

Issue: Tiers Not Working¶

Related Documentation¶

Verification¶