TradingView – charts, alerts and analysis workflow
The same EUR/USD can look different on TradingView and in your broker’s terminal because the chart and order may use different data and quote sides. This article explains how to check the price source, configure charts and use alerts. It also shows why an alert is not an order and why a signal visible in historical data may not have been available in real time. After covering MT4, MT5 and cTrader in the previous article, we focus on analysis tools and their connection to execution at the broker.

Ask which version of the rule actually produced the alert
An alert can arrive while the chart you are looking at shows no matching signal. That does not by itself prove either a bad alert or a repainting indicator. First compare the versions: script, inputs, symbol, price feed, timeframe and triggering condition. A screenshot taken later may show a different configuration from the one running when the notification was generated.
In our invented example, an alert is created at 10:00 UTC with threshold 1.3140. At 10:03 the user changes the chart input to 1.3150 but leaves that alert running. The rule is deliberately precise: after an M5 bar completes, its closing price must be strictly above the threshold and the preceding completed close must be at or below it. Both versions use the same stipulated feed and symbol. No intrabar touch or order execution is part of this condition.
Evaluate the stored and displayed rules separately
| Input or check | Original alert | Changed chart |
|---|---|---|
| Threshold | 1.3140 | 1.3150 |
| Previous completed close | 1.3138 | 1.3138 |
| Current completed close | 1.3144 | 1.3144 |
| Previous close at or below threshold | Yes | Yes |
| Current close strictly above threshold | Yes | No |
| Full crossing condition | True | False |
The alert’s rule passes while the current chart rule fails. TradingView’s official Pine documentation states that a running alert uses a saved copy of the script, inputs, symbol and timeframe from its creation. Later input changes do not update that running copy. A changed chart therefore does not establish that the original alert contradicted its own condition.
Give each version an identity in your notes. If you intend the new threshold to govern future alerts, recreate the alert in the new context as the documentation describes. Preserve the earlier configuration and messages for reconciliation. Overwriting the old record would make the apparent discrepancy harder to explain.
Separate the condition, the message and an actual fill
Suppose the completed-bar time is 10:05:00.000 UTC. In a fully hypothetical log, the alert is emitted at 10:05:00.200, a webhook receiver records it at 10:05:00.450, a trading request is submitted at 10:05:00.700 and a fill is recorded at 10:05:01.000. For this arithmetic only, all clocks are synchronised and the timestamps refer to the named events.
Emission to receipt takes 250 milliseconds; emission to fill takes 800 milliseconds. These are different intervals, and neither is the time from bar completion. They are invented observations, not service-level promises or typical TradingView performance. A received webhook proves receipt of that message, not acceptance of a trading request or execution at the chart’s closing price. Real delivery, processing and execution records need their own identifiers and timestamp conventions.
Resolve the mismatch before drawing a performance conclusion
Keep the alert message, stored settings and the relevant completed-bar values together. Check whether the message was a script condition, an emulator’s order-fill alert or another event; these are different sources of notification. Then inspect the receiving system and broker history if a real request was involved. The chart alone cannot establish every later state in that chain.
This case establishes a version mismatch, not the usefulness of the trading rule. It provides no return, slippage estimate or evidence that either threshold should be used. It also does not settle every possible repainting issue: a script can depend on unfinished bars or other timeframes, which require their own checks. The detailed lesson retains those distinctions and the original illustrations. Start with the smallest reproducible question: with the stored inputs and the completed data available then, was the stated alert condition true?
Three exercises with worked answers
The exercise data are hypothetical. Choose an answer, then check the calculation.
Continue to chart data, alerts and testing
The full lesson below keeps the original illustrations and advanced explanations. Use the version comparison to distinguish a saved condition from the chart now displayed.
1. Three layers of one price: data provider, chart, execution
When you look at a EUR/USD candle, you are looking at the outcome of three independent decisions. The first belongs to the data provider: it collects quotes and publishes the series from which the candle is built. The second belongs to the platform: TradingView aggregates that series into the chosen timeframe, draws it and computes indicators on it. The third belongs to the broker: it accepts your order and fills it on its own bid/ask, according to its own execution policy. Three layers, three different roles – and three different answers to the question "what is the price of EUR/USD". A role, however, is not the same thing as a separate company: the owners of these roles can overlap. The same entity whose prefix you see in the symbol may at the same time be a broker integrated with the platform. The separation of roles does not disappear because one name covers them all – the chart series and the transactional quote are produced for a different purpose, on a different account type, and can differ despite a shared owner.
In the Forex spot market there is no central exchange and no single official rate (art. 1.3). So there is no "true" candle against which the others would be wrong. There are different series, built from different streams of quotes. The sentence "TradingView shows the official Forex rate" is not so much imprecise as void.
| Layer | Who owns the property | What follows for you |
|---|---|---|
| Quote series | The data provider named in the symbol (the prefix before the colon) | Changing the provider changes the levels, the extremes and the moment a line is "touched" |
| Chart and indicators | The platform — aggregation, timeframe, candle construction; displayed time zone | The timeframe and chart type can change data and signals. Changing the chart’s displayed time zone changes labels, not Pine calculations or candles. |
| Alert | The platform's server – the condition is computed on the provider's series | An alert says "the condition on this series has been met", not "a trade is possible at this price" |
| Spread, slippage, rejection | The broker and the account type | These are not properties of the analytical platform – a single candle does not encode them, and the current spread is visible in the transactional layer, with a brokerage or a simulated account |
| Order execution | The broker's server | Stop activation is decided by the broker's quote, not by a line on the chart |

The practical consequence is a single one, and it recurs throughout this article: the chart is not proof of an execution price. If after a trade you are wondering why your stop loss was activated even though "the candle did not reach the level", the question is not "did TradingView get it wrong". It is: which price series builds this candle, which side of the market decided the activation, and did both measurements come from the same source. Exactly that procedure is described in the section on the defensive exit (art. 9.4) – here we are interested only in the tooling layer.
The reverse mistake is equally expensive. Since the chart price is not the execution price, comparing two platforms "point by point" without checking the data source settles nothing. A divergence of a fraction of a pip between feeds is neither a fault nor evidence of broker manipulation. It is the normal state of a decentralized market.
2. Symbol and data provider – why two EUR/USD candles need not be identical
A symbol on TradingView has two parts: the provider prefix and the instrument name. OANDA:EURUSD and FX:EURUSD are the same market seen through two different streams of quotes. Typing EURUSD on its own does not yet name a provider: the search window then shows a list of results, with the data source standing in every row next to the instrument name, so the choice is yours. If you do not check it, two people comparing "the same chart" may be comparing two different series without knowing it. So it is worth reading the prefix before you compare anything, and when you write levels down for yourself or for someone else – stating it explicitly.
A broker symbol in MT5 adds another layer. The broker may call the instrument EURUSD, EURUSD.r, EURUSDm or EURUSD# – the suffix usually denotes an account type, a specification or a pricing group. This is no longer a cosmetic naming question: an instrument with a suffix can have a different contract size, different trading hours and a different way of charging swap points.
Procedure for comparing two sources. If two daily EUR/USD candles differ and you want to know why, check in this order – check all relevant parameters, since several differences can occur at once:
- Provider. Read the symbol prefix on the chart and the server name in your broker's terminal. Two different sources mean two different series, and any further comparison makes sense only as an estimate.
- Side of the market. Establish whether the series uses Bid, Ask or a midpoint. At one instant, Ask − Bid is the spread, and the arithmetic mid = (Bid + Ask) / 2 lies exactly half a spread from each side. That does not imply a constant shift of an entire candle: the spread varies over time, and Bid and Ask highs may occur at different instants.
- Session and daily candle boundaries. Sources can define session boundaries and aggregate data differently. That can change OHLC even from shared ticks. TradingView’s displayed chart time zone, however, changes axis labels rather than candle boundaries or Pine calculations.
- Instrument specification. Symbol suffix, contract size, trading hours, the way the weekend break is treated.
- Filtering and aggregation. Providers treat single, isolated quotes differently. A candle wick built from one outlying tick at one provider may not appear at all at another.
None of these sources is "true" by definition. There is, however, one source appropriate to a particular purpose: if you are asking whether your order could have been filled, the appropriate source is your broker's quote history. If you are asking about the shape of market structure over weeks, any sensible feed will do, because the differences fit within the thickness of the line.
An event that makes this visible. During the violent move in sterling on 7 October 2016, GBP/USD quotes diverged between trading systems far enough that the Markets Committee report at the BIS discusses separately the mere task of establishing where the price low sat during that episode[4]. It is a vivid illustration of the mechanism described in this section: in conditions of thin liquidity the question "what was the lowest price" has no single answer, because the answer depends on whose quotes you are looking at. The specific levels quoted in popular write-ups differ for exactly that reason, and we do not repeat them here as numbers, because they would mislead about the precision available. The mechanics of liquidity gaps and how orders behave at such moments belong to art. 4.4.
3. Charts: timeframes, types, drawings and Bar Replay
The charting engine is what attracts users first, and at the same time what is easy to overrate. A more legible chart shortens the time you need to recognize a situation you already know how to recognize. It creates no edge where there is no defined system (art. 8.1) – without one, drawing lines for an hour remains an activity that merely looks like analysis.
Timeframes. Beyond the standard minute, hour and day grid, the platform supports custom timeframes, second-based timeframes and timeframes based on criteria other than time. The availability of some of them depends on the plan, and the range of history additionally on the instrument and the provider. Treat this as a parameter to check in the pricing page, not as a fixed property of the tool; we return to it in section 8. For multi-timeframe analysis (art. 5.11) the standard grid is sufficient on every plan.
The chart type changes how data is presented or transformed. Standard candles show OHLC from the selected series. Heikin Ashi averages prices, while Renko, Range, Kagi and Point & Figure group movement under their own rules; not every displayed value is a price available for execution at that instant. Backtests on synthetic prices can produce unrealistic results. TradingView can simulate Heikin Ashi fills on standard OHLC, but the result still depends on the emulator model. A real broker fills orders on its own Bid/Ask under the order type and execution policy, rather than on a plotted candle value alone.
Drawings and templates. A clear saving of time comes from the fact that a drawing lives across several timeframes at once: a line placed on the daily chart stays visible on lower timeframes of the same instrument until you restrict its range in the object's settings, so your levels remain one consistent map instead of three independent ones. The range of timeframes on which an object is to appear is set in exactly that place – the visibility tab does it for a single drawing. The second saving comes from templates: a saved set of indicators, colours and settings loads onto a new instrument with one command. Both functions guard consistency; about accuracy they say nothing. Tidiness in the workshop is often mistaken for an edge.
Replaying history – three different things under one name. In everyday use "Bar Replay" means anything that happens on scrolled-back history. Let us separate them, because each of these functions answers a different question. Bar Replay itself scrolls history candle by candle and hides what happened later. For practising chart reading (art. 5.6) it is an effective tool, because it removes the treacherous element of learning on a finished chart: knowing how the move ended.
On that same scrolled-back history the vendor offers separately trading on historical data. This is no longer scrolling alone: the documentation describes the scope of this mode explicitly – "You can open positions and place limit, stop, and stop-limit orders, just like you would with a real broker", and before starting the replay "you can also configure your initial capital, base currency, and commission size in the appropriate menu"; after the session there are tabs with an overview, performance, trade analysis and a list of trades, and two of them can be taken outside the platform: "The Performance and List of trades can also be exported for further analysis or record-keeping"[18] (checked 2026-08-22). Positions, limit and stop orders, commission and reports are therefore present in this mode. The third function is the Strategy Tester, which replays nothing for you and instead recomputes a saved strategy over the whole available stretch of history – section 6 describes it.
What all three have in common is what none of them does: they are not a record of execution at your broker. The fill is computed by the platform's simulation layer on the chosen provider's series, so it settles nothing about execution policy, available liquidity or the rejection of an order on a particular account. The vendor adds one more caveat to the historical trading mode: "Data on trades and the overall result are available only in the session itself, and they are not saved anywhere"[18] (checked 2026-08-22). The session is therefore not preserved anywhere, but two reports can be carried out of it before it closes – performance and the list of trades are covered by the export quoted above. What you copy into your journal by hand is only what those two reports do not contain: your own notes from the course of the session. The methodology of testing a strategy, with its split into a fitting sample and a validation sample, belongs to art. 11.7. The availability of replay on lower timeframes and the reach of history are sometimes restricted by plan – like all limits, you check this in the current pricing page.
Overlaying instruments and intermarket context. The ability to put several instruments on one chart, including as percentage change, is one of the genuine workshop advantages of this environment over a terminal connected to a single broker: you see the currency pair, the dollar index and the bond market together, without needing to hold each of those instruments at your broker. What follows from such a comparison for the market is described by art. 7.8 – here what counts is that the tool lets you pose the question in one window at all.
Screenshots for the journal. A chart screenshot contains the instrument, the timeframe and a timestamp, so it is suited to documenting a decision at the moment it is taken, rather than after the fact. A screenshot is a cheap way of keeping the record of your analysis from being rewritten later by memory. How to turn such material into a journal of process – one in which the result is one column among many – is described by art. 10.6.
4. Alerts – what an alert does and what it does not do
Alerts are an underrated part of this environment and at the same time the part around which the most misunderstandings have grown. Let us start from a definition, because everything that follows comes out of it: an alert is a condition computed on the platform's servers on a chosen data series, and meeting it generates an event and a notification. The vendor's documentation says so directly – alerts are created and triggered on TradingView's servers, not in your browser[1]. Closing the tab or switching off the computer does not switch off an active alert.
From that same definition follows what an alert does not do. It does not place an order. It does not reserve a price. It does not guarantee that at the moment of notification a trade is executable at the level that triggered the condition. The notification says only this much: "on provider X's series, condition Y has been met". Everything that happens next is a separate chain of events.
The trigger frequency decides whether the alert sees a closed candle. This is the decisive switch in that window and a recurring source of disappointment. For timeframe-dependent alerts – that is, alerts based on indicators, drawings or transformed chart types – four modes are available: once only, once per minute, once per bar and once per bar close. The first three can fire while the candle is still forming, on values that will still change before it closes. Only the last one waits for confirmation[3]. For plain price alerts the set is different and narrower – once only or every time[9].
The practical consequence: the condition "RSI crossed 30" set to "once per bar" may ring at 10:14 and turn out at 11:00 to be unmet, because the candle closed higher. This is not a platform fault. It is a choice of setting whose consequences the user usually did not think through.
Notification channels. The event can be delivered as an in-app notification, a pop-up window, a sound or an e-mail message. A fifth channel – an HTTP request sent to a given address, that is a webhook – is not available as readily as sound or e-mail. The vendor's pricing page lists webhook notifications as a plan-dependent item[8], so check it together with the limits from section 8, and regardless of plan the vendor imposes one more condition: webhooks work only on an account with two-factor authentication enabled[13]. The choice of channel itself does not change the nature of the event – it changes where you find out about it. Do not place passwords or secret account keys in the webhook payload; keep execution-layer credentials on that layer’s side.
An alert can have an expiration date after which it stops running. Current help documentation makes the Open-ended option available on Premium and Ultimate [14]. Open-ended does not mean unrestricted operation: TradingView also deactivates such an alert when all three conditions hold — it was created over a year ago, last triggered over a year ago and last edited over a year ago. Check its active status and whether the condition is still relevant; renewing a subscription does not replace alert review.
A webhook is one link in the chain – and only that. The request sent by an alert may reach your intermediary application, that application may prepare an instruction and pass it to a broker API, the broker may validate and execute it or reject it. Each of these transitions can fail: the application can be unavailable, a key can expire, the broker can reject the order because of size, spread or trading hours, and on reconnection badly written code can send the same order twice. We give no latency figure here, because a sensible number would require measurement in a specific chain – with a given hosting setup, broker and time of day – and without that it would be invention. Building and securing such an execution layer is the subject of art. 11.5 and art. 11.8; here the rule is enough: until you have measured the whole chain, assume that an alert is suited to a style in which a few seconds do not change the sense of the decision.
How to manage alerts so that they have value:
- An alert on a level that changes something. The notification "price touched 1.0900" is empty if you have not written down what you do when it rings. Set alerts at levels that invalidate your thesis or trigger a course of action described in advance.
- The alert opens a procedure; the decision comes at the end of it. The order is fixed: notification, checking conditions in the terminal where you place the order, only then the decision. In the procedure described here, the alert by itself is not a sufficient basis for entry.
- The message text should reconstruct the context. In the message field write down not the level itself but what you had in mind when setting the alert: which scenario you are checking and what invalidates it. When the notification arrives at night or three weeks later, you will not reconstruct the context from memory.
- Expiry date. A level the market has not touched for several weeks has usually lost the context in which it arose. An expiry date is set by default anyway, and removing it requires a Premium or Ultimate plan – so run a periodic review of the list regardless of the date you entered when creating the alert.
- Rotation instead of collecting. After an alert fires, delete it and set a new one in line with your current analysis. A limit on the number of active alerts is often helpful in this role – it forces a choice between levels instead of recording all of them.
- Check the frequency on every indicator alert. This one field returns as the first item on the diagnostic list in the next section – a divergence between what you saw on history and what you got live usually starts right here. We return to it in the next section.
5. Why the alert behaved differently from the signal on history
Before you treat such a report as a platform defect, it is worth knowing that every item on the list below produces exactly that picture with no defect at all. An illustrative example, to show the shape of the problem: the chart shows dozens of arrows exactly where it was worth acting, while an alert created from the same script rang three times in a month, once in a place that is not visible on history at all. The numbers are illustrative and come from no measurement – the mechanism does not depend on their size. Work through the list below in the given order; a confirmed cause can explain some differences, but the remaining checks can matter too.
- Open or closed candle. Check whether the alert was set to trigger on bar close. If not, the condition was checked on temporary values. Those values are no longer on the chart – only the final candle is left of them, so you are comparing two different measurements.
- Trigger frequency. The once-only mode switches the alert off after the first firing. The per-minute mode can report the same condition many times. The number of notifications says nothing in itself about the number of signals.
- Repainting. The Pine Script documentation defines it broadly, as a divergence in a script's behaviour on historical data and in real time, and notes that it is a common phenomenon whose mere occurrence is not yet evidence of dishonesty[6]. What matters is only whether you know which version of the behaviour you are seeing. A script that on history draws a signal in a place visible only after the fact cannot draw it there live.
- Higher-timeframe data. A value from an open HTF bar can change in realtime and look different after recalculation. That is not automatically future leakage. A separate error is
lookahead_onwithout the appropriate offset: it can expose an HTF value on historical bars before that value was available. Requesting a previous, confirmed value, such asclose[1]withlookahead_on, is the documented solution for HTF requests, provided the requested timeframe is genuinely higher HTF documentation. - A configuration change after the alert was created. The server-copy mechanism described above: a strategy alert works on the settings from the moment it was created[2]. If you have changed the script's parameters on the chart since then, you are comparing two different configurations.
- Data source. The alert is computed on the series of the provider named in the symbol. If you have since switched the chart to a different provider, or you are comparing the notification with a chart at your broker, part of the divergence comes from there and not from the script – the mechanism from section 2.
- A script execution error. A script that exceeds the environment's limits or hits a runtime error stops computing the condition. Check whether the alert list contains a stopped entry and whether the script reports an error on the current instrument.
- Current platform limitations. Alert count limits, refresh frequency and the availability of timeframes depend on the plan and are sometimes changed. If the seven points above have explained nothing, check the vendor's current documentation for whether the behaviour of the function has been modified since you learned to use it.
All eight items share one thing: none of them concerns the accuracy of the condition. They do not, however, form a single category, and treating them as one makes diagnosis harder. They fall into four groups:
- The data seen by the condition at the moment of computation – points 1, 3, 4 and 6. This is the largest group and the proper subject of this section.
- Alert and script configuration – points 2 and 5. Nothing here computed differently; it was set differently.
- Script execution – point 7. The condition did not give a different result, it simply stopped being computed.
- Platform limitations – point 8. The cause lies outside your script and outside your setting.
The division has practical value, because each group calls for a different check: the first – comparing data, the second – looking into the settings, the third – the alert list and error messages, the fourth – the vendor's current documentation. The distinction returns everywhere historical behaviour is compared with current behaviour.
6. Pine Script: indicator, strategy and the Strategy Tester
Pine Script is the language of the TradingView environment and of that environment only. The code runs on the platform's servers, on the data series of the chosen provider, and its products are drawings on the chart, values and alert events. It is not a substitute for a broker API and you should not infer the behaviour of a trading account from the behaviour of a script. As of 2026-08-22: the current version of the language described in the vendor's manual is Pine Script v6, and the documentation maintains descriptions of older versions in parallel[7].
Three classes of script that are easy to confuse. This distinction decides what you are entitled to say about a result:
- An indicator (
indicator) computes and visualizes values. It can fire an alert. It does not maintain the emulator’s order account as a strategy does, although it can calculate custom states and position models. - A strategy (
strategy) adds a simulation layer: it places virtual orders with the built-in broker emulator and keeps a performance record from them. This is a simulation inside the platform and its result has to be read that way. - A library (
library) makes functions available to other scripts and does not run as a standalone indicator or strategy; its exported functions run within the calling script.
The sentence "my Pine strategy made X" describes the result of an emulator. The sentence "my robot made X" describes an account. Mixing those two sentences is the source of the recurring misunderstandings around this tool.
Pine Script is useful for custom indicators, formalizing conditions and preliminary simulations. A chart script can request other symbols through request.*(), within environment limits; the separate Pine Screener scans instrument lists and has its own restrictions. Strong simulation results require subsequent validation. A poor test can reflect either a weak rule or incorrect implementation, data or settings — establish what was actually tested before rejecting the idea.
What it is not suited to. To executing orders on an account – that requires a separate execution layer (art. 11.5). To statistical analysis that goes beyond the chart, because this is not a general-purpose language (art. 11.8). And to settling whether an idea has value – on which, below.
The Strategy Tester is an emulator, even though it looks like a statement
The results tab shows a set of metrics that look like an account report. They are not. The result comes from an emulator that fills virtual orders on the chosen provider's series – the vendor's documentation describes it as a module that "implements the core logic of a broker within the strategy testing environment"[19] (checked 2026-08-22).
The rules of that emulator are a setting, not a fixed property. The same page lists among its parameters slippage – "Specifies the number of ticks to be added to the fill price of market and stop orders" – and execution delay, which "controls when an order is executed relative to the bar lifecycle"; with the "One tick" variant an order placed on a given bar is not filled until the next tick. Each of these parameters can also be set in code: "Each of the parameters specified in the properties of the strategy can be changed by editing the arguments of the strategy() function call"[19] (checked 2026-08-22). The claim that the emulator computes only on closed candles therefore describes one possible arrangement of settings, not a property of the tool – and that is why two tests of the same strategy can give two different results without changing a single line of the condition. Before you treat such a result as information about anything, establish four things – all of them explicit parameters, not guesses:
- What costs and what execution model were entered. Commission, slippage and execution delay are fields in the strategy settings and have default values. If you have not checked them, you do not know which system your result describes – it may describe a system without costs, that is one other than the one you intend to run.
- What one trade is in this test. Position size in the emulator is often set by default as a percentage of capital, which with a growing balance changes the character of the entire results curve.
- How many trades there were. A dozen or so trades generally give a highly uncertain performance estimate; the shape of the equity curve alone neither quantifies that uncertainty nor establishes an edge.
- Whether the condition uses the future. Check
request.security()settings and when values become available. An open bar can repaint, but that differs from exposing a future value on history. For HTF, compare the code with the documented confirmed-value pattern, such asclose[1]andlookahead_on; that option’s presence alone does not establish an error.
The full methodology – the split into a fitting sample and a validation sample, forward testing, examining how robust the result is to worse costs, and controlling the number of variants tried – belongs to art. 11.7 and is described there in full. In this article we stop at the boundary of the tool: the results tab says what the emulator would have done on this data series with these settings. It says nothing about the future or about executability.
One mechanism: a condition computed after the candle closes
Below there is no script to copy onto a chart. There is a sketch of a structure: the order of checks and the names of Pine Script calls written so that they can be carried into your own code, but not so that they can be pasted and run. This form is a choice, not a shortfall. A complete script handed over for pasting would be an artefact the reader runs on their own chart without their own verification, and that teaches above all trust in someone else's code. A sketch forces the opposite order: copy the order of checks, write the implementation yourself and verify it in the Pine editor on your own instrument and timeframe. We made the same choice for the MQL sketches in art. 11.5.
STRUCTURE SKETCH - tying an alert event to a confirmed candle
Directional notation for Pine Script v6. This is not a complete script.
declaration: a script of type indicator - it computes and draws, it does
not keep a record of positions or results
1. fastLength, slowLength := input parameters (input)
A hard-coded value closes off any change without editing the code.
2. fast, slow := exponential moving average of the close price
computed for both lengths from point 1
3. cross := fast crosses above slow
This condition on its own is checked at every recalculation of the
candle, including on a candle that is still forming.
4. confirmation := barstate.isconfirmed
True only at the last recalculation of the candle, that is after it
closes. Without this component point 3 can fire on values that will
still change before the close.
5. condition := cross AND confirmation
6. if condition: call alert() with the message text
and the frequency once per bar close
what this sketch does not contain and cannot contain:
no call that places an order - Pine Script has no access
to an account at a broker.
What this sketch entitles you to, and what it does not. barstate.isconfirmed limits one class of divergence: the alert event is allowed after bar confirmation; earlier script calculations can still use provisional values, and historical candles are always confirmed. The vendor's documentation calls this outright one of the ways to avoid repainting: "using barstate.isconfirmed is actually one way to avoid repainting that will reproduce on historical bars, which are always «confirmed»"[6] (checked 2026-08-22). It does not, however, eliminate the remaining sources of divergence. The same page names two different data feeds for historical and current bars, as well as price corrections introduced after the fact: "Historical and realtime bars are built using two different data feeds" and "exchanges/brokers sometimes make what are usually small adjustments to bar prices"[6] (checked 2026-08-22). On top of that come a change of the provider named in the symbol and a shift in the start of available history, which can also change the outcome of a recomputation. A confirmed candle therefore narrows the field of divergence between history and real time – it does not close it.
Where the frequency is set depends on which function the script calls. In the sketch above the event is generated by alert(). For that mechanism both the frequency and the message text follow from the arguments given in the code – the alert creation window offers no frequency choice here, and the vendor's documentation says so directly[10]. The alertcondition() function works the other way round: it takes no frequency parameter, so the user picks it in the alert creation window[11]. Only with that function does it make sense to ask whether the code and the window setting describe the same behaviour – with alert() there is nothing to reconcile. So if you are looking in the configuration window for a field that is not there, check the first line of the call in the script first.
Someone else's script from the public library
The public script library is a genuine resource and a genuine minefield at the same time. Before you let someone else's code into your decision process, do three things. First, check the version declaration in the first line – a script written in an older version of the language may behave differently from what its description suggests. Second, check whether the source is visible at all, because that depends on the publication type: with an open script, read the code, and if you do not understand it, you have no way of judging when it will fail. With a protected or invite-only script you will not see the code and this step cannot be done – what remains is only checking the behaviour, that is the third step. Third, check historical behaviour against current behaviour, following the list from section 5 – and not on the basis of a "non-repainting" line in the description, which without saying what exactly was checked means nothing.
A separate remark concerns popular zone-marking templates. If many users display the same script on the same instrument, they see the same levels – and that changes the distribution of orders around them. What follows from this for market behaviour belongs to the technical analysis section; here a tooling remark is enough: a script's popularity is not its validation.
7. Paper Trading, the broker emulator and broker integrations
Three terms are often used interchangeably, though they denote three different things. The broker emulator is the simulation layer in which a Pine strategy places virtual orders – it works inside the script and we described it in the previous section. Paper Trading is a simulated account on which you click orders manually from the chart. A broker integration is a connection to a real account, where the order panel on the chart passes instructions to your broker's system.
Paper Trading answers one question and does not answer another. It answers the question "can I operate this tool": where to place a pending order, how to modify a defensive level, how to switch between chart layouts, how to set an alert from the panel. That is real value, because gaps in operating the tool cost you precisely when you have to act quickly.
What it does not answer is the question "is this executable at my broker". And it is not the case that the spread is cut out of this simulation – the vendor's documentation describes fills in Paper Trading like this: "In most cases, buy orders are executed at the ask price, and sell orders at the bid price"[20] (checked 2026-08-22). The simulator can therefore reflect the spread of the chosen data source. What it does not do is prove the conditions of a particular brokerage account: a different quote source, a different instrument specification, a different execution policy and different available liquidity give a different cost for the same decision. If you want to check how your idea behaves on the quotes you will actually trade on, the appropriate environment is a demo account at the broker with whom you intend to trade. The differences between demo, paper trading, historical testing and a live account are taken apart by art. 11.7.
A separate boundary: a simulation also does not reproduce how you will behave in the face of a real loss. That is a genuine limitation, but it belongs to art. 10.2 rather than to a description of the tool – here it is enough to note that a positive result on a simulator validates neither the system nor the execution.
Broker integrations are a broker-dependent feature. The list of partners changes, and the scope of an integration can differ even within one list: one broker may make the full set of order types available through the on-chart panel, another only the basic ones. That is why we do not copy a list of names here – it would go out of date faster than the article. Check the current list in the broker selection panel on the platform and set it against your broker's documentation, asking three questions: is my account type covered by the integration, which order types does it support, and are the defensive mechanisms set through the panel held on the broker's server or do they require a running application. The answer to the third question is a property of the broker, and the platform does not settle it.
An order from the chart’s trading panel uses TradingView’s broker integration, but the exact communication path depends on the implementation. Do not assume which servers every instruction traverses without documentation. Separate interface response, integration communication, broker acceptance and execution when assessing response time. Without shared timestamps and logs, the overall user-visible time can be measured, but each delay cannot be assigned to a particular layer.
The mobile version is not equivalent to the browser version. Do not assume that the set of features, order types and tools is the same on every device – that depends on the app version, the operating system and the integration. Regardless of the feature scope, a phone works well as a receiver of notifications and poorly as a place for analysis: on a small screen you cannot see context from several timeframes at once. The limitations and emergency procedures for working from a phone are described by art. 11.4.
8. Plans and limits – a reference layer, not a permanent one
This section differs from the others and it is worth knowing what the difference is. The earlier sections described above all mechanisms: the division of roles between provider, platform and broker, or the difference between a condition computed on an open and on a closed candle. That layer ages more slowly than the interface, but we do not declare it unchanging: the vendor has already changed the scope of the historical trading mode, the emulator's parameters and the set of alert frequencies, so the descriptions in this article also carry a date and require checking. The plan names and the numbers below, however, age faster than a description of a mechanism – they are a state of the product: they were true on the day of checking and may stop being true without any announcement. The vendor has already changed both the naming of subscription tiers and the limits assigned to them. So treat the table as a reference point to be verified, not as knowledge to be memorized.
As of 2026-10-08, according to the vendor's pricing page[8] – the tiers visible in the default pricing table:
| Plan | Charts per tab | Indicators per chart | Price alerts | Technical alerts |
|---|---|---|---|---|
| Basic (free) | 1 | 2 | 3 | None |
| Essential | 2 | 5 | 20 | 20 |
| Plus | 4 | 10 | 100 | 100 |
| Premium | 8 | 25 | 400 | 400 |
| Ultimate | 16 | 50 | 1000 | 1000 |
Three things in this table deserve a comment, because in older write-ups they look different. First, the separation of price alerts from technical ones: these are two separate pools, each with its own counter. An alert based on a simple price level counts against a different limit than an alert based on an indicator, a drawing or a transformed chart type. Second, the naming of subscription tiers has changed over time and part of the material on the web still uses the old names – if some text shows you a "Pro" or "Pro+" plan, it describes the state before the renaming.
Third, names in older material do not establish present availability. Expert appears in older vendor posts and help pages [15][17], but the current pricing page at this review presents the five tiers in the table and identifies Ultimate as the plan for professional users. The presence of an old name does not mean that the plan can still be purchased. Check the offering for your country and your user classification before selecting a subscription.
We do not give prices in the article and that is a deliberate decision. The amount depends on the settlement currency, the country, the billing period and current promotions, so any number written here would be wrong for some readers on the day of publication and for the rest a few months later. You will see the current pricing in your own currency on the vendor's subscription page.
It is worth turning the question of cost around, though. A subscription to an analytical tool is a fixed cost and is usually compared with the size of the account. But an edge does not come from a subscription plan – it comes from a system and from the consistency of applying it (art. 8.2). Paying up reduces friction in your work – less switching, less manual limit management, fewer things to remember – but only in those features the purchased plan actually covers, and those do not line up into a single ladder. The vendor assigns the open-ended alert to the Premium and Ultimate plans[14], and the threshold for displaying more than eight charts on one tab to the Expert plan[17] (both pages checked 2026-08-22). Moving from Premium to Expert therefore increases the number of charts, but the documentation does not assign the open-ended alert to the Expert plan – that move by itself does not reduce the manual management of expiry dates. Compare each feature you need separately instead of ranking plans. The time saved on features your plan does cover is real and is an honest justification for the expense. The sentence "a better plan will improve my results" is not an honest justification – and there is no way to check it.
What you do not have to buy. Paid indicators sold as a ready-made edge are a separate category of expense and a separate risk: since you cannot see the code, you have no way of verifying whether the historical behaviour matches the current one – and that is the question that settles matters here (section 5). The alert limits on the Premium and Ultimate plans – 400 and 1000 respectively in each of the two pools, according to the table in section 8 – correspond to a need for hundreds of parallel observations; working with a handful of currency pairs, that number of observations is not needed.
9. Organizing your work: watchlists, layouts and the Ideas section
An example picture that is easy to recognize yourself in: twelve open tabs, three chart layouts, eight currency pairs and twenty minutes after which no decision has been made. The numbers are illustrative. An environment with large capabilities can amplify a lack of structure just as effectively as it can support one. The difference is made by a few decisions that have to be taken once.
Watchlists instead of one list of everything. A sensible division follows from why you are looking at a given instrument, not from which asset class it belongs to:
- Core – the pairs you trade and whose specifics you know. This list should be short and change rarely.
- Watching – instruments on which you hold an open position or a maturing scenario. This list rotates.
- Context – instruments you do not trade but read as background: the dollar index, the bond market, a volatility measure. Opened once a day, not continuously.
The size criterion is brutally simple: a list you cannot review in one pass has stopped being a watchlist. Every instrument added is a separate volatility profile, a separate release calendar and separate behaviour during thin-liquidity hours – and with twenty markets at once, attention stops being sufficient.
Chart layouts. The rule is the same: one layout, one purpose. A separate one for looking for a situation on one instrument across several timeframes, a separate one for reviewing several instruments at once, a separate one for context. Before you map this out, check one thing the table in section 8 does not cover: the number of saved layouts is a separate plan limit and has nothing to do with the "charts per tab" column. The first value says how many different configurations you are allowed to keep saved, the second – how many charts fit on one tab. If your plan lets you save fewer layouts than the three-way split described above requires, what remains is one layout rearranged by hand; the vendor does not give that number in the knowledge base and instead refers you to the pricing page for it[16] (checked 2026-08-22). Mixing those three purposes in one window ends with the review turning into analysis, and the analysis into an accidental click.
Notes on the chart. Annotating levels directly on the chart makes sense on one condition: the note records what you knew at the moment of placing it, not what followed later. "The level at which the third consecutive down move stopped" is a record of an observation. "Strong demand" is a record of an opinion that in a month will be unverifiable. The first form builds a map of the instrument, the second builds a justification for a thesis you already hold.
The Ideas section – what you see and what you do not
A public database of analyses is a large collection of its kind and at the same time a textbook example of sampling bias (survivorship bias – a related entry). The sample here is created by selection before publication, not by unsuccessful entries disappearing after it, and it is exactly that order which decides the name of the mechanism. It is made up of four independent elements, each working in the same direction:
- Publication is voluntary, and the decision to publish is taken before publication. The author decides whether to send the entry at all, and can keep it private – in which case it never reaches the public set. An analysis the author stopped believing in before pressing publish does not exist in this set. A view of the set is not a view of the attempts.
- There is no link to an account. A publication is not verified against any trade history. A description of a scenario and a result on an account are two different things, and the set shows only the first of them.
- Visibility and ranking position depend on reader reactions. Entries that collect a response rise higher – and a response is collected by theses that agree with what readers already think. What you see first is therefore a result of popularity, not of accuracy.
- Execution is invisible. Even when a scenario played out, you do not know at what price the author entered, whether they moved the defensive level and whether they took a position at all.
A public Ideas history is not a complete record of every decision its author makes. TradingView’s rules let authors edit or remove a public idea only within 15 minutes after publication, but moderators can subsequently hide rule-breaking posts [22]. There is also selection before publication: authors choose what to submit and what to keep private. Therefore, assume neither unrestricted later deletion of failed ideas nor completeness of the visible history. Even a complete set of public posts excludes analyses that were never published.
This is not an argument for ignoring other people's analyses. It is an argument for changing the question you approach them with. The value is in the process: a well-described entry shows how someone formulated a thesis, where they placed the level that invalidates it and what alternative scenario they allowed for. That is material for learning to read the market. The value is not in the result: follower counts and awarded ranks measure popularity, say nothing about accuracy, and there is no documented relationship between the one and the other.
The practical consequence is a single one: if you cannot reconstruct someone's reasoning on your own chart and check it in your own procedure, you have no basis for acting on it. Someone else's analysis can be a starting point for your own work. It cannot replace it.
The calendar and other built-in tools. The environment also offers a macro release calendar and market-strength overviews. For a quick check of whether anything is happening today, they are sufficient. The criteria for judging calendars, scanners and calculators – entry fields, time zones, the consensus convention and filters – are the subject of the next article (art. 11.3), while the interpretation of the releases themselves belongs to art. 6.4. The same applies to positioning data from CFTC reports, which community scripts sometimes bring onto the chart: the tool itself is neutral, and what follows from that data is described by art. 6.6.
10. What TradingView does not show
The limitations of an analytical tool rarely announce themselves with an error message. They announce themselves in the fact that the data you are looking at means something other than you assume. The four cases below describe exactly such situations.
Volume on a currency chart depends on the data source
Because Forex spot has no central exchange reporting turnover (art. 1.3), the bar under a currency chart does not measure the value of transactions concluded across the whole market. What it does measure depends on what the platform receives from the data provider, and it is not constant across all symbols. The vendor's documentation states the rule outright: "We always display volume when we receive it from the data provider", and where there is no turnover, tick volume is sometimes available: "In some cases, we don't have the trade volume, but the tick volume is available (it indicates the amount of price updates)"[23] (checked 2026-08-22). The same page lists symbols for which there is no volume at all – among others some currency pairs and CFDs – as well as instruments for which the indicator shows "n/a".
The data type can be checked, and it is worth doing before you read anything out of that bar. In Pine Script one variable handles this: the vendor's manual describes syminfo.volumetype as a string indicating the type of volume reported for the instrument, with possible values "base", "quote", "tick" and "n/a"[24] (checked 2026-08-22). Only the answer to that question settles whether you are looking at a count of quote changes, at turnover measured in one of the currencies of the pair, or at missing data. Changing the provider changes those values, and comparing them across platforms makes no sense.
That does not mean the reading is useless. The number of quote changes measures exactly what its definition says: how often the quote changed at that provider. It is, however, a poor approximation of what it is often used for – inferring the size of large participants' involvement. The sentence "high volume at this level" on a spot chart does not carry the content people usually ascribe to it.
Real volume in the currency market can be observed on exchange-traded futures – a centralized instrument with reported turnover. It is only worth remembering that it is a different instrument: its own trading hours, its own settlement mechanics, its own cost structure and a price series that does not overlap with spot point for point.
A single candle does not encode your spread
A candle is built from one price series, while your entry cost follows from the difference between two sides of the market at your broker in a particular second. A single candle does not encode that difference – from four values of one series you cannot reconstruct the other side of the market. That does not mean the spread cannot be read anywhere. The vendor's documentation points to two places where the platform shows it: "in the Buy/Sell on your chart" and "in the Order Dialog/Panel"[21] (checked 2026-08-22). What the vendor indicates there, however, are places of presentation, not ownership of the source: both belong to the transactional layer, not to the chart itself, and whose spread you see in them depends on the mode. With a connected brokerage account it is that account's spread; in simulation mode fills go at the ask and bid of the data source – "In most cases, buy orders are executed at the ask price, and sell orders at the bid price"[20] (checked 2026-08-22, more broadly in section 7). In neither variant is it the spread of the series from which the candle is built. So before you judge any distance on the chart to be safe, check in the symbol description which series you are seeing, and read the size of the spread where you place the order.
The two moments at which this divergence counts are predictable. The first is the macro release window: the spread can widen many times over and a pending order can behave completely differently from a quiet session – which is why an alert that lands in that window has a different value from the same alert an hour earlier (the mechanics of trading around releases: art. 8.8). The second is around the daily rollover of positions, when liquidity is thin and the spread can widen. A tight defensive level that looks distant on the chart can, at both of those moments, be reached without a price move in the sense in which you understand the word.
The daily candle closes at different hours
Broker terminals run in time zones set by the broker; the analytical platform applies its own convention for the instrument. The consequence is concrete: the daily candle may cover a different slice of the day in each of those places. If your condition rests on the shape of a closed daily candle, the same day can produce a signal in one place and not in the other – and that will be correct behaviour from both tools.
The check takes a minute: compare the closing hour of the daily candle on the chart with the closing hour at your broker. If they differ, decide which version you take as binding for your conditions, and stay with it. The same applies to the weekend – the moment trading opens on Sunday depends on the server, so the size of the gap can differ from place to place (art. 4.4).
Market depth, data delays and the reach of history
The three remaining limitations can be described briefly. First, in the spot market there is no single public order book, because there is no central exchange to keep one. The book itself the platform can display: the trading panel has a depth-of-market tab, except that it is fed by data from the connected broker, not from the provider of the chart series[12]. So there are two conditions: the account must be connected to the platform, and the broker must make level-two data available for that symbol – on retail FX accounts both conditions are often unmet. This is a dependency on the broker and the account type, not a missing feature in the platform, so start by checking both conditions in your broker's documentation; if they are not met, your method needs a different market (art. 3.3). Second, data from exchange markets is subject to the data providers' rules and is sometimes delayed – this also applies to currency futures if you use them as a reference point. The extent of the delay depends on the exchange and the data package purchased, not on the level of your platform subscription; you check it in the description of the specific instrument. Third, the depth of available history differs between instruments and timeframes, and on low timeframes it is often short – tests that require long minute history need an external data source and a separate tool (art. 11.7).
A checklist before using a level from the chart:
| What to check | Why it changes the outcome | Where you find the answer |
|---|---|---|
| The provider prefix in the symbol | A different series means different extremes and a different moment at which a level is touched | The symbol field on the chart |
| Which side of the market builds the candle | At one instant, Ask − Bid is the spread; the arithmetic mid is half a spread from each side. Candle extremes under a variable spread do not have one constant offset. | Symbol description and provider documentation |
| The closing hour of the daily candle | A different candle means a different signal from the same day | Comparing the chart with the broker's terminal |
| The alert trigger frequency | A condition on an open candle behaves differently from one after the close | The alert configuration window |
| Cost settings in the simulation | A result without commission and slippage describes a different system | Strategy settings in the results tab |
| Your broker's spread right now | The candle does not encode it, and it decides the cost of entry | The order panel with a connected account, or the terminal in which you place the order |
All six items come down to one question, and it is worth closing this article with it: where does the number I am looking at come from, and does it come from the same place as the decision I am basing on it. An analytical tool answers the first half of the question. The second half you have to check where you place the order.
The next article stays with tools but changes their class: release calendars, scanners and calculators are sources in which the question about where the data comes from – the consensus convention, the time zone of an entry, the definition of a field – is equally important, and sometimes even harder to ask.
FAQ – practical questions
Can I place Forex orders directly from TradingView?
I changed the script settings and the alert still behaves the old way. Why?
The alert rang, but I see no signal at that place on the chart. What happened?
Is the volume on a currency pair's chart reliable?
syminfo.volumetype. If it is tick volume, it is useful as a measure of activity and useless as a measure of turnover size – a different provider will give different values. In the spot market there is no central exchange reporting transactions, so inferring the size of participants' involvement requires a centralized market, that is futures – and that is already a different instrument, with its own trading hours and settlement mechanics.Is Pine Script suitable for automated trading?
How do I check whether a script behaves differently on history than live?
lookahead_on is an error, since the previous confirmed-value pattern, such as close[1], can be valid. Then record signals on open bars and compare them after closure and recalculation. A dozen or so sessions can begin observation, but do not establish the absence of every form of repainting. With protected code, you can assess visible behaviour but not the full implementation. A “non-repainting” claim needs stated testing conditions; repainting alone does not establish dishonesty.Can I transfer levels read off the chart 1:1 into my broker's terminal?
Sources and references
- TradingView Help Center, "Will alerts work if TradingView is not open on the computer?" – tradingview.com/support/solutions/43000548327. Vendor documentation: alerts are created and triggered on the platform's servers. Checked 2026-08-22.
- TradingView Help Center, "Strategy alerts" – tradingview.com/support/solutions/43000481368. Source of the rule that a strategy alert works on a server-side copy created at the moment the alert is set up, independent of later changes on the chart. Checked 2026-08-22.
- TradingView Help Center, "Differences between alert frequencies" – tradingview.com/support/solutions/43000474415. Description of alert trigger modes and of the difference between checking a condition on a forming candle and after it closes. Checked 2026-08-22.
- Markets Committee, "The sterling «flash event» of 7 October 2016", Bank for International Settlements, January 2017 – bis.org/publ/mktc09.htm. An analysis of the episode in which establishing the price low itself is discussed separately, given the divergence of quotes between trading systems.
- Barber, B., Odean, T. (2000). "Trading Is Hazardous to Your Wealth: The Common Stock Investment Performance of Individual Investors". The Journal of Finance, 55(2), 773–806. The relationship between trading frequency and the results of retail accounts; the study concerns the US equity market, and we carry the conclusion over solely as an argument for limiting the number of opportunities to enter.
- Pine Script® User Manual, "Repainting" – tradingview.com/pine-script-docs/concepts/repainting. Definition of the phenomenon as a divergence in a script's behaviour on historical data and in real time. Checked 2026-08-22.
- Pine Script® User Manual – tradingview.com/pine-script-docs. Source of information on the current version of the language (v6) and on the documentation of earlier versions maintained in parallel. Checked 2026-08-22.
- TradingView, subscription pricing – tradingview.com/pricing. Source of the plan names and of the chart, indicator and alert limits given in section 8. Values change over time; state as of 2026-08-22.
- TradingView Help Center, "Why is the Once Per Bar option missing?" – tradingview.com/support/solutions/43000690908. Source of the distinction between timeframe-dependent alerts, for which four trigger modes are available, and plain price alerts, for which the set has two elements. Checked 2026-08-22.
- TradingView Help Center, "Alerts on alert() function" – tradingview.com/support/solutions/43000597494. Source of the rule that for an alert created from an
alert()call, both the trigger frequency and the message text follow from the script's code and not from the settings in the alert creation window. Checked 2026-08-22. - Pine Script® User Manual, "Alerts" – tradingview.com/pine-script-docs/concepts/alerts. Source of the opposite rule for
alertcondition(): the function takes no frequency parameter, so the user picks it in the alert creation window. Checked 2026-08-22. - TradingView Help Center, "How do I get level 2 data?" – tradingview.com/support/solutions/43000480004. Source of the information that market depth data comes from the broker and requires a connected account and a broker that makes that data available. Checked 2026-08-22.
- TradingView Help Center, "How to configure webhook alerts" – tradingview.com/support/solutions/43000529348. Source of the condition that webhook alerts are permitted only with two-factor authentication enabled. Checked 2026-08-22.
- TradingView Help Center, "I upgraded to the Premium plan but my alerts still expiring in 2 months" – tradingview.com/support/solutions/43000688759. Source of the rule that an open-ended alert is available only on the Premium and Ultimate plans. Checked 2026-08-22.
- TradingView Help Center, “How much data is available for Bar Replay?” — tradingview.com. The help page uses the historical Expert name; its presence alone does not establish current plan availability. The current offering was checked separately in the pricing page on 2026-10-08.
- TradingView Help Center, "I cannot create a new layout" – tradingview.com/support/solutions/43000762819. Source of the information that the maximum number of saved chart layouts is a property of the subscription plan and is checked in the pricing page. Checked 2026-08-22.
- TradingView Blog, "New chart layout patterns at your disposal", 28 June 2024 – tradingview.com/blog/en/new-chart-layout-patterns-45487. A vendor post naming the Expert plan as the threshold for displaying more than eight charts on one tab. Checked 2026-08-22.
- TradingView Help Center, "Learn to trade on historical data" – tradingview.com/support/solutions/43000691889. Source of the description of the historical trading mode: positions, limit and stop orders, initial capital and commission, results tabs, the ability to export the Performance and List of trades tabs, and the caveat that session data is not saved anywhere. Checked 2026-08-22.
- TradingView Help Center, "Broker emulator" – tradingview.com/support/solutions/43000786181. Source of the description of the emulator as a module simulating order execution, and of its configurable parameters: slippage, execution delay and the ability to set them from the arguments of the strategy call. Checked 2026-08-22.
- TradingView Help Center, "How is position profit and loss in Paper Trading calculated?" – tradingview.com/support/solutions/43000719857. Source of the rule that on a simulated account buy orders are executed at the ask price and sell orders at the bid price. Checked 2026-08-22.
- TradingView Help Center, "Where can I see the spread?" – tradingview.com/support/solutions/43000479982. Source of the information that the platform shows the spread at the order buttons on the chart and in the order dialog and panel. Checked 2026-08-22.
- TradingView Help Center, "Publishing and updating ideas" – tradingview.com/support/solutions/43000591338. Source of the rule that a public entry can be edited or removed only within fifteen minutes of publication, and that after that time it is no longer possible. Checked 2026-08-22.
- TradingView Help Center, "The volume indicator on my chart looks odd or displays zero or n/a values" – tradingview.com/support/solutions/43000481397. Source of the rule that volume is displayed when the platform receives it from the data provider, and of the information about the availability of tick volume and about symbols without volume data. Checked 2026-08-22.
- Pine Script® User Manual, "Chart information" – tradingview.com/pine-script-docs/concepts/chart-information. Source of the description of the
syminfo.volumetypevariable and its four possible values. Checked 2026-08-22.