name: long-strangle description: Analyzes long strangle volatility plays with OTM call and put at different strikes. Requires numpy>=1.24.0, pandas>=2.0.0, matplotlib>=3.7.0, scipy>=1.10.0. Use when expecting very large price movement, want lower-cost alternative to straddle, analyzing high-volatility events, or evaluating wide-range breakout opportunities on stocks with elevated IV.

Long Strangle Strategy

Version: 1.0 Last Updated: 2025-12-12

Overview

A long strangle is a neutral volatility strategy similar to a straddle but with lower cost and wider breakevens. By purchasing an OTM call and OTM put at different strikes, the trader profits from very large moves in either direction while paying less premium than a straddle, though requiring larger moves to achieve profitability.

Quick Summary: Buy OTM call + Buy OTM put (different strikes) = Lower cost, needs bigger move

Strategy Characteristics

Position Structure:

Buy 1 call out-of-the-money (OTM)
Buy 1 put out-of-the-money (OTM)
Different strike prices (call higher, put lower)
Same expiration date

Risk Profile:

Maximum Loss: Total premium paid (call + put)
Maximum Profit: Unlimited (stock can move infinitely)
Breakeven Points:
- Upside: Call strike + Total premium
- Downside: Put strike - Total premium
Best Use: Expect very large move, want lower cost than straddle

Cost Components:

Call premium (debit)
Put premium (debit)
Total premium = Call + Put (lower than straddle)
Transaction costs: ~$0.65 per contract × 2 legs = $1.30

Quick Start

Calculate long strangle metrics:

from scripts.long_strangle_calculator import LongStrangle

# Example: TSLA at $250, expecting large move
position = LongStrangle(
    underlying_price=250.00,
    call_strike=265.00,   # 6% OTM call
    put_strike=235.00,    # 6% OTM put
    call_premium=8.50,
    put_premium=7.75,
    contracts=1
)

# Key metrics
print(f"Total Cost: ${position.total_cost:.2f}")
print(f"Upper Breakeven: ${position.upper_breakeven:.2f}")
print(f"Lower Breakeven: ${position.lower_breakeven:.2f}")
print(f"Required Move: {position.required_move_percent:.1f}%")
print(f"Cost Savings vs Straddle: {position.vs_straddle_savings:.1f}%")

Core Workflow

1. Identify High-Volatility Opportunity

Look for events likely to cause extreme moves:

Ideal Catalysts:

Biotech: Binary FDA approvals (pass/fail)
Tech Earnings: High-growth companies with uncertain guidance
Legal Outcomes: Major lawsuit verdicts
M&A Speculation: Takeover rumors or announcements
Product Launches: Make-or-break products

Market Conditions:

Stock with history of large post-event moves (>15%)
High implied volatility (IV rank >60)
Uncertain outcome (50/50 scenarios)
Sufficient liquidity in options

See references/catalyst-identification.md.

2. Strike Selection Framework

Strike Width Configurations:

Narrow Strangle (2-5% OTM each side):

Call: 2-5% above current price (delta ~0.35-0.45)
Put: 2-5% below current price (delta ~-0.35 to -0.45)
Higher cost, lower breakevens
Example: Stock $100 → Call $105, Put $95

Standard Strangle (5-10% OTM each side):

Call: 5-10% above current price (delta ~0.20-0.35)
Put: 5-10% below current price (delta ~-0.20 to -0.35)
Balanced cost and breakevens
Example: Stock $100 → Call $110, Put $90

Wide Strangle (10-20% OTM each side):

Call: 10-20% above current price (delta ~0.10-0.20)
Put: 10-20% below current price (delta ~-0.10 to -0.20)
Lower cost, very wide breakevens
Example: Stock $100 → Call $120, Put $80

Selection Criteria:

Match strike width to expected move magnitude
Balance premium cost vs. probability of profit
Consider historical post-event moves

See references/strike-selection-guide.md.

3. Strangle Width Optimization

Compare different strike configurations:

from scripts/strangle_optimizer import optimize_strangle_width

configs = optimize_strangle_width(
    underlying_price=250.00,
    otm_percentages=[5, 10, 15, 20],  # Test various widths
    volatility=0.80,
    days_to_expiration=7,
    historical_avg_move=18.0  # Historical post-earnings move
)

for config in configs:
    print(f"OTM {config['otm_pct']}%:")
    print(f"  Cost: ${config['total_premium']:.2f}")
    print(f"  Breakevens: ${config['lower_be']:.2f} - ${config['upper_be']:.2f}")
    print(f"  Required Move: {config['required_move_pct']:.1f}%")
    print(f"  Prob Profit: {config['prob_profit']:.1f}%")

See references/width-optimization.md.

4. Cost-Benefit vs Straddle

Compare strangle cost and requirements to straddle:

from scripts.strangle_vs_straddle import compare_strategies

comparison = compare_strangle_vs_straddle(
    underlying_price=250.00,
    atm_strike=250.00,
    atm_call_premium=15.00,
    atm_put_premium=14.50,
    otm_call_strike=265.00,
    otm_call_premium=8.50,
    otm_put_strike=235.00,
    otm_put_premium=7.75
)

print("Straddle:")
print(f"  Cost: ${comparison['straddle_cost']:.2f}")
print(f"  Breakevens: ±{comparison['straddle_be_pct']:.1f}%")
print("\nStrangle:")
print(f"  Cost: ${comparison['strangle_cost']:.2f}")
print(f"  Cost Savings: {comparison['cost_savings_pct']:.1f}%")
print(f"  Breakevens: +{comparison['upper_be_pct']:.1f}% / -{comparison['lower_be_pct']:.1f}%")

Decision Guide:

Use Strangle if: Historical moves >15%, want to reduce cost
Use Straddle if: Moderate moves expected (8-12%), tighter breakevens needed

See references/strangle-vs-straddle.md.

5. IV Rank and Expected Move

Assess volatility environment:

from scripts.iv_analyzer import analyze_iv_environment

analysis = analyze_iv_environment(
    symbol='TSLA',
    current_iv=0.80,
    lookback_period=252
)

print(f"IV Rank: {analysis['iv_rank']:.0f}")
print(f"IV Percentile: {analysis['iv_percentile']:.0f}")
print(f"Expected Move: {analysis['expected_move_pct']:.1f}%")
print(f"Historical Avg Move: {analysis['historical_avg']:.1f}%")
print(f"Strangle Breakevens Reasonable: {analysis['breakevens_achievable']}")

Ideal Environment:

IV Rank: 60-90 (high but not extreme)
Historical moves > Strangle breakevens
Expected move ≥ Required move

See references/iv-analysis.md.

6. Expiration Timing

Event-Driven Strangles:

1-3 days before event: Minimize theta while capturing IV
Week of event: Balance time and cost
After event: Capture move but risk IV crush

Time-Driven Strangles:

30-45 days: Standard volatility play
60-90 days: Longer-term speculation (expensive)
7-14 days: Short-term binary event

Timing Strategy:

Enter 2-5 days before catalyst
Avoid entering day-of (IV peak, max cost)
Exit day after event (before IV crush accelerates)

See references/timing-strategies.md.

7. Greeks Monitoring

Track strangle Greeks:

from scripts.greeks_calculator import calculate_strangle_greeks

greeks = calculate_strangle_greeks(
    call_strike=265.00,
    put_strike=235.00,
    underlying_price=250.00,
    volatility=0.80,
    time_to_expiration=7/365
)

print(f"Delta: {greeks['delta']:.3f}")    # ~0 (neutral)
print(f"Gamma: {greeks['gamma']:.3f}")    # Positive (benefits from moves)
print(f"Theta: {greeks['theta']:.3f}")    # Negative (time decay hurts)
print(f"Vega: {greeks['vega']:.3f}")      # Positive (benefits from IV increase)

Key Insights:

Delta: Near zero (directionally neutral)
Gamma: Lower than straddle (OTM strikes)
Theta: Negative but lower than straddle
Vega: High (very sensitive to IV changes)

See references/greeks-guide.md.

8. Position Sizing

Calculate risk-appropriate contracts:

from scripts.position_sizer import calculate_strangle_size

contracts = calculate_strangle_size(
    portfolio_value=100000,
    risk_per_trade=0.03,      # 3% max risk
    strangle_cost=1625         # $16.25 × 100
)
# Returns: 2 contracts (max risk $3,250 = 3.25%)

Sizing Guidelines:

Risk 2-5% of portfolio per strangle
Account for 100% loss potential
Consider multiple contracts if confident
Never oversize on single binary event

See references/position-sizing.md.

9. Entry Execution

Order Types:

Strangle Order: Single order for both legs (best execution)
Limit Order: Set maximum total premium
Individual Legs: Separate orders (worse pricing, wider spreads)

Best Practices:

Always enter as strangle order (better fill)
Set limit at mid-point of bid/ask
Adjust by $0.05-$0.10 if not filled
Avoid market orders (significant slippage on OTM options)

Timing:

Enter 2-5 days before event
Avoid immediate pre-event (IV spike)
Avoid post-event (IV crush risk)

10. Management and Exit

Profit Targets:

20-30% profit: Quick exit, lock gains
50% profit: Strong target for event plays
Breakeven reached: Consider partial exit

Stop Loss:

50-70% loss: Cut position, avoid max loss
Day after event: Exit if no move (IV crush coming)
Time-based: If event passes with small move

Post-Event Strategy:

Large move in direction: Close winning side, let loser expire
Moderate move: May still be unprofitable, exit both sides
No move: Accept loss, exit position
IV Crush: Exit immediately day after event

See references/exit-strategies.md.

Scripts

Calculator

# Calculate long strangle metrics
python scripts/long_strangle_calculator.py \
  --underlying TSLA \
  --price 250 \
  --call-strike 265 \
  --put-strike 235 \
  --call-premium 8.50 \
  --put-premium 7.75 \
  --contracts 1

Width Optimizer

# Compare different strike widths
python scripts/strangle_optimizer.py \
  --underlying TSLA \
  --price 250 \
  --otm-pcts 5 10 15 20 \
  --dte 7 \
  --volatility 0.80

IV Analyzer

# Analyze IV environment
python scripts/iv_analyzer.py \
  --symbol TSLA \
  --current-iv 0.80 \
  --lookback 252

Strangle vs Straddle Comparison

# Compare strangle to straddle
python scripts/strangle_vs_straddle.py \
  --underlying TSLA \
  --price 250 \
  --straddle-strike 250 \
  --call-strike 265 \
  --put-strike 235

References

Core Guides

quickstart-guide.md - 5-minute overview
installation-guide.md - Setup instructions
developer-guide.md - Code standards

Strategy-Specific

catalyst-identification.md - Finding high-volatility events
strike-selection-guide.md - OTM strike framework
width-optimization.md - Optimize strike spacing
strangle-vs-straddle.md - When to use each
iv-analysis.md - IV rank, percentile, expected move
timing-strategies.md - Optimal entry timing
greeks-guide.md - Delta, gamma, theta, vega
position-sizing.md - Risk management
exit-strategies.md - Profit targets, stop loss
examples.md - Real biotech/earnings plays

Dependencies

Required Packages:

numpy>=1.24.0
pandas>=2.0.0
matplotlib>=3.7.0
scipy>=1.10.0
yfinance>=0.2.0  # For historical IV and price data

Installation:

pip install -r requirements.txt

Python Version: 3.11+

Risk Warnings

⚠️ Key Risks:

Wider Breakevens: Requires larger move than straddle (10-20%+)
Lower Probability: OTM strikes = lower chance of profit
IV Crush: Severe vega loss after event (60-90% drop possible)
Time Decay: Theta eats premium if stock doesn't move
Both Sides Expire Worthless: Very possible with moderate moves
Gap Risk: Large overnight gaps may not fully capture value

Risk Mitigation:

Only use on historically volatile stocks (>15% moves)
Exit day after event (before IV crush accelerates)
Set stop loss at 50-70% of premium
Size conservatively (2-3% portfolio risk)
Verify historical moves justify breakevens
Have exit plan before entry

When to Use Long Strangle

✅ Ideal Scenarios:

Binary events (FDA approvals, major earnings)
Stocks with history of 15%+ post-event moves
High IV environment (IV rank 60-90)
Want lower cost than straddle (30-50% savings)
Willing to accept wider breakevens
Clear catalyst with uncertain outcome

❌ Avoid When:

Expected move <10% (insufficient for breakevens)
Low volatility environment (IV rank <40)
After event (IV already crushed)
Moderate moves expected (use straddle instead)
Can't accept very low probability of profit
Extreme IV (>95) - massive crush risk

Comparison to Other Strategies

vs. Long Straddle:

✅ Lower cost (30-50% cheaper)
❌ Wider breakevens (needs bigger move)
❌ Lower gamma (less responsive)
✅ Lower theta decay

vs. Iron Condor:

❌ Pay premium vs. collect
✅ Unlimited profit vs. capped
❌ Want volatility vs. want calm
✅ Benefit from IV increase

vs. Directional Play:

✅ No directional bias
❌ More expensive (two legs)
✅ Profit from move either way

Example Trade

Scenario: Biotech FDA decision, stock at $42, IV rank 85

Setup:

Buy 1 call $48 strike @ $2.10 (14% OTM)
Buy 1 put $36 strike @ $1.85 (14% OTM)
Total cost: $3.95 × 100 = $395 per strangle
Contracts: 3 (based on 3% portfolio risk on $40k)
Expiration: 7 days (2 days after FDA decision date)