Bracket orders with Alpaca

Here's a direct illustration for you and 'Andrew' of why you’re running into this issue with Alpaca and QuantConnect when attempting simulated bracket orders:

from AlgorithmImports import *

class BracketOrderAlpaca(QCAlgorithm):
    """
    This illustrative snippet shows why a classic three-leg “bracket order”
    (entry + take-profit + stop-loss) can’t be created with separate tickets
    when you run through the Alpaca brokerage model on QuantConnect.

    • The market BUY opens the long position.  
    • The limit SELL (take-profit) is accepted.  
    • The stop-market SELL (stop-loss) is rejected, because once the full
      position size has already been reserved by the outstanding limit order,
      Alpaca refuses a second sell that would over-allocate the position.
    """

    def initialize(self) -> None:
        self.set_start_date(2021, 1, 1)
        self.set_end_date(2022, 1, 1)
        self.set_cash(100_000)

        # Use Alpaca so we observe its order-routing rules
        self.set_brokerage_model(BrokerageName.ALPACA, AccountType.MARGIN)

        self._symbol: Symbol = self.add_equity("AAPL", Resolution.MINUTE).symbol

        # Keep track of the individual order tickets
        self._market_ticket: OrderTicket = None  # type: ignore[assignment]
        self._limit_ticket: OrderTicket = None   # type: ignore[assignment]
        self._stop_ticket: OrderTicket = None    # type: ignore[assignment]

    def on_data(self, data: Slice) -> None:
        # 1) Entry – BUY 100 shares at market
        if not self.portfolio.invested and self._market_ticket is None:
            self._market_ticket = self.market_order(self._symbol, 100, tag="Entry-MKT")
            self.debug(f"Market order submitted: #{self._market_ticket.order_id}")
            return

        # Proceed only after the entry has filled
        if (self._market_ticket is not None
                and self._market_ticket.status == OrderStatus.FILLED):

            entry_price: float = self._market_ticket.average_fill_price

            # 2) Take-profit – SELL 100 with a limit 5 % above entry
            if self._limit_ticket is None:
                tp_price: float = round(entry_price * 1.05, 2)
                self._limit_ticket = self.limit_order(
                    self._symbol, -100, tp_price, tag="TP-LMT")
                self.debug(f"Limit order submitted: #{self._limit_ticket.order_id} @ {tp_price}")
                return

            # 3) Stop-loss – attempt a second SELL for the same 100 shares
            # Alpaca will REJECT this because the outstanding limit already
            # accounts for the whole position, so this stop would exceed
            # the long quantity.
            if self._stop_ticket is None:
                sl_price: float = round(entry_price * 0.98, 2)
                self._stop_ticket = self.stop_market_order(
                    self._symbol, -100, sl_price, tag="SL-STP")
                self.debug(f"Stop order attempted: #{self._stop_ticket.order_id} @ {sl_price}")
                return

    def on_order_event(self, order_event: OrderEvent) -> None:
        # Watch the status transition: the stop order should come back as Error
        self.debug(f"OrderEvent >> id:{order_event.order_id} "
                   f"status:{order_event.status} msg:{order_event.message}")

Explanation:

• After your market order is filled, you try to submit both a limit and a stop order. Alpaca only lets you have open exit orders for the number of shares you hold (not more!), and does not allow both stop and limit exits for the full position unless you use their native bracket order API (which QuantConnect currently does not expose).
• You’ll see the second exit order (the stop, if limit is already working) is rejected (OrderStatus.Invalid), even in backtest/live logs, due to Alpaca internal constraints.

Result:
No workaround exists using only the QuantConnect Alpaca integration unless they add native bracket support. Code-simulated OCO works only if you use high-frequency (second/subsecond) data, which you cannot do at minute resolution without execution risk.

Alternatives:

• Use a broker that supports true bracket/OCO natively in QuantConnect (like IB).
• Submit only a take-profit or stop-loss, not both.
• Monitor QuantConnect’s roadmap for Alpaca bracket support and consider submitting a feature request on their forums.

Let me know if you need guidance on any of these workarounds or possible brokerage alternatives!

Sources: Other Order Types - QuantConnect.com, Order Tickets - QuantConnect.com, Stop Limit Order Regression Algorithm, Combo Order Ticket Demo Algorithm, Alpaca - QuantConnect.com

This is very disappointing. Having no support for something as basic as bracket orders to set both a stop loss and a take profit is such a letdown.

I've spent a good amount of time writing this algorithm so I can take advantage of everything QuantConnect has to offer, including the ability to switch brokers easily should the need ever arise. It's been great to work with, has very good documentation and good support, but everything I've read says true bracket/OCO orders are not yet a part of QuantConnect. Because of that, I believe I would run into the same issue if I tried to use IB. Additionally, my strategy is not high frequency, so Alpaca's “no commission” model works very well for me.

It seems my only option is to build something from scratch using Alpaca's API. Do any folks at QuantConnect have any feedback or suggestions? What is the timeline for adding bracket orders to QuantConnect? How do I submit a feature request?

Hi Andrew,

Please vote for the feature request:
[Feature Request] Support for Bracket Order #8253
so that it makes it to the roadmap .

Best regards,
Alex
 

Alexandre Catarino,

Thank you for your reply! I have added a vote to the Feature Request. Do you have any idea when the feature might be added?

Do you know if there is a workaround solution for the issue I'm running into, or is Mia's assessment correct that a workaround does not exist? Just wanting to make sure I'm not missing anything before I start working on rebuilding from scratch.