You’ve heard it before. A giant price swing happens to a stock — or the broader market — with no obvious rhyme or reason. In unison, the talking heads, your friends who trade, and even the voice inside your head say one word: “Algos.”
Trading algorithms, or “algos” make up roughly ⅔’s of all US trading. (Just another thing that AI has the potential to do better than humans.) These lightning fast computerized trading systems can latch onto technical breakouts and breakdowns and make precise buys and sells with no room for human error.
Everything you’ve ever wanted to know about Unusual Options Activity—in one convenient insider’s guide.Let us show you how to find Unusual Options Activity
So how can you get in on the algo action? Well, you could buy expensive subscriptions to trading algorithms (for instance, OptionsAlphaPro+ is a cool $200 per month). However, you’ve spent a long time honing your options trading knowledge and prowess — throwing that away in favor of taking on someone else’s algorithm isn’t usually preferred.
On the flip side, in order to make or even customize your own trading algorithm, you’ll need to learn some coding skills in a language like Python. And that, too, isn’t usually preferred for the busy trader who only cares about descending a trading-terminator upon the market to do his or her bidding.
At that moment, it feels hopeless. This is how “they” box you out of the market — if you can’t code, you don’t want to drop $200 a month on some questionable program, or you don’t want to use someone else’s crappy program, then you’re out of luck — right?
Wrong. Introducing ChatGPT.
Get a custom-designed trading program tailored to your individual needs, skill level, and schedule.Level Up Your Trading
What is ChatGPT and How Can ChatGPT Be Used for Options Trading?
Before you ask — this isn’t an ad. ChatGPT is a free, powerful language model developed by OpenAI — and we have no connection to them in any way. But the utility of ChatGPT’s service is pretty incredible. Among other things, you can use it to write a variety of scripts, including those for options trading, with zero knowledge of coding, scripting, python, or anything else.
Options trading is a complex and dynamic process that requires a deep understanding of the markets, as well as the ability to quickly analyze and react to market conditions. Meaning, while you won’t need knowledge of how to code, you’ll still need a firm understanding of options trading and the markets. Think about it: a trading algorithm is like telling a super fast machine how to execute trades. Still, ChatGPT makes it easy, and in this article, we’re going to make it even easier.
One of the key challenges in options trading is the ability to quickly and accurately analyze large amounts of data and make informed trading decisions — without involving your emotions. ChatGPT can be used to help with this process by providing a tool for analyzing and processing large amounts of data quickly and accurately.
Outside of making scripts (the main topic we’ll cover here), options traders can quickly analyze historical market data and identify patterns and trends that may provide insight into future market movements. This can help traders make more informed trading decisions and potentially increase their chances of success.
One of the benefits of using ChatGPT in the options trading process is its ability to generate code. As the user inputs parameters and goals for their trading strategy, ChatGPT can generate scripts based on the parameters, thus allowing the trader to have an immediate and accurate implementation of their strategy.
Another benefit of using ChatGPT in options trading is its ability to assist with automating the trading process. With ChatGPT, traders can write scripts that automatically execute trades based on certain conditions and signals. This can help traders save time and increase the speed and efficiency of their trading process.
Step-by-step: Using ChatGPT to Write Scripts and Trading Algorithms
To use ChatGPT to write options trading scripts, you will first need to access the model through an API or by using OpenAI’s GPT-3 Playground. Find that link here. You’ll also want to get comfortable with a brokerage that allows direct plug-ins of a script into their interface, so that you can fully automate your trading process and get the most out of the trading algorithm. Three solid brokerages that allow this and still allot for excellent order execution are IBKR, Thinkorswim, and Tradier. We have no affiliation with any of them. Additionally, Thinkorswim in particular offers a solid paper trading platform that you can use to test these strategies in a risk-free manner, with real market data..
Once you have access to the model and have become familiar with your brokerage of choice, you can input your desired trading strategy and parameters, and ChatGPT will generate code based on your inputs. Then, you can test the script using historical market data and make any necessary adjustments before using it in live trading. Let’s look at a few example scripts and trading algorithms that we’ve built to shine some light on the process.
QQQ Strategy: Bullish When the RSI is Oversold
For a simple starter script, let’s look at the RSI rule.
For the uninitiated, RSI — or the relative strength indicator — attempts to depict when a security is oversold or overbought, and by how much. A simple rule of thumb for reading RSI is that when the RSI is below 30, a security is oversold, and prone to bounce. Likewise, when the RSI is over 70, the security is overbought, and prone to take a pause.
With that in mind, let’s make a rudimentary script that does just that, using QQQ as the target, and at-the-money options as the tool.
Simple — a python script you could plug directly into a brokerage for auto-execution of trades when the RSI fits the parameters described. When this strategy was back tested on SPY using the 15 minute timeframe it carried a win rate of 66% according to TrendSpider.
But how about a more complex strategy?
SPY Strategy: MACD Crossover With Bollinger Band Confirmation
The headline of this strategy may sound complicated, but it’s relatively simple. The MACD indicator — which stands for moving average convergence divergence, is essentially two different moving averages measured against one another. The MACD looks like this:
Source: TradingView
With that in mind, let’s ask ChatGPT to write a nuanced MACD strategy, using another indicator — Bollinger Bands — as a confirmation.
This is where ChatGPT shines — no matter how complex the task, AI is capable of getting it done. For those of us who understand and are willing to trade nuanced strategies like this, it can be a pain to hunt down these opportunities and pounce on them immediately. With ChatGPT, one could theoretically set this script up on multiple high-liquidity tickers — just like setting hunting traps.
NVDA Strategy: Exploiting the Earnings Run-Up
Here’s an example of a more specific strategy with a 60% win rate over the last 10 years, including 40 total instances, with an average return of +2.56% when used with shares. When the strategy wins, the average return is +7.49%.
The strategy is simple: 15 days before earnings, buy at-the-money call options in Nvidia, expiring the week following earnings. Then, moments before the report is set to release, sell the options. In this strategy, we aren’t looking to trade the earnings itself — just the run-up. With a solid performance of the past 10 years, this is a specific strategy that we can count on ChatGPT to execute.
Here’s what I asked ChatGPT:
Here’s what it gave us:
Since that full script included a scroll bar, we weren’t able to fully screenshot the result. Here’s that full result:
import alpaca_trade_api as tradeapi
from datetime import datetime, timedelta
import pytz
# Replace with your Alpaca API credentials
API_KEY = ‘YOUR_API_KEY’
API_SECRET = ‘YOUR_API_SECRET’
BASE_URL = ‘https://paper-api.alpaca.markets’ # Use paper trading for testing
# Initialize Alpaca API
api = tradeapi.REST(API_KEY, API_SECRET, base_url=BASE_URL, api_version=’v2′)
# Replace with the desired stock symbol (e.g., NVDA)
symbol = ‘NVDA’
# Function to calculate the buying date 15 days before earnings
def calculate_buying_date():
earnings_date = api.get_earnings_calendar(symbol=symbol).earnings_date.date()
buying_date = earnings_date – timedelta(days=15)
return buying_date
# Main trading logic
def trade_nvda_earnings():
buying_date = calculate_buying_date()
today = datetime.now(pytz.timezone(‘US/Eastern’)).date()
if today == buying_date:
# Find the at-the-money strike price
quotes = api.get_latest_trade(symbol)
atm_strike_price = quotes.price
# Buy at-the-money call options using a market order
api.submit_order(
symbol=symbol,
qty=1, # Number of options contracts to buy
side=’buy’,
type=’market’,
time_in_force=’gtc’,
order_class=’simple’,
price=atm_strike_price,
option_type=’call’,
tif=’opg’, # Order placed on the market open
option_symbol=f”{symbol}{expiration_date.strftime(‘%y%m%d’)}C{int(atm_strike_price)}”
)
# Schedule a market sell order for the same option at 3:55 PM EST on the day of the earnings report
sell_time = datetime.now(pytz.timezone(‘US/Eastern’)).replace(day=15, hour=15, minute=55, second=0, microsecond=0)
api.submit_order(
symbol=symbol,
qty=1, # Number of options contracts to sell
side=’sell’,
type=’market’,
time_in_force=’gtc’,
order_class=’simple’,
price=atm_strike_price,
option_type=’call’,
tif=’gtc’, # Good ’til canceled
option_symbol=f”{symbol}{expiration_date.strftime(‘%y%m%d’)}C{int(atm_strike_price)}”,
executed_at=sell_time
)
# Schedule the script to run periodically (e.g., daily)
if __name__ == ‘__main__’:
trade_nvda_earnings()
This is another instance of a simple strategy that you could perform on your own, without ChatGPT or any fancy algorithms. However, automation takes emotion and time out of the equation, and that’s why we’re talking about it in this article.
Now, let’s focus on some momentum trading strategies that are used with stock rather than options. For this, we’ll look at a stock that carries high enough volatility and has enough backtesting data behind it in order to generate favorable returns in the backtest: Tesla.
TSLA VWAP, EMA, RSI Strategy (+86% Over the Last 2 Years vs. -30.29% Buy and Hold, May 2021-May 2023)
In this strategy, we enter a long position if the 30 minute candle closes above the VWAP while the RSI is above 45, and the 20 EMA is above the 50 EMA.
Between May 2021 and May 2023, this strategy yielded +86.64% returns in Tesla, while the simple buy and hold strategy performed -30.29%.
Here’s how we turned it into a trading script using ChatGPT:
Here’s the script we got in return:
As is the case above, the script cuts off from the right, so if you don’t want to run this command yourself, here is the full code from ChatGPT:
import alpaca_trade_api as tradeapi
import pandas as pd
from datetime import datetime, timedelta
# Replace with your Alpaca API credentials
API_KEY = ‘YOUR_API_KEY’
API_SECRET = ‘YOUR_API_SECRET’
BASE_URL = ‘https://paper-api.alpaca.markets’ # Use paper trading for testing
# Initialize Alpaca API
api = tradeapi.REST(API_KEY, API_SECRET, base_url=BASE_URL, api_version=’v2′)
# Replace with the desired stock symbol (e.g., TSLA for Tesla)
symbol = ‘TSLA’
# Function to check if all conditions are met
def are_conditions_met():
# Get 30-minute historical data for the last 2 trading days
end_time = datetime.now()
start_time = end_time – timedelta(days=2)
timeframe = “30Min”
historical_data = api.get_barset(symbol, timeframe, start=start_time, end=end_time).df
# Calculate VWAP for the last 30-minute candle
vwap = historical_data[‘vwap’].iloc[-1]
# Calculate RSI for the last 14 periods (adjust as needed)
close_prices = historical_data[‘close’]
delta = close_prices.diff()
gain = delta.where(delta > 0, 0)
loss = -delta.where(delta < 0, 0)
avg_gain = gain.rolling(window=14).mean()
avg_loss = loss.rolling(window=14).mean()
rs = avg_gain / avg_loss
rsi = 100 – (100 / (1 + rs)).iloc[-1]
# Get 20-day and 50-day EMA
ema_20 = close_prices.ewm(span=20).mean().iloc[-1]
ema_50 = close_prices.ewm(span=50).mean().iloc[-1]
# Get the current Tesla stock price
current_price = api.get_latest_trade(symbol).price
# Check if conditions are met
return rsi > 45 and ema_20 > ema_50 and current_price > vwap
# Main trading logic
def trade_tesla():
while True:
if are_conditions_met():
# Buy shares of Tesla
api.submit_order(
symbol=symbol,
qty=1, # Number of shares to buy
side=’buy’,
type=’market’,
time_in_force=’gtc’
)
else:
# Sell shares of Tesla if any condition becomes null
api.submit_order(
symbol=symbol,
qty=1, # Number of shares to sell
side=’sell’,
type=’market’,
time_in_force=’gtc’
)
# Run the trading script
if __name__ == ‘__main__’:
trade_tesla()
That’s one example of a high-performing trading strategy from ChatGPT. In this instance, you’ll only augment the total quantity of shares you want the script to buy based on your account size and risk tolerance. Here’s another script in Tesla from ChatGPT:
TSLA RVOL & RSI Strategy: (+2405.0% over 4 years vs +1500.2% from buy and hold, August 21st 2019-August 21st 2023)
This simple strategy enters a long position in Tesla when the RVOL is greater than 2, and the RSI is greater than 50. It exits the trade if the strategy has gained more than 12%, or the strategy has lost more than -2%.
Once again, this (somewhat long script) extends beyond what we can screenshot, so here’s the script in its full form:
import alpaca_trade_api as tradeapi
import time
# Replace with your Alpaca API credentials
API_KEY = ‘YOUR_API_KEY’
API_SECRET = ‘YOUR_API_SECRET’
BASE_URL = ‘https://paper-api.alpaca.markets’ # Use paper trading for testing
# Initialize Alpaca API
api = tradeapi.REST(API_KEY, API_SECRET, base_url=BASE_URL, api_version=’v2′)
# Replace with the desired stock symbol (e.g., TSLA for Tesla)
symbol = ‘TSLA’
# Function to check if conditions are met
def are_conditions_met():
# Get the latest trade for Tesla
latest_trade = api.get_latest_trade(symbol)
# Calculate RVOL (Relative Volume)
avg_volume_20d = api.get_barset(symbol, ‘day’, limit=20).df[‘volume’].mean()
current_volume = latest_trade.volume
rvol = current_volume / avg_volume_20d
# Calculate RSI for the last 14 periods (adjust as needed)
historical_data = api.get_barset(symbol, ’15Min’, limit=14).df[‘close’]
delta = historical_data.diff()
gain = delta.where(delta > 0, 0)
loss = -delta.where(delta < 0, 0)
avg_gain = gain.mean()
avg_loss = loss.mean()
rs = avg_gain / avg_loss
rsi = 100 – (100 / (1 + rs))
return rvol > 2 and rsi > 50
# Function to place a market order to buy shares
def buy_shares():
latest_trade = api.get_latest_trade(symbol)
current_price = latest_trade.price
buying_power = api.get_account().cash
# Calculate the number of shares to buy
shares_to_buy = int(buying_power / current_price)
# Place a market order to buy shares
api.submit_order(
symbol=symbol,
qty=shares_to_buy,
side=’buy’,
type=’market’,
time_in_force=’gtc’
)
# Function to check if it’s time to exit based on gains or losses
def is_time_to_exit(initial_value):
latest_trade = api.get_latest_trade(symbol)
current_price = latest_trade.price
# Calculate the current value of the position
current_value = current_price * initial_value
# Calculate the percentage gain or loss
percent_change = ((current_value – initial_value) / initial_value) * 100
return percent_change > 12 or percent_change < -2
# Function to place a market order to sell shares
def sell_shares():
latest_trade = api.get_latest_trade(symbol)
current_price = latest_trade.price
position = api.get_position(symbol)
shares_to_sell = position.qty
# Place a market order to sell shares
api.submit_order(
symbol=symbol,
qty=shares_to_sell,
side=’sell’,
type=’market’,
time_in_force=’gtc’
)
# Main trading logic
def trade_tesla():
while True:
if are_conditions_met():
# Buy shares if conditions are met
latest_trade = api.get_latest_trade(symbol)
initial_value = latest_trade.price * api.get_account().cash
buy_shares()
# Check for exit conditions every hour
time.sleep(3600) # Wait for an hour
if is_time_to_exit(initial_value):
sell_shares()
if __name__ == ‘__main__’:
trade_tesla()
Notably, there are areas where ChatGPT hasn’t yet broken through — strategies that still need a human touch.
For instance, you could tell ChatGPT to create a strategy that hunts for trend reversals with 100% average volume, however, ChatGPT still doesn’t understand the nuance of reversal candles and technical patterns (though you could theoretically define those items).
Additionally, some aspects of these scripts may need to be adjusted, augmented, or reworked.
The Bottom Line: A Great Tool, but Nothing is Perfect
Obviously, using ChatGPT or any other tool for options trading does not guarantee success — options trading carries a high degree of risk, it’s complicated, and if anyone had “cracked the code” it would quickly become world news.
As we made clear it’s crucial to have a solid understanding of options trading and the risks involved before using any script to trade. Additionally, it is essential to regularly backtest and monitor the script performance and adjust it if needed. Market conditions change — what worked in 2021 (Buying and rolling call options like a mad man) didn’t work in 2022. Backtesting will help show you what works and what doesn’t.
In conclusion, ChatGPT is a powerful tool that can be used to help with the options trading process by analyzing data and generating code — but nothing is perfect, it’s only as good as the instruction you give it. By using ChatGPT, options traders can quickly and accurately analyze market data, test and implement new strategies, and automate the trading process. However, as with any tool, it is essential to understand the risks involved and to use it with caution.
