Combining entry order with stop loss

To set a stop loss order that will exit the position at a 50% loss, you would need to set the stop price at 50% of the purchase price. However, the exact purchase price might not be known at the time of placing the order, especially if the order doesn't execute immediately.

You can get the fill price in the OnOrderEvents event handler. Once you have the entry fill price, you can calculate the price level for the stop loss order. Here is an example of how you might do this in Python:

self.stop_loss = None

def OnOrderEvent(self, orderEvent):
    if orderEvent.Status == OrderStatus.Filled:
        if orderEvent.OrderId == self.ticket.OrderId:
            fillPrice = orderEvent.FillPrice
            stopPrice = fillPrice * 0.5  # 50% of the fill price
            self.stop_loss = self.StopMarketOrder(orderEvent.Symbol, -orderEvent.FillQuantity, stopPrice)

In this example, self.ticket is the order ticket of your entry order (the market order you mentioned). When the entry order is filled, a stop market order is placed with a stop price at 50% of the fill price.

Please note that this is a simplified example and you might need to adjust it according to your specific needs. For example, you might want to add checks to ensure that the stop loss order is only placed once, or to update the stop price under certain conditions.

Sources:

• Stop Market Orders
• Other Order Types

Thank you Mia, I tried to implement your code, however, the OnOrderEvent() method is called before the ticket is returned from the original Buy() method so the ticket is still None in OnOrderEvent(), what am I doing wrong? 

The issue you're experiencing might be due to the asynchronous nature of order events. When you place an order, the OnOrderEvent method can be called before the order ticket is returned and assigned to self.ticket.

To handle this, you can use a flag to indicate whether the entry order has been placed. Here's an example:

self.entry_placed = False
self.stop_loss = None

def OnData(self, data):
    if not self.entry_placed:
        self.ticket = self.Buy("SPY", 100)
        self.entry_placed = True

def OnOrderEvent(self, orderEvent):
    if orderEvent.Status == OrderStatus.Filled:
        if self.entry_placed and orderEvent.OrderId == self.ticket.OrderId:
            fillPrice = orderEvent.FillPrice
            stopPrice = fillPrice * 0.5  # 50% of the fill price
            self.stop_loss = self.StopMarketOrder(orderEvent.Symbol, -orderEvent.FillQuantity, stopPrice)
            self.entry_placed = False  # Reset the flag

In this example, self.entry_placed is a flag that is set to True when the entry order is placed. In the OnOrderEvent method, the stop loss order is only placed if self.entry_placed is True and the filled order is the entry order. After the stop loss order is placed, self.entry_placed is reset to False.

This should ensure that the stop loss order is placed correctly. However, please note that this is a simplified example and you might need to adjust it according to your specific needs.

Sources:

• Order Events
• Other Order Types

I still do not see how this will work in all cases - if by the asynchronous nature of order events OnOrderEvent() is called before the ticket gets its value that the new flag of entry_placed will remain False and the stop order will not be placed…

You're correct, Nathan. The asynchronous nature of order events can indeed cause the OnOrderEvent method to be called before the order ticket is returned from the Buy method. This is because order events are triggered asynchronously as they occur.

One way to handle this is to keep track of the order IDs and their corresponding stop prices in a dictionary. When an order is filled, you can look up the stop price in the dictionary using the order ID from the order event. Here's an example:

self.stop_prices = {}

def OnData(self, data):
    if not self.Portfolio.Invested:
        ticket = self.Buy("SPY", 100)
        self.stop_prices[ticket.OrderId] = self.Securities["SPY"].Price * 0.5  # 50% of the current price

def OnOrderEvent(self, orderEvent):
    if orderEvent.Status == OrderStatus.Filled:
        if orderEvent.OrderId in self.stop_prices:
            stopPrice = self.stop_prices[orderEvent.OrderId]
            self.StopMarketOrder(orderEvent.Symbol, -orderEvent.FillQuantity, stopPrice)
            del self.stop_prices[orderEvent.OrderId]  # Remove the entry from the dictionary

In this example, self.stop_prices is a dictionary that maps order IDs to stop prices. When an order is placed, an entry is added to the dictionary with the order ID as the key and the stop price as the value. When an order is filled, the stop price is looked up in the dictionary using the order ID from the order event, and a stop market order is placed with the retrieved stop price. After the stop market order is placed, the entry is removed from the dictionary.

This should ensure that the stop market order is placed correctly even if the OnOrderEvent method is called before the order ticket is returned from the Buy method.

Sources:

• Order Events
• Other Order Types

How about simply placing the stop loss order together with the original order. If the original is a market order then I know the fill price - something like that:

self.Buy(option_to_trade.Symbol, 1)

entry_midprice = 0.5 * (option_to_trade.AskPrice + option_to_trade.BidPrice)

self.StopMarketOrder(option_to_trade.Symbol, -1, 0.5 * entry_midprice)

Will that work?

Yes, Nathan, your approach should work in most cases. You're placing a market order to buy the option and then immediately placing a stop market order to sell the option if its price falls to 50% of the entry midprice. Here's your code:

self.Buy(option_to_trade.Symbol, 1)
entry_midprice = 0.5 * (option_to_trade.AskPrice + option_to_trade.BidPrice)
self.StopMarketOrder(option_to_trade.Symbol, -1, 0.5 * entry_midprice)

However, please note a few things:

1. The entry_midprice is calculated based on the current ask and bid prices, which might not exactly match the fill price of the market order. The fill price depends on the market conditions at the time the order is executed.

2. If the market order doesn't execute immediately (for example, due to low liquidity), the stop market order might be placed with an incorrect stop price.

3. If the market gaps down past your stop price before the stop market order is executed, the order might be filled at a worse price than the stop price you set. There's no guarantee that a stop market order fills at the stop price.

Sources:

• Stop Market Orders
• Other Order Types