Get started

Bill Williams Indicators

Williams Fractal MA Pullback Strategy (1.5 RR) - BY DANISHOverview This strategy is a price action and moving average-based scalping strategy designed for low timeframes (1m, 5m, 15m). It combines trend alignment with pullbacks to key moving averages and uses Williams Fractals as entry triggers. It aims to catch high-probability scalping trades in the direction of the prevailing trend while keeping strict risk management with a 1.5:1 risk-to-reward ratio. Indicators Used Three Simple Moving Averages (SMA): Fast SMA: 20 periods (Green) Medium SMA: 50 periods (Yellow) Slow SMA: 100 periods (Red) Williams Fractals (Period 2): Identifies short-term local highs (red) and lows (green) for potential reversal or continuation setups. Trend Rules Bullish Trend (Long Setup): Fast SMA (20) > Medium SMA (50) > Slow SMA (100) Moving averages must not be crossing Bearish Trend (Short Setup): Slow SMA (100) > Medium SMA (50) > Fast SMA (20) Moving averages must not be crossing This ensures trades are only taken in the direction of the prevailing trend. Entry Rules Long Entry (Buy): Price pulls back to either the 20 SMA (fast) or 50 SMA (medium) without closing below the 100 SMA (slow). A green Williams Fractal forms after the pullback. Confirm all trend alignment rules (20>50>100). Enter a long position at the close of the candle that confirms the fractal. Short Entry (Sell): Price pulls back to either the 20 SMA (fast) or 50 SMA (medium) without closing above the 100 SMA (slow). A red Williams Fractal forms after the pullback. Confirm all trend alignment rules (100>50>20). Enter a short position at the close of the candle that confirms the fractal. Risk Management & Stop Loss Long Trades: If price stayed above 50 SMA during pullback → SL is just below 50 SMA If price dipped below 50 SMA but stayed above 100 SMA → SL is just below 100 SMA Short Trades: If price stayed below 50 SMA during pullback → SL is just above 50 SMA If price rose above 50 SMA but stayed below 100 SMA → SL is just above 100 SMA Take Profit (TP) Fixed 1.5 Risk-to-Reward ratio TP = Risk × 1.5 This ensures each trade has a positive expectancy and follows consistent risk-reward management. Additional Rules Fractals Confirmation: The strategy waits for 2 bars to close before confirming the fractal signal to avoid repainting. No trades are taken if the price violates the 100-period SMA during the pullback. Designed for scalping on low timeframes: 1m, 5m, or 15m charts. Visuals on Chart SMA Lines: 20 SMA (Green) 50 SMA (Yellow) 100 SMA (Red) Fractal Arrows: Green fractal → potential long entry Red fractal → potential short entry Trade Highlights: Strategy plots entries and exit levels automatically with stop loss and take profit. How to Use Add the script to a 1m, 5m, or 15m chart. Enable the strategy tester to see backtesting results. Follow the trend alignment rules strictly for high-probability scalping trades. Optionally, combine with volume filters or market structure analysis for better performance. Benefits Trades only in aligned trend direction, avoiding counter-trend traps. Pullback + fractal logic provides high-probability entries. Risk-to-reward of 1.5:1 ensures good risk management. Avoids fractal repainting by waiting for candle close. Ideal Conditions Works best on volatile assets like crypto or forex pairs with clear trending moves. Best applied to liquid markets with tight spreads for scalping. ✅ Summary: Trend-aligned scalping strategy Pullback to MA + fractal confirmation Fixed 1.5 RR risk management Works on low timeframes (1m, 5m, 15m) Clean visual signals with SMMAs and fractals
Pine Script® strategy
by dani704
TJR asia session sweep//@version=5 strategy("TJR asia session sweep", "TJR Asia Sweep", overlay=true, max_lines_count=500, max_labels_count=500) // Input settings show_asian = input.bool(true, "Show Asian Session", group="Visual Settings") show_london = input.bool(true, "Show London Session", group="Visual Settings") show_swing_points = input.bool(true, "Show Asian Swing Points", group="Visual Settings") show_market_structure = input.bool(true, "Show Market Structure", group="Visual Settings") show_bos = input.bool(true, "Show Break of Structure", group="Visual Settings") // Session Time Settings asian_start_hour_input = input.int(22, "Asian Session Start Hour", minval=0, maxval=23, group="Session Times") asian_end_hour_input = input.int(3, "Asian Session End Hour", minval=0, maxval=23, group="Session Times") london_start_hour_input = input.int(3, "London Session Start Hour", minval=0, maxval=23, group="Session Times") london_end_hour_input = input.int(8, "London Session End Hour", minval=0, maxval=23, group="Session Times") session_timezone = input.string("America/New_York", "Session Timezone", options= , group="Session Times") // Risk Management Settings use_atr_sl = input.bool(false, "Use ATR Multiplier for Stop Loss", group="Risk Management") atr_length = input.int(14, "ATR Length", minval=1, maxval=50, group="Risk Management") atr_multiplier = input.float(2.0, "ATR Multiplier for Stop Loss", minval=0.5, maxval=10.0, group="Risk Management") force_london_close = input.bool(true, "Force Close at London Session End", group="Risk Management") cutoff_minutes = input.int(60, "Minutes Before Session End to Stop New Trades", minval=0, maxval=300, group="Risk Management") // Position Sizing Settings position_sizing_method = input.string("USD Risk", "Position Sizing Method", options= , group="Position Sizing") usd_risk_per_trade = input.float(100.0, "USD Risk Per Trade", minval=1.0, maxval=10000.0, group="Position Sizing") fixed_contracts = input.float(1.0, "Fixed Number of Contracts", minval=0.01, maxval=1000.0, step=0.01, group="Position Sizing") // Color settings asian_color = input.color(color.red, "Asian Session Color") london_color = input.color(color.blue, "London Session Color") swing_high_color = input.color(color.orange, "Swing High Color") swing_low_color = input.color(color.lime, "Swing Low Color") bullish_structure_color = input.color(color.green, "Bullish Structure Color") bearish_structure_color = input.color(color.red, "Bearish Structure Color") bos_color = input.color(color.orange, "Break of Structure Color") // Line settings line_width = input.int(2, "Line Width", minval=1, maxval=5) // ATR calculation for stop loss atr = ta.atr(atr_length) // Position size calculation function calculate_position_size(entry_price, stop_loss_price) => var float position_size = na if position_sizing_method == "Fixed Contracts" position_size := fixed_contracts else // USD Risk method stop_distance = math.abs(entry_price - stop_loss_price) if stop_distance > 0 // Calculate position size based on USD risk per trade // For forex: position_size = risk_amount / (stop_distance * point_value) // For most forex pairs, point value = 1 (since we're dealing with price differences directly) position_size := usd_risk_per_trade / stop_distance else position_size := fixed_contracts // Fallback to fixed contracts if stop distance is 0 position_size // Session time definitions (using input variables) asian_start_hour = asian_start_hour_input asian_end_hour = asian_end_hour_input london_start_hour = london_start_hour_input london_end_hour = london_end_hour_input // Get current hour using selected timezone current_hour = hour(time, session_timezone) // Previous hour for transition detection prev_hour = hour(time , session_timezone) // Session transition detection asian_start = current_hour == asian_start_hour and prev_hour != asian_start_hour asian_end = current_hour == asian_end_hour and prev_hour != asian_end_hour london_start = current_hour == london_start_hour and prev_hour != london_start_hour london_end = current_hour == london_end_hour and prev_hour != london_end_hour // Session activity detection asian_active = (current_hour >= asian_start_hour) or (current_hour < asian_end_hour) london_active = (current_hour >= london_start_hour) and (current_hour < london_end_hour) // Session boxes - keep previous sessions visible var box asian_session_box = na var box london_session_box = na // Create Asian session box if show_asian and asian_start // Create new box at session start (previous box remains visible) asian_session_box := box.new(bar_index, high, bar_index + 1, low, border_color=asian_color, bgcolor=color.new(asian_color, 90), border_width=2, border_style=line.style_solid) // Pre-calculate session highs and lows for consistency asian_session_length = asian_active and not na(asian_session_box) ? bar_index - box.get_left(asian_session_box) + 1 : 1 current_asian_high = ta.highest(high, asian_session_length) current_asian_low = ta.lowest(low, asian_session_length) // Update Asian session box continuously during session if show_asian and asian_active and not na(asian_session_box) box.set_right(asian_session_box, bar_index) // Update box to contain session highs and lows box.set_top(asian_session_box, current_asian_high) box.set_bottom(asian_session_box, current_asian_low) // Create London session box if show_london and london_start // Create new box at session start (previous box remains visible) london_session_box := box.new(bar_index, high, bar_index + 1, low, border_color=london_color, bgcolor=color.new(london_color, 90), border_width=2, border_style=line.style_solid) // Pre-calculate London session highs and lows for consistency london_session_length = london_active and not na(london_session_box) ? bar_index - box.get_left(london_session_box) + 1 : 1 current_london_high = ta.highest(high, london_session_length) current_london_low = ta.lowest(low, london_session_length) // Update London session box continuously during session if show_london and london_active and not na(london_session_box) box.set_right(london_session_box, bar_index) // Update box to contain session highs and lows box.set_top(london_session_box, current_london_high) box.set_bottom(london_session_box, current_london_low) // Asian Session Swing Points Detection var float asian_session_high = na var float asian_session_low = na var int asian_high_bar = na var int asian_low_bar = na // Asian Session Absolute High/Low for TP levels var float asian_absolute_high = na var float asian_absolute_low = na var line asian_high_line = na var line asian_low_line = na var label asian_high_label = na var label asian_low_label = na var bool high_broken = false var bool low_broken = false // London Session High/Low tracking for stop loss var float london_session_high = na var float london_session_low = na // Market structure tracking variables var string breakout_direction = na // "bullish" or "bearish" var float last_hh_level = na // Last Higher High level var float last_hl_level = na // Last Higher Low level var float last_ll_level = na // Last Lower Low level var float last_lh_level = na // Last Lower High level var int structure_count = 0 var string last_structure_type = na // "HH", "HL", "LL", "LH" // Legacy variables for compatibility var float last_swing_high = na var float last_swing_low = na var int last_high_bar = na var int last_low_bar = na // Market structure state tracking var float pending_high = na var float pending_low = na var int pending_high_bar = na var int pending_low_bar = na var bool waiting_for_confirmation = false // Break of Structure tracking variables var float most_recent_hl = na var float most_recent_lh = na var int most_recent_hl_bar = na var int most_recent_lh_bar = na var bool bos_detected = false // Trading variables var bool trade_taken = false // Trade visualization boxes (based on Casper strategy approach) var box current_profit_box = na var box current_sl_box = na // Update swing points during Asian session if asian_active and show_swing_points // Always track absolute high/low for both TP levels and breakout detection if na(asian_absolute_high) or high > asian_absolute_high asian_absolute_high := high if na(asian_absolute_low) or low < asian_absolute_low asian_absolute_low := low // Use absolute high/low for breakout levels (simplified logic) if na(asian_session_high) or high > asian_session_high asian_session_high := high asian_high_bar := bar_index if na(asian_session_low) or low < asian_session_low asian_session_low := low asian_low_bar := bar_index // Track London session high/low for stop loss levels if london_active if na(london_session_high) or high > london_session_high london_session_high := high if na(london_session_low) or low < london_session_low london_session_low := low // Draw initial lines when Asian session ends if asian_end and show_swing_points if not na(asian_session_high) and not na(asian_high_bar) // Draw extending line for high asian_high_line := line.new(asian_high_bar, asian_session_high, bar_index + 200, asian_session_high, color=swing_high_color, width=2, style=line.style_dashed, extend=extend.right) asian_high_label := label.new(bar_index + 5, asian_session_high, "Asian High: " + str.tostring(asian_session_high, "#.####"), style=label.style_label_left, color=swing_high_color, textcolor=color.white, size=size.small) if not na(asian_session_low) and not na(asian_low_bar) // Draw extending line for low asian_low_line := line.new(asian_low_bar, asian_session_low, bar_index + 200, asian_session_low, color=swing_low_color, width=2, style=line.style_dashed, extend=extend.right) asian_low_label := label.new(bar_index + 5, asian_session_low, "Asian Low: " + str.tostring(asian_session_low, "#.####"), style=label.style_label_left, color=swing_low_color, textcolor=color.white, size=size.small) // Reset break flags for new session high_broken := false low_broken := false // Check for breakouts during London session if london_active and show_swing_points and not na(asian_session_high) and not na(asian_session_low) // Check if Asian high is broken if not high_broken and not low_broken and high > asian_session_high high_broken := true // Update high line to end at break point if not na(asian_high_line) line.set_x2(asian_high_line, bar_index) line.set_extend(asian_high_line, extend.none) // Remove the low line (first break wins) if not na(asian_low_line) line.delete(asian_low_line) if not na(asian_low_label) label.delete(asian_low_label) // Add break marker label.new(bar_index, asian_session_high * 1.001, "HIGH BREAK!", style=label.style_label_down, color=color.red, textcolor=color.white, size=size.normal) // Set breakout direction and initialize structure tracking breakout_direction := "bullish" last_swing_high := asian_session_high last_swing_low := asian_session_low last_high_bar := bar_index structure_count := 0 // Check if Asian low is broken if not low_broken and not high_broken and low < asian_session_low low_broken := true // Update low line to end at break point if not na(asian_low_line) line.set_x2(asian_low_line, bar_index) line.set_extend(asian_low_line, extend.none) // Remove the high line (first break wins) if not na(asian_high_line) line.delete(asian_high_line) if not na(asian_high_label) label.delete(asian_high_label) // Add break marker label.new(bar_index, asian_session_low * 0.999, "LOW BREAK!", style=label.style_label_up, color=color.red, textcolor=color.white, size=size.normal) // Set breakout direction and initialize structure tracking breakout_direction := "bearish" last_swing_high := asian_session_high last_swing_low := asian_session_low last_low_bar := bar_index structure_count := 0 // Stop extending lines when London session ends (if not already broken) if london_end and show_swing_points if not high_broken and not na(asian_high_line) line.set_x2(asian_high_line, bar_index) line.set_extend(asian_high_line, extend.none) if not low_broken and not na(asian_low_line) line.set_x2(asian_low_line, bar_index) line.set_extend(asian_low_line, extend.none) // Force close all trades at London session end (if enabled) if london_end and force_london_close if strategy.position_size != 0 // Extend boxes immediately before session close to prevent timing issues if not na(current_profit_box) // Ensure minimum 8 bars width or extend to current bar, whichever is longer box_left = box.get_left(current_profit_box) min_right = box_left + 8 final_right = math.max(min_right, bar_index) box.set_right(current_profit_box, final_right) current_profit_box := na // Clear reference after extending if not na(current_sl_box) // Ensure minimum 8 bars width or extend to current bar, whichever is longer box_left = box.get_left(current_sl_box) min_right = box_left + 8 final_right = math.max(min_right, bar_index) box.set_right(current_sl_box, final_right) current_sl_box := na // Clear reference after extending strategy.close_all(comment="London Close") trade_taken := false // Reset trade flag for next session // Market structure detection after breakout (only during London session and before first BoS) if show_market_structure and not na(breakout_direction) and london_active and not bos_detected // Bullish structure tracking (HH, HL alternating) if breakout_direction == "bullish" // Check for Higher High pattern: Bullish candle followed by bearish candle pattern_high = math.max(high , high) prev_hh = na(last_hh_level) ? last_swing_high : last_hh_level // HH Detection: Only if we expect HH next (no last structure or last was HL) if (na(last_structure_type) or last_structure_type == "HL") and close > open and close < open and pattern_high > prev_hh and close > prev_hh // Check consolidation is_too_close = not na(last_high_bar) and (bar_index - last_high_bar) <= 4 should_create_hh = true if is_too_close and structure_count > 0 and pattern_high <= last_hh_level should_create_hh := false if should_create_hh structure_count := structure_count + 1 label.new(bar_index - 1, high + (high * 0.0003), "HH" + str.tostring(structure_count), style=label.style_none, color=color.new(color.white, 100), textcolor=color.white, size=size.small) last_hh_level := pattern_high last_swing_high := pattern_high last_high_bar := bar_index last_structure_type := "HH" // HL Detection: Only if we expect HL next (last was HH) pattern_low = math.min(low , low) prev_hl = na(last_hl_level) ? last_swing_low : last_hl_level if last_structure_type == "HH" and close < open and close > open and pattern_low > prev_hl and close > prev_hl // Check consolidation is_too_close = not na(last_low_bar) and (bar_index - last_low_bar) <= 4 should_create_hl = true if is_too_close and pattern_low <= last_hl_level should_create_hl := false if should_create_hl structure_count := structure_count + 1 label.new(bar_index - 1, low - (low * 0.0003), "HL" + str.tostring(structure_count), style=label.style_none, color=color.new(color.white, 100), textcolor=color.white, size=size.small) last_hl_level := pattern_low most_recent_hl := pattern_low // Update most recent HL for BoS detection most_recent_hl_bar := bar_index - 1 // Store HL bar position last_low_bar := bar_index last_structure_type := "HL" // Bearish structure tracking (LL, LH alternating) if breakout_direction == "bearish" // Check for Lower Low pattern: Bearish candle followed by bullish candle pattern_low = math.min(low , low) prev_ll = na(last_ll_level) ? last_swing_low : last_ll_level // LL Detection: Only if we expect LL next (no last structure or last was LH) if (na(last_structure_type) or last_structure_type == "LH") and close < open and close > open and pattern_low < prev_ll and close < prev_ll // Check consolidation is_too_close = not na(last_low_bar) and (bar_index - last_low_bar) <= 4 should_create_ll = true if is_too_close and structure_count > 0 and pattern_low >= last_ll_level should_create_ll := false if should_create_ll structure_count := structure_count + 1 label.new(bar_index - 1, low - (low * 0.0003), "LL" + str.tostring(structure_count), style=label.style_none, color=color.new(color.white, 100), textcolor=color.white, size=size.small) last_ll_level := pattern_low last_swing_low := pattern_low last_low_bar := bar_index last_structure_type := "LL" // LH Detection: Only if we expect LH next (last was LL) pattern_high = math.max(high , high) prev_lh = na(last_lh_level) ? last_swing_high : last_lh_level if last_structure_type == "LL" and close > open and close < open and pattern_high < prev_lh and close < prev_lh // Check consolidation is_too_close = not na(last_high_bar) and (bar_index - last_high_bar) <= 4 should_create_lh = true if is_too_close and pattern_high >= last_lh_level should_create_lh := false if should_create_lh structure_count := structure_count + 1 label.new(bar_index - 1, high + (high * 0.0003), "LH" + str.tostring(structure_count), style=label.style_none, color=color.new(color.white, 100), textcolor=color.white, size=size.small) last_lh_level := pattern_high most_recent_lh := pattern_high // Update most recent LH for BoS detection most_recent_lh_bar := bar_index - 1 // Store LH bar position last_high_bar := bar_index last_structure_type := "LH" // Check if we're within the cutoff period before London session end current_minute = minute(time, session_timezone) london_end_time_minutes = london_end_hour * 60 // Convert London end hour to minutes current_time_minutes = current_hour * 60 + current_minute // Current time in minutes // Calculate minutes remaining in London session london_session_minutes_remaining = london_end_time_minutes - current_time_minutes // Handle day rollover case (e.g., if london_end is 8:00 (480 min) and current is 23:30 (1410 min)) if london_session_minutes_remaining < 0 london_session_minutes_remaining := london_session_minutes_remaining + (24 * 60) // Add 24 hours in minutes // Only allow trades if more than cutoff_minutes remaining in London session allow_new_trades = london_session_minutes_remaining > cutoff_minutes // Break of Structure (BoS) Detection and Trading Logic - Only first BoS per London session and outside cutoff period if show_bos and london_active and show_market_structure and not bos_detected and not trade_taken and allow_new_trades // Bullish BoS: Price closes below the most recent HL (after bullish breakout) - SELL SIGNAL if breakout_direction == "bullish" and not na(most_recent_hl) and not na(most_recent_hl_bar) // Check minimum distance requirement (at least 4 candles between BoS and HL) if close < most_recent_hl and (bar_index - most_recent_hl_bar) >= 4 // Draw dotted line from HL position to BoS point line.new(most_recent_hl_bar, most_recent_hl, bar_index, most_recent_hl, color=bos_color, width=2, style=line.style_dotted, extend=extend.none) // Calculate center position for BoS label center_bar = math.round((most_recent_hl_bar + bar_index) / 2) // Draw BoS label below the line for HL break label.new(center_bar, most_recent_hl - (most_recent_hl * 0.0005), "BoS", style=label.style_none, color=color.new(color.white, 100), textcolor=bos_color, size=size.normal) // SELL ENTRY if not na(london_session_high) and not na(asian_absolute_low) // Calculate stop loss based on settings stop_loss_level = use_atr_sl ? close + (atr * atr_multiplier) : london_session_high take_profit_level = asian_absolute_low entry_price = close // Calculate position size based on user settings position_size = calculate_position_size(entry_price, stop_loss_level) strategy.entry("SELL", strategy.short, qty=position_size, comment="BoS Sell") strategy.exit("SELL EXIT", "SELL", stop=stop_loss_level, limit=take_profit_level, comment="SL/TP") // Create trade visualization boxes (TradingView style) - minimum 8 bars width // Blue profit zone box (from entry to take profit) current_profit_box := box.new(left=bar_index, top=take_profit_level, right=bar_index + 8, bottom=entry_price, bgcolor=color.new(color.blue, 70), border_width=0) // Red stop loss zone box (from entry to stop loss) current_sl_box := box.new(left=bar_index, top=entry_price, right=bar_index + 8, bottom=stop_loss_level, bgcolor=color.new(color.red, 70), border_width=0) trade_taken := true bos_detected := true // Mark BoS as detected for this session // Bearish BoS: Price closes above the most recent LH (after bearish breakout) - BUY SIGNAL if breakout_direction == "bearish" and not na(most_recent_lh) and not na(most_recent_lh_bar) // Check minimum distance requirement (at least 4 candles between BoS and LH) if close > most_recent_lh and (bar_index - most_recent_lh_bar) >= 4 // Draw dotted line from LH position to BoS point line.new(most_recent_lh_bar, most_recent_lh, bar_index, most_recent_lh, color=bos_color, width=1, style=line.style_dotted, extend=extend.none) // Calculate center position for BoS label center_bar = math.round((most_recent_lh_bar + bar_index) / 2) // Draw BoS label above the line for LH break label.new(center_bar, most_recent_lh + (most_recent_lh * 0.0005), "BoS", style=label.style_none, color=color.new(color.white, 100), textcolor=bos_color, size=size.normal) // BUY ENTRY if not na(london_session_low) and not na(asian_absolute_high) // Calculate stop loss based on settings stop_loss_level = use_atr_sl ? close - (atr * atr_multiplier) : london_session_low take_profit_level = asian_absolute_high entry_price = close // Calculate position size based on user settings position_size = calculate_position_size(entry_price, stop_loss_level) strategy.entry("BUY", strategy.long, qty=position_size, comment="BoS Buy") strategy.exit("BUY EXIT", "BUY", stop=stop_loss_level, limit=take_profit_level, comment="SL/TP") // Create trade visualization boxes (TradingView style) - minimum 8 bars width // Blue profit zone box (from entry to take profit) current_profit_box := box.new(left=bar_index, top=entry_price, right=bar_index + 8, bottom=take_profit_level, bgcolor=color.new(color.blue, 70), border_width=0) // Red stop loss zone box (from entry to stop loss) current_sl_box := box.new(left=bar_index, top=stop_loss_level, right=bar_index + 8, bottom=entry_price, bgcolor=color.new(color.red, 70), border_width=0) trade_taken := true bos_detected := true // Mark BoS as detected for this session // Position close detection for extending boxes (based on Casper strategy) if barstate.isconfirmed and strategy.position_size == 0 and strategy.position_size != 0 // Extend trade visualization boxes to exact exit point when position closes if not na(current_profit_box) // Ensure minimum 8 bars width or extend to current bar, whichever is longer box_left = box.get_left(current_profit_box) min_right = box_left + 8 final_right = math.max(min_right, bar_index) box.set_right(current_profit_box, final_right) current_profit_box := na // Clear reference after extending if not na(current_sl_box) // Ensure minimum 8 bars width or extend to current bar, whichever is longer box_left = box.get_left(current_sl_box) min_right = box_left + 8 final_right = math.max(min_right, bar_index) box.set_right(current_sl_box, final_right) current_sl_box := na // Clear reference after extending // Backup safety check - extend boxes if position is closed but boxes still active if not na(current_profit_box) and strategy.position_size == 0 box_left = box.get_left(current_profit_box) min_right = box_left + 8 final_right = math.max(min_right, bar_index) box.set_right(current_profit_box, final_right) current_profit_box := na if not na(current_sl_box) and strategy.position_size == 0 box_left = box.get_left(current_sl_box) min_right = box_left + 8 final_right = math.max(min_right, bar_index) box.set_right(current_sl_box, final_right) current_sl_box := na // Reset everything when new Asian session starts if asian_start and show_swing_points asian_session_high := na asian_session_low := na asian_high_bar := na asian_low_bar := na // Reset absolute levels asian_absolute_high := na asian_absolute_low := na asian_high_line := na asian_low_line := na asian_high_label := na asian_low_label := na high_broken := false low_broken := false // Reset London session levels london_session_high := na london_session_low := na // Reset market structure tracking breakout_direction := na last_hh_level := na last_hl_level := na last_ll_level := na last_lh_level := na last_swing_high := na last_swing_low := na last_high_bar := na last_low_bar := na structure_count := 0 last_structure_type := na pending_high := na pending_low := na pending_high_bar := na pending_low_bar := na waiting_for_confirmation := false // Reset BoS tracking most_recent_hl := na most_recent_lh := na most_recent_hl_bar := na most_recent_lh_bar := na bos_detected := false // Reset trading trade_taken := false // Reset current trade boxes current_profit_box := na current_sl_box := na // Debug info (optional) show_debug = input.bool(false, "Show Debug Info") if show_debug var table debug_table = table.new(position.top_right, 2, 3, bgcolor=color.white, border_width=1) if barstate.islast table.cell(debug_table, 0, 0, "Current Hour:", text_color=color.black) table.cell(debug_table, 1, 0, str.tostring(current_hour), text_color=color.black) table.cell(debug_table, 0, 1, "Asian Active:", text_color=color.black) table.cell(debug_table, 1, 1, str.tostring((current_hour >= asian_start_hour) or (current_hour < asian_end_hour)), text_color=color.black) table.cell(debug_table, 0, 2, "London Active:", text_color=color.black) table.cell(debug_table, 1, 2, str.tostring((current_hour >= london_start_hour) and (current_hour < london_end_hour)), text_color=color.black)
Pine Script® strategy
by Elliodoh
XAUUSD lucky trendThis version introduces a strict midline filter to keep signals trend-aligned without revealing any specific settings. Long signals are permitted only when price is clearly established on the bullish side of the midline for the entire candle, so brief dips through the line are ignored. Short signals are permitted only when price is clearly established on the bearish side of the midline for the entire candle, so brief spikes through the line are ignored. This helps avoid whipsaws around the midline and reduces counter-trend entries, especially during choppy transitions. All other components of the indicator remain unchanged: the original signal logic, quality filters, and frequency controls still determine when a setup is valid. The result is fewer but cleaner prompts that better reflect sustained directional bias rather than temporary noise around the midline.
Pine Script® indicator
by xuziyu409
VWAP Suite (Updated 3W + Long Term)VWAP Suite (Updated 3W + Long Term)VWAP Suite (Updated 3W + Long Term)VWAP Suite (Updated 3W + Long Term)VWAP Suite (Updated 3W + Long Term)VWAP Suite (Updated 3W + Long Term)VWAP Suite (Updated 3W + Long Term)VWAP Suite (Updated 3W + Long Term)VWAP Suite (Updated 3W + Long Term)VWAP Suite (Updated 3W + Long Term)VWAP Suite (Updated 3W + Long Term)VWAP Suite (Updated 3W + Long Term)VWAP Suite (Updated 3W + Long Term)VWAP Suite (Updated 3W + Long Term)VWAP Suite (Updated 3W + Long Term)VWAP Suite (Updated 3W + Long Term)VWAP Suite (Updated 3W + Long Term)v
Pine Script® indicator
by ldraco
23:00 London 15m -> Asia Close (No colors)//@version=5 indicator("23:00 London 15m -> Asia Close (No colors)", overlay=true, max_lines_count=50, max_labels_count=50) tz = "Europe/London" // set Asia close in London time asiaCloseHour = input.int(6, "Asia close hour (London)", minval=0, maxval=23) asiaCloseMin = input.int(0, "Asia close minute", minval=0, maxval=59) is15 = timeframe.period == "15" is2300 = hour(time, tz) == 23 and minute(time, tz) == 0 cond = is15 and is2300 var line hiLine = na var line loLine = na var label info = na f_asiaCloseTs(_t) => y = year(_t, tz) m = month(_t, tz) d = dayofmonth(_t, tz) closeToday = timestamp(tz, y, m, d, asiaCloseHour, asiaCloseMin) closeNext = timestamp(tz, y, m, d + 1, asiaCloseHour, asiaCloseMin) _t >= closeToday ? closeNext : closeToday if cond hi = high lo = low endTs = f_asiaCloseTs(time) if not na(hiLine) line.delete(hiLine) if not na(loLine) line.delete(loLine) if not na(info) label.delete(info) // High line hiLine := line.new(time, hi, endTs, hi, xloc=xloc.bar_time, extend=extend.none, width=2) // Low line loLine := line.new(time, lo, endTs, lo, xloc=xloc.bar_time, extend=extend.none, width=2) // Label with exact values info := label.new(endTs, hi, xloc=xloc.bar_time, text="23:00 London (15m) High: " + str.tostring(hi, format.mintick) + " Low: " + str.tostring(lo, format.mintick), style=label.style_label_left)
Pine Script® indicator
by danevsb
Momentum Ghost MachineTrend Strength + Momentum Ghost Machine: The Complete Velocity System Two powerful engines, one chart. This indicator fuses a robust Trend Strength Oscillator with the modern, noise-canceling "Momentum Ghost Machine" to give you a complete picture of market direction and hidden velocity in a single pane. Stop guessing if the move is real. See the Trend (Background) and feel the Speed (Ghost Line) simultaneously. 🔥 CORE FEATURES 1. The Trend Strength Oscillator (Background Engine) The background histogram is a dedicated engine that measures the pure strength and direction of the current trend. Green Zones (Above 0): Indicate Bulls are in control and the trend is rising. Red Zones (Below 0): Indicate Bears are in control and the trend is falling. Smart Smoothing: Includes a built-in JMA (Jurik Moving Average) smoother to filter out market noise and prevent false signals during choppy conditions. 2. Momentum Ghost Machine (The Velocity Engine) A highly responsive momentum oscillator designed to detect shifts in market speed before price turns. 4-State Color System: Dark Green: Strong Upside Acceleration (The "Go" Signal). Light Green: Upside Deceleration (Momentum fading, prepare for a pause). Dark Red: Strong Downside Acceleration (The "Drop" Signal). Light Red: Downside Deceleration (Selling pressure fading, prepare for a bounce). 3. Signal Line Crossovers The Ghost Machine includes a fast-reacting Signal Line (Orange). Cross Above: Bullish momentum injection. Cross Below: Bearish momentum injection. 🚀 HOW TO USE For Trend Trading: Wait for the Trend Background to turn Green. Confirm entry when the Ghost Machine Line crosses above its orange signal line and turns Dark Green. For Reversals: Look for Divergence: If price makes a higher high but the Ghost Machine makes a lower high (Light Green), momentum is exhausted. Wait for the Ghost Machine to turn Red and cross below the signal line for a high-probability short. For Exits: If you are Long (Dark Green) and the bar turns Light Green, momentum is slowing. This is your warning to tighten stops or take profit. ⚙️ SETTINGS & CUSTOMIZATION Trend Settings: Adjust length and smoothing type (JMA, EMA, SMA, etc.) to match your trading style. Ghost Machine: Fine-tune momentum sensitivity and post-smoothing to fit your specific asset (Crypto, Forex, or Indices). Visuals: Fully customizable colors for every state of the trend and momentum. "Trend is direction. Momentum is fuel. This tool tracks both."
Pine Script® indicator
by DarwinIsidro
mua HARSI RSI Shadow Strategy M1 (Fixed)HARSI – Heikin Ashi RSI Shadow Indicator HARSI (Heikin Ashi RSI Shadow) is a momentum-based oscillator that combines the concept of Heikin Ashi smoothing with the Relative Strength Index (RSI) to reduce market noise and highlight short-term trend strength. Instead of plotting traditional price candles, HARSI transforms RSI values into a zero-centered oscillator (RSI − 50), allowing traders to clearly identify bullish and bearish momentum around the median line. The smoothing mechanism inspired by Heikin Ashi candles helps filter out false signals, making the indicator especially effective on lower timeframes such as M1. The RSI Shadow reacts quickly to momentum shifts while maintaining smooth transitions, which makes it suitable for scalping and intraday trading. Key threshold levels (such as ±20 and ±30) can be used to detect momentum expansion, exhaustion, and potential continuation setups. HARSI works best in liquid markets and can be used as a standalone momentum indicator or combined with trend filters such as moving averages or VWAP for higher-probability trades. Key Features: Zero-centered RSI oscillator (RSI − 50) Heikin Ashi–style smoothing to reduce noise Clear momentum-based entry signals Optimized for lower timeframes (M1 scalping) Suitable for both Spot and Futures trading
Pine Script® strategy
by RumeryWise0288
TWR of Bill WilliamsThis indicator was taken from the book “Trading Chaos Pt 1” by Bill Williams. TWR contains 3 Moving Averages Ripple - MA with 5 bars length Wave - MA with 13 bars length Tide - MA with 34 bars length According to Bill Williams, you should take only a long position if the Ripple(5 bars length) is higher than Wave(13) and Tide(34). Also, you should take only a short position, if the Ripple (the fastest MA) is lower than Wave MA and Tide MA(slowest MA). This indicator is also used if you want to fill in the Profitunity Trading Partner table.
Pine Script® indicator
by vildstein
VSA Effort Result v1.0VSA Effort vs Result by StupidRich Detects volume-spread divergence: - "Er": High volume, narrow spread (absorption) - "eR": Low volume, wide spread (momentum) Features: • Clean text labels (customizable size) • Wide vertical lines matching candle range • Adjustable thresholds & volume SMA • Works on all timeframes/assets Perfect for spotting institutional absorption at key levels. if u wanna buy me a coffee, just dm @stupidrichboy on Telegram hope it help
Pine Script® indicator
by dchu3112
Buy Sell Signal Pro New (iqraa888)Buy Sell Signal Pro New • by iqraa888 This indicator generates BUY/SELL signals based on EMA trend change and includes ATR-based risk management levels. Key Features Trend logic: Fast EMA vs Slow EMA (trend flip detection) Optional candle confirmation (bullish candle for BUY / bearish candle for SELL) Automatic SL/TP using ATR with configurable Risk:Reward Intermediate target levels (TP1, TP2, …) and final TP Right-side TP number boxes beside each target line Yellow diamond shows invalidation when an opposite signal appears while in a position Alerts: BUY, SELL, TP hit, SL hit, Invalidation Notes Designed for intraday timeframes (15/30/45 min). Not financial advice. Always backtest and manage risk.
Pine Script® indicator
by iqraa888
Multi-indicator Signal Builder [Skyrexio]Overview Multi-Indicator Signal Builder is a versatile, all-in-one script designed to streamline your trading workflow by combining multiple popular technical indicators under a single roof. It features a single-entry, single-exit logic, intrabar stop-loss/take-profit handling, an optional time filter, a visually accessible condition table, and a built-in statistics label. Traders can choose any combination of 12+ indicators (RSI, Ultimate Oscillator, Bollinger %B, Moving Averages, ADX, Stochastic, MACD, PSAR, MFI, CCI, Heikin Ashi, and a “TV Screener” placeholder) to form entry or exit conditions. This script aims to simplify strategy creation and analysis , making it a powerful toolkit for technical traders. Indicators Overview RSI (Relative Strength Index) Measures recent price changes to evaluate overbought or oversold conditions on a 0–100 scale. Ultimate Oscillator (UO) Uses weighted averages of three different timeframes, aiming to confirm price momentum while avoiding false divergences. Bollinger %B Expresses price relative to Bollinger Bands, indicating whether price is near the upper band (overbought) or lower band (oversold). Moving Average (MA) Smooths price data over a specified period. The script supports both SMA and EMA to help identify trend direction and potential crossovers. ADX (Average Directional Index) Gauges the strength of a trend (0–100). Higher ADX signals stronger momentum, while lower ADX indicates a weaker trend. Stochastic Compares a closing price to a price range over a given period to identify momentum shifts and potential reversals. MACD (Moving Average Convergence/Divergence) Tracks the difference between two EMAs plus a signal line, commonly used to spot momentum flips through crossovers. PSAR (Parabolic SAR) Plots a trailing stop-and-reverse dot that moves with the trend. Often used to signal potential reversals when price crosses PSAR. MFI (Money Flow Index) Similar to RSI but incorporates volume data. A reading above 80 can suggest overbought conditions, while below 20 may indicate oversold. CCI (Commodity Channel Index) Identifies cyclical trends or overbought/oversold levels by comparing current price to an average price over a set timeframe. Heikin Ashi A type of candlestick charting that filters out market noise. The script uses a streak-based approach (multiple consecutive bullish or bearish bars) to gauge mini-trends. TV Screener A placeholder condition designed to integrate external buy/sell logic (like a TradingView “Buy” or “Sell” rating). Users can override or reference external signals if desired. Unique Features Multi-Indicator Entry and Exit You can selectively enable any subset of 12+ classic indicators, each with customizable parameters and conditions. A position opens only if all enabled entry conditions are met, and it closes only when all enabled exit conditions are satisfied, helping reduce false triggers. Single-Entry / Single-Exit with Intrabar SL/TP The script supports a single position at a time. Once a position is open, it monitors intrabar to see if the price hits your stop-loss or take-profit levels before the bar closes, making results more realistic for fast-moving markets. Time Window Filter Users may specify a start/end date range during which trades are allowed, making it convenient to focus on specific market cycles for backtesting or live trading. Condition Table and Statistics A table at the bottom of the chart lists all active entry/exit indicators. Upon each closed trade, an integrated statistics label displays net profit, total trades, win/loss count, average and median PnL, etc. Seamless Alerts and Automation • Configure alerts in TradingView using “Any alert() function call.” • The script sends JSON alert messages you can route to your own webhook. • The indicator can be integrated with Skyrexio alert bots to automate execution on major cryptocurrency exchanges. Optional MA/PSAR Plots For added visual clarity, optionally plot the chosen moving averages or PSAR on the chart to confirm signals without stacking multiple indicators. Methodology Multi-Indicator Entry Logic When multiple entry indicators are enabled (e.g., RSI + Stochastic + MACD), the script requires all signals to align before generating an entry. Each indicator can be set for crossovers, crossunders, thresholds (above/below), etc. This “AND” logic aims to filter out low-confidence triggers. Single-Entry Intrabar SL/TP • One Position At a Time: Once an entry signal triggers, a trade opens at the bar’s close. • Intrabar Checks: Stop-loss and take-profit levels (if enabled) are monitored on every tick. If either is reached, the position closes immediately, without waiting for the bar to end. Exit Logic All Conditions Must Agree: If the trade is still open (SL/TP not triggered), then all enabled exit indicators must confirm a closure before the script exits on the bar’s close. Time Filter Optional Trading Window: You can activate a date/time range to constrain entries and exits strictly to that interval. Justification of Methodology Indicator Confluence: Combining multiple tools (RSI, MACD, etc.) can reduce noise and false signals. Intrabar SL/TP: Capturing real-time spikes or dips provides a more precise reflection of typical live trading scenarios. Single-Entry Model: Straightforward for both manual and automated tracking (especially important in bridging to bots). Custom Date Range: Helps refine backtesting for specific market conditions or to avoid known irregular data periods. How to Use Add the Script to Your Chart • In TradingView, open Indicators , search for “Multi-indicator Signal Builder” . • Click to add it to your chart. Configure Inputs • Time Filter: Set a start and end date for trades. • Alerts Messages: Input any JSON or text payload needed by your external service or bot. • Entry Conditions: Enable and configure any indicators (e.g., RSI, MACD) for a confluence-based entry. • Close Conditions: Enable exit indicators, along with optional SL (negative %) and TP (positive %) levels. Set Up Alerts • In TradingView, select “Create Alert” → Condition = “Any alert() function call” → choose this script. • Entry Alert: Triggers on the script’s entry signal. • Close Alert: Triggers on the script’s close signal (or if SL/TP is hit). • Skyrexio Alert Bots: You can route these alerts via webhook to Skyrexio alert bots to automate order execution on major crypto exchanges (or any other supported broker). Visual Reference • A condition table at the bottom summarizes active signals. • Statistics Label updates automatically as trades are closed, showing PnL stats and distribution metrics. Backtesting Guidelines Symbol/Timeframe: Works on multiple assets and timeframes; always do thorough testing. Realistic Costs: Adjust commissions and potential slippage to match typical exchange conditions. Risk Management: If using the built-in stop-loss/take-profit, set percentages that reflect your personal risk tolerance. Longer Test Horizons: Verify performance across diverse market cycles to gauge reliability. Example of statistic calculation Test Period: 2023-01-01 to 2025-12-31 Initial Capital: $1,000 Commission: 0.1%, Slippage ~5 ticks Trade Count: 680 (varies by strategy conditions) Win rate: 75.44% (varies by strategy conditions) Net Profit: +90.14% (varies by strategy conditions) Disclaimer This indicator is provided strictly for informational and educational purposes. It does not constitute financial or trading advice. Past performance never guarantees future results. Always test thoroughly in demo environments before using real capital. Enjoy exploring the Multi-Indicator Signal Builder! Experiment with different indicator combinations and adjust parameters to align with your trading preferences, whether you trade manually or link your alerts to external automation services. Happy trading and stay safe!
Pine Script® indicator
by Skyrexio
AMT VWAP [hardi]█ OVERVIEW AMT VWAP is a clean, minimalist VWAP indicator with Standard Deviation bands, designed to complement the Auction Market Theory (AMT) trading methodology by Fabio Valentino. This indicator focuses on one thing and does it well: displaying VWAP and its deviation bands clearly on your chart. █ FEATURES - Daily VWAP with automatic reset - ±1 Standard Deviation bands (cyan) - ±2 Standard Deviation bands (orange) - extreme zones - Clean labels that don't clutter your chart - Info table showing current bias and zone - Compact Mode for mobile/smartphone users - Fully customizable colors and settings - Built-in alerts for all levels █ HOW TO USE VWAP (Volume Weighted Average Price) represents the "fair value" where most volume has transacted. In AMT methodology: BIAS DETERMINATION: - Price ABOVE VWAP = Bullish bias (buyers in control) - Price BELOW VWAP = Bearish bias (sellers in control) TRADING ZONES: - ±1 SD: Normal deviation zone - potential mean reversion area - ±2 SD: Extreme zone - high probability reversal area (95%+ reversion rate) ENTRY STRATEGIES: 1. Trend Following: Buy pullbacks to VWAP in uptrend, sell rallies to VWAP in downtrend 2. Mean Reversion: Fade moves at ±2 SD bands with confirmation █ RECOMMENDED SETUP Use this indicator together with: - TradingView's built-in "SVP HD" (Session Volume Profile) for POC/VAH/VAL levels - AMT CVD indicator (companion indicator) for order flow analysis This combination gives you the complete AMT toolkit: - SVP HD → Key levels (POC, VAH, VAL) - AMT VWAP → Dynamic support/resistance & bias - AMT CVD → Aggression, Absorption, Exhaustion signals █ SETTINGS Display Settings: - Compact Mode - Enable for cleaner mobile view - Show Labels - Toggle level labels - Label Size - Adjust for your screen VWAP Settings: - Band Multipliers - Adjust SD band distance (default: 1.0 and 2.0) - Colors - Fully customizable - Line widths - Adjust visibility Alerts: - Near VWAP - Near ±1 SD - Near ±2 SD (extreme zones) █ METHODOLOGY This indicator is based on Auction Market Theory as taught by Fabio Valentino: "The market is a continuous auction seeking fair value. VWAP represents this fair value dynamically throughout the session. Deviations from VWAP create trading opportunities as price tends to revert to the mean." Key principles: - Read, don't predict - Location over technique - Evidence-based entries █ ALERTS Set alerts for: - Price approaching VWAP (potential support/resistance) - Price at ±1 SD (first deviation - watch for reaction) - Price at ±2 SD (extreme - high probability reversal zone) █ NOTES - Works on all timeframes - Best used on 15m for intraday entries - VWAP resets daily at market open - Combine with volume profile for best results █ CREDITS Based on Auction Market Theory methodology by Fabio Valentino. Indicator developed for the trading community. If you find this useful, please leave a like! 👍 vwap, volume-weighted-average-price, standard-deviation, bands, auction-market-theory, amt, fabio-valentino, mean-reversion, trend-following, intraday, day-trading, support-resistance, fair-value
Pine Script® indicator
by hardimans351