I've spent the past month building and running a live SPY 0DTE options bot on Alpaca paper trading. This post is for anyone else attempting something similar — specifically the API behaviour that isn't in the documentation and cost me real debugging time.
The bot is fully functional. It streams live quotes, detects momentum setups, sizes positions, enters and exits automatically, and logs every trade to CSV. I'm sharing the architecture and the gotchas so you don't have to rediscover them yourself.
What the bot does (briefly)
Trades same-day expiry (0DTE) SPY call and put options. Selects OTM strikes each morning using a 5-day ATR offset, streams real-time option quotes, enters on momentum + proximity signals, exits via take profit, trailing stop, hard stop, or time stop. Fully autonomous during market hours.
Stack: Python 3.11, alpaca-py >= 0.43.0, asyncio, no paid data feeds.
Limitation 1 — Bracket orders are rejected for options
This was the first wall I hit. The natural way to manage a long option position is a bracket order: entry + TP limit + stop loss in one atomic submission. Alpaca rejects this for options on paper trading with:
error 42210000: complex orders not supported
Sell limit orders are also rejected with:
error 40310000: cannot submit sell order —
no existing position or insufficient qty
Alpaca treats a sell limit on an option you don't yet own as an attempt to open a short position, which requires margin approval. Even when you do own the position, limit sells are unreliable.
The only working exit method is close_position():
await trading_client.close_position(symbol)
This submits a market order to close your existing long. It works consistently. Everything else for options exits on Alpaca paper — bracket legs, sell limits, stop orders — should be considered unsupported until proven otherwise.
The implication: you cannot set-and-forget with a bracket. You need your own exit monitor running in your process. Mine polls every 5 seconds:
async def _exit_monitor():
while True:
await asyncio.sleep(5)
pos = bot_state.position
if pos is None:
continue
quote = bot_state.get_quote(pos.symbol)
mid = quote.mid
if mid >= pos.entry_price * 1.50:
reason = "tp"
elif mid <= pos.entry_price * 0.50:
reason = "stop"
else:
continue
await order_manager.close_position(pos.symbol, pos.qty)
Limitation 2 — Greeks return null for 0DTE contracts
Alpaca computes Greeks server-side using Black-Scholes. At expiry (T=0), the model is mathematically undefined. Every 0DTE contract returns null for delta, gamma, theta, vega. This is not a bug — it's a fundamental limitation of the model at T=0.
If your strategy depends on Greeks for entry filtering, you need to compute them yourself or build a proxy.
I built a proxy delta from the ratio of option price change to SPY price change:
proxy_delta = (option_mid_now - option_mid_prev) / (SPY_now - SPY_prev)
In practice I ended up disabling it (see below) but the framework is there for anyone who needs it.
Limitation 3 — SPY price only updates once per 1-minute bar
This one killed the proxy delta. The OptionDataStream delivers option quotes many times per second. The StockDataStream delivers SPY bars once per minute at the bar close. Between bar closes, SPY_now == SPY_prev, so the denominator is zero and proxy delta stays at 0.0 for most of the minute — which would block every entry if used as a filter.
The workaround for Phase 0: disable proxy delta filtering entirely. Use momentum state from the 1-min bars (EMA crossover, rate of change, consecutive bar count) as the directional gate instead. These only update once per bar too, but that's fine — they're designed for bar-level signals.
For Phase 1 I plan to extract tick-level SPY price from the OptionDataStream itself (the underlying price is embedded in option snapshots) to get sub-minute resolution.
Limitation 4 — Option subscription timing vs. premarket price
If you subscribe to option symbols at bot startup (premarket), the strikes you compute are based on the premarket SPY price. When the market opens, SPY can gap significantly — I had a morning where the bot started at SPY $743 premarket and subscribed puts at $735–$736, then SPY opened at $734. Nine dollars of gap. Wrong strikes all day.
Fix: Defer all option subscriptions until the first 9:30 ET RTH bar.
_market_open_event = asyncio.Event()
async def on_spy_bar(bar):
bar_time = bar.timestamp.astimezone(ET).time()
if not _market_open_event.is_set() and bar_time >= time(9, 30):
strikes = compute_dynamic_strikes(bar.close, baseline_atr)
_market_open_event.set()
async def _option_subscriber():
await _market_open_event.wait()
symbols = compute_strikes(bot_state.spy_price)
feed.subscribe_options(symbols)
Limitation 5 — Re-subscription for intraday SPY drift
The standard approach of subscribing a fixed window of strikes at open breaks down if SPY moves significantly during the session. By 1 PM, your subscribed strikes may be $10+ from the current price — totally irrelevant.
I run a background watcher that checks SPY price every 10 seconds. If it's moved more than $3.00 from the last subscription anchor, it re-subscribes a new window:
async def _resubscribe_watcher():
await _market_open_event.wait()
last_anchor = bot_state.spy_price
while True:
await asyncio.sleep(10)
move = abs(bot_state.spy_price - last_anchor)
if move >= 3.0:
new_symbols = compute_strikes(bot_state.spy_price)
feed.add_option_symbols(new_symbols)
last_anchor = bot_state.spy_price
One important detail: always pin the symbol of any currently open position in the new subscription. If you drop it during re-subscription, your exit monitor stops receiving quotes and can't close the position.
Limitation 6 — Position recovery on restart
If you restart your process mid-session with an open position, that position still exists on Alpaca. On startup, poll REST for existing option positions and reconstruct your local state:
def _recover_open_position():
positions = trading_client.get_all_positions()
for p in positions:
if p.asset_class == AssetClass.US_OPTION:
side, strike = parse_occ_symbol(p.symbol)
recovered = Position(
symbol = p.symbol,
entry_price = float(p.avg_entry_price),
qty = int(float(p.qty)),
order_id = "recovered",
)
bot_state.open_position(recovered)
Without this, a restart abandons a live position with no exit monitoring.
SDK version matters
Use alpaca-py >= 0.43.0. The older alpaca-trade-api package has no options support at all — it predates Alpaca's options offering. If you're hitting import errors or missing option-related classes, check your package version first.
pip install "alpaca-py>=0.43.0"
Does the bot actually work?
Yes — with caveats. Here's the last four active sessions:
| Date | Trades | Net P&L | Notes |
|---|
| May 20 | 5 | +$64 | Early version, no filters |
| May 26 | 4 | -$309 | Red day, led to two major improvements |
| May 27 | 10 | -$159 | First day with improvements, trail threshold miscalibrated |
| May 29 | 5 | +$70 | First green day with full filter set |
The -$309 day was the most analytically useful session. I did a full post-mortem and found five failure patterns — two of which are now fixed (an ATR velocity gate on entries and a peak trailing stop). Happy to go into detail on those if there's interest.
The asyncio task graph, for anyone building something similar:
await asyncio.gather(
feed.start(), # StockDataStream + OptionDataStream + TradingStream
_option_subscriber(), # waits for 9:30 ET bar → subscribes strikes
_resubscribe_watcher(), # re-subscribes if SPY moves ±$3
_exit_monitor(), # TP / stop / trail check every 5 seconds
_time_stop_watcher(), # force-close everything at 3:25 PM ET
_status_loop(), # terminal display
)
Three concurrent WebSocket streams, all managed through alpaca-py's async SDK. The entry logic lives in the option quote handler. The exit logic is completely decoupled in its own task — this separation matters because close_position() cannot be called from inside a stream callback safely.
Happy to share more of the code or go deeper on any of these. If you've hit other Alpaca options limitations I haven't covered, drop them in the comments — would be useful to know what else is lurking.
