Struct OrderBuilder 

pub struct OrderBuilder<'a, C> { /* private fields */ }

Builder for creating orders with a fluent interface

All validation is deferred to the build() method to ensure no silent failures occur during order construction.

Implementations

impl<'a, C> OrderBuilder<'a, C>

pub fn new(client: &'a C, contract: &'a Contract) -> Self

Creates a new OrderBuilder

pub fn buy(self, quantity: impl Into<f64>) -> Self

Set order to buy the specified quantity

pub fn sell(self, quantity: impl Into<f64>) -> Self

Set order to sell the specified quantity

pub fn market(self) -> Self

Create a market order

pub fn limit(self, price: impl Into<f64>) -> Self

Create a limit order at the specified price

pub fn stop(self, stop_price: impl Into<f64>) -> Self

Create a stop order at the specified stop price

pub fn stop_limit( self, stop_price: impl Into<f64>, limit_price: impl Into<f64>, ) -> Self

Create a stop-limit order

pub fn trailing_stop( self, trailing_percent: f64, stop_price: impl Into<f64>, ) -> Self

Create a trailing stop order

pub fn order_type(self, order_type: OrderType) -> Self

Set a custom order type

pub fn trailing_stop_limit( self, trailing_percent: f64, stop_price: impl Into<f64>, limit_offset: f64, ) -> Self

Create a trailing stop limit order

pub fn market_if_touched(self, trigger_price: impl Into<f64>) -> Self

Market if Touched - triggers market order when price is touched

pub fn limit_if_touched( self, trigger_price: impl Into<f64>, limit_price: impl Into<f64>, ) -> Self

Limit if Touched - triggers limit order when price is touched

pub fn market_to_limit(self) -> Self

Market to Limit - starts as market order, remainder becomes limit

pub fn discretionary( self, limit_price: impl Into<f64>, discretionary_amt: f64, ) -> Self

Discretionary order - limit order with hidden discretionary amount

pub fn sweep_to_fill(self, limit_price: impl Into<f64>) -> Self

Sweep to Fill - prioritizes speed of execution over price

pub fn block(self, limit_price: impl Into<f64>) -> Self

Block order - for large volume option orders (min 50 contracts)

pub fn midprice(self, price_cap: Option<f64>) -> Self

Midprice order - fills at midpoint between bid/ask or better

pub fn relative(self, offset: f64, price_cap: Option<f64>) -> Self

Relative/Pegged-to-Primary - seeks more aggressive price than NBBO

pub fn passive_relative(self, offset: f64) -> Self

Passive Relative - seeks less aggressive price than NBBO

pub fn at_auction(self, price: impl Into<f64>) -> Self

At Auction - for pre-market opening period execution

pub fn market_on_close(self) -> Self

Market on Close - executes as market order at or near closing price

pub fn limit_on_close(self, limit_price: impl Into<f64>) -> Self

Limit on Close - executes as limit order at close if price is met

pub fn market_on_open(self) -> Self

Market on Open - executes as market order at market open

pub fn limit_on_open(self, limit_price: impl Into<f64>) -> Self

Limit on Open - executes as limit order at market open

pub fn market_with_protection(self) -> Self

Market with Protection - market order with protection against extreme price movements (futures only)

pub fn stop_with_protection(self, stop_price: impl Into<f64>) -> Self

Stop with Protection - stop order with protection against extreme price movements (futures only)

pub fn time_in_force(self, tif: TimeInForce) -> Self

Set time in force for the order

pub fn day_order(self) -> Self

Order valid for the day only

pub fn good_till_cancel(self) -> Self

Good till cancelled order

pub fn good_till_date(self, date: impl Into<String>) -> Self

Good till specific date

pub fn fill_or_kill(self) -> Self

Fill or kill order

pub fn immediate_or_cancel(self) -> Self

Immediate or cancel order

pub fn outside_rth(self) -> Self

Allow order execution outside regular trading hours

pub fn regular_hours_only(self) -> Self

Restrict order to regular trading hours only

pub fn trading_hours(self, hours: TradingHours) -> Self

Set trading hours preference

pub fn hidden(self) -> Self

Hide order from market depth (only works for NASDAQ-routed orders)

pub fn account(self, account: impl Into<String>) -> Self

Set account for order

pub fn parent(self, parent_id: i32) -> Self

Set parent order ID for attached orders

pub fn oca_group(self, group: impl Into<String>, oca_type: i32) -> Self

Set OCA group

pub fn do_not_transmit(self) -> Self

Do not transmit order immediately

pub fn bracket(self) -> BracketOrderBuilder<'a, C>

Create bracket orders with take profit and stop loss

pub fn condition(self, condition: impl Into<OrderCondition>) -> Self

Add a condition to the order.

The first condition is always treated as AND. Use and_condition() or or_condition() for subsequent conditions to specify the logical relationship.

Example

use ibapi::orders::builder::price;

let order_id = client.order(&contract)
    .buy(100)
    .market()
    .condition(price(265598, "SMART").greater_than(150.0))
    .submit().await?;

pub fn and_condition(self, condition: impl Into<OrderCondition>) -> Self

Add a condition that must be met along with previous conditions (AND logic).

Example

use ibapi::orders::builder::{price, margin};

let order_id = client.order(&contract)
    .buy(100)
    .market()
    .condition(price(265598, "SMART").greater_than(150.0))
    .and_condition(margin().greater_than(30))
    .submit().await?;

pub fn or_condition(self, condition: impl Into<OrderCondition>) -> Self

Add a condition where either this OR previous conditions trigger the order (OR logic).

Example

use ibapi::orders::builder::{price, volume};

let order_id = client.order(&contract)
    .buy(100)
    .market()
    .condition(price(265598, "SMART").less_than(100.0))
    .or_condition(volume(265598, "SMART").greater_than(50_000_000))
    .submit().await?;

pub fn algo(self, algo: impl Into<AlgoParams>) -> Self

Set algorithm strategy and parameters.

Accepts either a strategy name (string) or an algo builder.

Example with builder

use ibapi::orders::builder::vwap;

let order_id = client.order(&contract)
    .buy(1000)
    .limit(150.0)
    .algo(vwap()
        .max_pct_vol(0.2)
        .start_time("09:00:00 US/Eastern")
        .end_time("16:00:00 US/Eastern")
        .build()?)
    .submit().await?;

Example with string (for custom strategies)

let order_id = client.order(&contract)
    .buy(1000)
    .limit(150.0)
    .algo("Vwap")
    .algo_param("maxPctVol", "0.2")
    .submit().await?;

pub fn algo_param( self, key: impl Into<String>, value: impl Into<String>, ) -> Self

Add algorithm parameter.

Use this to add individual parameters when using a strategy name string. When using algo builders, parameters are set via the builder methods.

pub fn what_if(self) -> Self

Mark as what-if order for margin/commission calculation

pub fn volatility(self, volatility: f64) -> Self

Set volatility for volatility orders

pub fn not_held(self) -> Self

Mark order as not held

pub fn all_or_none(self) -> Self

Mark order as all or none

pub fn good_after_time(self, time: impl Into<String>) -> Self

Set good after time

pub fn good_till_time(self, time: impl Into<String>) -> Self

Set good till time (stored in good_till_date field)

pub fn min_trade_qty(self, qty: i32) -> Self

Set minimum trade quantity for pegged orders

pub fn min_compete_size(self, size: i32) -> Self

Set minimum compete size for pegged orders

pub fn compete_against_best_offset(self, offset: f64) -> Self

Set compete against best offset for pegged orders

pub fn mid_offset_at_whole(self, offset: f64) -> Self

Set mid offset at whole for pegged orders

pub fn mid_offset_at_half(self, offset: f64) -> Self

Set mid offset at half for pegged orders

pub fn build(self) -> Result<Order, ValidationError>

Build the Order struct with full validation

impl<'a> OrderBuilder<'a, Client>

pub fn submit(self) -> Result<OrderId, Error>

Submit the order synchronously Returns the order ID assigned to the submitted order

pub fn build_order(self) -> Result<Order, Error>

Build the order and return it without submitting Useful for batch operations or custom submission logic

pub fn analyze(self) -> Result<OrderState, Error>

Analyze order for margin/commission (what-if)

impl<'a> OrderBuilder<'a, Client>

pub async fn submit(self) -> Result<OrderId, Error>

Submit the order asynchronously Returns the order ID assigned to the submitted order

pub fn build_order(self) -> Result<Order, Error>

Build the order and return it without submitting Useful for batch operations or custom submission logic

pub async fn analyze(self) -> Result<OrderState, Error>

Analyze order for margin/commission (what-if)