Trading 0DTE Options with the IBKR Native API

# Strategy for trading 0DTE straddles via the IBKR native API
# Buy/sell the 0DTE ATM straddle if recent 0DTE straddles under/over-predicted the day's spoos move

from threading import Thread, Event
import time
from typing import Any
from ibapi.common import BarData
from ibapi.wrapper import EWrapper
from ibapi.client import EClient
from ibapi.contract import Contract, ContractDetails
from ibapi.order import *
from ibapi.common import *
from ibapi.account_summary_tags import AccountSummaryTags
import pandas as pd
import requests
from bs4 import BeautifulSoup


# make url for 0DTE ATM option contracts from yahoo
# can only get approx 5 days' worth of expired contracts
def make_url(expiry, contract_type, strike):
    return f"https://finance.yahoo.com/quote/SPXW{expiry}{contract_type}0{strike*1000}"

# get 0dte options prices from yahoo
# use beautiful soup to parse the HTML and extract values from relevant tags
def get_0dte_prices(expiry, contract_type, strike):
    url = make_url(expiry, contract_type, strike)

    # headers to simulate browser request
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.150 Safari/537.36"
    }

    # get web page
    response = requests.get(url, headers=headers)

    # parse
    soup = BeautifulSoup(response.text, "html.parser")

    # extract last traded price (HTML specification is from inspection of Yahoo options data pages)
    last_traded_price_tag = soup.find(
        "fin-streamer", {"data-test": "qsp-price", "data-field": "regularMarketPrice"}
    )
    last_traded_price = (
        float(last_traded_price_tag["value"]) if last_traded_price_tag else "Not found"
    )

    # extract open price (HTML specification is from inspection of Yahoo options data pages)
    open_price_tag = soup.find("td", {"data-test": "OPEN-value"})
    open_price = float(open_price_tag.text) if open_price_tag else "Not found"

    return (open_price, last_traded_price)


# class for trading the straddles strategy
class ibStraddlesApp(EClient, EWrapper):
    def __init__(self, ticker):
        EClient.__init__(self, self)
        self.ticker = ticker
        self.next_req_id = 0  # keep track of request ids
        self.connection_ready = Event()  # to signal the connection has been established
        self.done = (
            Event()
        )  # for signalling between threads when a message has been fully processed
        self.historical_data = []  # for storing historical data
        self.price = {}  # for storing current option contract price data

    def increment_req_id(self):
        self.next_req_id += 1

    # override Ewrapper.error
    def error(
        self, reqId: TickerId, errorCode: int, errorString: str, contract: Any = None
    ):
        print("Error: ", reqId, " ", errorCode, " ", errorString)
        if errorCode == 502:
            # not connected
            # set self.done (a threading.Event) to True
            self.done.set()

    # override Ewrapper.nextValidID - used to signal that the connection between application and TWS is complete, and
    # returns the next valid orderID (for any future transactions).
    # if we send messages before the connection has been established, they can be lost
    # so wait for this method to be called
    def nextValidId(self, orderId: int):
        self.nextorderId = orderId
        print(f"Connection ready, next valid order ID: {orderId}")
        self.connection_ready.set()  # signal that the connection is ready

    # override Ewrapper.contractDetails
    # gets back contract details
    def contractDetails(self, reqId: int, contractDetails: ContractDetails):
        super().contractDetails(reqId, contractDetails)
        print(contractDetails)

    # override Ewraper.contractDetailsEnd
    # signals that the contract details request has completed
    def contractDetailsEnd(self, reqId: int):
        print(f"Contract details request {reqId} complete")
        self.done.set()

    # override Ewrapper.historicalData
    # TWS sends data from reqHistoricalData to this callback
    def historicalData(self, reqId: int, bar: BarData):
        d = {
            "Ticker": self.ticker,
            "Date": bar.date,
            "Open": bar.open,
            "High": bar.high,
            "Low": bar.close,
            "Close": bar.close,
        }
        self.historical_data.append(d)

    # override EWrapper.historicalDataEnd is received
    # signals that historical market data request is complete
    # (note only sent if reqHistoricalData invoked with keepUpToDate=False)
    def historicalDataEnd(self, reqId: int, start: str, end: str):
        print(f"Historical data request complete")
        self.done.set()

    # callback for handling current price data requests
    # see https://ibkrcampus.com/ibkr-api-page/twsapi-doc/#available-tick-types for available tickTypes
    def tickPrice(self, reqId, tickType, price, attrib):
        """Key self.price with the reqId that made the request so that you can keep track of which item belongs to which contract.
        See usage below for example.
        """
        if not reqId in self.price.keys():
            self.price[reqId] = {}

        # handle bid price (tickType = 1)
        if tickType == 1:
            print("The current bid price is: ", price)
            self.price[reqId]["bid"] = price

        # handle ask price (tickType = 2)
        if tickType == 2:
            print("The current ask price is: ", price)
            self.price[reqId]["ask"] = price

    # override Ewrapper.tickSnapshotEnd
    # signals snapshot request is complete
    def tickSnapshotEnd(self, reqId: int):
        print(f"Current price data request complete")
        self.done.set()

    # override Ewrapper order callbacks - just print execution and order status to screen
    # in practice, you would monitor these and handle appropriately (eg if order wasn't filled)
    def orderStatus(
        self,
        orderId,
        status,
        filled,
        remaining,
        avgFullPrice,
        permId,
        parentId,
        lastFillPrice,
        clientId,
        whyHeld,
        mktCapPrice,
    ):
        print(
            "orderStatus - orderid:",
            orderId,
            "status:",
            status,
            "filled",
            filled,
            "remaining",
            remaining,
            "lastFillPrice",
            lastFillPrice,
        )

    def openOrder(self, orderId, contract, order, orderState):
        print(
            "openOrder id:",
            orderId,
            contract.symbol,
            contract.secType,
            "@",
            contract.exchange,
            ":",
            order.action,
            order.orderType,
            order.totalQuantity,
            orderState.status,
        )

    def execDetails(self, reqId, contract, execution):
        print(
            "Order Executed: ",
            reqId,
            contract.symbol,
            contract.secType,
            contract.currency,
            execution.execId,
            execution.orderId,
            execution.shares,
            execution.lastLiquidity,
        )


# define our event loop - this will run in its own thread
def run_loop(app):
    app.run()


##### Instantiate a trading app and wait for a successful connection

# instantiate an ibStraddlesApp
# ticker of the underlying
app = ibStraddlesApp(ticker="SPX")

# connect
# clientID identifies our application
app.connect("127.0.0.1", 7496, clientId=0)

# start the application's event loop in a thread
api_thread = Thread(target=run_loop, args=(app,), daemon=True)
api_thread.start()

# wait until the Ewrapper.nextValidId callback is triggered, indicating a successful connection
app.connection_ready.wait()

##### Get SPX data required for trading signal

# required date range - will need to update this
start_date = "20240318"
end_date = "20240322"
date_range = pd.date_range(start=start_date, end=end_date)
num_days = len(date_range)

# get recent SPX data
spx = Contract()
spx.symbol = "SPX"
spx.secType = "IND"
spx.currency = "USD"
spx.exchange = "CBOE"

# request historical SPX data and increment request id
app.reqHistoricalData(
    reqId=app.next_req_id,
    contract=spx,
    # 8:30 chicago is 9:30 NY
    endDateTime=f"{end_date} 16:00:00 US/Central",
    durationStr=f"{num_days} D",
    whatToShow="TRADES",
    barSizeSetting="1 day",
    useRTH=1,
    formatDate=1,
    keepUpToDate=False,
    chartOptions=[],
)
app.increment_req_id()

# wait for historical data to come back before continuing
app.done.wait()

# reset event
app.done.clear()

# make dataframe from receieved SPX data
spx_prices = pd.DataFrame(app.historical_data)

# save to disk
# spx_prices.to_csv("./ibkr-api/spx_prices.csv")

print("spx price data:")
print(spx_prices)

# check you have the expected data:
if len(spx_prices["Date"]) < 5:
    raise Exception("Missing SPX data, stopping")

##### Get options data and calculate trading signal

# get historical ATM 0DTE XPSW options prices from Yahoo
expected_moves = []
actual_moves = []
for d in spx_prices["Date"][:-1]:  # don't get today's data yet
    # get ATM strike from each day's SPX open price
    spx_open = spx_prices.loc[spx_prices["Date"] == d, "Open"].iloc[0]

    # round to nearest $5
    strike = round(spx_open / 5) * 5

    # get epxiry from date string
    expiry = str(d)[2:]

    # get put open and last traded prices
    p_open, p_close = get_0dte_prices(expiry=expiry, contract_type="P", strike=strike)

    # if we didn't find an ATM strike:
    # a bit of hack to get the nearest existing strike
    # in reality you'd be more careful
    while p_open == "Not found":
        strike -= 5
        p_open, p_close = get_0dte_prices(
            expiry=expiry, contract_type="P", strike=strike
        )

    # get call open and last traded prices
    c_open, c_close = get_0dte_prices(expiry=expiry, contract_type="C", strike=strike)

    # calculate straddle open and last traded prices
    straddle_open_price = p_open + c_open

    # calculate straddle-implied expected move and store
    expected_move = 0.85 * straddle_open_price
    expected_moves.append(expected_move)

    # calculate actual move from SPX prices and store
    spx_close = spx_prices.loc[spx_prices["Date"] == d, "Close"].iloc[0]
    actual_move = abs(spx_close - spx_open)
    actual_moves.append(actual_move)

    print("Expected move, actual move:")
    print(expected_move, actual_move)

# calculate recent average expected and actual moves
ave_expected_move = sum(expected_moves) / len(expected_moves)
ave_actual_move = sum(actual_moves) / len(actual_moves)
print("Average expected move, average actual move")
print(ave_expected_move, ave_actual_move)

##### Prepare contract objects and get current prices for trading

# get today's ATM strike and expiry
today_open = spx_prices["Open"].iloc[-1]
strike = round(today_open / 5) * 5
expiry = spx_prices["Date"].iloc[-1]
print(f"Today's strike:{strike}, today's expiry: {expiry}")

# create an options contract representing today's 0DTE ATM call
call = Contract()
call.symbol = "SPXW"
call.secType = "OPT"
call.currency = "USD"
call.exchange = "SMART"
call.lastTradeDateOrContractMonth = expiry
call.strike = strike
call.right = "C"
call.tradingClass = "SPXW"

# keep track of the reqId for the call
call_req_id = app.next_req_id

# get the call's current bid-ask prices
print("Current call prices:")
app.reqMktData(
    reqId=call_req_id,
    contract=call,
    genericTickList="",  # get all available data
    snapshot=True,  # requires appropriate market data subscription
    regulatorySnapshot=False,
    mktDataOptions=[],
)
app.increment_req_id()
app.done.wait()
app.done.clear()

# call prices:
# note app.price is keyed by reqId
print(app.price[call_req_id])

# create an options contract representing today's 0DTE ATM put
put = Contract()
put.symbol = "SPXW"
put.secType = "OPT"
put.currency = "USD"
put.exchange = "SMART"
put.lastTradeDateOrContractMonth = expiry
put.strike = strike
put.right = "P"
put.tradingClass = "SPXW"

# keep track of the reqId for the put
put_req_id = app.next_req_id

# get the put's current bid-ask prices
print("Current put prices:")
app.reqMktData(
    reqId=put_req_id,
    contract=put,
    genericTickList="",  # get all available data types
    snapshot=True,  # requires appropriate market data subscription
    regulatorySnapshot=False,
    mktDataOptions=[],
)
app.increment_req_id()
app.done.wait()
app.done.clear()

# put prices:
# note app.price is keyed by reqId
print(app.price[put_req_id])

##### Trade logic

# Now we have call and put prices for today, we can shoot off limit orders at these prices
# I prefer this to shooting off a market order into a potentially illiquid product
# You can even add a buffer to your limit order beyond the current top of book price to give you more chance of getting filled
# Many ways to do this - up to you.
# But in practice, you'll need to manage your orders and fills - you might end up chasing the market

# sell today's 0DTE ATM straddle if SPX has moved less than implied by recent straddle prices
if ave_actual_move < ave_expected_move:
    # sell today's 0DTE stradle
    # sell call:
    print("Selling today's 0DTE ATM straddle")
    order = Order()
    order.action = "SELL"
    order.totalQuantity = 1  # note will be multiplied by contract multiplier
    order.orderType = "LMT"
    order.lmtPrice = app.price[call_req_id]["bid"]  # limit sell the call at the bid
    order.transmit = True
    app.placeOrder(app.nextorderId, call, order)
    app.nextorderId += 1

    # sell put:
    order = Order()
    order.action = "SELL"
    order.totalQuantity = 1  # note will be multiplied by contract multiplier
    order.orderType = "LMT"
    order.lmtPrice = app.price[put_req_id]["bid"]  # limit sell the put at the bid
    order.transmit = True
    app.placeOrder(app.nextorderId, put, order)
    app.nextorderId += 1
# buy today's 0DTE ATM straddle if SPX has moved more than implied by recent straddle prices
else:
    # buy today's 0DTE stradle
    # buy call:
    print("Buying today's 0DTE ATM straddle")
    order = Order()
    order.action = "BUY"
    order.totalQuantity = 1  # note will be multiplied by contract multiplier
    order.orderType = "LMT"
    order.lmtPrice = app.price[call_req_id]["ask"]  # limit buy the call at the ask
    order.transmit = True
    app.placeOrder(app.nextorderId, call, order)
    app.nextorderId += 1

    # buy put:
    order = Order()
    order.action = "BUY"
    order.totalQuantity = 1  # note will be multiplied by contract multiplier
    order.orderType = "LMT"
    order.lmtPrice = app.price[put_req_id]["ask"]  # limit buy the put at the ask
    order.transmit = True
    app.placeOrder(app.nextorderId, put, order)
    app.nextorderId += 1

# You'll want to handle the order as well - maybe cancel it if the market runs away for instance.
# When placing orders via the API and building a robust trading system, it is important to monitor for callback notifications,
# specifically for IBApi::EWrapper::error, IBApi::EWrapper::orderStatus changes, IBApi::EWrapper::openOrder warnings, and
# IBApi::EWrapper::execDetails to ensure proper operation.
# Here we just use these methods to print execution details to screen.

# disconnect once orders handled satisfactorily
# commented here for simplicity since we didn't do any order handling
# app.disconnect()