Support and Resistance levels from Options Data

4 часа назад

INTRODUCTION
This script is designed to visualize key support and resistance levels derived from options data on TradingView charts. It overlays lines, labels, and boxes to highlight levels such as Put Walls (gamma support), Call Walls (gamma resistance), Gamma Flip points, Vanna levels, and more.

These levels are intended to help traders identify potential areas of price magnetism, reversal, or breakout based on options market dynamics. All calculations and visualizations are based on user-provided data pasted into the input field, as Pine Script cannot directly fetch external options data due to platform limitations (explained below).

For convenience, my website allows users to interact with a bot that will generate the string for up to 30 tickers at once getting nearly real-time data on demand (data is cached for 15min). With the output string pasted into this indicator, it's a bliss to shuffle through your portfolio and see those levels for each ticker.

The script is open-source under TradingView's terms, allowing users to study, modify, and improve it. It draws inspiration from common options-derived metrics like gamma exposure and vanna, which are widely discussed in financial literature. No external code is copied without rights; all logic is original or based on standard mathematical formulas.

How the Options Levels Are Calculated
The levels displayed by this script are not computed within Pine Script itself—instead, they rely on pre-calculated values provided by the user (via a pasted data string). These values are derived from options chain data fetched from financial APIs (e.g., using libraries like yfinance in Python). Here's a step-by-step overview of how these levels are generally calculated externally before being input into the script:

Fetching Options Data:
Historical and current options chain data for a ticker (e.g., strikes, open interest, volume, implied volatility, expirations) is retrieved for near-term expirations (e.g., up to 90 days).
Current stock price is obtained from recent history.


Gamma Support (Put Wall) and Resistance (Call Wall):
Gamma Calculation: For each option, gamma (the rate of change of delta) is computed using the Black-Scholes formula:
gamma = N'(d1) / (S * sigma * sqrt(T))
where S is the stock price, K is the strike, T is time to expiration (in years), sigma is implied volatility, r is the risk-free rate (e.g., 0.0445), and N'(d1) is the normal probability density function.
Weighted gamma is multiplied by open interest and aggregated by strike.
The Put Wall is the strike below the current price with the highest weighted gamma from puts (acting as support).
The Call Wall is the strike above the current price with the highest weighted gamma from calls (acting as resistance).
Short-term versions focus on strikes closer to the money (e.g., within 10-15% of the price).


Gamma Flip Level:
Net dealer gamma exposure (GEX) is calculated across all strikes:
GEX = sum (gamma * OI * 100 * S^2 * sign * decay)
where sign is +1 for calls/-1 for puts, and decay is 1 / sqrt(T).
The flip point is the price where net GEX changes sign (from positive to negative or vice versa), interpolated between strikes.


Vanna Levels:
Vanna (sensitivity of delta to volatility) is calculated:
vanna = -N'(d1) * d2 / sigma
where d2 = d1 - sigma * sqrt(T).
Weighted by open interest, the highest positive and negative vanna strikes are identified.


Other Levels:

• S1/R1: Significant strikes with high combined open interest and volume (80% OI + 20% volume), below/above price for support/resistance.
  
• Implied Move: ATM implied volatility scaled by S * sigma * sqrt(d/365) (e.g., for 7 days).
  
• Call/Put Ratio: Total call contracts divided by put contracts (OI + volume).
  
• IV Percentage: Average ATM implied volatility.
  
• Options Activity Level: Average contracts per unique strike, binned into levels (0-4).
  
• Stop Loss: Dynamically set below the lowest support (e.g., Put Wall, Gamma Flip), adjusted by IV (tighter in low IV).
  
• Fib Target: 1.618 extension from Put Wall to Call Wall range.
  
• Previous day levels are stored for comparison (e.g., to detect Call Wall movement >2.5% for alerts).
  

Effect as Support and Resistance in Technical Trading
Options levels like gamma walls influence price action due to market maker hedging:

• Put Wall (Gamma Support): High put gamma below price creates a "magnet" effect—market makers buy stock as price falls, providing support. Traders might look for bounces here as entry points for longs.
  
• Call Wall (Gamma Resistance): High call gamma above price leads to selling pressure from hedging, acting as resistance. Rejections here could signal trims, sells or even shorts.
  
• Gamma Flip: Where gamma exposure flips sign, often a volatility pivot—crossing it can accelerate moves (bullish above, bearish below).
  
• Vanna Levels: Positive/negative vanna indicate volatility sensitivity; crosses may signal regime shifts.
  
• Implied Move: Shows expected range; prices outside suggest overextension.
  
• S1/R1 and Fib Target: Volume/OI clusters act as classic S/R; Fib extensions project upside targets post-breakout.
  

In trading, these are not guarantees—combine with TA (e.g., volume, trends). High activity levels imply stronger effects; low CP ratio suggests bearish sentiment. Alerts trigger on proximities/crosses for awareness, not advice.

Limitations of the TradingView Platform for Data Pulling
TradingView's Pine Script is sandboxed for security and performance:

No direct internet access or API calls (e.g., can't fetch yfinance data in-script).
Limited to chart data/symbol info; no real-time options chains.
Inputs are static per load; updates require manual pasting.
Caching isn't persistent across sessions.

This prevents dynamic data pulling, ensuring scripts remain lightweight but requiring external tools for fresh data.

Creative Solution for On-Demand Data Pulling
To overcome these limitations, users can use external tools or scripts (e.g., Python-based) to fetch and compute levels on demand. The tool processes tickers, generates a formatted string (e.g., "TICKER:level1,level2,...;TIMESTAMP:unix;"), and users paste it into the script's input. This keeps data fresh without violating platform rules, as computation happens off-platform. For example, run a local script to query APIs and output the string—adaptable for any ticker.
Script Functionality Breakdown

Inputs: Custom data string (parsed for levels/timestamp); toggles for short-term/previous/Vanna/stop loss; style options (colors, transparency).
Parsing: Extracts levels for the chart symbol; gets timestamp for "updated ago" display.
Drawing: Lines/labels for levels; boxes for gamma zones/implied move; clears old elements on updates.
Info Panel: Top-right summary with metrics (CP ratio, IV, distances, activity); emojis for quick status.
Alerts: Conditions for proximities, crosses, bounces (e.g., 0.5% bounce from Put Wall).
Performance: Uses vars for persistence; efficient for real-time.

This script is educational—test thoroughly. Not financial advice; past performance isn't indicative of future results. Feedback welcome via TradingView comments.

4 часа назад

Информация о релизе

- some finishing touches and added the format of the data string

// The custom_level_data string follows this format:
// TICKER1:val0,val1,val2,...,val16;TICKER2:val0,val1,val2,...,val16;...;TIMESTAMP:unix_timestamp;
// Where:
// - Each ticker's data starts with "TICKER:" (e.g., "AAPL:") followed by exactly 17 comma-separated float values, ended by a semicolon.
// - The values represent (in order):
// 0: S1 (support level)
// 1: R1 (resistance level)
// 2: Implied move (absolute price value)
// 3: Put Wall (gamma support)
// 4: Call Wall (gamma resistance)
// 5: Gamma Flip level
// 6: IV (implied volatility in %)
// 7: C/P ratio (call/put ratio)
// 8: Trend (% change, e.g., in call wall)
// 9: Options activity level (0-4: Very Low to Very High)
// 10: Short-term Put Wall
// 11: Short-term Call Wall
// 12: Previous short-term Put Wall
// 13: Previous short-term Call Wall
// 14: Positive Vanna level
// 15: Negative Vanna level
// 16: Suggested Stop Loss level
// - The string ends with "TIMESTAMP:" followed by a Unix timestamp (integer seconds since epoch).
// - No spaces, newlines, or extra characters; the code cleans the input automatically.
// Example: "AAPL:100.0,110.0,5.0,95.0,115.0,105.0,25.0,1.2,0.5,3,94.0,116.0,93.0,117.0,120.0,90.0,92.0;TIMESTAMP:1725148800;"