Bracket orders?

Hey David,

You can achieve this by using a combination of limit orders and stop limit orders. When one of the orders fills, you can cancel the other orders in the bracket using the OnOrderEvent event handler. Here's an example in Python:

self.stop_loss = None
self.take_profit = None

def OnOrderEvent(self, orderEvent):
    if orderEvent.Status == OrderStatus.Filled:
        if orderEvent.OrderId == self.ticket.OrderId:
            self.stop_loss = self.StopMarketOrder(orderEvent.Symbol, -orderEvent.FillQuantity, orderEvent.FillPrice * 0.95)
            self.take_profit = self.LimitOrder(orderEvent.Symbol, -orderEvent.FillQuantity, orderEvent.FillPrice * 1.10)
        elif self.stop_loss is not None and orderEvent.OrderId == self.stop_loss.OrderId:
            self.take_profit.Cancel()
        elif self.take_profit is not None and orderEvent.OrderId == self.take_profit.OrderId:
            self.stop_loss.Cancel()

This code snippet will create a stop loss and take profit order when your initial order is filled. When either the stop loss or take profit order is filled, it will cancel the other order.

Make sure to set the brokerage model to a brokerage that supports these order types, such as:

self.SetBrokerageModel(BrokerageName.QuantConnectBrokerage)

For more information on order types, you can refer to the QuantConnect documentation on trading and orders.

I hope this helps!

Hey David Eldringhoff,

I copied and pasted a sample code below on how I did this:

def OnOrderEvent(self, orderEvent):
            currentContract = self.Securities[self.future.Mapped]
            quantity = 1
            order = self.Transactions.GetOrderById(orderEvent.OrderId)
            if order.Status == OrderStatus.Filled and order.Type == OrderType.Market and order.Direction == 0:
                entry_price = orderEvent.FillPrice
                self.limOrder = self.LimitOrder(currentContract.Symbol, -quantity, orderEvent.FillPrice + 1)
                self.stopOrder1 = self.StopMarketOrder(currentContract.Symbol, -quantity, orderEvent.FillPrice - 2)

This part gets triggered as soon as a position is filled.

If you're using limit orders just tag your buy order with a name and then check if the limit order that got filled also has the same tag. You would do this so that you dont get any problems with limit order from the sell side.

Hope it helps.

Best,
Nico

Thanks to both of you.  I've got it close to working but the backtests seem to either have a loop in the onorderevent section where it just buys and sells the limit and stop loss orders and 10000 orders a day occur or both the limit and stop loss fire at the exact same time as the initial order placement which doesnt make sense to me.

Hey David Eldringhoff,

I forgot a crucial part in my code that cancels the rest of the bracket when one order gets triggered. This is the rest of the code:

if order.Status == OrderStatus.Filled:
	if order.Type == OrderType.Limit or order.Type == OrderType.StopMarket:
	self.Transactions.CancelOpenOrders(order.Symbol)

Again, if you're using limit orders to enter the market and not a market order you will have to add an if statement to the limit order that checks that there is no tag like you used in the limit order for entering the market.

This should solve the problem you're having with the numerous orders you're having.

Best,
Nico

Do you have issues in backtesting where the purchase order is placed and then the limit or stop loss fill at the exact same time as the initial order?  it happens on every order.

Fill: $14,286.50 USD

Fill: $14,284.00 USD

Limit: $14,284.00 USD

Stop: $14,289.00 USD

Fill: $14,300.00 USD

Fill: $14,296.75 USD

Limit: $14,296.75 USD

Stop: $14,303.25 USD

Hey David Eldringhoff,

I'm guessing that you're using tick resolution? a few months ago I made a algo which seemed to work really well. The results where amazing and it also worked with futures, the backtests where extremly good and it seemed like I could get rich really fast. Now everytime this happens something can't be right. I had similar execution times like you and I even tried it live with the paper trading node. Sometimes I was winning 6k-10k a day by doing absolutly nothing. When putting the same algo with IB to the test the results were nowhere near. They were even negative! 

So be careful when playing around with tick data. I guess that in the backtest and in live trading the algo will be able to reach every upward tick while in the real market it will fail misserably

There were times in real market trading where the algo would buy and sell in the same second but didn't happen often

Can anyone with Quantconnect chime in?  The real main issue here I think is that we need bracket order support with Interactive brokers and a correct representation of bracket orders on backtesting.  It looks like its not supported correctly with Quantconnect.  

If I place a futures order manually on Interactive brokers , prior to submitting the order, I have the ability to attach a bracket order.  I can bracket the order with a limit order and stop loss.  Importantly, when doing so it does not increase margin requirements.  

I can try to reproduce this by using the techniques above (and I built a manual bracket like this in the ondata section which actually works much better than the OnOrderEvent section but still increases margin requirements when it shouldn't) but they do not work for a few reasons.  One reason, is that by doing so the orders are submitted separately and therefore require additional margin.  The original order for the underlying plus extra margin for the extra orders.  I've tested this on IB, if an order for a futures contract is placed followed by a separate limit and stop order it will use additional margin, whereas if you place the original order with a bracket attached the additional margin is not required.  With bracket orders the additional order is automatically cancelled when either the limit or stop is triggered. These are reasons why we could benefit from bracket order functionality.

Additionally, this doesn't work because the orders are filled immediately for some reason.  I've adjusted the stop distances and they still fill instantly.  I initially suspected that it was filling because the stops were within range of the current bar but even if I extend the stops out, they still fill instantly.  There is something incorrectly processing here.  

Thanks

OK couldn't fix the OnOrderEvent bracket orders.  They are still closing the exact same minute that they are placed which doesn't make sense.  However, if I switch to place the bracket orders in the OnData section they work more normally.  However, it caused another issue.  Most orders work as planned but some have both the limit order and the stop market order fire in the same minute.  I suspect this is a data problem and here is why.  I'm trying to scalp for an ATR value in futures contract in only the overnight hours, where volatility is low.  The ATR is about 2-5 points on a minute time frame.  Below you will see a few normal orders followed by one where both bracket orders fill at once.  The stop market order was placed for 1 ATR outside the fill price of the contract I'm holding but the stopmarket order filled like 50 points outside the value of the order.  On trading view, the price did not fluctuate anymore than a few points in that minute of the day.  It definitely did not move >50 points in that minute.

NORMAL orders with brackets:
 

Stop: $11,024.25 USD

Fill: $11,045.75 USD

Fill: $11,041.75 USD

Limit: $11,041.75 USD

Stop: $11,051.00 USD

Fill: $11,060.00 USD

Fill: $11,057.00 USD

Limit: $11,057.00 USD

Stop: $11,063.75 USD

Fill: $11,042.25 USD

Fill: $11,045.75 USD

Limit: $11,045.75 USD

INCORRECT order with brackets:
 

Fill: $11,062.50 USD

Fill: $11,057.75 USD

Limit: $11,057.75 USD

Fill: $11,119.50 USD

Stop: $11,068.00 USD

actually I just noticed these aren't working right either.  The limit orders to close for profit are still firing the same minute that the initial order is placed….  Not every single order I place wins the exact minute I place the order.  Something isn't working right.