Get started

Pine utilities

Chartlense Dashboard (Data, Trend & Levels)Chartlense Dashboard (Data, Trend & Levels) Overview The Chartlense Dashboard is a compact overlay that consolidates key data points from multiple indicators into a single, clean table on your chart. Its primary function is to reduce indicator clutter and provide essential, at-a-glance information about the current market conditions. This dashboard is designed for traders who want a clear and organized view of the key data without having to load and manage numerous separate indicators. chartlense.com Key Features & Functionality 📊 Consolidated Data Panel: Displays real-time values from essential indicators, including RSI, MACD, and multiple EMAs. This saves screen space and simplifies your analysis workflow. 🎯 Automatic Key Levels: The script automatically identifies and displays the nearest important support and resistance levels, adapting as the price moves. 📐 Flexible Layouts (Vertical & Horizontal): Choose the layout that best fits your workspace. Dock the dashboard vertically to the left of your chart or arrange it horizontally along the bottom via the settings menu. ✨ Minimalist Design: Engineered for maximum information with a minimal footprint to keep your main chart area clean and readable. ⚙️ Fully Customizable: Users can show or hide any data point. This allows you to tailor the dashboard to display only the information relevant to your specific trading strategy. How to Use Click 'Add to favorite indicators'. Open any chart and add the "Chartlense Dashboard" from your favorite indicators list. Customize the displayed data in the Settings (⚙️) to fit your needs. vertical layout (left of chart) horizontal layout (bottom of chart) The Next Step in Your Analysis 🚀 About This Indicator & ChartLense This dashboard is a free, stand-alone tool provided by ChartLense. It is designed to work alongside our primary product, the ChartLense Chrome Extension. The purpose of this indicator is to provide a clean overview of market data. The purpose of the Chrome Extension is to perform a comprehensive analysis of the chart's structure. It identifies specific trading setups, calculates a risk score, and suggests precise entry and exit levels. If you find this dashboard useful for organizing data, you may find the extension useful for a more in-depth analysis. You can learn more at chartlense.com Disclaimer: This script is for informational purposes only and does not constitute investment advice. Always make your trading decisions based on your own analysis and risk assessment.
Pine Script® indicator
by ChartLense
Multi-Timeframe Crypto Market Trend Detector — Bull, Bear, or NeThis indicator is designed to help traders quickly identify whether the crypto market is in a Bullish, Bearish, or Neutral phase by combining trend analysis across multiple timeframes. 📊 How it works: Uses 200-period SMA as the primary trend reference. Evaluates Weekly (1W) and Daily (1D) trends separately. Confirms the trend direction with RSI and an optional Fear & Greed Index value. Shows a color-coded table on the chart for quick visual identification of the market phase. ✅ Trend logic: Bullish = Price above SMA200 + RSI > 50 or Fear & Greed > 50 Bearish = Price below SMA200 + RSI < 50 or Fear & Greed < 50 Otherwise → Neutral 🛠 Features: Dual timeframe analysis (1W macro trend + 1D current trend) Clean visual table in the top-right corner Supports manual input of the Fear & Greed Index (update daily from alternative.me) Works on any crypto pair, including BTC, ETH, and altcoins ⚡ Use case: Align your trades with the macro and daily trends. If both timeframes point in the same direction, signals have higher probability. Tip: Use this tool alongside volume analysis and support/resistance levels for better accuracy. 👌 If you find this script useful, don’t forget to give it a 👍 and add it to your favorites!
Pine Script® indicator
by CryptoAle992
Intelligent Currency Breakout ChannelIndicator: Intelligent Currency Breakout Channel This document provides a detailed explanation of the "Intelligent Currency Breakout Channel" indicator for TradingView. 1. Overview The Intelligent Currency Breakout Channel is an advanced technical analysis tool designed to identify periods of price consolidation and signal potential breakouts. It automatically draws channels around ranging price action and utilizes sophisticated volume analysis to provide deeper insights into market sentiment. The indicator also includes a built-in logarithmic regression screener to help traders align their breakout signals with the broader market trend. 2. Key Features Automatic Channel Detection: The indicator identifies periods of low volatility and automatically draws a containing channel (box) around the price action. Breakout Signals: It generates clear visual alerts (▲ for bullish, ▼ for bearish) when the price closes decisively outside of a channel. In-Depth Volume Analysis: Within each channel, the indicator plots volume as candlestick-like bars, offering three distinct modes: Total Volume, Buy/Sell Comparison, and Volume Delta. This helps traders gauge the strength and conviction behind price movements. Real-time Sentiment Gauge: When a channel is active, a dynamic color-graded gauge appears on the right side of the chart. It visualizes the current volume delta momentum relative to its recent range, offering an at-a-glance sentiment reading. Integrated Trend Screener: A secondary analysis tool based on logarithmic regression is included to determine the underlying trend direction (Up, Down, or Neutral), which can be used to filter breakout signals. Fully Customizable: Users can extensively customize all parameters, from calculation lengths and breakout sensitivity to the visual appearance of every component. 3. How to Use Channel Formation: Watch for the indicator to draw a new channel. This signifies that the market is in a consolidation or ranging phase. The formation of a channel itself can be an alertable event. Volume Interpretation: Observe the volume bars inside the channel. An increase in volume as the price approaches the channel's upper or lower boundary can foreshadow a potential breakout. Use the Volume Display Mode to analyze if buying pressure (Comparison, Delta) or selling pressure is building. Breakout Confirmation: A bullish breakout signal (▲) appears when the price closes above the channel's upper boundary. A bearish breakout signal (▼) appears when the price closes below the lower boundary. For higher-quality signals, enable the Strong Closes Only option. Trend Confirmation (Screener): Use the screener's plot and background color to confirm the broader trend. For instance, you might choose to only take bullish breakout signals when the screener indicates an uptrend (green background) and bearish signals when it indicates a downtrend (red background). Sentiment Gauge: The pointer on the gauge indicates current momentum. A pointer in the upper (green) section suggests bullish pressure, while a pointer in the lower (red) section suggests bearish pressure. This can provide additional confluence for a trade decision. 4. Settings and Inputs Main Settings Overlap Channels: If enabled, allows multiple channels to be drawn on the chart simultaneously, even if they overlap. When disabled, a new channel will only form if it doesn't intersect with an existing one. Strong Closes Only: If enabled, a breakout is only triggered if the midpoint of the candle's body (average of open and close) is outside the channel. This helps filter out false signals caused by long wicks. If disabled, any close outside the channel triggers a breakout. Normalization Length: The lookback period (in bars) used for price normalization. A higher value creates a more stable normalization but may be slower to react to recent price changes. Box Detection Length: The lookback period used to detect the channel formation pattern. A lower value will result in more frequent channels but may be more sensitive to noise. A higher value will result in fewer, but potentially more significant, channels. Volume Analysis Show Volume Analysis: Toggles the visibility of the candlestick-like volume bars inside the channel. Volume Display Mode: Volume: Displays total volume as symmetrical bars around the channel's midline. Comparison: Shows buying volume (green) above the midline and selling volume (red) below it. Delta: Shows the net difference between buying and selling volume. Positive delta is shown above the midline, and negative delta is shown below. Volume Delta Timeframe Source: The timeframe from which to source volume data for calculations. Using a lower timeframe can provide a more granular view of volume dynamics. Volume Scaling: A multiplier that adjusts the vertical size of the volume bars relative to the channel's height. Appearance Volume Text Size: Sets the size of the volume data text displayed in the corners of the channel. Options: Tiny, Small, Medium, Large. Bullish Color: The primary color for all bullish visual elements, including breakout signals and positive volume bars. Bearish Color: The primary color for all bearish visual elements, including breakout signals and negative volume bars. Screener Settings Lookback Period: The number of bars used for the logarithmic regression calculation to determine the trend. Screener Type: Log Regression Channel: The signal is based on the slope of the entire regression channel over the lookback period. An upward sloping channel is bullish (1), and a downward sloping one is bearish (-1). Logarithmic Regression: The signal is based on the most recent value of the regression line compared to its value 3 bars ago. This provides a more responsive measure of the immediate trend. 5. Alerts You can set up the following alerts through the TradingView alerts panel: New Channel Formed: Triggers when a new price consolidation channel is detected and drawn on the chart. Bullish Breakout: Triggers when the price breaks out and closes above the upper boundary of a channel. Bearish Breakout: Triggers when the price breaks out and closes below the lower boundary of a channel. Is In Channel: Triggers on every bar that the price is currently trading inside an active channel. Signal UP: Triggers when the Screener's signal turns bullish (1). Signal DOWN: Triggers when the Screener's signal turns bearish (-1).
Pine Script® indicator
by imtpcsuva
FXSArbitrage Spread (Custom Start Time) This indicator analyzes the spread and correlation between two selected instruments or currency pairs. Key Features: Displays the percentage change of the two instruments in a separate chart (does not overlay the main chart). Lines show the entire historical price movement of the selected instruments. Calculates the current spread and correlation from a chosen date and time (default — last Monday 00:00). Spread and corr values are rounded to two decimal places for convenience. The top-right table displays: corr — correlation coefficient between the instruments, spread — current spread between the pairs, Average max deviation for the period — manual input, Maximum deviation for the entire period — manual input. The top-left table shows the color of each pair for clarity. Alerts can be set for specific corr and spread values. Features: Historical lines allow visual tracking of dynamics over the entire available period. Current spread is calculated separately from the selected start time, allowing analysis of current conditions without affecting historical visualization. Fully customizable: line colors, calculation period, start date/time for spread, manual statistical data.
Pine Script® indicator
by esnk23
AInfluence Manual Data Input Utility Indicator V101AInfluence (Manual Data Input Utility Indicator) V101 Overview This utility indicator enables you to plot an external data series directly on your TradingView chart. It is designed for users who want to correlate custom datasets, such as sentiment analysis, economic data, or other external metrics, with price action. Instructions 1. Add the indicator to your chart. 2. Go into the indicator's "Settings" panel. 3. Paste your pre-formatted data into the text input field. Data Formatting Rules The script requires a specific format for each data point, which consists of a numerical value and a timestamp • Structure: Each data point must be on a new line. • Limit: You can paste a maximum of 146 records. Example Data: 93.1562,2025-09-06 00:59:11 94.9062,2025-09-06 01:59:21 93.4062,2025-09-06 02:59:18 95.2188,2025-09-06 03:59:31 93.4062,2025-09-06 04:59:21 91.4583,2025-09-06 05:58:51 93.7812,2025-09-06 06:59:17 The source code for this indicator is open and accessible.
Pine Script® indicator
by theoversighter
Custom Trade Checklist by [YSFX]# Custom Trade Checklist: Your On-Chart Trading Co-Pilot ## Overview Ever taken a trade based on impulse, only to realize you forgot a key step in your analysis? The Custom Trade Checklist is a simple yet powerful on-chart utility designed to help you remain disciplined and consistent with your trading strategy. By externalizing your trading plan into a visible, interactive checklist, you can reduce emotional decision-making and systematically verify your criteria before entering or exiting a trade. This tool acts as your personal co-pilot, ensuring you follow your rules on every single trade. ## Key Features ✅ Fully Customizable Rules: Define up to 10 unique checklist items tailored to your specific trading strategy. Examples include "Market Structure Aligned?", "RSI Oversold?", "News Events Checked?", or "Risk/Reward > 2:1?". ⚪ Dynamic Status Tracking: Use a simple dropdown menu in the settings to mark each rule with intuitive symbols like: ✅ / ✓ - Completed / True ❌ / ✕ - Failed / False 🟡 - Pending / Caution ⚪ - Neutral / Not Checked And many more for complete flexibility. 📋 Clean & Minimalist Display: The checklist is presented in a clean, unobtrusive table that can be positioned in any corner of your chart, ensuring it provides guidance without cluttering your analysis. ⚙️ Flexible Configuration: Choose the maximum number of entries to display. Optionally hide disabled checklist items to keep your view focused on what's active. Customize the table title to match your strategy (e.g., "Pre-Trade Checklist", "Swing Trade Rules"). 🎨 Complete Color Control: Personalize every aspect of the table's appearance. You can independently set the colors for the title, text, background, border, and each individual status symbol to perfectly match your chart's theme. ## How to Use Add the Indicator to your chart. Open the Settings Panel by clicking the gear icon (⚙️) on the indicator. Define Your Rules: Go through Entry 1 to Entry 10. For each rule you want to use, check the box to enable it. In the text field, write your rule (e.g., "Price above 200 EMA"). Update Your Status: Before placing a trade, go back into the settings and update the status dropdown for each rule based on your analysis. Customize Appearance: Under the "General" tab, change the table title and position. Under the "Colors" tab, adjust the colors to your liking. ## Who Is This For? This tool is perfect for: Discretionary Traders who need to enforce a consistent set of rules. New Traders looking to build good habits and internalize their trading plan. Systematic Traders who want a final pre-flight check before executing a trade. Anyone working on improving their trading psychology and reducing impulsive actions. This indicator does not generate signals or trading advice; it is a utility to support the trader's own process and discipline. We hope it helps you achieve greater consistency in your trading journey!
Pine Script® indicator
by YunusSFx
Bar Index & TimeLibrary to convert a bar index to a timestamp and vice versa. Utilizes runtime memory to store the 𝚝𝚒𝚖𝚎 and 𝚝𝚒𝚖𝚎_𝚌𝚕𝚘𝚜𝚎 values of every bar on the chart (and optional future bars), with the ability of storing additional custom values for every chart bar. █  PREFACE This library aims to tackle some problems that pine coders (from beginners to advanced) often come across, such as: I'm trying to draw an object with a 𝚋𝚊𝚛_𝚒𝚗𝚍𝚎𝚡 that is more than 10,000 bars into the past, but this causes my script to fail. How can I convert the 𝚋𝚊𝚛_𝚒𝚗𝚍𝚎𝚡 to a UNIX time so that I can draw visuals using xloc.bar_time ? I have a diagonal line drawing and I want to get the "y" value at a specific time, but line.get_price() only accepts a bar index value. How can I convert the timestamp into a bar index value so that I can still use this function? I want to get a previous 𝚘𝚙𝚎𝚗 value that occurred at a specific timestamp. How can I convert the timestamp into a historical offset so that I can use 𝚘𝚙𝚎𝚗 ? I want to reference a very old value for a variable. How can I access a previous value that is older than the maximum historical buffer size of 𝚟𝚊𝚛𝚒𝚊𝚋𝚕𝚎 ? This library can solve the above problems (and many more) with the addition of a few lines of code, rather than requiring the coder to refactor their script to accommodate the limitations. █  OVERVIEW The core functionality provided is conversion between xloc.bar_index and xloc.bar_time values. The main component of the library is the 𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊 object, created via the 𝚌𝚘𝚕𝚕𝚎𝚌𝚝𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊() function which basically stores the 𝚝𝚒𝚖𝚎 and 𝚝𝚒𝚖𝚎_𝚌𝚕𝚘𝚜𝚎 of every bar on the chart, and there are 3 more overloads to this function that allow collecting and storing additional data. Once a 𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊 object is created, use any of the exported methods: Methods to convert a UNIX timestamp into a bar index or bar offset: 𝚝𝚒𝚖𝚎𝚜𝚝𝚊𝚖𝚙𝚃𝚘𝙱𝚊𝚛𝙸𝚗𝚍𝚎𝚡(), 𝚐𝚎𝚝𝙽𝚞𝚖𝚋𝚎𝚛𝙾𝚏𝙱𝚊𝚛𝚜𝙱𝚊𝚌𝚔() Methods to retrieve the stored data for a bar index: 𝚝𝚒𝚖𝚎𝙰𝚝𝙱𝚊𝚛𝙸𝚗𝚍𝚎𝚡(), 𝚝𝚒𝚖𝚎𝙲𝚕𝚘𝚜𝚎𝙰𝚝𝙱𝚊𝚛𝙸𝚗𝚍𝚎𝚡(), 𝚟𝚊𝚕𝚞𝚎𝙰𝚝𝙱𝚊𝚛𝙸𝚗𝚍𝚎𝚡(), 𝚐𝚎𝚝𝙰𝚕𝚕𝚅𝚊𝚛𝚒𝚊𝚋𝚕𝚎𝚜𝙰𝚝𝙱𝚊𝚛𝙸𝚗𝚍𝚎𝚡() Methods to retrieve the stored data at a number of bars back (i.e., historical offset): 𝚝𝚒𝚖𝚎(), 𝚝𝚒𝚖𝚎𝙲𝚕𝚘𝚜𝚎(), 𝚟𝚊𝚕𝚞𝚎() Methods to retrieve all the data points from the earliest bar (or latest bar) stored in memory, which can be useful for debugging purposes: 𝚐𝚎𝚝𝙴𝚊𝚛𝚕𝚒𝚎𝚜𝚝𝚂𝚝𝚘𝚛𝚎𝚍𝙳𝚊𝚝𝚊(), 𝚐𝚎𝚝𝙻𝚊𝚝𝚎𝚜𝚝𝚂𝚝𝚘𝚛𝚎𝚍𝙳𝚊𝚝𝚊() Note: the library's strong suit is referencing data from very old bars in the past, which is especially useful for scripts that perform its necessary calculations only on the last bar. █  USAGE Step 1 Import the library. Replace with the latest available version number for this library. //@version=6 indicator("Usage") import n00btraders/ChartData/ Step 2 Create a 𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊 object to collect data on every bar. Do not declare as `var` or `varip`. chartData = ChartData.collectChartData() // call on every bar to accumulate the necessary data Step 3 Call any method(s) on the 𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊 object. Do not modify its fields directly. if barstate.islast int firstBarTime = chartData.timeAtBarIndex(0) int lastBarTime = chartData.time(0) log.info("First `time`: " + str.format_time(firstBarTime) + ", Last `time`: " + str.format_time(lastBarTime)) █  EXAMPLES • Collect Future Times The overloaded 𝚌𝚘𝚕𝚕𝚎𝚌𝚝𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊() functions that accept a 𝚋𝚊𝚛𝚜𝙵𝚘𝚛𝚠𝚊𝚛𝚍 argument can additionally store time values for up to 500 bars into the future. //@version=6 indicator("Example `collectChartData(barsForward)`") import n00btraders/ChartData/1 chartData = ChartData.collectChartData(barsForward = 500) var rectangle = box.new(na, na, na, na, xloc = xloc.bar_time, force_overlay = true) if barstate.islast int futureTime = chartData.timeAtBarIndex(bar_index + 100) int lastBarTime = time box.set_lefttop(rectangle, lastBarTime, open) box.set_rightbottom(rectangle, futureTime, close) box.set_text(rectangle, "Extending box 100 bars to the right. Time: " + str.format_time(futureTime)) • Collect Custom Data The overloaded 𝚌𝚘𝚕𝚕𝚎𝚌𝚝𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊() functions that accept a 𝚟𝚊𝚛𝚒𝚊𝚋𝚕𝚎𝚜 argument can additionally store custom user-specified values for every bar on the chart. //@version=6 indicator("Example `collectChartData(variables)`") import n00btraders/ChartData/1 var map variables = map.new() variables.put("open", open) variables.put("close", close) variables.put("open-close midpoint", (open + close) / 2) variables.put("boolean", open > close ? 1 : 0) chartData = ChartData.collectChartData(variables = variables) var fgColor = chart.fg_color var table1 = table.new(position.top_right, 2, 9, color(na), fgColor, 1, fgColor, 1, true) var table2 = table.new(position.bottom_right, 2, 9, color(na), fgColor, 1, fgColor, 1, true) if barstate.isfirst table.cell(table1, 0, 0, "ChartData.value()", text_color = fgColor) table.cell(table2, 0, 0, "open ", text_color = fgColor) table.merge_cells(table1, 0, 0, 1, 0) table.merge_cells(table2, 0, 0, 1, 0) for i = 1 to 8 table.cell(table1, 0, i, text_color = fgColor, text_halign = text.align_left, text_font_family = font.family_monospace) table.cell(table2, 0, i, text_color = fgColor, text_halign = text.align_left, text_font_family = font.family_monospace) table.cell(table1, 1, i, text_color = fgColor) table.cell(table2, 1, i, text_color = fgColor) if barstate.islast for i = 1 to 8 float open1 = chartData.value("open", 5000 * i) float open2 = i < 3 ? open : -1 table.cell_set_text(table1, 0, i, "chartData.value(\"open\", " + str.tostring(5000 * i) + "): ") table.cell_set_text(table2, 0, i, "open : ") table.cell_set_text(table1, 1, i, str.tostring(open1)) table.cell_set_text(table2, 1, i, open2 >= 0 ? str.tostring(open2) : "Error") • xloc.bar_index → xloc.bar_time The 𝚝𝚒𝚖𝚎 value (or 𝚝𝚒𝚖𝚎_𝚌𝚕𝚘𝚜𝚎 value) can be retrieved for any bar index that is stored in memory by the 𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊 object. //@version=6 indicator("Example `timeAtBarIndex()`") import n00btraders/ChartData/1 chartData = ChartData.collectChartData() if barstate.islast int start = bar_index - 15000 int end = bar_index - 100 // line.new(start, close, end, close) // !ERROR - `start` value is too far from current bar index start := chartData.timeAtBarIndex(start) end := chartData.timeAtBarIndex(end) line.new(start, close, end, close, xloc.bar_time, width = 10) • xloc.bar_time → xloc.bar_index Use 𝚝𝚒𝚖𝚎𝚜𝚝𝚊𝚖𝚙𝚃𝚘𝙱𝚊𝚛𝙸𝚗𝚍𝚎𝚡() to find the bar that a timestamp belongs to. If the timestamp falls in between the close of one bar and the open of the next bar, the 𝚜𝚗𝚊𝚙 parameter can be used to determine which bar to choose: 𝚂𝚗𝚊𝚙.𝙻𝙴𝙵𝚃 - prefer to choose the leftmost bar (typically used for closing times) 𝚂𝚗𝚊𝚙.𝚁𝙸𝙶𝙷𝚃 - prefer to choose the rightmost bar (typically used for opening times) 𝚂𝚗𝚊𝚙.𝙳𝙴𝙵𝙰𝚄𝙻𝚃 (or 𝚗𝚊) - copies the same behavior as xloc.bar_time uses for drawing objects //@version=6 indicator("Example `timestampToBarIndex()`") import n00btraders/ChartData/1 startTimeInput = input.time(timestamp("01 Aug 2025 08:30 -0500"), "Session Start Time") endTimeInput = input.time(timestamp("01 Aug 2025 15:15 -0500"), "Session End Time") chartData = ChartData.collectChartData() if barstate.islastconfirmedhistory int startBarIndex = chartData.timestampToBarIndex(startTimeInput, ChartData.Snap.RIGHT) int endBarIndex = chartData.timestampToBarIndex(endTimeInput, ChartData.Snap.LEFT) line1 = line.new(startBarIndex, 0, startBarIndex, 1, extend = extend.both, color = color.new(color.green, 60), force_overlay = true) line2 = line.new(endBarIndex, 0, endBarIndex, 1, extend = extend.both, color = color.new(color.green, 60), force_overlay = true) linefill.new(line1, line2, color.new(color.green, 90)) // using Snap.DEFAULT to show that it is equivalent to drawing lines using `xloc.bar_time` (i.e., it aligns to the same bars) startBarIndex := chartData.timestampToBarIndex(startTimeInput) endBarIndex := chartData.timestampToBarIndex(endTimeInput) line.new(startBarIndex, 0, startBarIndex, 1, extend = extend.both, color = color.yellow, width = 3) line.new(endBarIndex, 0, endBarIndex, 1, extend = extend.both, color = color.yellow, width = 3) line.new(startTimeInput, 0, startTimeInput, 1, xloc.bar_time, extend.both, color.new(color.blue, 85), width = 11) line.new(endTimeInput, 0, endTimeInput, 1, xloc.bar_time, extend.both, color.new(color.blue, 85), width = 11) • Get Price of Line at Timestamp The pine script built-in function line.get_price() requires working with bar index values. To get the price of a line in terms of a timestamp, convert the timestamp into a bar index or offset. //@version=6 indicator("Example `line.get_price()` at timestamp") import n00btraders/ChartData/1 lineStartInput = input.time(timestamp("01 Aug 2025 08:30 -0500"), "Line Start") chartData = ChartData.collectChartData() var diagonal = line.new(na, na, na, na, force_overlay = true) if time <= lineStartInput line.set_xy1(diagonal, bar_index, open) if barstate.islastconfirmedhistory line.set_xy2(diagonal, bar_index, close) if barstate.islast int timeOneWeekAgo = timenow - (7 * timeframe.in_seconds("1D") * 1000) // Note: could also use `timetampToBarIndex(timeOneWeekAgo, Snap.DEFAULT)` and pass the value directly to `line.get_price()` int barsOneWeekAgo = chartData.getNumberOfBarsBack(timeOneWeekAgo) float price = line.get_price(diagonal, bar_index - barsOneWeekAgo) string formatString = "Time 1 week ago: {0,number,#} - Equivalent to {1} bars ago 𝚕𝚒𝚗𝚎.𝚐𝚎𝚝_𝚙𝚛𝚒𝚌𝚎(): {2,number,#.##}" string labelText = str.format(formatString, timeOneWeekAgo, barsOneWeekAgo, price) label.new(timeOneWeekAgo, price, labelText, xloc.bar_time, style = label.style_label_lower_right, size = 16, textalign = text.align_left, force_overlay = true) █  RUNTIME ERROR MESSAGES This library's functions will generate a custom runtime error message in the following cases: 𝚌𝚘𝚕𝚕𝚎𝚌𝚝𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊() is not called consecutively, or is called more than once on a single bar Invalid 𝚋𝚊𝚛𝚜𝙵𝚘𝚛𝚠𝚊𝚛𝚍 argument in the 𝚌𝚘𝚕𝚕𝚎𝚌𝚝𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊() function Invalid 𝚟𝚊𝚛𝚒𝚊𝚋𝚕𝚎𝚜 argument in the 𝚌𝚘𝚕𝚕𝚎𝚌𝚝𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊() function Invalid 𝚕𝚎𝚗𝚐𝚝𝚑 argument in any of the functions that accept a number of bars back Note: there is no runtime error generated for an invalid 𝚝𝚒𝚖𝚎𝚜𝚝𝚊𝚖𝚙 or 𝚋𝚊𝚛𝙸𝚗𝚍𝚎𝚡 argument in any of the functions. Instead, the functions will assign 𝚗𝚊 to the returned values. Any other runtime errors are due to incorrect usage of the library. █  NOTES • Function Descriptions The library source code uses Markdown for the exported functions. Hover over a function/method call in the Pine Editor to display formatted, detailed information about the function/method. //@version=6 indicator("Demo Function Tooltip") import n00btraders/ChartData/1 chartData = ChartData.collectChartData() int barIndex = chartData.timestampToBarIndex(timenow) log.info(str.tostring(barIndex)) • Historical vs. Realtime Behavior Under the hood, the data collector for this library is declared as `var`. Because of this, the 𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊 object will always reflect the latest available data on realtime updates. Any data that is recorded for historical bars will remain unchanged throughout the execution of a script. //@version=6 indicator("Demo Realtime Behavior") import n00btraders/ChartData/1 var map variables = map.new() variables.put("open", open) variables.put("close", close) chartData = ChartData.collectChartData(variables) if barstate.isrealtime varip float initialOpen = open varip float initialClose = close varip int updateCount = 0 updateCount += 1 float latestOpen = open float latestClose = close float recordedOpen = chartData.valueAtBarIndex("open", bar_index) float recordedClose = chartData.valueAtBarIndex("close", bar_index) string formatString = "# of updates: {0} 𝚘𝚙𝚎𝚗 at update #1: {1,number,#.##} 𝚌𝚕𝚘𝚜𝚎 at update #1: {2,number,#.##} " + "𝚘𝚙𝚎𝚗 at update #{0}: {3,number,#.##} 𝚌𝚕𝚘𝚜𝚎 at update #{0}: {4,number,#.##} " + "𝚘𝚙𝚎𝚗 stored in memory: {5,number,#.##} 𝚌𝚕𝚘𝚜𝚎 stored in memory: {6,number,#.##}" string labelText = str.format(formatString, updateCount, initialOpen, initialClose, latestOpen, latestClose, recordedOpen, recordedClose) label.new(bar_index, close, labelText, style = label.style_label_left, force_overlay = true) • Collecting Chart Data for Other Contexts If your use case requires collecting chart data from another context, avoid directly retrieving the 𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊 object as this may exceed memory limits . //@version=6 indicator("Demo Return Calculated Results") import n00btraders/ChartData/1 timeInput = input.time(timestamp("01 Sep 2025 08:30 -0500"), "Time") var int oneMinuteBarsAgo = na // !ERROR - Memory Limits Exceeded // chartDataArray = request.security_lower_tf(syminfo.tickerid, "1", ChartData.collectChartData()) // oneMinuteBarsAgo := chartDataArray.last().getNumberOfBarsBack(timeInput) // function that returns calculated results (a single integer value instead of an entire `ChartData` object) getNumberOfBarsBack() => chartData = ChartData.collectChartData() chartData.getNumberOfBarsBack(timeInput) calculatedResultsArray = request.security_lower_tf(syminfo.tickerid, "1", getNumberOfBarsBack()) oneMinuteBarsAgo := calculatedResultsArray.size() > 0 ? calculatedResultsArray.last() : na if barstate.islast string labelText = str.format("The selected timestamp occurs 1-minute bars ago", oneMinuteBarsAgo) label.new(bar_index, hl2, labelText, style = label.style_label_left, size = 16, force_overlay = true) • Memory Usage The library's convenience and ease of use comes at the cost of increased usage of computational resources. For simple scripts, using this library will likely not cause any issues with exceeding memory limits. But for large and complex scripts, you can reduce memory issues by specifying a lower 𝚌𝚊𝚕𝚌_𝚋𝚊𝚛𝚜_𝚌𝚘𝚞𝚗𝚝 amount in the indicator() or strategy() declaration statement. //@version=6 // !ERROR - Memory Limits Exceeded using the default number of bars available (~20,000 bars for Premium plans) //indicator("Demo `calc_bars_count` parameter") // Reduce number of bars using `calc_bars_count` parameter indicator("Demo `calc_bars_count` parameter", calc_bars_count = 15000) import n00btraders/ChartData/1 map variables = map.new() variables.put("open", open) variables.put("close", close) variables.put("weekofyear", weekofyear) variables.put("dayofmonth", dayofmonth) variables.put("hour", hour) variables.put("minute", minute) variables.put("second", second) // simulate large memory usage chartData0 = ChartData.collectChartData(variables) chartData1 = ChartData.collectChartData(variables) chartData2 = ChartData.collectChartData(variables) chartData3 = ChartData.collectChartData(variables) chartData4 = ChartData.collectChartData(variables) chartData5 = ChartData.collectChartData(variables) chartData6 = ChartData.collectChartData(variables) chartData7 = ChartData.collectChartData(variables) chartData8 = ChartData.collectChartData(variables) chartData9 = ChartData.collectChartData(variables) log.info(str.tostring(chartData0.time(0))) log.info(str.tostring(chartData1.time(0))) log.info(str.tostring(chartData2.time(0))) log.info(str.tostring(chartData3.time(0))) log.info(str.tostring(chartData4.time(0))) log.info(str.tostring(chartData5.time(0))) log.info(str.tostring(chartData6.time(0))) log.info(str.tostring(chartData7.time(0))) log.info(str.tostring(chartData8.time(0))) log.info(str.tostring(chartData9.time(0))) if barstate.islast result = table.new(position.middle_right, 1, 1, force_overlay = true) table.cell(result, 0, 0, "Script Execution Successful ✅", text_size = 40) █  EXPORTED ENUMS Snap   Behavior for determining the bar that a timestamp belongs to.   Fields:      LEFT : Snap to the leftmost bar.      RIGHT : Snap to the rightmost bar.      DEFAULT : Default `xloc.bar_time` behavior. Note: this enum is used for the 𝚜𝚗𝚊𝚙 parameter of 𝚝𝚒𝚖𝚎𝚜𝚝𝚊𝚖𝚙𝚃𝚘𝙱𝚊𝚛𝙸𝚗𝚍𝚎𝚡(). █  EXPORTED TYPES Note: users of the library do not need to worry about directly accessing the fields of these types; all computations are done through method calls on an object of the 𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊 type. Variable   Represents a user-specified variable that can be tracked on every chart bar.   Fields:      name (series string) : Unique identifier for the variable.      values (array) : The array of stored values (one value per chart bar). ChartData   Represents data for all bars on a chart.   Fields:      bars (series int) : Current number of bars on the chart.      timeValues (array) : The `time` values of all chart (and future) bars.      timeCloseValues (array) : The `time_close` values of all chart (and future) bars.      variables (array) : Additional custom values to track on all chart bars. █  EXPORTED FUNCTIONS collectChartData()   Collects and tracks the `time` and `time_close` value of every bar on the chart.   Returns: `ChartData` object to convert between `xloc.bar_index` and `xloc.bar_time`. collectChartData(barsForward)   Collects and tracks the `time` and `time_close` value of every bar on the chart as well as a specified number of future bars.   Parameters:      barsForward (simple int) : Number of future bars to collect data for.   Returns: `ChartData` object to convert between `xloc.bar_index` and `xloc.bar_time`. collectChartData(variables)   Collects and tracks the `time` and `time_close` value of every bar on the chart. Additionally, tracks a custom set of variables for every chart bar.   Parameters:      variables (simple map) : Custom values to collect on every chart bar.   Returns: `ChartData` object to convert between `xloc.bar_index` and `xloc.bar_time`. collectChartData(barsForward, variables)   Collects and tracks the `time` and `time_close` value of every bar on the chart as well as a specified number of future bars. Additionally, tracks a custom set of variables for every chart bar.   Parameters:      barsForward (simple int) : Number of future bars to collect data for.      variables (simple map) : Custom values to collect on every chart bar.   Returns: `ChartData` object to convert between `xloc.bar_index` and `xloc.bar_time`. █  EXPORTED METHODS method timestampToBarIndex(chartData, timestamp, snap)   Converts a UNIX timestamp to a bar index.   Namespace types: ChartData   Parameters:      chartData (series ChartData) : The `ChartData` object.      timestamp (series int) : A UNIX time.      snap (series Snap) : A `Snap` enum value.   Returns: A bar index, or `na` if unable to find the appropriate bar index. method getNumberOfBarsBack(chartData, timestamp)   Converts a UNIX timestamp to a history-referencing length (i.e., number of bars back).   Namespace types: ChartData   Parameters:      chartData (series ChartData) : The `ChartData` object.      timestamp (series int) : A UNIX time.   Returns: A bar offset, or `na` if unable to find a valid number of bars back. method timeAtBarIndex(chartData, barIndex)   Retrieves the `time` value for the specified bar index.   Namespace types: ChartData   Parameters:      chartData (series ChartData) : The `ChartData` object.      barIndex (int) : The bar index.   Returns: The `time` value, or `na` if there is no `time` stored for the bar index. method time(chartData, length)   Retrieves the `time` value of the bar that is `length` bars back relative to the latest bar.   Namespace types: ChartData   Parameters:      chartData (series ChartData) : The `ChartData` object.      length (series int) : Number of bars back.   Returns: The `time` value `length` bars ago, or `na` if there is no `time` stored for that bar. method timeCloseAtBarIndex(chartData, barIndex)   Retrieves the `time_close` value for the specified bar index.   Namespace types: ChartData   Parameters:      chartData (series ChartData) : The `ChartData` object.      barIndex (series int) : The bar index.   Returns: The `time_close` value, or `na` if there is no `time_close` stored for the bar index. method timeClose(chartData, length)   Retrieves the `time_close` value of the bar that is `length` bars back from the latest bar.   Namespace types: ChartData   Parameters:      chartData (series ChartData) : The `ChartData` object.      length (series int) : Number of bars back.   Returns: The `time_close` value `length` bars ago, or `na` if there is none stored. method valueAtBarIndex(chartData, name, barIndex)   Retrieves the value of a custom variable for the specified bar index.   Namespace types: ChartData   Parameters:      chartData (series ChartData) : The `ChartData` object.      name (series string) : The variable name.      barIndex (series int) : The bar index.   Returns: The value of the variable, or `na` if that variable is not stored for the bar index. method value(chartData, name, length)   Retrieves a variable value of the bar that is `length` bars back relative to the latest bar.   Namespace types: ChartData   Parameters:      chartData (series ChartData) : The `ChartData` object.      name (series string) : The variable name.      length (series int) : Number of bars back.   Returns: The value `length` bars ago, or `na` if that variable is not stored for the bar index. method getAllVariablesAtBarIndex(chartData, barIndex)   Retrieves all custom variables for the specified bar index.   Namespace types: ChartData   Parameters:      chartData (series ChartData) : The `ChartData` object.      barIndex (series int) : The bar index.   Returns: Map of all custom variables that are stored for the specified bar index. method getEarliestStoredData(chartData)   Gets all values from the earliest bar data that is currently stored in memory.   Namespace types: ChartData   Parameters:      chartData (series ChartData) : The `ChartData` object.   Returns: A tuple: method getLatestStoredData(chartData, futureData)   Gets all values from the latest bar data that is currently stored in memory.   Namespace types: ChartData   Parameters:      chartData (series ChartData) : The `ChartData` object.      futureData (series bool) : Whether to include the future data that is stored in memory.   Returns: A tuple:
Pine Script® library
by n00btraders
Cumulative Returns by Session [BackQuant]Cumulative Returns by Session What this is This tool breaks the trading day into three user-defined sessions and tracks how much each session contributes to return, volatility, and volume. It then aggregates results over a rolling window so you can see which session has been pulling its weight, how streaky each session has been, and how sessions relate to one another through a compact correlation heatmap. We’ve also given the functionality for the user to use a simplified table, just by switching off all settings they are not interested in. How it works 1) Session segmentation You define APAC, EU, and US sessions with explicit hours and time zones. The script detects when each session starts and ends on every intraday bar and records its open, intraday high and low, close, and summed volume. 2) Per-session math At each session end the script computes: Return — either Percent: (Close−Open)÷Open×100(Close − Open) ÷ Open × 100(Close−Open)÷Open×100 or Points: (Close−Open)(Close − Open)(Close−Open), based on your selection. Volatility — either Range: (High−Low)÷Open×100(High − Low) ÷ Open × 100(High−Low)÷Open×100 or ATR scaled by price: ATR÷Open×100ATR ÷ Open × 100ATR÷Open×100. Volume — total volume transacted during that session. 3) Storage and lookback Each day’s three session stats are stored as a row. You choose how many recent sessions to keep in memory. The script then: Builds cumulative returns for APAC, EU, US across the lookback. Computes averages, win rates, and a Sharpe-like ratio avgreturn÷avgvolatilityavg return ÷ avg volatilityavgreturn÷avgvolatility per session. Tracks streaks of positive or negative sessions to show momentum. Tracks drawdowns on cumulative returns to show worst runs from peak. Computes rolling means over a short window for short-term drift. 4) Correlation heatmap Using the stored arrays of session returns, the script calculates Pearson correlations between APAC–EU, APAC–US, and EU–US, and colors the matrix by strength and sign so you can spot coupling or decoupling at a glance. What it plots Three lines: cumulative return for APAC, EU, US over the chosen lookback. Zero reference line for orientation. A statistics table with cumulative %, average %, positive session rate, and optional columns for volatility, average volume, max drawdown, current streak, return-to-vol ratio, and rolling average. A small correlation heatmap table showing APAC, EU, US cross-session correlations. How to use it Pick the asset — leave Custom Instrument empty to use the chart symbol, or point to another symbol for cross-asset studies. Set your sessions and time zones — defaults approximate APAC, EU, and US hours, but you can align them to exchange times or your workflow. Choose calculation modes — Percent vs Points for return, Range vs ATR for volatility. Points are convenient for futures and fixed-tick assets, Percent is comparable across symbols. Decide the lookback — more sessions smooths lines and stats; fewer sessions makes the tool more reactive. Toggle analytics — add volatility, volume, drawdown, streaks, Sharpe-like ratio, rolling averages, and the correlation table as needed. Why session attribution helps Different sessions are driven by different flows. Asia often sets the overnight tone, Europe adds liquidity and direction changes, and the US session can dominate range expansion. Separating contributions by session helps you: Identify which session has been the main driver of net trend. Measure whether volatility or volume is concentrated in a specific window. See if one session’s gains are consistently given back in another. Adapt tactics: fade during a mean-reverting session, press during a trending session. Reading the tables Cumulative % — sum of session returns over the lookback. The sign and slope tell you who is carrying the move. Avg Return % and Positive Sessions % — direction and hit rate. A low average but high hit rate implies many small moves; the reverse implies occasional big swings. Avg Volatility % — typical intrabars range for that session. Compare with Avg Return to judge efficiency. Return/Vol Ratio — return per unit of volatility. Higher is better for stability. Max Drawdown % — worst cumulative give-back within the lookback. A quick way to spot riskiness by session. Current Streak — consecutive up or down sessions. Useful for mean-reversion or regime awareness. Rolling Avg % — short-window drift indicator to catch recent turnarounds. Correlation matrix — green clusters indicate sessions tending to move together; red indicates offsetting behavior. Settings overview Basic Number of Sessions — how many recent days to include. Custom Instrument — analyze another ticker while staying on your current chart. Session Configuration and Times Enable or hide APAC, EU, US rows. Set hours per session and the specific time zone for each. Calculation Methods Return Calculation — Percent or Points. Volatility Calculation — Range or ATR; ATR Length when applicable. Advanced Analytics Correlation, Drawdown, Momentum, Sharpe-like ratio, Rolling Statistics, Rolling Period. Display Options and Colors Show Statistics Table and its position. Toggle columns for Volatility and Volume. Pick individual colors for each session line and row accents. Common applications Session bias mapping — find which window tends to trend in your market and plan exposure accordingly. Strategy scheduling — allocate attention or risk to the session with the best return-to-vol ratio. News and macro awareness — see if correlation rises around central bank cycles or major data releases. Cross-asset monitoring — set the Custom Instrument to a driver (index future, DXY, yields) to see if your symbol reacts in a particular session. Notes This indicator works on intraday charts, since sessions are defined within a day. If you change session clocks or time zones, give the script a few bars to accumulate fresh rows. Percent vs Points and Range vs ATR choices affect comparability across assets, so be consistent when comparing symbols. Session context is one of the simplest ways to explain a messy tape. By separating the day into three windows and scoring each one on return, volatility, and consistency, this tool shows not just where price ended up but when and how it got there. Use the cumulative lines to spot the steady driver, read the table to judge quality and risk, and glance at the heatmap to learn whether the sessions are amplifying or canceling one another. Adjust the hours to your market and let the data tell you which session deserves your focus.
Pine Script® indicator
by BackQuant
Stocks Multi-Indicator Alerts (cryptodaddy)//@version=6 // Multi-Indicator Alerts // -------------------------------------------- // This script combines technical indicators and basic analyst data // to produce composite buy and sell signals. Each block is heavily // commented so future modifications are straightforward. indicator("Multi-Indicator Alerts", overlay=true, max_labels_count=500) //// === Daily momentum indicators === // Relative Strength Index measures price momentum. rsiLength = input.int(14, "RSI Length") rsi = ta.rsi(close, rsiLength) // Money Flow Index incorporates volume to track capital movement. // In Pine Script v6 the function only requires a price source and length; // volume is taken from the built-in `volume` series automatically. mfLength = input.int(14, "Money Flow Length") mf = ta.mfi(hlc3, mfLength) // `mfUp`/`mfDown` flag a turn in money flow over the last two bars. mfUp = ta.rising(mf, 2) mfDown = ta.falling(mf, 2) //// === WaveTrend oscillator === // A simplified WaveTrend model produces "dots" indicating potential // exhaustion points. Values beyond +/-53 are treated as oversold/overbought. n1 = input.int(10, "WT Channel Length") n2 = input.int(21, "WT Average Length") ap = hlc3 // typical price esa = ta.ema(ap, n1) // smoothed price d = ta.ema(math.abs(ap - esa), n1) // smoothed deviation ci = (ap - esa) / (0.015 * d) // channel index tci = ta.ema(ci, n2) // trend channel index wt1 = tci // main line wt2 = ta.sma(wt1, 4) // signal line greenDot = ta.crossover(wt1, wt2) and wt1 < -53 redDot = ta.crossunder(wt1, wt2) and wt1 > 53 plotshape(greenDot, title="Green Dot", style=shape.circle, color=color.green, location=location.belowbar, size=size.tiny) plotshape(redDot, title="Red Dot", style=shape.circle, color=color.red, location=location.abovebar, size=size.tiny) //// === Analyst fundamentals === // Fundamental values from TradingView's database. If a ticker lacks data // these will return `na` and the related conditions simply evaluate false. rating = request.financial(syminfo.tickerid, "rating", period="FY") targetHigh = request.financial(syminfo.tickerid, "target_high_price", period="FY") targetLow = request.financial(syminfo.tickerid, "target_low_price", period="FY") upsidePct = (targetHigh - close) / close * 100 downsidePct = (close - targetLow) / close * 100 // `rating` comes back as a numeric value (1 strong sell -> 5 strong buy). Use // thresholds instead of string comparisons so the script compiles even when // the broker only supplies numeric ratings. ratingBuy = rating >= 4 // buy or strong buy ratingNeutralOrBuy = rating >= 3 // neutral or better upsideCondition = upsidePct >= 2 * downsidePct // upside at least twice downside downsideCondition = downsidePct >= upsidePct // downside greater or equal //// === Daily moving-average context === // 50 EMA represents short-term trend; 200 EMA long-term bias. ema50 = ta.ema(close, 50) ema200 = ta.ema(close, 200) longBias = close > ema200 // price above 200-day = long bias momentumFavorable = close > ema50 // price above 50-day = positive momentum //// === Weekly trend filter === // Higher timeframe confirmation to reduce noise. weeklyClose = request.security(syminfo.tickerid, "W", close) weeklyEMA20 = request.security(syminfo.tickerid, "W", ta.ema(close, 20)) weeklyRSI = request.security(syminfo.tickerid, "W", ta.rsi(close, rsiLength)) // Weekly Money Flow uses the same two-argument `ta.mfi()` inside `request.security`. weeklyMF = request.security(syminfo.tickerid, "W", ta.mfi(hlc3, mfLength)) weeklyFilter = weeklyClose > weeklyEMA20 //// === Buy evaluation === // Each true condition contributes one point to `buyScore`. c1_buy = rsi < 50 // RSI below midpoint c2_buy = mfUp // Money Flow turning up c3_buy = greenDot // WaveTrend oversold bounce c4_buy = ratingBuy // Analyst rating Buy/Strong Buy c5_buy = upsideCondition // Forecast upside twice downside buyScore = (c1_buy?1:0) + (c2_buy?1:0) + (c3_buy?1:0) + (c4_buy?1:0) + (c5_buy?1:0) // Require all five conditions plus trend filters and persistence for two bars. buyCond = c1_buy and c2_buy and c3_buy and c4_buy and c5_buy and longBias and momentumFavorable and weeklyFilter and weeklyRSI > 50 and weeklyMF > 50 buySignal = buyCond and buyCond //// === Sell evaluation === // Similar logic as buy side but inverted. c1_sell = rsi > 70 // RSI above overbought threshold c2_sell = mfDown // Money Flow turning down c3_sell = redDot // WaveTrend overbought reversal c4_sell = ratingNeutralOrBuy // Analysts neutral or still buy c5_sell = downsideCondition // Downside at least equal to upside sellScore = (c1_sell?1:0) + (c2_sell?1:0) + (c3_sell?1:0) + (c4_sell?1:0) + (c5_sell?1:0) // For exits require weekly filters to fail or long bias lost. sellCond = c1_sell and c2_sell and c3_sell and c4_sell and c5_sell and (not longBias or not weeklyFilter or weeklyRSI < 50) sellSignal = sellCond and sellCond // Plot composite scores for quick reference. plot(buyScore, "Buy Score", color=color.green) plot(sellScore, "Sell Score", color=color.red) //// === Confidence table === // Shows which of the five buy/sell checks are currently met. var table status = table.new(position.top_right, 5, 2, border_width=1) if barstate.islast table.cell(status, 0, 0, "RSI", bgcolor=c1_buy?color.new(color.green,0):color.new(color.red,0)) table.cell(status, 1, 0, "MF", bgcolor=c2_buy?color.new(color.green,0):color.new(color.red,0)) table.cell(status, 2, 0, "Dot", bgcolor=c3_buy?color.new(color.green,0):color.new(color.red,0)) table.cell(status, 3, 0, "Rating", bgcolor=c4_buy?color.new(color.green,0):color.new(color.red,0)) table.cell(status, 4, 0, "Target", bgcolor=c5_buy?color.new(color.green,0):color.new(color.red,0)) table.cell(status, 0, 1, "RSI>70", bgcolor=c1_sell?color.new(color.red,0):color.new(color.green,0)) table.cell(status, 1, 1, "MF down",bgcolor=c2_sell?color.new(color.red,0):color.new(color.green,0)) table.cell(status, 2, 1, "Red dot", bgcolor=c3_sell?color.new(color.red,0):color.new(color.green,0)) table.cell(status, 3, 1, "Rating", bgcolor=c4_sell?color.new(color.red,0):color.new(color.green,0)) table.cell(status, 4, 1, "Target", bgcolor=c5_sell?color.new(color.red,0):color.new(color.green,0)) //// === Alert text === // Include key metrics in alerts so the chart doesn't need to be opened. buyMsg = "BUY: RSI " + str.tostring(rsi, "#.##") + ", MF " + str.tostring(mf, "#.##") + ", Upside " + str.tostring(upsidePct, "#.##") + "%" + ", Downside " + str.tostring(downsidePct, "#.##") + "%" + ", Rating " + str.tostring(rating, "#.##") sellMsg = "SELL: RSI " + str.tostring(rsi, "#.##") + ", MF " + str.tostring(mf, "#.##") + ", Upside " + str.tostring(upsidePct, "#.##") + "%" + ", Downside " + str.tostring(downsidePct, "#.##") + "%" + ", Rating " + str.tostring(rating, "#.##") // Alert conditions use static messages; dynamic data is sent via `alert()` alertcondition(buySignal, title="Buy Signal", message="Buy conditions met") alertcondition(sellSignal, title="Sell Signal", message="Sell conditions met") if buySignal alert(buyMsg, alert.freq_once_per_bar_close) if sellSignal alert(sellMsg, alert.freq_once_per_bar_close) //// === Watch-out flags === // Gentle warnings when trends weaken but before full sell signals. warnRSI = rsi > 65 and rsi <= 65 warnAnalyst = upsidePct < 2 * downsidePct and upsidePct > downsidePct alertcondition(warnRSI, title="RSI Watch", message="RSI creeping above 65") alertcondition(warnAnalyst, title="Analyst Watch", message="Analyst upside shrinking") if warnRSI alert("RSI creeping above 65: " + str.tostring(rsi, "#.##"), alert.freq_once_per_bar_close) if warnAnalyst alert("Analyst upside shrinking: up " + str.tostring(upsidePct, "#.##") + "% vs down " + str.tostring(downsidePct, "#.##") + "%", alert.freq_once_per_bar_close) //// === Plot bias moving averages === plot(ema50, color=color.orange, title="EMA50") plot(ema200, color=color.blue, title="EMA200") //// === Cross alerts for context === goldenCross = ta.crossover(ema50, ema200) deathCross = ta.crossunder(ema50, ema200) alertcondition(goldenCross, title="Golden Cross", message="50 EMA crossed above 200 EMA") alertcondition(deathCross, title="Death Cross", message="50 EMA crossed below 200 EMA")
Pine Script® indicator
by leandrobanking
عكفة الماكد المتقدمة - أبو فارس ©// 🔒 Advanced MACD Curve © 2025 // 💡 Idea & Creativity: Engineer Abu Elias // 🛠️ Development & Implementation: Abu Fares // 📜 All intellectual rights reserved - Copying, modifying, or redistributing is not permitted // 🚫 Any attempt to tamper with this code or violate intellectual property rights is legally prohibited // 📧 For inquiries and licensing: Please contact the developer, Abu Fares
Pine Script® indicator
by ABU_FARIS
عكفة الماكد المتقدمة - أبو فارس ©// 🔒 عكفة الماكد المتقدمة © 2025 // 💡 فكرة وإبداع: المهندس أبو الياس // 🛠️ تطوير وتنفيذ: أبو فارس // 📜 جميع الحقوق الفكرية محفوظة - لا يُسمح بالنسخ أو التعديل أو إعادة التوزيع // 🚫 أي محاولة للعبث بهذا الكود أو انتهاك الحقوق الفكرية مرفوضة قانونياً // 📧 للاستفسارات والتراخيص: يرجى التواصل مع المطور أبو فارس // 🔒 Advanced MACD Curve © 2025 // 💡 Idea & Creativity: Engineer Abu Elias // 🛠️ Development & Implementation: Abu Fares // 📜 All intellectual rights reserved - Copying, modifying, or redistributing is not permitted // 🚫 Any attempt to tamper with this code or violate intellectual property rights is legally prohibited // 📧 For inquiries and licensing: Please contact the developer, Abu Fares
Pine Script® indicator
by ABU_FARIS
Smart Money Concepts Probability (Expo) RitSmart Money Concepts Probability (Expo) — v2 Overview This indicator maps market structure using confirmed swing pivots and quantifies the follow-through of SMC events—CHoCH, SMS, and BMS—as real-time probabilities. It adds robust filters (ATR swing size, multi-timeframe bias) and statistically honest display (Laplace smoothing and Wilson confidence bands) to reduce noise and make the stats you see on the chart closer to what actually plays out. How it works Detects confirmed swing highs/lows with ta.pivothigh/ta.pivotlow. Tracks a structure state machine: bias flips to CHoCH (±1), confirms to SMS (±2), then BMS/continuations (>|±2|). Logs every transition as a success (continuation) or failure (reversion) and computes: Raw Win%, Laplace-smoothed probability, and Wilson confidence interval. Draws Premium/Discount/Mid zones between the latest swing high/low and shows contextual probability labels at the extremes. Filters & Upgrades ATR swing filter: ignores tiny breaks; only counts pivots that exceed a user-set multiple of ATR. MTF bias gate: only allows bullish sequences when price is above an HTF moving average (and vice-versa). Label throttle: minimum bar spacing between plotted events to keep charts readable. Response vs. Period: choose short-term or long-term structure resolution. Outputs & Visuals On-chart labels/lines for CHoCH/SMS/BMS (bull/bear colors). Top-right table with Wins, Losses, Profitability, Laplace p̂, and Wilson CI (with sample-size guard). Probability labels near current Up/Dn extremes. Optional alerts containing ticker, timeframe, and the current probability summary. Using the stats Profitability = all-time raw follow-through rate. Laplace p̂ stabilizes small-N swings. Wilson CI shows a conservative range; the lower bound is a practical “floor.” For best results, align entries with MTF bias, ensure swings pass the ATR filter, and favor entries in Discount (for longs) / Premium (for shorts) when the structure agrees. Notes This is an analytical tool, not a signal service. Always validate on your markets/timeframes and combine with risk management.
Pine Script® indicator
by yuji52289
Retail Sentiment Indicator - Multi-Asset CFD & Fear/Greed IndexRetail Sentiment Indicator - Multi-Asset CFD & Fear/Greed Index Overview The Retail Sentiment Indicator provides real-time sentiment data for major financial instruments including stocks, forex, commodities, and cryptocurrencies. This indicator displays retail trader positioning and market sentiment using CFD data and fear/greed indices. Methodology and Scale Calculation This indicator operates on a **-50 to +50 scale** with zero representing perfect market equilibrium. Scale Interpretation: - **Zero (0)**: Market balance - exactly 50% of investors buying, 50% selling - **Positive values**: Majority buying pressure - Example: If 63% of investors are buying, the indicator shows +13 (63 - 50 = +13) - **Negative values**: Majority selling pressure - Example: If 92% of investors are selling, the indicator shows -42 (50 - 92 = -42) BTC Fear & Greed Index Scaling: The original `BTC FEAR&GREED` index is natively scaled from 0-100 by its creator. In our indicator, this data has been rescaled to also fit the -50 to +50 range for consistency with other sentiment data sources. This unified scaling approach allows for direct comparison across all instruments and data sources within the indicator. -Important Data Source Selection- Bitcoin (BTC) Data Sources When viewing Bitcoin charts, the indicator offers **two different data sources**: 1. **Default Auto-Mode**: `BTCUSD Retail CFD` - Retail CFD traders sentiment data (automatically loaded). 2. **Manual Selection**: `BTC FEAR&GREED` - Fear & Greed Index from website: alternative dot me **To access BTC Fear & Greed Index**: Input settings -> disable checkbox "Auto-load Sentiment Data" -> manually select "BTC FEAR&GREED" from the dropdown menu. US Stock Market Data Sources For US stocks and indices (S&P 500, NASDAQ, Dow Jones), there are **two data source options**: 1. **Default Auto-Mode**: Individual retail CFD sentiment data for each instrument 2. **Manual Selection**: `SNN FEAR&GREED` - SNN's Fear & Greed Index covering the overall US market sentiment. SNN was used as the name to avoid any potential trademark infringement. **To access SNN Fear & Greed Index**: When viewing US market charts, disable in input settings checkbox "Auto-load Sentiment Data" and manually select "SNN FEAR&GREED" from the dropdown menu. This distinction allows traders to choose between **instrument-specific retail sentiment** (auto-mode) or **broader market sentiment indices** (manual selection). Features - **Auto-Detection**: Automatically loads sentiment data based on the current chart symbol - **Manual Selection**: Choose from 40+ supported instruments when auto-detection is unavailable - **Multiple Data Sources**: Combines retail CFD sentiment with Fear & Greed indices - **Visual Zones**: Clear greed/fear zones with color-coded backgrounds - **Real-time Updates**: Live sentiment data from merged data sources Supported Instruments Major Indices - S&P 500, NASDAQ, Dow Jones 30, DAX Forex Pairs - Major pairs: EURUSD, GBPUSD, USDJPY, USDCHF, USDCAD - Cross pairs: EURJPY, GBPJPY, AUDUSD, NZDUSD, and 20+ others Commodities - Precious metals: Gold (XAUUSD), Silver (XAGUSD) - Energy: WTI Oil - Agricultural: Wheat, Coffee - Industrial: Copper Cryptocurrencies - Bitcoin (BTC) sentiment data - BTC & SNN Fear & Greed indices How to Use 1. **Auto Mode** (Default): Enable "Auto-load Sentiment Data" to automatically display sentiment for the current chart symbol 2. **Manual Mode**: Disable auto-load and select from the dropdown menu for specific instruments 3. **Interpretation**: - Values above 0 (green) indicate retail greed/bullish sentiment - Values below 0 (red) indicate retail fear/bearish sentiment - Fear & Greed indices use 0-100 scale (50 is neutral) Data Sources This indicator uses curated sentiment data from retail CFD providers and established fear/greed indices. Data is updated regularly and sourced from reputable financial data providers. Trading Strategy & Market Philosophy Contrarian Trading Approach The primary purpose of this indicator is based on the fundamental market principle that **the majority of retail investors are often wrong**, and markets typically move opposite to the positions held by the majority of market participants. Key Strategy Guidelines: - **Contrarian Signal**: When the majority of users are positioned on one side of the market, there is statistically greater market advantage in taking positions in the opposite direction - **Trend Exhaustion Signal**: An interesting observed phenomenon occurs when, during a long-lasting trend where the majority of investors have consistently been on the wrong side, the Sentiment indicator suddenly shows that the majority has flipped and opened positions in the direction of that long-running trend. This is often a signal of fuel exhaustion for further movement in that direction Interpretation Examples - High greed readings (majority bullish) → Consider bearish opportunities - High fear readings (majority bearish) → Consider bullish opportunities - Sudden sentiment flip during established trends → Potential trend reversal signal Technical Notes - Built with PineScript v6 - Dynamic symbol detection with fallback options - Optimized for performance with minimal resource usage - Color-coded visualization with customizable zones Data Sources & Expansion Acknowledgments We extend our gratitude to **TradingView** for enabling the use of custom data feeds based on GitHub repositories, making this comprehensive sentiment analysis possible. Data Expansion Opportunities As the operator of this indicator, I am **open to suggestions for new data sources** that could be integrated and published. If you have ideas for additional instruments or sentiment data: How to Submit Suggestions: 1. Send a **private message** with your proposal 2. Include: **instrument/data type**, **source**, and **brief description** 3. If technically feasible, we will work to import and publish the data Data Infrastructure Status Current Data Upload Process: Please note that sentiment data uploads may occasionally experience minor interruptions. However, this should not pose significant issues as sentiment data typically changes gradually rather than rapidly. Infrastructure Development: We are actively working on establishing permanent cloud-based infrastructure to ensure continuous, automated data collection and upload processes. This will provide more reliable and consistent data availability in the future. Disclaimer This indicator is for educational and informational purposes only. Sentiment data should be used as part of a comprehensive trading strategy and not as the sole basis for trading decisions. Past performance does not guarantee future results. The contrarian approach described is a market theory and may not always produce profitable results.
Pine Script® indicator
by OpenTrading_ai
Calculator - AOC📊 Calculator - AOC Indicator 🚀 The Calculator - AOC indicator is a powerful and user-friendly tool designed for TradingView to help traders plan and visualize trades with precision. It calculates key trade metrics, displays entry, take-profit (TP), stop-loss (SL), and liquidation levels, and provides a clear overview of risk management and potential profits. Perfect for both novice and experienced traders! 💡 ✨ Features 📈 Trade Planning: Input your Entry Price, Take Profit (TP), Stop Loss (SL), and Trade Direction (Long/Short) to visualize your trade setup on the chart. 💰 Risk Management: Set your Initial Capital and Risk per Trade (%) to calculate the optimal Position Size and Risk Amount for each trade. ⚖️ Leverage Support: Define your Leverage to compute the Required Margin and Liquidation Price, ensuring you stay aware of potential risks. 📊 Risk/Reward Ratio: Automatically calculates the Risk-to-Reward Ratio to evaluate trade profitability. 🎨 Visuals: Displays Entry, TP, SL, and Liquidation levels as lines and boxes on the chart, with customizable Line Width, Line Style, and Label Size. ✅ Trade Validation: Checks if your trade setup is valid (e.g., correct TP/SL placement) and highlights issues like potential liquidation risks with color-coded statuses (Correct ✅, Incorrect ❌, or Liquidation ⚠️). 📋 Summary Table: A clean, top-right table summarizes key metrics: Capital, Risk %, Risk Amount, Position Size, Potential Profit, Risk/Reward, Margin, Liquidation Price, Trade Status, and % to TP/SL. 🖌️ Customization: Adjust Line Extension (Bars) for how far lines extend, and choose from Solid, Dashed, or Dotted line styles for a personalized chart experience. 🛠️ How to Use Add to Chart: Apply the indicator to your TradingView chart. Configure Inputs: Accountability: Set your Initial Capital and Risk per Trade (%). Target: Enter Entry Price, TP, and SL prices. Leverage: Specify your leverage (e.g., 10x). Direction: Choose Long or Short. Display Settings: Customize Line Width, Line Style, Label Size, and Line Extension. Analyze: The indicator plots Entry, TP, SL, and Liquidation levels on the chart and displays a table with all trade metrics. Validate: Check the Trade Status in the table to ensure your setup is valid or if adjustments are needed. 🎯 Why Use It? Plan Smarter: Visualize your trade setup and understand your risk/reward profile instantly. Stay Disciplined: Precise position sizing and risk calculations help you stick to your trading plan. Avoid Mistakes: Clear validation warnings prevent costly errors like incorrect TP/SL placement or liquidation risks. User-Friendly: Intuitive visuals and a summary table make trade analysis quick and easy. 📝 Notes Ensure Entry, TP, and SL prices align with your trade direction to avoid "Incorrect" or "Liquidation" statuses. The indicator updates dynamically on the latest bar, ensuring real-time visuals. Best used with proper risk management to maximize trading success! 💪 Happy trading! 🚀📈
Pine Script® indicator
by AlchimistOfCrypto